commit 61fcf7dd7129292fe8f079aea8c76cf6742ceabe Author: yuhawu <15545526+yuhawu@user.noreply.gitee.com> Date: Mon Nov 24 10:25:20 2025 +0800 初始提交：知书小程序项目 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e69de29 diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..b91d231 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,15 @@ +{ + // 使用 IntelliSense 了解相关属性。 + // 悬停以查看现有属性的描述。 + // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + { + "type": "pwa-chrome", + "request": "launch", + "name": "Launch Chrome against localhost", + "url": "https://api.buzhiyushu.cn", + "webRoot": "${workspaceFolder}" + } + ] +} \ No newline at end of file diff --git a/App.vue b/App.vue new file mode 100644 index 0000000..6c36b9b --- /dev/null +++ b/App.vue @@ -0,0 +1,85 @@ + + + + + diff --git a/README.md b/README.md new file mode 100644 index 0000000..4183138 --- /dev/null +++ b/README.md @@ -0,0 +1,63 @@ +# 图书上传系统 - 页面拆分说明 + +## 已完成工作 + +已将原有的单页面应用拆分为三个独立页面： + +1. **首页(pages/index/index.vue)** + - 重新设计为导航页面 + - 提供两种上传方式的入口：ISBN上传和仅书名上传 + - 简洁直观的UI，便于用户选择 + +2. **ISBN上传页面(pages/isbn-upload/index.vue)** + - 专门用于ISBN扫码上传 + - 包含扫码功能、书籍信息填写、图片上传等功能 + - 与原页面中的ISBN上传部分功能一致 + +3. **仅书名上传页面(pages/title-upload/index.vue)** + - 专门用于根据书名搜索上传 + - 包含书名搜索、结果选择、图片上传等功能 + - 与原页面中的仅书名上传部分功能一致 + +## 下一步操作 + +为完成系统集成，需要进行以下操作： + +1. **更新pages.json配置文件** + - 添加新创建的页面路径 + ```json + { + "pages": [ + { + "path": "pages/index/index", + "style": { + "navigationBarTitleText": "图书上传系统" + } + }, + { + "path": "pages/isbn-upload/index", + "style": { + "navigationBarTitleText": "ISBN上传" + } + }, + { + "path": "pages/title-upload/index", + "style": { + "navigationBarTitleText": "仅书名上传" + } + } + // 其他已有页面... + ] + } + ``` + +2. **测试新页面功能** + - 确保所有功能正常运行 + - 检查页面间的跳转是否流畅 + - 验证各项功能是否与原系统一致 + +## 注意事项 + +- 拆分后的页面共用同样的组件和样式 +- 保留了原始功能，只是将其分散到不同页面 +- 如有UI上的问题，可能需要调整相应的样式 \ No newline at end of file diff --git a/api/kongfz.js b/api/kongfz.js new file mode 100644 index 0000000..5b9e8d0 --- /dev/null +++ b/api/kongfz.js @@ -0,0 +1,650 @@ +/** + * 孔夫子旧书网API服务 + */ + +/** + * 登录孔夫子旧书网 + * @param {string} username - 用户名 + * @param {string} password - 密码 + * @returns {Promise<{success: boolean, token: string, message: string}>} - 登录结果 + */ +export function login(username, password) { + return new Promise((resolve, reject) => { + if (!username || !password) { + resolve({ + success: false, + message: '请输入用户名和密码' + }); + return; + } + + // 构建请求参数 + const url = 'https://login.kongfz.com/Pc/Login/account'; + const data = { + loginName: username, + loginPass: password, + autoLogin: '0', + returnUrl: 'http://user.kongfz.com/' + }; + + // 发送请求 + uni.request({ + url: url, + method: 'POST', + data: data, + header: { + 'Content-Type': 'application/x-www-form-urlencoded' + // 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36' + }, + success: (res) => { + console.log("登录...", res) + // 检查登录是否成功 + if (res.data && res.data.indexOf( + "window.location.href='https://login.kongfz.cn/Pc/Session/rsync") !== -1) { + // 提取PHPSESSID + const cookies = res.cookies; + let phpsessid = ''; + + if (cookies && cookies.length > 0) { + for (const cookie of cookies) { + if (cookie.indexOf('PHPSESSID=') !== -1) { + phpsessid = cookie.split('PHPSESSID=')[1].split(';')[0]; + break; + } + } + } + + if (phpsessid) { + resolve({ + success: true, + token: phpsessid, + message: '登录成功' + }); + } else { + resolve({ + success: false, + message: '登录失败: 未找到PHPSESSID' + }); + } + } else { + // 尝试解析错误信息 + try { + const data = JSON.parse(res.data); + if (data.errCode === 1001) { + resolve({ + success: false, + message: '登录失败: 账号或密码错误' + }); + } else if (data.errInfo) { + resolve({ + success: false, + message: `登录失败: ${data.errInfo}` + }); + } else { + resolve({ + success: false, + message: '登录失败: 未知错误' + }); + } + } catch (e) { + resolve({ + success: false, + message: '登录失败: 响应不包含成功跳转信息' + }); + } + } + }, + fail: (err) => { + reject(new Error(`登录请求失败: ${err.errMsg}`)); + } + }); + }); +} + +/** + * 获取商品列表 + * @param {string} token - 登录令牌 + * @param {Object} params - 查询参数 + * @param {function} onProgress - 进度回调 + * @returns {Promise} - 商品列表 + */ +export function fetchItems(token, params = {}, onProgress = null) { + return new Promise((resolve, reject) => { + if (!token) { + reject(new Error('请先登录获取Token')); + return; + } + // const token = 'ebb26189289d0dc068f9aac748881bccf890e694'; + const url = 'https://seller.kongfz.com/pc-gw/book-manage-service/client/pc/goods/unSold/list'; + const headers = { + 'Cookie': `PHPSESSID=${token}`, + // 'Cookie': 'PHPSESSID=ebb26189289d0dc068f9aac748881bccf890e694' + // 'User-Agent' 头在浏览器环境中无法设置，会被拒绝 + // 'Content-Type': 'application/json' + }; + + let page = 1; + const size = 50; + const allItemIds = []; + + const fetchPage = () => { + // 准备请求体 + const requestBody = { + "requestType": "onSale", // 标识 出售中 + "isItemSnEqual": "0", + "page": page, + "size": size + }; + + // 添加可选参数 + if (params.itemSn) requestBody.itemSn = params.itemSn; + if (params.priceMin) requestBody.priceMin = params.priceMin; + if (params.priceMax) requestBody.priceMax = params.priceMax; + if (params.startCreateTime) requestBody.startCreateTime = params.startCreateTime; + if (params.endCreateTime) requestBody.endCreateTime = params.endCreateTime; + + // 调用进度回调 + if (onProgress) { + onProgress(`正在获取第 ${page} 页数据...`); + // 添加请求参数日志 + if (page === 1) { + onProgress(`请求参数: ${JSON.stringify(requestBody)}`); + } + } + console.log("请求参数", requestBody) + + // 发送请求 + uni.request({ + url: url, + method: 'POST', + data: requestBody, + header: headers, + success: (res) => { + if (res.statusCode !== 200) { + console.error('API 失败响应:', res); + reject(new Error(`API返回错误: HTTP ${res.statusCode}`)); + return; + } + + const data = res.data; + if (!data.status) { + console.error('API 失败响应:', data); + reject(new Error(`API返回错误: ${data.errMessage || '未知错误'}`)); + return; + } + + // 获取商品列表 + const result = data.result || {}; + const productInfo = result.productInfoPageResult || {}; + const items = productInfo.list || []; + const pager = productInfo.pager || {}; + + // 提取商品ID + for (const item of items) { + const itemId = item.itemId; + if (itemId) { + allItemIds.push({ + id: itemId, + status: 'wait' + }); + } + } + + // 更新状态 + const totalPages = pager.pages || 0; + const totalCount = pager.count || 0; + if (onProgress) { + onProgress(`获取到 ${items.length} 个商品 (第 ${page}/${totalPages} 页)`); + // 添加更详细的商品信息 + if (items.length > 0) { + const firstItem = items[0]; + onProgress( + `商品示例: ID=${firstItem.itemId}, 标题=${firstItem.title || '无标题'}, 价格=${firstItem.price || '未知'}` + ); + } + // 添加总数信息 + onProgress(`当前已获取: ${allItemIds.length}/${totalCount} 个商品`); + } + + // 检查是否还有下一页 + if (page >= totalPages) { + if (onProgress) { + onProgress(`拉取完成，共获取 ${allItemIds.length} 个商品`); + if (allItemIds.length === 0) { + onProgress('未找到符合条件的商品，请检查筛选条件'); + } else { + onProgress( + `商品ID示例: ${allItemIds.slice(0, 3).map(item => item.id).join(', ')}${allItemIds.length > 3 ? '...' : ''}` + ); + } + } + resolve(allItemIds); + } else { + page++; + // 延迟1秒后获取下一页 + if (onProgress) { + onProgress(`等待1秒后获取下一页...`); + } + setTimeout(fetchPage, 1000); + } + }, + fail: (err) => { + const errorMsg = `拉取商品失败: ${err.errMsg}`; + if (onProgress) { + onProgress(errorMsg); + onProgress('请检查网络连接是否正常'); + onProgress('请确认登录状态是否有效'); + } + reject(new Error(errorMsg)); + } + }); + }; + + // 开始获取第一页 + fetchPage(); + }); +} + +/** + * 获取商品模板字段 + * @param {string} token - 登录令牌 + * @param {string} itemId - 商品ID + * @returns {Promise} - 商品模板字段 + */ +export function getItemTplFields(token, itemId) { + return new Promise((resolve, reject) => { + if (!token) { + reject(new Error('请先登录获取Token')); + return; + } + + const url = + `https://seller.kongfz.com/pc/itemInfo/getTplFields?itemId=${itemId}&isClone=1&v=${Math.floor(Date.now() / 1000)}`; + + uni.request({ + url: url, + method: 'GET', + header: { + 'Cookie': `PHPSESSID=${token}`, + // 'User-Agent' 头在浏览器环境中无法设置，会被拒绝 + 'Referer': 'https://seller.kongfz.com/', + 'Origin': 'https://seller.kongfz.com' + }, + success: (res) => { + if (res.statusCode !== 200) { + reject(new Error(`HTTP错误: ${res.statusCode}`)); + return; + } + + const data = res.data; + if (data.status === 1) { + resolve(data); + } else { + reject(new Error(`API返回错误: ${data.message || '未知错误'}`)); + } + }, + fail: (err) => { + reject(new Error(`请求失败: ${err.errMsg}`)); + } + }); + }); +} + +/** + * 提交商品表单 + * @param {string} token - 登录令牌 + * @param {Object} itemData - 商品数据 + * @param {Object} priceConfig - 价格配置 + * @returns {Promise} - 是否成功 + */ +export function submitItemForm(token, itemData, priceConfig) { + return new Promise((resolve, reject) => { + if (!token) { + reject(new Error('请先登录获取Token')); + return; + } + + // 准备表单数据 + const formData = { + "pageType": "clone" + }; + + // 添加图书基本信息（bookSection） + const bookSection = (itemData.data && itemData.data.bookSection) || []; + for (const field of bookSection) { + const key = field.key; + const value = field.value; + + // 处理嵌套字段（如出版时间） + if (field.group) { + for (const subField of field.group) { + const subKey = subField.key; + const subValue = subField.value; + + if (subKey && subValue !== null && subValue !== undefined) { + formData[subKey] = String(subValue); + } + + // 处理options中的嵌套 + if (subField.options) { + const selectedValue = subField.value; // 获取当前选中的值 + for (const option of subField.options) { + const optionValue = option.value; + // 如果选项是当前选中的，或者选项中有group字段，则处理其中的字段 + if (String(optionValue) === String(selectedValue) || option.group) { + if (option.group) { + for (const optionField of option.group) { + const optionKey = optionField.key; + const optionValue = optionField.value; + + if (optionKey && optionValue !== null && optionValue !== undefined) { + formData[optionKey] = String(optionValue); + } + + // 处理更深层的嵌套 + if (optionField.group) { + for (const deepField of optionField.group) { + const deepKey = deepField.key; + const deepValue = deepField.value; + + if (deepKey && deepValue !== null && deepValue !== undefined) { + formData[deepKey] = String(deepValue); + } + } + } + } + } + } + } + } + + // 处理更深层的嵌套（如年月） + if (subField.group) { + for (const deepField of subField.group) { + const deepKey = deepField.key; + const deepValue = deepField.value; + + if (deepKey && deepValue !== null && deepValue !== undefined) { + formData[deepKey] = String(deepValue); + } + } + } + } + } + + // 添加顶层字段 + if (key && value !== null && value !== undefined) { + formData[key] = String(value); + } + + // 特殊处理 yearsGroup 字段，确保处理其 options 中的字段 + if (key === 'yearsGroup' && field.options) { + const selectedValue = value; // 获取当前选中的值 + for (const option of field.options) { + const optionValue = option.value; + // 如果选项是当前选中的，处理其中的字段 + if (String(optionValue) === String(selectedValue) && option.group) { + for (const optionField of option.group) { + const optionKey = optionField.key; + const optionValue = optionField.value; + + if (optionKey && optionValue !== null && optionValue !== undefined) { + formData[optionKey] = String(optionValue); + } + + // 处理出版时间的年月字段 + if (optionKey === 'pubDate' && optionField.group) { + for (const dateField of optionField.group) { + const dateKey = dateField.key; + const dateValue = dateField.value; + + if (dateKey && dateValue !== null && dateValue !== undefined) { + formData[dateKey] = String(dateValue); + } + } + } + } + } + } + } + } + + // 添加商品基本信息 + const goodsSection = (itemData.data && itemData.data.goodsSection) || []; + for (const field of goodsSection) { + const key = field.key; + const value = field.value; + + // 跳过 images 字段，因为我们会单独处理图片 + if (key === 'images') { + const images = field.images || []; + for (let i = 0; i < images.length; i++) { + formData[`images[${i}][imgId]`] = String(images[i].imgId || ''); + formData[`images[${i}][imgType]`] = String(images[i].imgType || ''); + formData[`images[${i}][imgDesc]`] = ''; + formData[`images[${i}][isMain]`] = String(images[i].isMain || ''); + formData[`images[${i}][imgUrl]`] = images[i].imgUrl || ''; + } + continue; + } + + if (key && value !== null && value !== undefined) { + // 特殊处理价格字段 + if (key === 'price') { + try { + let price = parseFloat(value); + // 应用价格调整 + if (priceConfig.configType === 1) { // 折扣 + price *= (priceConfig.value / 100); + } else if (priceConfig.configType === 2) { // 加减值 + price += priceConfig.value; // priceConfig.value已经包含了正负号 + } else if (priceConfig.configType === 3) { // 直接赋值 + price = priceConfig.value; + } + formData[key] = price.toFixed(2); + } catch (e) { + formData[key] = String(value); + } + } else { + // 添加到表单数据 + formData[key] = String(value); + } + } + } + + // 添加物流信息 + const shippingSection = (itemData.data && itemData.data.shippingSection) || []; + for (const field of shippingSection) { + const key = field.key; + const value = field.value; + + if (key && value !== null && value !== undefined) { + formData[key] = String(value); + } + } + + // 添加交付信息 + const deliverSection = (itemData.data && itemData.data.deliverSection) || []; + for (const field of deliverSection) { + const key = field.key; + const value = field.value; + + if (key && value !== null && value !== undefined) { + formData[key] = String(value); + } + } + + // 添加分类ID + const categorySection = (itemData.data && itemData.data.categorySection) || {}; + if (categorySection.value !== null && categorySection.value !== undefined) { + formData.catId = String(categorySection.value); + } + + const url = 'https://seller.kongfz.com/pc/itemInfo/add'; + console.log("formData1111111111", formData) + // 发送请求 + uni.request({ + url: url, + method: 'POST', + data: formData, + header: { + 'Cookie': `PHPSESSID=${token}`, + // 'User-Agent' 头在浏览器环境中无法设置，会被拒绝 + 'Content-Type': 'application/x-www-form-urlencoded', + 'Referer': 'https://seller.kongfz.com/', + 'Origin': 'https://seller.kongfz.com' + }, + success: (res) => { + console.log("处理后的res", res) + if (res.statusCode !== 200) { + reject(new Error(`HTTP错误: ${res.statusCode}`)); + return; + } + + const data = res.data; + if (res.statusCode === 200 && data.status === 1) { + // 保存新商品ID到本地存储，同时保存对应的旧商品ID + if (data.data) { + try { + const newId = String(data.data); // 确保newId为字符串 + const oldId = String(formData.itemId); // 确保oldId为字符串 + + // 严格校验oldId和newId都不为空 + const existingNewIds = uni.getStorageSync('kongfz_new_ids') || []; + const newIds = Array.isArray(existingNewIds) ? existingNewIds : []; + if (oldId && newId && oldId.trim() !== '' && newId.trim() !== '') { + newIds.push({ + oldId: oldId, + newId: newId, + createTime: new Date().toISOString() + }); + uni.setStorageSync('kongfz_new_ids', newIds); + console.log('新商品ID已保存:', newId, '对应旧ID:', oldId); + console.log('存储的ids', newIds); + } else { + console.warn('跳过保存无效的商品ID:', { + oldId, + newId + }); + } + } catch (e) { + console.error('保存新商品ID失败:', e); + } + } + resolve(true); + } else { + resolve(false); + } + }, + fail: (err) => { + reject(new Error(`提交表单失败: ${err.errMsg}`)); + } + }); + }); +} + +/** + * 批量更新孔网平台商品ID + * @param {Array} items - 商品ID对应关系数组，格式：[{oldPlatformId: "旧ID", newPlatformId: "新ID"}] + * @returns {Promise<{success: boolean, message: string}>} - 处理结果 + */ +export function batchUpdatePddPlatformId(items) { + return new Promise((resolve, reject) => { + if (!items || !Array.isArray(items) || items.length === 0) { + resolve({ + success: false, + message: '请提供有效的商品ID对应关系' + }); + return; + } + + const url = 'https://api.buzhiyushu.cn/zhishu/shopGoodsPublished/batchUpdateKfzPlatformId'; + + uni.request({ + url: url, + method: 'POST', + data: items, + header: { + 'Content-Type': 'application/json' + }, + success: (res) => { + if (res.statusCode === 200) { + const data = res.data; + if (data.code === 200) { + resolve({ + success: true, + message: data.msg || '操作成功' + }); + } else { + resolve({ + success: false, + message: data.msg || '操作失败' + }); + } + } else { + resolve({ + success: false, + message: `HTTP错误: ${res.statusCode}` + }); + } + }, + fail: (err) => { + reject(new Error(`请求失败: ${err.errMsg}`)); + } + }); + }); +} + +/** + * 删除商品 + * @param {string} token - 登录令牌 + * @param {string} itemId - 商品ID + * @returns {Promise} - 是否成功 + */ +export function deleteItem(token, itemId) { + return new Promise((resolve, reject) => { + if (!token) { + reject(new Error('请先登录获取Token')); + return; + } + + const url = 'https://seller.kongfz.com/pc-gw/book-manage-service/client/pc/goods/quickUpdate'; + + // 准备JSON数据 + const payload = { + "itemId": String(itemId), + "updateType": "delete", + "value": "1" + }; + + uni.request({ + url: url, + method: 'POST', + data: payload, + header: { + 'Cookie': `PHPSESSID=${token}`, + // 'User-Agent' 头在浏览器环境中无法设置，会被拒绝 + 'Content-Type': 'application/json; charset=UTF-8', + 'Referer': 'https://seller.kongfz.com/', + 'Origin': 'https://seller.kongfz.com' + }, + success: (res) => { + console.log("delect", res) + if (res.statusCode !== 200) { + reject(new Error(`HTTP错误: ${res.statusCode}`)); + return; + } + + const result = res.data; + if (result.status === true || result.status === 1) { + resolve(true); + } else { + resolve(false); + } + }, + fail: (err) => { + reject(new Error(`删除商品时出错: ${err.errMsg}`)); + } + }); + }); +} \ No newline at end of file diff --git a/components/BookConditionSelect.vue b/components/BookConditionSelect.vue new file mode 100644 index 0000000..90bfcb5 --- /dev/null +++ b/components/BookConditionSelect.vue @@ -0,0 +1,247 @@ + + + + + \ No newline at end of file diff --git a/components/BookFilterDisplay.vue b/components/BookFilterDisplay.vue new file mode 100644 index 0000000..6b3c712 --- /dev/null +++ b/components/BookFilterDisplay.vue @@ -0,0 +1,552 @@ + + + + + \ No newline at end of file diff --git a/components/BookProductList.vue b/components/BookProductList.vue new file mode 100644 index 0000000..3ff4cef --- /dev/null +++ b/components/BookProductList.vue @@ -0,0 +1,865 @@ + + + + + \ No newline at end of file diff --git a/components/CameraUpload.vue b/components/CameraUpload.vue new file mode 100644 index 0000000..a3fb778 --- /dev/null +++ b/components/CameraUpload.vue @@ -0,0 +1,681 @@ + + + + + \ No newline at end of file diff --git a/components/CategoryDropdown.vue b/components/CategoryDropdown.vue new file mode 100644 index 0000000..8747043 --- /dev/null +++ b/components/CategoryDropdown.vue @@ -0,0 +1,338 @@ + + + + + + \ No newline at end of file diff --git a/components/FormInput.vue b/components/FormInput.vue new file mode 100644 index 0000000..a3de53d --- /dev/null +++ b/components/FormInput.vue @@ -0,0 +1,71 @@ + + + + + \ No newline at end of file diff --git a/components/LocationPicker.vue b/components/LocationPicker.vue new file mode 100644 index 0000000..5e9d04a --- /dev/null +++ b/components/LocationPicker.vue @@ -0,0 +1,112 @@ + + + + + \ No newline at end of file diff --git a/components/MemberBookCheck.js b/components/MemberBookCheck.js new file mode 100644 index 0000000..06b0eb3 --- /dev/null +++ b/components/MemberBookCheck.js @@ -0,0 +1,892 @@ +/** + * 获取用户业务信息的公共方法 + * @param {Number} userId - 用户ID + * @returns {Promise} - 返回Promise，包含请求结果 + */ +export const getUserRecbusiness = async (userId) => { + const [err, response] = await uni.request({ + // url: 'https://newadmin.buzhiyushu.cn/settledMember/record/queryMemberBooksCount', + url: 'https://go.order.service.buzhiyushu.cn/api/user/getUserRecbusiness', + // method: 'POST', + method: 'GET', + data: { + userId: userId // 确保转换为数字类型 + }, + header: { + 'Content-Type': 'application/x-www-form-urlencoded' + } + }); + + // console.log('查询会员书籍数量结果:', response); + + // 检查是否有错误 + if (err) { + throw err; + } + + return response; +}; + +/** + * 检查孔网翻新会员状态的公共方法 + * @param {Number} userId - 用户ID + * @returns {Promise} - 返回Promise，包含请求结果 + */ +export const checkKwfwMemberStatus = async (userId) => { + const res = await uni.request({ + url: 'https://go.order.service.buzhiyushu.cn/api/orders/checkStatus', + method: 'POST', + header: { + 'Content-Type': 'application/x-www-form-urlencoded' + }, + data: { + userId: userId, + type: 3 + } + }); + + console.log('查询孔网翻新会员结果:', res); + return res[1] || res; // 兼容数组结构（H5/小程序不同返回） +}; + +/** + * 检查用户是否可以上传书籍 + * @param {Object} options - 配置选项 + * @param {Boolean} options.showToast - 是否显示未登录提示，默认为true + * @param {Boolean} options.showModal - 是否显示上传达到上限的提示，默认为true + * @param {String} options.modalTitle - 提示弹窗的标题，默认为"提示" + * @param {String} options.rechargeUrl - 充值页面的URL，默认为"/pages/user/recharge" + * @returns {Promise} - 返回Promise，resolve为true表示可以上传，false表示不可上传 + */ +export const checkMemberBooksCount = async (options = {}) => { + // 默认选项 + const defaultOptions = { + showToast: true, + showModal: true, + modalTitle: '提示', + rechargeUrl: '/pages/user/recharge', + amount: 1 // 默认充值金额，单位元 + }; + + // 合并选项 + const mergedOptions = { + ...defaultOptions, + ...options + }; + + try { + // 获取用户ID + const userId = uni.getStorageSync('userId'); + console.log('获取到的userId:', userId); + + // 检查用户是否已登录 + if (!userId) { + if (mergedOptions.showToast) { + uni.showToast({ + title: '用户未登录，请先登录', + icon: 'none', + duration: 2500 + }); + } + return false; + } + + // 调用查询接口 + const response = await getUserRecbusiness(userId); + console.log("响应",response) + // 判断接口返回值 + if (response.statusCode === 200 && response.data.data.isVip === false) { + // 如果返回false，提示用户去充值 + if (mergedOptions.showModal) { + return new Promise((resolve) => { + uni.showModal({ + title: mergedOptions.modalTitle, + content: '您的上传数量已达上限，请充值后继续使用', + confirmText: '去充值', + cancelText: '取消', + success: (res) => { + if (res.confirm) { + // 跳转到会员选择页面，指定只显示xcx上书会员 + uni.navigateTo({ + url: '/pages/user/memberSelect?from=memberCheck&type=xcx' + }); + + // 返回一个Promise，在用户返回时重新检查 + return new Promise((resolve) => { + // 设置一个全局回调函数，供会员选择页面调用 + getApp().memberSelectCallback = (success) => { + if (success) { + // 充值成功，重新检查权限 + checkMemberBooksCount(mergedOptions) + .then(canUpload => { + if (canUpload) { + uni.showToast({ + title: '现在您可以上传书籍了', + icon: 'success', + duration: 2000 + }); + resolve(true); + } else { + resolve(false); + } + }); + } else { + resolve(false); + } + }; + }); + } else { + // 用户取消，返回false表示不能上传 + resolve(false); + } + } + }); + }); + } + return false; + } + + // 如果返回true，表示可以上传 + return true; + } catch (error) { + console.error('查询会员书籍数量失败:', error); + // 接口调用失败时，默认允许上传，避免阻断用户使用 + return true; + } +}; + +// 保存当前的settledId，用于支付通知 +let currentSettledId = null; + +/** + * 调用微信支付 + * @param {Number} amount - 充值金额 + * @param {Number} settledId - 会员等级ID + * @param {String} paymentType - 支付类型，'normal' 为普通会员，'kwfw' 为孔网翻新会员 + * @param {String} orderId - 订单id + * @returns {Promise} - 返回支付结果 + */ +export const callWxPay = async (amount, settledId, paymentType = 'normal', orderId) => { + try { + // 保存settledId到模块变量，供后续调用使用 + currentSettledId = settledId; + console.log('当前的settledId1:', currentSettledId); + // 获取用户openid + const openid = uni.getStorageSync('openId'); + if (!openid) { + throw new Error('未获取到openid'); + } + + // 获取用户ID + const userId = uni.getStorageSync('userId'); + if (!userId) { + throw new Error('未获取到userId'); + } + + // 构造支付请求参数 + const payData = { + openid: openid, + taskId: userId, // 使用用户ID作为任务ID + total: amount * 1, // 金额转为分 + totalStr: amount.toString(), + description: `充值金额:${amount}元`, + settledId: settledId + }; + + console.log('发起支付请求参数:', payData); + + // 调用后端支付接口 + const [err, res] = await uni.request({ + url: 'https://api.buzhiyushu.cn/xcx/jsapiPay', + method: 'POST', + data: payData, + header: { + 'Content-Type': 'application/json' + } + }); + + if (err) { + throw err; + } + + console.log('支付接口返回:', res); + + if (res.statusCode === 200 && res.data.code === 200) { + // 获取支付参数 + const payParams = res.data.data; + console.log('支付参数:', payParams); + console.log('支付参数完整数据:', JSON.stringify(payParams)); + + // 调起微信支付 + return new Promise((resolve) => { + // 在小程序环境中使用wx.requestPayment + wx.requestPayment({ + appId: payParams.appId, + timeStamp: payParams.timeStamp, + nonceStr: payParams.nonceStr, + package: payParams.package, + signType: 'RSA', + paySign: payParams.paySign, + success: function(res) { + console.log('支付成功', res); + // 支付成功后，调用订单查询接口确认支付状态 + checkPayStatus(payParams.outTradeNo, currentSettledId, paymentType, + orderId).then(orderResult => { + if (orderResult.success) { + resolve({ + success: true, + data: res, + orderResult + }); + } else { + resolve({ + success: false, + error: '支付状态确认失败' + }); + } + }).catch(err => { + console.error('订单查询失败', err); + // 即使订单查询失败，也认为支付成功，因为用户已经完成了支付流程 + resolve({ + success: true, + data: res, + orderQueryFailed: true + }); + }); + }, + fail: function(err) { + console.error('支付失败', err); + resolve({ + success: false, + error: err + }); + }, + complete: function(res) { + console.log('支付完成', res); + } + }); + }); + } else { + throw new Error(res.data.msg || '支付接口调用失败'); + } + } catch (error) { + console.error('微信支付失败:', error); + uni.showToast({ + title: '支付失败:' + error.message, + icon: 'none' + }); + return { + success: false, + error + }; + } +}; + +/** + * 查询支付订单状态 + * @param {String} outTradeNo - 商户订单号 + * @param {Number} [settledId] - 会员等级ID，可选 + * @param {String} paymentType - 支付类型，'normal' 为普通会员，'kwfw' 为孔网翻新会员 + * @returns {Promise} - 返回订单查询结果 + */ +export const checkPayStatus = async (outTradeNo, currentSettledId, paymentType = 'normal', orderId) => { + try { + console.log('查询订单号:', outTradeNo); // 添加日志确认订单号 + console.log('当前的settledId2:', currentSettledId); + console.log("订单号", orderId); + // 如果未提供settledId参数，使用模块变量 + const finalSettledId = currentSettledId; + if (finalSettledId) { + console.log('使用会员等级ID:', finalSettledId); + } + + const [err, res] = await uni.request({ + url: 'https://api.buzhiyushu.cn/xcx/queryOrder', + method: 'POST', + data: { + outTradeNo: outTradeNo + }, + header: { + 'Content-Type': 'application/json' + } + }); + + if (err) { + throw err; + } + + console.log('订单查询结果:', res); + + if (res.statusCode === 200 && res.data.code === 200) { + // 根据支付类型执行不同的处理逻辑 + if (paymentType === 'normal') { + // 普通会员支付：调用通知接口保存支付记录 + try { + 获取用户ID + const userId = uni.getStorageSync('userId'); + + // 准备通知数据 + const notifyData = { + ...res.data.data, // 将查询到的订单数据传递给通知接口 + userId: userId // 添加用户ID + }; + + // 如果有会员等级ID，添加到通知数据中 + if (finalSettledId) { + notifyData.settledId = finalSettledId; + console.log('添加会员等级ID到通知数据:', finalSettledId); + } + console.log("当前的settledId3:", notifyData.settledId); + console.log("通知数据:", notifyData); + + const [notifyErr, notifyRes] = await uni.request({ + url: 'https://newadmin.buzhiyushu.cn/wechatPay/notification', + method: 'POST', + data: notifyData, + header: { + 'Content-Type': 'application/json' + } + }); + + if (notifyErr) { + console.error('保存支付记录失败:', notifyErr); + } else { + console.log('保存支付记录结果:', notifyRes); + } + } catch (notifyError) { + console.error('调用支付通知接口失败:', notifyError); + } + } + + return { + success: true, + data: res.data.data, + isPaid: res.data.data.trade_state === 'SUCCESS' + }; + } else { + return { + success: false, + error: res.data.msg || '订单查询失败' + }; + } + } catch (error) { + console.error('查询订单状态失败:', error); + return { + success: false, + error + }; + } +}; + +/** + * 获取会员等级列表 + * @returns {Promise} - 返回会员等级列表 + */ +export const getMemberLevelList = async () => { + try { + const [err, res] = await uni.request({ + url: 'https://newadmin.buzhiyushu.cn/settledCostConfig/list', + // url: 'http://localhost:8089/settledCostConfig/list', + method: 'GET', + header: { + 'Content-Type': 'application/json' + } + }); + + if (err) { + throw err; + } + + console.log('获取会员等级列表结果:', res); + + if (res.data.code === 200 && res.data.data && res.data.data.length > 0) { + return res.data.data; + } else { + throw new Error('获取会员等级列表失败'); + } + } catch (error) { + console.error('获取会员等级列表失败:', error); + throw error; + } +}; + +/** + * 显示会员等级选择器 + * @param {Array} levelList - 会员等级列表 + * @returns {Promise} - 返回用户选择的会员等级 + */ +export const showMemberLevelSelector = (levelList) => { + return new Promise((resolve) => { + // 构建选择项 + const items = levelList.map(level => ({ + text: `${level.name || '会员等级'} (${level.price}元)`, + value: level + })); + + // 显示操作菜单让用户选择 + uni.showActionSheet({ + itemList: items.map(item => item.text), + success: function(res) { + const selectedIndex = res.tapIndex; + if (selectedIndex >= 0 && selectedIndex < items.length) { + resolve(items[selectedIndex].value); + } else { + resolve(null); + } + }, + fail: function() { + resolve(null); // 用户取消选择 + } + }); + }); +}; + +/** + * 检查用户是否为孔网翻新会员 + * @param {Object} options - 配置选项 + * @param {Boolean} options.showToast - 是否显示未登录提示，默认为true + * @param {Boolean} options.showModal - 是否显示非会员提示，默认为true + * @param {String} options.modalTitle - 提示弹窗的标题，默认为"提示" + * @returns {Promise} - 返回Promise，resolve为true表示是会员，false表示不是会员 + */ +export const checkKwfwMember = async (options = {}) => { + const defaultOptions = { + showToast: true, + showModal: true, + modalTitle: '提示' + }; + + const mergedOptions = { ...defaultOptions, ...options }; + + try { + const userId = uni.getStorageSync('userId'); + console.log('检查孔网翻新会员，获取到的userId:', userId); + + if (!userId) { + if (mergedOptions.showToast) { + uni.showToast({ + title: '用户未登录，请先登录', + icon: 'none', + duration: 2500 + }); + } + return false; + } + + // ✅ 调用公共方法 + let response; + try { + response = await checkKwfwMemberStatus(userId); + } catch (err) { + console.error('请求出错:', err); + throw err; + } + + // ✅ 确保返回结构存在 + if (!response || !response.data) { + throw new Error('接口调用失败'); + } + + const { code, data, message } = response.data; + console.log('会员检查结果:', code, data); + + // ✅ 1. 情况一：接口返回用户不存在 + if (code === 40001) { + return await handleNotMemberModal(mergedOptions); + } + + // ✅ 2. 情况二：接口正常返回，但 isVip 为 false + if (code === 200 && data && data.isVip === false) { + return await handleNotMemberModal(mergedOptions); + } + + // ✅ 3. 情况三：是会员 + if (code === 200 && data && data.isVip === true) { + console.log('当前用户是孔网翻新会员 ✅'); + return true; + } + + // 其他异常情况 + console.warn('接口返回未知状态:', code, message); + return false; + + } catch (error) { + console.error('查询孔网翻新会员失败:', error); + if (mergedOptions.showToast) { + uni.showToast({ + title: '网络错误，请稍后重试', + icon: 'none' + }); + } + return false; + } +}; + +// ✅ 单独提取弹窗逻辑，便于多处调用 +const handleNotMemberModal = (mergedOptions) => { + return new Promise((resolve) => { + if (!mergedOptions.showModal) return resolve(false); + + uni.showModal({ + title: mergedOptions.modalTitle, + content: '您还不是孔网翻新会员，需要开通会员才能使用此功能', + confirmText: '开通会员', + cancelText: '取消', + success: (res) => { + if (res.confirm) { + uni.navigateTo({ + url: '/pages/user/memberSelect?from=kwfw&type=kwfw' + }); + + getApp().kwfwMemberCallback = (success) => { + if (success) { + checkKwfwMember(mergedOptions).then((isMember) => { + if (isMember) { + uni.showToast({ + title: '开通成功，现在您可以使用孔网翻新功能了', + icon: 'success', + duration: 2000 + }); + resolve(true); + } else { + resolve(false); + } + }); + } else { + resolve(false); + } + }; + } else { + resolve(false); + } + } + }); + }); +}; + + + +/** + * 孔网翻新会员订单插入接口（预留） + * @param {Object} orderData - 订单数据 + * @returns {Promise} - 返回订单插入结果 + */ +/** + * 支付前插入孔网翻新会员订单记录（预留接口） + * @param {Object} orderData 订单数据 + * @returns {Object} 插入结果，包含orderId + */ +export const createKwfwMemberOrder = async (orderData) => { + try { + console.log('支付前创建孔网翻新会员订单:', orderData); + + // 获取并验证用户ID + let userId = orderData.userId || uni.getStorageSync('userId'); + if (!userId || userId === 'undefined') { + console.error('用户未登录或userId无效'); + return { + success: false, + error: '用户未登录，请先登录' + }; + } + + // 第一步：创建服务 + // 确保所有参数都有有效值 + const serviceName = orderData.serviceName || 'xcx翻新会员'; + const price = orderData.originalPrice || orderData.price || '1'; + const unit = orderData.unit || '月'; + const length = orderData.length || '1'; + const sort = orderData.sort || '1' + let vipType = ''; + if (orderData.memberType == 'kwfw') { + vipType = 'xcxRenovate'; + } else { + vipType = 'xcxLetter'; + }; + const createServiceData = { + service_name: String(serviceName), + price: String(price), + unit: String(unit), + length: String(length), + type: String(vipType), + sort: String(sort) + }; + console.log('createServiceData:', createServiceData); + + // 验证所有必需参数 + if (!createServiceData.service_name || createServiceData.service_name === 'undefined' || + !createServiceData.price || createServiceData.price === 'undefined' || + !createServiceData.unit || createServiceData.unit === 'undefined' || + !createServiceData.length || createServiceData.length === 'undefined') { + console.error('参数验证失败:', createServiceData); + return { + success: false, + error: '参数不完整，请检查orderData中的serviceName、originalPrice、unit、length字段' + }; + } + + const [serviceErr, serviceResponse] = await uni.request({ + url: 'https://go.order.service.buzhiyushu.cn/api/createService', + method: 'POST', + data: createServiceData, + header: { + 'Content-Type': 'application/x-www-form-urlencoded' + } + }); + + if (serviceErr) { + console.error('创建服务失败:', serviceErr); + return { + success: false, + error: '创建服务失败: ' + serviceErr.errMsg + }; + } + + console.log('创建服务成功:', serviceResponse); + const serviceId = serviceResponse.data.data + if (!serviceId) { + console.error('服务创建成功但未返回服务ID'); + return { + success: false, + error: '服务创建成功但未返回服务ID' + }; + } + + // 第二步：创建订单 + const createOrderData = { + orderType: String(vipType), + userId: String(userId), + goodsId: String(serviceId), + count: String(1), + note: orderData.note || '孔网翻新会员订单' + }; + console.log('createOrderData:', createOrderData); + const [orderErr, orderResponse] = await uni.request({ + url: 'https://go.order.service.buzhiyushu.cn/api/orders/createOrder', + method: 'POST', + data: createOrderData, + header: { + 'Content-Type': 'application/x-www-form-urlencoded' + // 'Content-Type': 'multipart/form-data' + } + }); + + if (orderErr) { + console.error('创建订单失败:', orderErr); + return { + success: false, + error: '创建订单失败: ' + orderErr.errMsg + }; + } + + console.log('创建订单成功:', orderResponse.data); + const orderId = orderResponse.data.data + + if (!orderId) { + console.error('订单创建成功但未返回订单ID'); + return { + success: false, + error: '订单创建成功但未返回订单ID' + }; + } + + return { + success: true, + orderId: orderId, + serviceId: serviceId, + message: '订单创建成功', + serviceData: serviceResponse.data, + orderData: orderResponse.data + }; + } catch (error) { + console.error('创建孔网翻新会员订单失败:', error); + return { + success: false, + error: error.message + }; + } +}; + +/** + * 支付后更新孔网翻新会员订单记录 + * @param {String} orderId 订单ID + * @param {Object} payResult 支付结果 + * @returns {Object} 更新结果 + */ +export const updateKwfwMemberOrder = async (orderId, payResult, userId) => { + try { + console.log('支付后更新孔网翻新会员订单:', { + orderId, + payResult, + userId + }); + // orderId 参数已经是实际的订单ID数字，不需要再次提取 + const actualOrderId = String(orderId) + console.log("actualOrderId", actualOrderId) + + // 调用订单更新接口 + const [err, response] = await uni.request({ + url: 'https://go.order.service.buzhiyushu.cn/api/orders/orderForPay', + method: 'POST', + data: { + orderId: String(actualOrderId), + orderInfo: JSON.stringify(payResult), + userId: String(userId), + }, + header: { + 'Content-Type': 'application/x-www-form-urlencoded' + } + }); + + if (err) { + console.error('更新订单失败:', err); + return { + success: false, + error: '更新订单失败: ' + err.errMsg + }; + } + + console.log('订单更新接口返回:', response); + + if (response.statusCode === 200) { + return { + success: true, + message: '订单更新成功', + data: response.data + }; + } else { + return { + success: false, + error: '订单更新失败: ' + (response.data?.message || '未知错误') + }; + } + } catch (error) { + console.error('更新孔网翻新会员订单失败:', error); + return { + success: false, + error: error.message + }; + } +}; + +/** + * 更新用户书籍数量限制 + * @param {Object} payResult 支付结果 + * @param {String} orderId 订单ID + * @param {String} userId 用户ID + * @param {String} settledId 会员等级ID + * @returns {Promise} 返回更新结果 + */ +export const updateUserBooksCountLimit = async (payResult, orderId, userId, settledId) => { + try { + console.log('更新用户书籍数量限制:', { + payResult, + orderId, + userId, + settledId + }); + + // 调用后端接口更新用户书籍数量限制 + const [err, response] = await uni.request({ + url: 'https://newadmin.buzhiyushu.cn/updateUserBooksCountLimit', + method: 'POST', + data: { + payResult: JSON.stringify(payResult), + orderId: orderId, + userId: userId, + settledId: settledId + }, + header: { + 'Content-Type': 'application/x-www-form-urlencoded' + } + }); + + if (err) { + console.error('更新用户书籍数量限制失败:', err); + return { + success: false, + error: '更新用户书籍数量限制失败: ' + err.errMsg + }; + } + + console.log('更新用户书籍数量限制接口返回:', response); + + if (response.statusCode === 200 && response.data.code === 200) { + return { + success: true, + message: '用户书籍数量限制更新成功', + data: response.data.data + }; + } else { + return { + success: false, + error: '更新用户书籍数量限制失败: ' + (response.data?.msg || '未知错误') + }; + } + } catch (error) { + console.error('更新用户书籍数量限制失败:', error); + return { + success: false, + error: error.message + }; + } +}; + +/** + * 获取所有服务列表 + * @param {String} type - 服务类型 + * @returns {Promise} - 返回服务列表 + */ +export const getAllServices = async (type) => { + try { + const [err, response] = await uni.request({ + url: 'https://go.order.service.buzhiyushu.cn/api/getAllServices', + method: 'POST', + data: { + type: type + }, + header: { + 'Content-Type': 'application/json' + } + }); + + if (err) { + throw err; + } + + console.log('获取所有服务列表结果:', response); + + // 检查响应状态 + if (response.statusCode === 200 && response.data.code === 200) { + return { + success: true, + data: response.data.data, + message: response.data.message + }; + } else { + throw new Error(response.data.message || '获取服务列表失败'); + } + } catch (error) { + console.error('获取所有服务列表失败:', error); + return { + success: false, + error: error.message || '网络请求失败' + }; + } +}; + + +export default { + getUserRecbusiness, + checkKwfwMemberStatus, + checkMemberBooksCount, + callWxPay, + checkPayStatus, + getMemberLevelList, + showMemberLevelSelector, + checkKwfwMember, + createKwfwMemberOrder, + updateKwfwMemberOrder, + updateUserBooksCountLimit, + getAllServices +}; \ No newline at end of file diff --git a/components/PriceComparison.vue b/components/PriceComparison.vue new file mode 100644 index 0000000..87ef85e --- /dev/null +++ b/components/PriceComparison.vue @@ -0,0 +1,716 @@ + + + + + \ No newline at end of file diff --git a/components/PriceStockControl.vue b/components/PriceStockControl.vue new file mode 100644 index 0000000..ebb07ea --- /dev/null +++ b/components/PriceStockControl.vue @@ -0,0 +1,227 @@ + + + + + \ No newline at end of file diff --git a/components/StoragePicker.vue b/components/StoragePicker.vue new file mode 100644 index 0000000..2ab8f43 --- /dev/null +++ b/components/StoragePicker.vue @@ -0,0 +1,235 @@ + + + + + \ No newline at end of file diff --git a/components/TabBar.vue b/components/TabBar.vue new file mode 100644 index 0000000..a5f80c5 --- /dev/null +++ b/components/TabBar.vue @@ -0,0 +1,47 @@ + + + + + \ No newline at end of file diff --git a/components/WarehouserSelector.vue b/components/WarehouserSelector.vue new file mode 100644 index 0000000..17786f1 --- /dev/null +++ b/components/WarehouserSelector.vue @@ -0,0 +1,508 @@ + + + + + + \ No newline at end of file diff --git a/index.html b/index.html new file mode 100644 index 0000000..c3ff205 --- /dev/null +++ b/index.html @@ -0,0 +1,20 @@ + + + + + + + + + + +
+ + + diff --git a/main.js b/main.js new file mode 100644 index 0000000..2f50c91 --- /dev/null +++ b/main.js @@ -0,0 +1,22 @@ +import Vue from 'vue' +import App from './App' +import store from './store' +import uniAjax from '@/utils/request.js' +import uView from '@/uni_modules/uview-ui' +import CryptoJS from 'crypto-js' +import share from './static/share' + +Vue.prototype.$http = uniAjax +Vue.prototype.$store = store +Vue.use(uView) +Vue.config.productionTip = false +Vue.mixin(share); + +App.mpType = 'app' + +const app = new Vue({ + store, + ...App, + share +}) +app.$mount() diff --git a/manifest.json b/manifest.json new file mode 100644 index 0000000..bd09619 --- /dev/null +++ b/manifest.json @@ -0,0 +1,45 @@ +{ + "name" : "zhizhu", + "appid" : "__UNI__CAA2B01", + "description" : "", + "versionName" : "1.0.0", + "versionCode" : "100", + "mp-weixin" : { + "appid" : "wx703b8fb6c3da692a", + "setting" : { + "urlCheck" : false, + "es6" : true, + "postcss" : true, + "minified" : true + }, + "usingComponents" : true, + "lazyCodeLoading" : "requiredComponents" + }, + "mp-alipay" : { + // ← 这是支付宝小程序配置 + "usingComponents" : true + }, // ← 最后一个配置项不需要逗号 + "vueOptions" : { + "runtimeCompiler" : true // 确保开启运行时编译 + }, + "request" : { + "domain" : [ + "`https://api.buzhiyushu.cn" // 替换为你后端项目的域名或 IP 地址 + ] + }, + "app-plus" : { + "modules" : { + "OAuth" : {} + }, + "distribute" : { + "sdkConfigs" : { + "oauth" : { + "weixin" : { + "appid" : "wx703b8fb6c3da692a", + "UniversalLinks" : "" + } + } + } + } + } +} diff --git a/node_modules/.bin/detect-libc b/node_modules/.bin/detect-libc new file mode 100644 index 0000000..76becf3 --- /dev/null +++ b/node_modules/.bin/detect-libc @@ -0,0 +1,16 @@ +#!/bin/sh +basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')") + +case `uname` in + *CYGWIN*|*MINGW*|*MSYS*) + if command -v cygpath > /dev/null 2>&1; then + basedir=`cygpath -w "$basedir"` + fi + ;; +esac + +if [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir/../detect-libc/bin/detect-libc.js" "$@" +else + exec node "$basedir/../detect-libc/bin/detect-libc.js" "$@" +fi diff --git a/node_modules/.bin/detect-libc.cmd b/node_modules/.bin/detect-libc.cmd new file mode 100644 index 0000000..1c5d86d --- /dev/null +++ b/node_modules/.bin/detect-libc.cmd @@ -0,0 +1,17 @@ +@ECHO off +GOTO start +:find_dp0 +SET dp0=%~dp0 +EXIT /b +:start +SETLOCAL +CALL :find_dp0 + +IF EXIST "%dp0%\node.exe" ( + SET "_prog=%dp0%\node.exe" +) ELSE ( + SET "_prog=node" + SET PATHEXT=%PATHEXT:;.JS;=;% +) + +endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\detect-libc\bin\detect-libc.js" %* diff --git a/node_modules/.bin/detect-libc.ps1 b/node_modules/.bin/detect-libc.ps1 new file mode 100644 index 0000000..5ebeae1 --- /dev/null +++ b/node_modules/.bin/detect-libc.ps1 @@ -0,0 +1,28 @@ +#!/usr/bin/env pwsh +$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent + +$exe="" +if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) { + # Fix case when both the Windows and Linux builds of Node + # are installed in the same directory + $exe=".exe" +} +$ret=0 +if (Test-Path "$basedir/node$exe") { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & "$basedir/node$exe" "$basedir/../detect-libc/bin/detect-libc.js" $args + } else { + & "$basedir/node$exe" "$basedir/../detect-libc/bin/detect-libc.js" $args + } + $ret=$LASTEXITCODE +} else { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & "node$exe" "$basedir/../detect-libc/bin/detect-libc.js" $args + } else { + & "node$exe" "$basedir/../detect-libc/bin/detect-libc.js" $args + } + $ret=$LASTEXITCODE +} +exit $ret diff --git a/node_modules/.bin/sass b/node_modules/.bin/sass new file mode 100644 index 0000000..dde8400 --- /dev/null +++ b/node_modules/.bin/sass @@ -0,0 +1,16 @@ +#!/bin/sh +basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')") + +case `uname` in + *CYGWIN*|*MINGW*|*MSYS*) + if command -v cygpath > /dev/null 2>&1; then + basedir=`cygpath -w "$basedir"` + fi + ;; +esac + +if [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir/../sass/sass.js" "$@" +else + exec node "$basedir/../sass/sass.js" "$@" +fi diff --git a/node_modules/.bin/sass.cmd b/node_modules/.bin/sass.cmd new file mode 100644 index 0000000..0cf95f6 --- /dev/null +++ b/node_modules/.bin/sass.cmd @@ -0,0 +1,17 @@ +@ECHO off +GOTO start +:find_dp0 +SET dp0=%~dp0 +EXIT /b +:start +SETLOCAL +CALL :find_dp0 + +IF EXIST "%dp0%\node.exe" ( + SET "_prog=%dp0%\node.exe" +) ELSE ( + SET "_prog=node" + SET PATHEXT=%PATHEXT:;.JS;=;% +) + +endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\sass\sass.js" %* diff --git a/node_modules/.bin/sass.ps1 b/node_modules/.bin/sass.ps1 new file mode 100644 index 0000000..715ffd5 --- /dev/null +++ b/node_modules/.bin/sass.ps1 @@ -0,0 +1,28 @@ +#!/usr/bin/env pwsh +$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent + +$exe="" +if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) { + # Fix case when both the Windows and Linux builds of Node + # are installed in the same directory + $exe=".exe" +} +$ret=0 +if (Test-Path "$basedir/node$exe") { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & "$basedir/node$exe" "$basedir/../sass/sass.js" $args + } else { + & "$basedir/node$exe" "$basedir/../sass/sass.js" $args + } + $ret=$LASTEXITCODE +} else { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & "node$exe" "$basedir/../sass/sass.js" $args + } else { + & "node$exe" "$basedir/../sass/sass.js" $args + } + $ret=$LASTEXITCODE +} +exit $ret diff --git a/node_modules/.package-lock.json b/node_modules/.package-lock.json new file mode 100644 index 0000000..f9cd9e8 --- /dev/null +++ b/node_modules/.package-lock.json @@ -0,0 +1,282 @@ +{ + "name": "zhizhu", + "lockfileVersion": 3, + "requires": true, + "packages": { + "node_modules/@dcloudio/uni-ui": { + "version": "1.5.7", + "resolved": "https://registry.npmjs.org/@dcloudio/uni-ui/-/uni-ui-1.5.7.tgz", + "integrity": "sha512-DugxSIrQrze1FLdUOj9a+JEQ0bHGjnJTcGUK1mN/MivKg7nuKJBRWk5Ipa9sUdoBznX6ndz5h2e7Uao6x1CdCw==", + "license": "Apache-2.0" + }, + "node_modules/@parcel/watcher": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/@parcel/watcher/-/watcher-2.5.1.tgz", + "integrity": "sha512-dfUnCxiN9H4ap84DvD2ubjw+3vUNpstxa0TneY/Paat8a3R4uQZDLSvWjmznAY/DoahqTHl9V46HF/Zs3F29pg==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "dependencies": { + "detect-libc": "^1.0.3", + "is-glob": "^4.0.3", + "micromatch": "^4.0.5", + "node-addon-api": "^7.0.0" + }, + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + }, + "optionalDependencies": { + "@parcel/watcher-android-arm64": "2.5.1", + "@parcel/watcher-darwin-arm64": "2.5.1", + "@parcel/watcher-darwin-x64": "2.5.1", + "@parcel/watcher-freebsd-x64": "2.5.1", + "@parcel/watcher-linux-arm-glibc": "2.5.1", + "@parcel/watcher-linux-arm-musl": "2.5.1", + "@parcel/watcher-linux-arm64-glibc": "2.5.1", + "@parcel/watcher-linux-arm64-musl": "2.5.1", + "@parcel/watcher-linux-x64-glibc": "2.5.1", + "@parcel/watcher-linux-x64-musl": "2.5.1", + "@parcel/watcher-win32-arm64": "2.5.1", + "@parcel/watcher-win32-ia32": "2.5.1", + "@parcel/watcher-win32-x64": "2.5.1" + } + }, + "node_modules/@parcel/watcher-win32-x64": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/@parcel/watcher-win32-x64/-/watcher-win32-x64-2.5.1.tgz", + "integrity": "sha512-9lHBdJITeNR++EvSQVUcaZoWupyHfXe1jZvGZ06O/5MflPcuPLtEphScIBL+AiCWBO46tDSHzWyD0uDmmZqsgA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/braces": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "fill-range": "^7.1.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/chokidar": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz", + "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==", + "dev": true, + "license": "MIT", + "dependencies": { + "readdirp": "^4.0.1" + }, + "engines": { + "node": ">= 14.16.0" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/crypto-js": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/crypto-js/-/crypto-js-4.2.0.tgz", + "integrity": "sha512-KALDyEYgpY+Rlob/iriUtjV6d5Eq+Y191A5g4UqLAi8CyGP9N1+FdVbkc1SxKc2r4YAYqG8JzO2KGL+AizD70Q==", + "license": "MIT" + }, + "node_modules/detect-libc": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-1.0.3.tgz", + "integrity": "sha512-pGjwhsmsp4kL2RTz08wcOlGN83otlqHeD/Z5T8GXZB+/YcpQ/dgo+lbU8ZsGxV0HIvqqxo9l7mqYwyYMD9bKDg==", + "dev": true, + "license": "Apache-2.0", + "optional": true, + "bin": { + "detect-libc": "bin/detect-libc.js" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/fill-range": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/immutable": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/immutable/-/immutable-5.1.1.tgz", + "integrity": "sha512-3jatXi9ObIsPGr3N5hGw/vWWcTkq6hUYhpQz4k0wLC+owqWi/LiugIw9x0EdNZ2yGedKN/HzePiBvaJRXa0Ujg==", + "dev": true, + "license": "MIT" + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "license": "MIT", + "optional": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true, + "license": "MIT", + "optional": true, + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/micromatch": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "braces": "^3.0.3", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/node-addon-api": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-7.1.1.tgz", + "integrity": "sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==", + "dev": true, + "license": "MIT", + "optional": true + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "license": "MIT", + "optional": true, + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/readdirp": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz", + "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 14.18.0" + }, + "funding": { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/sass": { + "version": "1.86.3", + "resolved": "https://registry.npmjs.org/sass/-/sass-1.86.3.tgz", + "integrity": "sha512-iGtg8kus4GrsGLRDLRBRHY9dNVA78ZaS7xr01cWnS7PEMQyFtTqBiyCrfpTYTZXRWM94akzckYjh8oADfFNTzw==", + "dev": true, + "license": "MIT", + "dependencies": { + "chokidar": "^4.0.0", + "immutable": "^5.0.2", + "source-map-js": ">=0.6.2 <2.0.0" + }, + "bin": { + "sass": "sass.js" + }, + "engines": { + "node": ">=14.0.0" + }, + "optionalDependencies": { + "@parcel/watcher": "^2.4.1" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/uview-ui": { + "version": "2.0.38", + "resolved": "https://registry.npmjs.org/uview-ui/-/uview-ui-2.0.38.tgz", + "integrity": "sha512-6egHDf9lXHKpG3hEjRE0vMx4+VWwKk/ReTf5x18KrIKqdvdPRqO3+B8Unh7vYYwrIxzAWIlmhZ9RJpKI/4UqPQ==", + "engines": { + "HBuilderX": "^3.1.0" + } + } + } +} diff --git a/node_modules/@dcloudio/uni-ui/LICENSE b/node_modules/@dcloudio/uni-ui/LICENSE new file mode 100644 index 0000000..7a4a3ea --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. \ No newline at end of file diff --git a/node_modules/@dcloudio/uni-ui/README.md b/node_modules/@dcloudio/uni-ui/README.md new file mode 100644 index 0000000..6928c7b --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/README.md @@ -0,0 +1,245 @@ +### [查看文档](https://uniapp.dcloud.io/component/uniui/uni-transition) +#### 如使用过程中有任何问题，或者您对uni-ui有一些好的建议，欢迎加入 uni-ui 交流群：871950839 + +## uni-ui产品特点 + +### 1. 高性能 + +目前为止，在小程序和混合app领域，暂时还没有比 `uni-ui` 更高性能的框架。 +- 自动差量更新数据 + +虽然uni-app支持小程序自定义组件，所有小程序的ui库都可以用。但小程序自定义组件的ui库都需要使用setData手动更新数据，在大数据量时、或高频更新数据时，很容易产生性能问题。 + +而 `uni-ui` 属于vue组件，uni-app引擎底层自动diff更新数据。当然其实插件市场里众多vue组件都具备这个特点。 +- 优化逻辑层和视图层通讯折损 + +非H5，不管是小程序还是App，不管是app的webview渲染还是原生渲染，全都是逻辑层和视图层分离的。这里就有一个逻辑层和视图层通讯的折损问题。 +比如在视图层拖动一个可跟手的组件，由于通讯的损耗，用js监听很难做到实时跟手。 + +这时就需要使用css动画以及平台底层提供的wxs、bindingx等技术。不过这些技术都比较复杂，所以 `uni-ui` 里做了封装，在需要跟手式操作的ui组件，比如swiperaction列表项左滑菜单，就在底层使用了这些技术，实现了高性能的交互体验 +- 背景停止 + +很多ui组件是会一直动的，比如轮播图、跑马灯。即便这个窗体被新窗体挡住，它在背景层仍然在消耗着硬件资源。在Android的webview版本为chrome66以上，背景操作ui会引发很严重的性能问题，造成前台界面明显卡顿。 + +而 `uni-ui` 的组件，会自动判断自己的显示状态，在组件不再可见时，不会再消耗硬件资源。 + +### 2. 全端 + + `uni-ui` 的组件都是多端自适应的，底层会抹平很多小程序平台的差异或bug。 + +比如导航栏navbar组件，会自动处理不同端的状态栏。 +比如swiperaction组件，在app和微信小程序上会使用交互体验更好的wxs技术，但在不支持wxs的其他小程序端会使用js模拟类似效果。 + + `uni-ui` 还支持nvue原生渲染，[详见](https://github.com/dcloudio/uni-ui/tree/nvue-uni-ui) + +未来 `uni-ui` 还会支持pc等大屏设备。 + +### 3. 与uni统计自动集成实现免打点 + +uni统计是优秀的多端统计平台，见[tongji.dcloud.net.cn](https://tongji.dcloud.net.cn)。 + +除了一张报表看全端，它的另一个重要特点是免打点。 +比如使用 `uni-ui` 的navbar标题栏、收藏、购物车等组件，均可实现自动打点，统计页面标题等各种行为数据。 +当然你也可以关闭uni统计，这不是强制的。 + +### 4. 主题扩展 + + `uni-ui` 支持[uni.scss](https://uniapp.dcloud.io/collocation/uni-scss)，可以方便的切换App的风格。 + +ui是一种需求非常发散的产品，DCloud官方也无意用 `uni-ui` 压制第三方ui插件的空间，但官方有义务在性能和多端方面提供一个开源的标杆给大家。 + +我们欢迎更多优秀的ui组件出现，也欢迎更多人贡献 `uni-ui` 的主题风格，满足更多用户的需求。 + + +# 快速开始 + +## 方式一：使用 uni_modules 安装（推荐） + +使用 `uni_modules` 方式安装组件库，可以直接通过插件市场导入，通过右键菜单快速更新组件，不需要引用、注册，直接在页面中使用 `uni-ui` 组件。[点击安装 uni-ui 组件库](https://ext.dcloud.net.cn/plugin?id=55) + +**注意：下载最新的组件目前仅支持 uni_modules ,非 uni_modules 版本最高支持到组件的1.2.10版本** + +如不能升级到 `uni_modules` 版本，可以使用 `uni_modules` 安装好对应组件，将组件拷贝到对应目录。 + +例如需更新 `uni-list`和`uni-badge` ,将 `uni_modules>uni-list>components`和`uni_modules>uni-badege>components`下所有目录拷贝到如下目录即可： + +**目录示例** +```json {2,3,4,5,6,7} +┌─components 组件目录 +│ ├─uni-list list 列表目录 +│ │ └─uni-list.vue list 组件文件 +│ ├─uni-list-item list-item 列表目录 +│ │ └─uni-list-item.vue list 组件文件 +│ ├─uni-badge badge 角标目录 +│ │ └─uni-badge.vue badge 组件文件 +│ └─ //.... 更多组件文件 +├─pages 业务页面文件存放的目录 +│ ├─index +│ │ └─index.vue index示例页面 +├─main.js Vue初始化入口文件 +├─App.vue 应用配置，用来配置App全局样式以及监听 应用生命周期 +├─manifest.json 配置应用名称、appid、logo、版本等打包信息，详见 +└─pages.json 配置页 + +``` + + +## 方式二：使用 npm 安装 + +在 `vue-cli` 项目中可以使用 `npm` 安装 `uni-ui` 库 ，或者直接在 `HBuilderX` 项目中使用 `npm` 。（不推荐后一种方式） + +> **注意** +> cli 项目默认是不编译 `node_modules` 下的组件的，导致条件编译等功能失效 ，导致组件异常 +> 需要在根目录创建 `vue.config.js` 文件 ，增加 `@dcloudio/uni-ui` 包的编译即可正常 +> ```javascript +> // vue.config.js +> module.exports = { +> transpileDependencies:['@dcloudio/uni-ui'] +> } +> ``` + + + +**准备 sass** + +`vue-cli` 项目请先安装 sass 及 sass-loader，如在 HBuliderX 中使用，可跳过此步。 + +- 安装 sass +``` + npm i sass -D 或 yarn add sass -D +``` + +- 安装 sass-loader +``` +npm i sass-loader@10.1.1 -D 或 yarn add sass-loader@10.1.1 -D +``` + +> sass-loader 请使用低于 @11.0.0 的版本，[sass-loader@11.0.0 不支持 vue@2.6.12 ](https://stackoverflow.com/questions/66082397/typeerror-this-getoptions-is-not-a-function) + + +**安装 uni-ui** + +``` +npm i @dcloudio/uni-ui 或 yarn add @dcloudio/uni-ui +``` + + + +在 ``script`` 中引用组件： + +```javascript +import {uniBadge} from '@dcloudio/uni-ui' +//import uniBadge from '@dcloudio/uni-ui/lib/uni-badge/uni-badge.vue' //也可使用此方式引入组件 +export default { + components: {uniBadge} +} +``` + + +在 ``template`` 中使用组件： + +```html + + + +``` +> **注意** +> - `CLI` 引用方式， `H5` 端不支持在 `main.js` 中全局注册组件，如有需求请使用（[easyCom](https://uniapp.dcloud.io/collocation/pages?id=easycom)） 的方式引用组件 +> - 使用 npm 安装的组件，默认情况下 babel-loader 会忽略所有 node_modules 中的文件 ，导致条件编译失效，需要通过配置 `vue.config.js` 解决： +> ```javascript +> // 在根目录创建 vue.config.js 文件，并配置如下 +> module.exports = { +> transpileDependencies: ['@dcloudio/uni-ui'] +> } +> ``` + + +## 使用 npm + easycom + +使用 `npm` 安装好 `uni-ui` 之后，需要配置 `easycom` 规则，让 `npm` 安装的组件支持 `easycom` + +打开项目根目录下的 `pages.json` 并添加 `easycom` 节点： + +```javascript {8} +// pages.json + +{ + "easycom": { + "autoscan": true, + "custom": { + // uni-ui 规则如下配置 + "^uni-(.*)": "@dcloudio/uni-ui/lib/uni-$1/uni-$1.vue" + } + }, + + // 其他内容 + pages:[ + // ... + ] +} + +``` + +### uni-ui 已支持的组件列表 +|组件名|组件说明| +|---|---| +|uni-badge|[数字角标](https://ext.dcloud.net.cn/plugin?name=uni-badge)| +|uni-breadcrumb|[面包屑](https://ext.dcloud.net.cn/plugin?name=uni-breadcrumb)| +|uni-calendar|[日历](https://ext.dcloud.net.cn/plugin?name=uni-calendar)| +|uni-card|[卡片](https://ext.dcloud.net.cn/plugin?name=uni-card)| +|uni-collapse|[折叠面板](https://ext.dcloud.net.cn/plugin?name=uni-collapse)| +|uni-combox|[组合框](https://ext.dcloud.net.cn/plugin?name=uni-combox)| +|uni-countdown|[倒计时](https://ext.dcloud.net.cn/plugin?name=uni-countdown)| +|uni-data-checkbox|[数据选择器](https://ext.dcloud.net.cn/plugin?name=uni-data-checkbox)| +|uni-data-picker|[数据驱动的picker选择器](https://ext.dcloud.net.cn/plugin?name=uni-data-picker)| +|uni-data-select|[下拉框选择器](https://ext.dcloud.net.cn/plugin?name=uni-data-select)| +|uni-dateformat|[日期格式化](https://ext.dcloud.net.cn/plugin?name=uni-dateformat)| +|uni-datetime-picker|[日期选择器](https://ext.dcloud.net.cn/plugin?name=uni-datetime-picker)| +|uni-drawer|[抽屉](https://ext.dcloud.net.cn/plugin?name=uni-drawer)| +|uni-easyinput|[增强输入框](https://ext.dcloud.net.cn/plugin?name=uni-easyinput)| +|uni-fab|[悬浮按钮](https://ext.dcloud.net.cn/plugin?name=uni-fab)| +|uni-fav|[收藏按钮](https://ext.dcloud.net.cn/plugin?name=uni-fav)| +|uni-file-picker|[文件选择上传](https://ext.dcloud.net.cn/plugin?name=uni-file-picker)| +|uni-forms|[表单](https://ext.dcloud.net.cn/plugin?name=uni-forms)| +|uni-goods-nav|[商品导航](https://ext.dcloud.net.cn/plugin?name=uni-goods-nav)| +|uni-grid|[宫格](https://ext.dcloud.net.cn/plugin?name=uni-grid)| +|uni-group|[分组](https://ext.dcloud.net.cn/plugin?name=uni-group)| +|uni-icons|[图标](https://ext.dcloud.net.cn/plugin?name=uni-icons)| +|uni-indexed-list|[索引列表](https://ext.dcloud.net.cn/plugin?name=uni-indexed-list)| +|uni-link|[超链接](https://ext.dcloud.net.cn/plugin?name=uni-link)| +|uni-list|[列表](https://ext.dcloud.net.cn/plugin?name=uni-list)| +|uni-load-more|[加载更多](https://ext.dcloud.net.cn/plugin?name=uni-load-more)| +|uni-nav-bar|[自定义导航栏](https://ext.dcloud.net.cn/plugin?name=uni-nav-bar)| +|uni-notice-bar|[通告栏](https://ext.dcloud.net.cn/plugin?name=uni-notice-bar)| +|uni-number-box|[数字输入框](https://ext.dcloud.net.cn/plugin?name=uni-number-box)| +|uni-pagination|[分页器](https://ext.dcloud.net.cn/plugin?name=uni-pagination)| +|uni-popup|[弹出层](https://ext.dcloud.net.cn/plugin?name=uni-popup)| +|uni-rate|[评分](https://ext.dcloud.net.cn/plugin?name=uni-rate)| +|uni-row|[布局-行](https://ext.dcloud.net.cn/plugin?name=uni-row)| +|uni-scss|[辅助样式](https://ext.dcloud.net.cn/plugin?name=uni-scss)| +|uni-search-bar|[搜索栏](https://ext.dcloud.net.cn/plugin?name=uni-search-bar)| +|uni-section|[标题栏](https://ext.dcloud.net.cn/plugin?name=uni-section)| +|uni-segmented-control|[分段器](https://ext.dcloud.net.cn/plugin?name=uni-segmented-control)| +|uni-steps|[步骤条](https://ext.dcloud.net.cn/plugin?name=uni-steps)| +|uni-swipe-action|[滑动操作](https://ext.dcloud.net.cn/plugin?name=uni-swipe-action)| +|uni-swiper-dot|[轮播图指示点](https://ext.dcloud.net.cn/plugin?name=uni-swiper-dot)| +|uni-table|[表格](https://ext.dcloud.net.cn/plugin?name=uni-table)| +|uni-tag|[标签](https://ext.dcloud.net.cn/plugin?name=uni-tag)| +|uni-title|[章节标题](https://ext.dcloud.net.cn/plugin?name=uni-title)| +|uni-tooltip|[提示文字](https://ext.dcloud.net.cn/plugin?name=uni-tooltip)| +|uni-transition|[过渡动画](https://ext.dcloud.net.cn/plugin?name=uni-transition)| + + +### 其他 + +- uni-ui 是全端兼容的基于flex布局的、无dom的ui库 +- uni-ui 是uni-app内置组件的扩展。注意与web开发不同，uni-ui不包括基础组件，它是基础组件的补充。web开发中有的开发者习惯用一个ui库完成所有开发，但在uni-app体系中，推荐开发者首先使用性能更高的基础组件，然后按需引入必要的扩展组件。 + + +> **注意** +> - `uni-ui` 不支持使用 `Vue.use()` 的方式安装 + + + +### 贡献代码 +在使用 `uni-ui` 中，如遇到无法解决的问题，请提 [Issues](https://github.com/dcloudio/uni-ui/issues) 给我们，假如您有更好的点子或更好的实现方式，也欢迎给我们提交 [PR](https://github.com/dcloudio/uni-ui/pulls) \ No newline at end of file diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-badge/uni-badge.vue b/node_modules/@dcloudio/uni-ui/lib/uni-badge/uni-badge.vue new file mode 100644 index 0000000..956354b --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-badge/uni-badge.vue @@ -0,0 +1,268 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-breadcrumb-item/uni-breadcrumb-item.vue b/node_modules/@dcloudio/uni-ui/lib/uni-breadcrumb-item/uni-breadcrumb-item.vue new file mode 100644 index 0000000..420aaf5 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-breadcrumb-item/uni-breadcrumb-item.vue @@ -0,0 +1,126 @@ + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-breadcrumb/uni-breadcrumb.vue b/node_modules/@dcloudio/uni-ui/lib/uni-breadcrumb/uni-breadcrumb.vue new file mode 100644 index 0000000..81fb63e --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-breadcrumb/uni-breadcrumb.vue @@ -0,0 +1,46 @@ + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-calendar/calendar.js b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/calendar.js new file mode 100644 index 0000000..55eed81 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/calendar.js @@ -0,0 +1,544 @@ +/** +* @1900-2100区间内的公历、农历互转 +* @charset UTF-8 +* @github https://github.com/jjonline/calendar.js +* @Author Jea杨(JJonline@JJonline.Cn) +* @Time 2014-7-21 +* @Time 2016-8-13 Fixed 2033hex、Attribution Annals +* @Time 2016-9-25 Fixed lunar LeapMonth Param Bug +* @Time 2017-7-24 Fixed use getTerm Func Param Error.use solar year,NOT lunar year +* @Version 1.0.3 +* @公历转农历：calendar.solar2lunar(1987,11,01); //[you can ignore params of prefix 0] +* @农历转公历：calendar.lunar2solar(1987,09,10); //[you can ignore params of prefix 0] +*/ +/* eslint-disable */ +var calendar = { + + /** + * 农历1900-2100的润大小信息表 + * @Array Of Property + * @return Hex + */ + lunarInfo: [0x04bd8, 0x04ae0, 0x0a570, 0x054d5, 0x0d260, 0x0d950, 0x16554, 0x056a0, 0x09ad0, 0x055d2, // 1900-1909 + 0x04ae0, 0x0a5b6, 0x0a4d0, 0x0d250, 0x1d255, 0x0b540, 0x0d6a0, 0x0ada2, 0x095b0, 0x14977, // 1910-1919 + 0x04970, 0x0a4b0, 0x0b4b5, 0x06a50, 0x06d40, 0x1ab54, 0x02b60, 0x09570, 0x052f2, 0x04970, // 1920-1929 + 0x06566, 0x0d4a0, 0x0ea50, 0x06e95, 0x05ad0, 0x02b60, 0x186e3, 0x092e0, 0x1c8d7, 0x0c950, // 1930-1939 + 0x0d4a0, 0x1d8a6, 0x0b550, 0x056a0, 0x1a5b4, 0x025d0, 0x092d0, 0x0d2b2, 0x0a950, 0x0b557, // 1940-1949 + 0x06ca0, 0x0b550, 0x15355, 0x04da0, 0x0a5b0, 0x14573, 0x052b0, 0x0a9a8, 0x0e950, 0x06aa0, // 1950-1959 + 0x0aea6, 0x0ab50, 0x04b60, 0x0aae4, 0x0a570, 0x05260, 0x0f263, 0x0d950, 0x05b57, 0x056a0, // 1960-1969 + 0x096d0, 0x04dd5, 0x04ad0, 0x0a4d0, 0x0d4d4, 0x0d250, 0x0d558, 0x0b540, 0x0b6a0, 0x195a6, // 1970-1979 + 0x095b0, 0x049b0, 0x0a974, 0x0a4b0, 0x0b27a, 0x06a50, 0x06d40, 0x0af46, 0x0ab60, 0x09570, // 1980-1989 + 0x04af5, 0x04970, 0x064b0, 0x074a3, 0x0ea50, 0x06b58, 0x05ac0, 0x0ab60, 0x096d5, 0x092e0, // 1990-1999 + 0x0c960, 0x0d954, 0x0d4a0, 0x0da50, 0x07552, 0x056a0, 0x0abb7, 0x025d0, 0x092d0, 0x0cab5, // 2000-2009 + 0x0a950, 0x0b4a0, 0x0baa4, 0x0ad50, 0x055d9, 0x04ba0, 0x0a5b0, 0x15176, 0x052b0, 0x0a930, // 2010-2019 + 0x07954, 0x06aa0, 0x0ad50, 0x05b52, 0x04b60, 0x0a6e6, 0x0a4e0, 0x0d260, 0x0ea65, 0x0d530, // 2020-2029 + 0x05aa0, 0x076a3, 0x096d0, 0x04afb, 0x04ad0, 0x0a4d0, 0x1d0b6, 0x0d250, 0x0d520, 0x0dd45, // 2030-2039 + 0x0b5a0, 0x056d0, 0x055b2, 0x049b0, 0x0a577, 0x0a4b0, 0x0aa50, 0x1b255, 0x06d20, 0x0ada0, // 2040-2049 + /** Add By JJonline@JJonline.Cn**/ + 0x14b63, 0x09370, 0x049f8, 0x04970, 0x064b0, 0x168a6, 0x0ea50, 0x06b20, 0x1a6c4, 0x0aae0, // 2050-2059 + 0x0a2e0, 0x0d2e3, 0x0c960, 0x0d557, 0x0d4a0, 0x0da50, 0x05d55, 0x056a0, 0x0a6d0, 0x055d4, // 2060-2069 + 0x052d0, 0x0a9b8, 0x0a950, 0x0b4a0, 0x0b6a6, 0x0ad50, 0x055a0, 0x0aba4, 0x0a5b0, 0x052b0, // 2070-2079 + 0x0b273, 0x06930, 0x07337, 0x06aa0, 0x0ad50, 0x14b55, 0x04b60, 0x0a570, 0x054e4, 0x0d160, // 2080-2089 + 0x0e968, 0x0d520, 0x0daa0, 0x16aa6, 0x056d0, 0x04ae0, 0x0a9d4, 0x0a2d0, 0x0d150, 0x0f252, // 2090-2099 + 0x0d520], // 2100 + + /** + * 公历每个月份的天数普通表 + * @Array Of Property + * @return Number + */ + solarMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], + + /** + * 天干地支之天干速查表 + * @Array Of Property trans["甲","乙","丙","丁","戊","己","庚","辛","壬","癸"] + * @return Cn string + */ + Gan: ['\u7532', '\u4e59', '\u4e19', '\u4e01', '\u620a', '\u5df1', '\u5e9a', '\u8f9b', '\u58ec', '\u7678'], + + /** + * 天干地支之地支速查表 + * @Array Of Property + * @trans["子","丑","寅","卯","辰","巳","午","未","申","酉","戌","亥"] + * @return Cn string + */ + Zhi: ['\u5b50', '\u4e11', '\u5bc5', '\u536f', '\u8fb0', '\u5df3', '\u5348', '\u672a', '\u7533', '\u9149', '\u620c', '\u4ea5'], + + /** + * 天干地支之地支速查表<=>生肖 + * @Array Of Property + * @trans["鼠","牛","虎","兔","龙","蛇","马","羊","猴","鸡","狗","猪"] + * @return Cn string + */ + Animals: ['\u9f20', '\u725b', '\u864e', '\u5154', '\u9f99', '\u86c7', '\u9a6c', '\u7f8a', '\u7334', '\u9e21', '\u72d7', '\u732a'], + + /** + * 24节气速查表 + * @Array Of Property + * @trans["小寒","大寒","立春","雨水","惊蛰","春分","清明","谷雨","立夏","小满","芒种","夏至","小暑","大暑","立秋","处暑","白露","秋分","寒露","霜降","立冬","小雪","大雪","冬至"] + * @return Cn string + */ + solarTerm: ['\u5c0f\u5bd2', '\u5927\u5bd2', '\u7acb\u6625', '\u96e8\u6c34', '\u60ca\u86f0', '\u6625\u5206', '\u6e05\u660e', '\u8c37\u96e8', '\u7acb\u590f', '\u5c0f\u6ee1', '\u8292\u79cd', '\u590f\u81f3', '\u5c0f\u6691', '\u5927\u6691', '\u7acb\u79cb', '\u5904\u6691', '\u767d\u9732', '\u79cb\u5206', '\u5bd2\u9732', '\u971c\u964d', '\u7acb\u51ac', '\u5c0f\u96ea', '\u5927\u96ea', '\u51ac\u81f3'], + + /** + * 1900-2100各年的24节气日期速查表 + * @Array Of Property + * @return 0x string For splice + */ + sTermInfo: ['9778397bd097c36b0b6fc9274c91aa', '97b6b97bd19801ec9210c965cc920e', '97bcf97c3598082c95f8c965cc920f', + '97bd0b06bdb0722c965ce1cfcc920f', 'b027097bd097c36b0b6fc9274c91aa', '97b6b97bd19801ec9210c965cc920e', + '97bcf97c359801ec95f8c965cc920f', '97bd0b06bdb0722c965ce1cfcc920f', 'b027097bd097c36b0b6fc9274c91aa', + '97b6b97bd19801ec9210c965cc920e', '97bcf97c359801ec95f8c965cc920f', '97bd0b06bdb0722c965ce1cfcc920f', + 'b027097bd097c36b0b6fc9274c91aa', '9778397bd19801ec9210c965cc920e', '97b6b97bd19801ec95f8c965cc920f', + '97bd09801d98082c95f8e1cfcc920f', '97bd097bd097c36b0b6fc9210c8dc2', '9778397bd197c36c9210c9274c91aa', + '97b6b97bd19801ec95f8c965cc920e', '97bd09801d98082c95f8e1cfcc920f', '97bd097bd097c36b0b6fc9210c8dc2', + '9778397bd097c36c9210c9274c91aa', '97b6b97bd19801ec95f8c965cc920e', '97bcf97c3598082c95f8e1cfcc920f', + '97bd097bd097c36b0b6fc9210c8dc2', '9778397bd097c36c9210c9274c91aa', '97b6b97bd19801ec9210c965cc920e', + '97bcf97c3598082c95f8c965cc920f', '97bd097bd097c35b0b6fc920fb0722', '9778397bd097c36b0b6fc9274c91aa', + '97b6b97bd19801ec9210c965cc920e', '97bcf97c3598082c95f8c965cc920f', '97bd097bd097c35b0b6fc920fb0722', + '9778397bd097c36b0b6fc9274c91aa', '97b6b97bd19801ec9210c965cc920e', '97bcf97c359801ec95f8c965cc920f', + '97bd097bd097c35b0b6fc920fb0722', '9778397bd097c36b0b6fc9274c91aa', '97b6b97bd19801ec9210c965cc920e', + '97bcf97c359801ec95f8c965cc920f', '97bd097bd097c35b0b6fc920fb0722', '9778397bd097c36b0b6fc9274c91aa', + '97b6b97bd19801ec9210c965cc920e', '97bcf97c359801ec95f8c965cc920f', '97bd097bd07f595b0b6fc920fb0722', + '9778397bd097c36b0b6fc9210c8dc2', '9778397bd19801ec9210c9274c920e', '97b6b97bd19801ec95f8c965cc920f', + '97bd07f5307f595b0b0bc920fb0722', '7f0e397bd097c36b0b6fc9210c8dc2', '9778397bd097c36c9210c9274c920e', + '97b6b97bd19801ec95f8c965cc920f', '97bd07f5307f595b0b0bc920fb0722', '7f0e397bd097c36b0b6fc9210c8dc2', + '9778397bd097c36c9210c9274c91aa', '97b6b97bd19801ec9210c965cc920e', '97bd07f1487f595b0b0bc920fb0722', + '7f0e397bd097c36b0b6fc9210c8dc2', '9778397bd097c36b0b6fc9274c91aa', '97b6b97bd19801ec9210c965cc920e', + '97bcf7f1487f595b0b0bb0b6fb0722', '7f0e397bd097c35b0b6fc920fb0722', '9778397bd097c36b0b6fc9274c91aa', + '97b6b97bd19801ec9210c965cc920e', '97bcf7f1487f595b0b0bb0b6fb0722', '7f0e397bd097c35b0b6fc920fb0722', + '9778397bd097c36b0b6fc9274c91aa', '97b6b97bd19801ec9210c965cc920e', '97bcf7f1487f531b0b0bb0b6fb0722', + '7f0e397bd097c35b0b6fc920fb0722', '9778397bd097c36b0b6fc9274c91aa', '97b6b97bd19801ec9210c965cc920e', + '97bcf7f1487f531b0b0bb0b6fb0722', '7f0e397bd07f595b0b6fc920fb0722', '9778397bd097c36b0b6fc9274c91aa', + '97b6b97bd19801ec9210c9274c920e', '97bcf7f0e47f531b0b0bb0b6fb0722', '7f0e397bd07f595b0b0bc920fb0722', + '9778397bd097c36b0b6fc9210c91aa', '97b6b97bd197c36c9210c9274c920e', '97bcf7f0e47f531b0b0bb0b6fb0722', + '7f0e397bd07f595b0b0bc920fb0722', '9778397bd097c36b0b6fc9210c8dc2', '9778397bd097c36c9210c9274c920e', + '97b6b7f0e47f531b0723b0b6fb0722', '7f0e37f5307f595b0b0bc920fb0722', '7f0e397bd097c36b0b6fc9210c8dc2', + '9778397bd097c36b0b70c9274c91aa', '97b6b7f0e47f531b0723b0b6fb0721', '7f0e37f1487f595b0b0bb0b6fb0722', + '7f0e397bd097c35b0b6fc9210c8dc2', '9778397bd097c36b0b6fc9274c91aa', '97b6b7f0e47f531b0723b0b6fb0721', + '7f0e27f1487f595b0b0bb0b6fb0722', '7f0e397bd097c35b0b6fc920fb0722', '9778397bd097c36b0b6fc9274c91aa', + '97b6b7f0e47f531b0723b0b6fb0721', '7f0e27f1487f531b0b0bb0b6fb0722', '7f0e397bd097c35b0b6fc920fb0722', + '9778397bd097c36b0b6fc9274c91aa', '97b6b7f0e47f531b0723b0b6fb0721', '7f0e27f1487f531b0b0bb0b6fb0722', + '7f0e397bd097c35b0b6fc920fb0722', '9778397bd097c36b0b6fc9274c91aa', '97b6b7f0e47f531b0723b0b6fb0721', + '7f0e27f1487f531b0b0bb0b6fb0722', '7f0e397bd07f595b0b0bc920fb0722', '9778397bd097c36b0b6fc9274c91aa', + '97b6b7f0e47f531b0723b0787b0721', '7f0e27f0e47f531b0b0bb0b6fb0722', '7f0e397bd07f595b0b0bc920fb0722', + '9778397bd097c36b0b6fc9210c91aa', '97b6b7f0e47f149b0723b0787b0721', '7f0e27f0e47f531b0723b0b6fb0722', + '7f0e397bd07f595b0b0bc920fb0722', '9778397bd097c36b0b6fc9210c8dc2', '977837f0e37f149b0723b0787b0721', + '7f07e7f0e47f531b0723b0b6fb0722', '7f0e37f5307f595b0b0bc920fb0722', '7f0e397bd097c35b0b6fc9210c8dc2', + '977837f0e37f14998082b0787b0721', '7f07e7f0e47f531b0723b0b6fb0721', '7f0e37f1487f595b0b0bb0b6fb0722', + '7f0e397bd097c35b0b6fc9210c8dc2', '977837f0e37f14998082b0787b06bd', '7f07e7f0e47f531b0723b0b6fb0721', + '7f0e27f1487f531b0b0bb0b6fb0722', '7f0e397bd097c35b0b6fc920fb0722', '977837f0e37f14998082b0787b06bd', + '7f07e7f0e47f531b0723b0b6fb0721', '7f0e27f1487f531b0b0bb0b6fb0722', '7f0e397bd097c35b0b6fc920fb0722', + '977837f0e37f14998082b0787b06bd', '7f07e7f0e47f531b0723b0b6fb0721', '7f0e27f1487f531b0b0bb0b6fb0722', + '7f0e397bd07f595b0b0bc920fb0722', '977837f0e37f14998082b0787b06bd', '7f07e7f0e47f531b0723b0b6fb0721', + '7f0e27f1487f531b0b0bb0b6fb0722', '7f0e397bd07f595b0b0bc920fb0722', '977837f0e37f14998082b0787b06bd', + '7f07e7f0e47f149b0723b0787b0721', '7f0e27f0e47f531b0b0bb0b6fb0722', '7f0e397bd07f595b0b0bc920fb0722', + '977837f0e37f14998082b0723b06bd', '7f07e7f0e37f149b0723b0787b0721', '7f0e27f0e47f531b0723b0b6fb0722', + '7f0e397bd07f595b0b0bc920fb0722', '977837f0e37f14898082b0723b02d5', '7ec967f0e37f14998082b0787b0721', + '7f07e7f0e47f531b0723b0b6fb0722', '7f0e37f1487f595b0b0bb0b6fb0722', '7f0e37f0e37f14898082b0723b02d5', + '7ec967f0e37f14998082b0787b0721', '7f07e7f0e47f531b0723b0b6fb0722', '7f0e37f1487f531b0b0bb0b6fb0722', + '7f0e37f0e37f14898082b0723b02d5', '7ec967f0e37f14998082b0787b06bd', '7f07e7f0e47f531b0723b0b6fb0721', + '7f0e37f1487f531b0b0bb0b6fb0722', '7f0e37f0e37f14898082b072297c35', '7ec967f0e37f14998082b0787b06bd', + '7f07e7f0e47f531b0723b0b6fb0721', '7f0e27f1487f531b0b0bb0b6fb0722', '7f0e37f0e37f14898082b072297c35', + '7ec967f0e37f14998082b0787b06bd', '7f07e7f0e47f531b0723b0b6fb0721', '7f0e27f1487f531b0b0bb0b6fb0722', + '7f0e37f0e366aa89801eb072297c35', '7ec967f0e37f14998082b0787b06bd', '7f07e7f0e47f149b0723b0787b0721', + '7f0e27f1487f531b0b0bb0b6fb0722', '7f0e37f0e366aa89801eb072297c35', '7ec967f0e37f14998082b0723b06bd', + '7f07e7f0e47f149b0723b0787b0721', '7f0e27f0e47f531b0723b0b6fb0722', '7f0e37f0e366aa89801eb072297c35', + '7ec967f0e37f14998082b0723b06bd', '7f07e7f0e37f14998083b0787b0721', '7f0e27f0e47f531b0723b0b6fb0722', + '7f0e37f0e366aa89801eb072297c35', '7ec967f0e37f14898082b0723b02d5', '7f07e7f0e37f14998082b0787b0721', + '7f07e7f0e47f531b0723b0b6fb0722', '7f0e36665b66aa89801e9808297c35', '665f67f0e37f14898082b0723b02d5', + '7ec967f0e37f14998082b0787b0721', '7f07e7f0e47f531b0723b0b6fb0722', '7f0e36665b66a449801e9808297c35', + '665f67f0e37f14898082b0723b02d5', '7ec967f0e37f14998082b0787b06bd', '7f07e7f0e47f531b0723b0b6fb0721', + '7f0e36665b66a449801e9808297c35', '665f67f0e37f14898082b072297c35', '7ec967f0e37f14998082b0787b06bd', + '7f07e7f0e47f531b0723b0b6fb0721', '7f0e26665b66a449801e9808297c35', '665f67f0e37f1489801eb072297c35', + '7ec967f0e37f14998082b0787b06bd', '7f07e7f0e47f531b0723b0b6fb0721', '7f0e27f1487f531b0b0bb0b6fb0722'], + + /** + * 数字转中文速查表 + * @Array Of Property + * @trans ['日','一','二','三','四','五','六','七','八','九','十'] + * @return Cn string + */ + nStr1: ['\u65e5', '\u4e00', '\u4e8c', '\u4e09', '\u56db', '\u4e94', '\u516d', '\u4e03', '\u516b', '\u4e5d', '\u5341'], + + /** + * 日期转农历称呼速查表 + * @Array Of Property + * @trans ['初','十','廿','卅'] + * @return Cn string + */ + nStr2: ['\u521d', '\u5341', '\u5eff', '\u5345'], + + /** + * 月份转农历称呼速查表 + * @Array Of Property + * @trans ['正','一','二','三','四','五','六','七','八','九','十','冬','腊'] + * @return Cn string + */ + nStr3: ['\u6b63', '\u4e8c', '\u4e09', '\u56db', '\u4e94', '\u516d', '\u4e03', '\u516b', '\u4e5d', '\u5341', '\u51ac', '\u814a'], + + /** + * 返回农历y年一整年的总天数 + * @param lunar Year + * @return Number + * @eg:var count = calendar.lYearDays(1987) ;//count=387 + */ + lYearDays: function (y) { + var i; var sum = 348 + for (i = 0x8000; i > 0x8; i >>= 1) { sum += (this.lunarInfo[y - 1900] & i) ? 1 : 0 } + return (sum + this.leapDays(y)) + }, + + /** + * 返回农历y年闰月是哪个月；若y年没有闰月 则返回0 + * @param lunar Year + * @return Number (0-12) + * @eg:var leapMonth = calendar.leapMonth(1987) ;//leapMonth=6 + */ + leapMonth: function (y) { // 闰字编码 \u95f0 + return (this.lunarInfo[y - 1900] & 0xf) + }, + + /** + * 返回农历y年闰月的天数 若该年没有闰月则返回0 + * @param lunar Year + * @return Number (0、29、30) + * @eg:var leapMonthDay = calendar.leapDays(1987) ;//leapMonthDay=29 + */ + leapDays: function (y) { + if (this.leapMonth(y)) { + return ((this.lunarInfo[y - 1900] & 0x10000) ? 30 : 29) + } + return (0) + }, + + /** + * 返回农历y年m月（非闰月）的总天数，计算m为闰月时的天数请使用leapDays方法 + * @param lunar Year + * @return Number (-1、29、30) + * @eg:var MonthDay = calendar.monthDays(1987,9) ;//MonthDay=29 + */ + monthDays: function (y, m) { + if (m > 12 || m < 1) { return -1 }// 月份参数从1至12，参数错误返回-1 + return ((this.lunarInfo[y - 1900] & (0x10000 >> m)) ? 30 : 29) + }, + + /** + * 返回公历(!)y年m月的天数 + * @param solar Year + * @return Number (-1、28、29、30、31) + * @eg:var solarMonthDay = calendar.leapDays(1987) ;//solarMonthDay=30 + */ + solarDays: function (y, m) { + if (m > 12 || m < 1) { return -1 } // 若参数错误 返回-1 + var ms = m - 1 + if (ms == 1) { // 2月份的闰平规律测算后确认返回28或29 + return (((y % 4 == 0) && (y % 100 != 0) || (y % 400 == 0)) ? 29 : 28) + } else { + return (this.solarMonth[ms]) + } + }, + + /** + * 农历年份转换为干支纪年 + * @param lYear 农历年的年份数 + * @return Cn string + */ + toGanZhiYear: function (lYear) { + var ganKey = (lYear - 3) % 10 + var zhiKey = (lYear - 3) % 12 + if (ganKey == 0) ganKey = 10// 如果余数为0则为最后一个天干 + if (zhiKey == 0) zhiKey = 12// 如果余数为0则为最后一个地支 + return this.Gan[ganKey - 1] + this.Zhi[zhiKey - 1] + }, + + /** + * 公历月、日判断所属星座 + * @param cMonth [description] + * @param cDay [description] + * @return Cn string + */ + toAstro: function (cMonth, cDay) { + var s = '\u9b54\u7faf\u6c34\u74f6\u53cc\u9c7c\u767d\u7f8a\u91d1\u725b\u53cc\u5b50\u5de8\u87f9\u72ee\u5b50\u5904\u5973\u5929\u79e4\u5929\u874e\u5c04\u624b\u9b54\u7faf' + var arr = [20, 19, 21, 21, 21, 22, 23, 23, 23, 23, 22, 22] + return s.substr(cMonth * 2 - (cDay < arr[cMonth - 1] ? 2 : 0), 2) + '\u5ea7'// 座 + }, + + /** + * 传入offset偏移量返回干支 + * @param offset 相对甲子的偏移量 + * @return Cn string + */ + toGanZhi: function (offset) { + return this.Gan[offset % 10] + this.Zhi[offset % 12] + }, + + /** + * 传入公历(!)y年获得该年第n个节气的公历日期 + * @param y公历年(1900-2100)；n二十四节气中的第几个节气(1~24)；从n=1(小寒)算起 + * @return day Number + * @eg:var _24 = calendar.getTerm(1987,3) ;//_24=4;意即1987年2月4日立春 + */ + getTerm: function (y, n) { + if (y < 1900 || y > 2100) { return -1 } + if (n < 1 || n > 24) { return -1 } + var _table = this.sTermInfo[y - 1900] + var _info = [ + parseInt('0x' + _table.substr(0, 5)).toString(), + parseInt('0x' + _table.substr(5, 5)).toString(), + parseInt('0x' + _table.substr(10, 5)).toString(), + parseInt('0x' + _table.substr(15, 5)).toString(), + parseInt('0x' + _table.substr(20, 5)).toString(), + parseInt('0x' + _table.substr(25, 5)).toString() + ] + var _calday = [ + _info[0].substr(0, 1), + _info[0].substr(1, 2), + _info[0].substr(3, 1), + _info[0].substr(4, 2), + + _info[1].substr(0, 1), + _info[1].substr(1, 2), + _info[1].substr(3, 1), + _info[1].substr(4, 2), + + _info[2].substr(0, 1), + _info[2].substr(1, 2), + _info[2].substr(3, 1), + _info[2].substr(4, 2), + + _info[3].substr(0, 1), + _info[3].substr(1, 2), + _info[3].substr(3, 1), + _info[3].substr(4, 2), + + _info[4].substr(0, 1), + _info[4].substr(1, 2), + _info[4].substr(3, 1), + _info[4].substr(4, 2), + + _info[5].substr(0, 1), + _info[5].substr(1, 2), + _info[5].substr(3, 1), + _info[5].substr(4, 2) + ] + return parseInt(_calday[n - 1]) + }, + + /** + * 传入农历数字月份返回汉语通俗表示法 + * @param lunar month + * @return Cn string + * @eg:var cnMonth = calendar.toChinaMonth(12) ;//cnMonth='腊月' + */ + toChinaMonth: function (m) { // 月 => \u6708 + if (m > 12 || m < 1) { return -1 } // 若参数错误 返回-1 + var s = this.nStr3[m - 1] + s += '\u6708'// 加上月字 + return s + }, + + /** + * 传入农历日期数字返回汉字表示法 + * @param lunar day + * @return Cn string + * @eg:var cnDay = calendar.toChinaDay(21) ;//cnMonth='廿一' + */ + toChinaDay: function (d) { // 日 => \u65e5 + var s + switch (d) { + case 10: + s = '\u521d\u5341'; break + case 20: + s = '\u4e8c\u5341'; break + case 30: + s = '\u4e09\u5341'; break + default : + s = this.nStr2[Math.floor(d / 10)] + s += this.nStr1[d % 10] + } + return (s) + }, + + /** + * 年份转生肖[!仅能大致转换] => 精确划分生肖分界线是“立春” + * @param y year + * @return Cn string + * @eg:var animal = calendar.getAnimal(1987) ;//animal='兔' + */ + getAnimal: function (y) { + return this.Animals[(y - 4) % 12] + }, + + /** + * 传入阳历年月日获得详细的公历、农历object信息 <=>JSON + * @param y solar year + * @param m solar month + * @param d solar day + * @return JSON object + * @eg:console.log(calendar.solar2lunar(1987,11,01)); + */ + solar2lunar: function (y, m, d) { // 参数区间1900.1.31~2100.12.31 + // 年份限定、上限 + if (y < 1900 || y > 2100) { + return -1// undefined转换为数字变为NaN + } + // 公历传参最下限 + if (y == 1900 && m == 1 && d < 31) { + return -1 + } + // 未传参 获得当天 + if (!y) { + var objDate = new Date() + } else { + var objDate = new Date(y, parseInt(m) - 1, d) + } + var i; var leap = 0; var temp = 0 + // 修正ymd参数 + var y = objDate.getFullYear() + var m = objDate.getMonth() + 1 + var d = objDate.getDate() + var offset = (Date.UTC(objDate.getFullYear(), objDate.getMonth(), objDate.getDate()) - Date.UTC(1900, 0, 31)) / 86400000 + for (i = 1900; i < 2101 && offset > 0; i++) { + temp = this.lYearDays(i) + offset -= temp + } + if (offset < 0) { + offset += temp; i-- + } + + // 是否今天 + var isTodayObj = new Date() + var isToday = false + if (isTodayObj.getFullYear() == y && isTodayObj.getMonth() + 1 == m && isTodayObj.getDate() == d) { + isToday = true + } + // 星期几 + var nWeek = objDate.getDay() + var cWeek = this.nStr1[nWeek] + // 数字表示周几顺应天朝周一开始的惯例 + if (nWeek == 0) { + nWeek = 7 + } + // 农历年 + var year = i + var leap = this.leapMonth(i) // 闰哪个月 + var isLeap = false + + // 效验闰月 + for (i = 1; i < 13 && offset > 0; i++) { + // 闰月 + if (leap > 0 && i == (leap + 1) && isLeap == false) { + --i + isLeap = true; temp = this.leapDays(year) // 计算农历闰月天数 + } else { + temp = this.monthDays(year, i)// 计算农历普通月天数 + } + // 解除闰月 + if (isLeap == true && i == (leap + 1)) { isLeap = false } + offset -= temp + } + // 闰月导致数组下标重叠取反 + if (offset == 0 && leap > 0 && i == leap + 1) { + if (isLeap) { + isLeap = false + } else { + isLeap = true; --i + } + } + if (offset < 0) { + offset += temp; --i + } + // 农历月 + var month = i + // 农历日 + var day = offset + 1 + // 天干地支处理 + var sm = m - 1 + var gzY = this.toGanZhiYear(year) + + // 当月的两个节气 + // bugfix-2017-7-24 11:03:38 use lunar Year Param `y` Not `year` + var firstNode = this.getTerm(y, (m * 2 - 1))// 返回当月「节」为几日开始 + var secondNode = this.getTerm(y, (m * 2))// 返回当月「节」为几日开始 + + // 依据12节气修正干支月 + var gzM = this.toGanZhi((y - 1900) * 12 + m + 11) + if (d >= firstNode) { + gzM = this.toGanZhi((y - 1900) * 12 + m + 12) + } + + // 传入的日期的节气与否 + var isTerm = false + var Term = null + if (firstNode == d) { + isTerm = true + Term = this.solarTerm[m * 2 - 2] + } + if (secondNode == d) { + isTerm = true + Term = this.solarTerm[m * 2 - 1] + } + // 日柱 当月一日与 1900/1/1 相差天数 + var dayCyclical = Date.UTC(y, sm, 1, 0, 0, 0, 0) / 86400000 + 25567 + 10 + var gzD = this.toGanZhi(dayCyclical + d - 1) + // 该日期所属的星座 + var astro = this.toAstro(m, d) + + return { 'lYear': year, 'lMonth': month, 'lDay': day, 'Animal': this.getAnimal(year), 'IMonthCn': (isLeap ? '\u95f0' : '') + this.toChinaMonth(month), 'IDayCn': this.toChinaDay(day), 'cYear': y, 'cMonth': m, 'cDay': d, 'gzYear': gzY, 'gzMonth': gzM, 'gzDay': gzD, 'isToday': isToday, 'isLeap': isLeap, 'nWeek': nWeek, 'ncWeek': '\u661f\u671f' + cWeek, 'isTerm': isTerm, 'Term': Term, 'astro': astro } + }, + + /** + * 传入农历年月日以及传入的月份是否闰月获得详细的公历、农历object信息 <=>JSON + * @param y lunar year + * @param m lunar month + * @param d lunar day + * @param isLeapMonth lunar month is leap or not.[如果是农历闰月第四个参数赋值true即可] + * @return JSON object + * @eg:console.log(calendar.lunar2solar(1987,9,10)); + */ + lunar2solar: function (y, m, d, isLeapMonth) { // 参数区间1900.1.31~2100.12.1 + var isLeapMonth = !!isLeapMonth + var leapOffset = 0 + var leapMonth = this.leapMonth(y) + var leapDay = this.leapDays(y) + if (isLeapMonth && (leapMonth != m)) { return -1 }// 传参要求计算该闰月公历 但该年得出的闰月与传参的月份并不同 + if (y == 2100 && m == 12 && d > 1 || y == 1900 && m == 1 && d < 31) { return -1 }// 超出了最大极限值 + var day = this.monthDays(y, m) + var _day = day + // bugFix 2016-9-25 + // if month is leap, _day use leapDays method + if (isLeapMonth) { + _day = this.leapDays(y, m) + } + if (y < 1900 || y > 2100 || d > _day) { return -1 }// 参数合法性效验 + + // 计算农历的时间差 + var offset = 0 + for (var i = 1900; i < y; i++) { + offset += this.lYearDays(i) + } + var leap = 0; var isAdd = false + for (var i = 1; i < m; i++) { + leap = this.leapMonth(y) + if (!isAdd) { // 处理闰月 + if (leap <= i && leap > 0) { + offset += this.leapDays(y); isAdd = true + } + } + offset += this.monthDays(y, i) + } + // 转换闰月农历 需补充该年闰月的前一个月的时差 + if (isLeapMonth) { offset += day } + // 1900年农历正月一日的公历时间为1900年1月30日0时0分0秒(该时间也是本农历的最开始起始点) + var stmap = Date.UTC(1900, 1, 30, 0, 0, 0) + var calObj = new Date((offset + d - 31) * 86400000 + stmap) + var cY = calObj.getUTCFullYear() + var cM = calObj.getUTCMonth() + 1 + var cD = calObj.getUTCDate() + + return this.solar2lunar(cY, cM, cD) + } +} + +export default calendar diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-calendar/i18n/en.json b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/i18n/en.json new file mode 100644 index 0000000..fcbd13c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/i18n/en.json @@ -0,0 +1,12 @@ +{ + "uni-calender.ok": "ok", + "uni-calender.cancel": "cancel", + "uni-calender.today": "today", + "uni-calender.MON": "MON", + "uni-calender.TUE": "TUE", + "uni-calender.WED": "WED", + "uni-calender.THU": "THU", + "uni-calender.FRI": "FRI", + "uni-calender.SAT": "SAT", + "uni-calender.SUN": "SUN" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-calendar/i18n/index.js b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/i18n/index.js new file mode 100644 index 0000000..de7509c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/i18n/index.js @@ -0,0 +1,8 @@ +import en from './en.json' +import zhHans from './zh-Hans.json' +import zhHant from './zh-Hant.json' +export default { + en, + 'zh-Hans': zhHans, + 'zh-Hant': zhHant +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-calendar/i18n/zh-Hans.json b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/i18n/zh-Hans.json new file mode 100644 index 0000000..1ca43de --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/i18n/zh-Hans.json @@ -0,0 +1,12 @@ +{ + "uni-calender.ok": "确定", + "uni-calender.cancel": "取消", + "uni-calender.today": "今日", + "uni-calender.SUN": "日", + "uni-calender.MON": "一", + "uni-calender.TUE": "二", + "uni-calender.WED": "三", + "uni-calender.THU": "四", + "uni-calender.FRI": "五", + "uni-calender.SAT": "六" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-calendar/i18n/zh-Hant.json b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/i18n/zh-Hant.json new file mode 100644 index 0000000..e0fe33b --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/i18n/zh-Hant.json @@ -0,0 +1,12 @@ +{ + "uni-calender.ok": "確定", + "uni-calender.cancel": "取消", + "uni-calender.today": "今日", + "uni-calender.SUN": "日", + "uni-calender.MON": "一", + "uni-calender.TUE": "二", + "uni-calender.WED": "三", + "uni-calender.THU": "四", + "uni-calender.FRI": "五", + "uni-calender.SAT": "六" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-calendar/uni-calendar-item.vue b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/uni-calendar-item.vue new file mode 100644 index 0000000..a54135e --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/uni-calendar-item.vue @@ -0,0 +1,187 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-calendar/uni-calendar.vue b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/uni-calendar.vue new file mode 100644 index 0000000..0beebfb --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/uni-calendar.vue @@ -0,0 +1,567 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-calendar/util.js b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/util.js new file mode 100644 index 0000000..e0c5103 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-calendar/util.js @@ -0,0 +1,360 @@ +import CALENDAR from './calendar.js' + +class Calendar { + constructor({ + date, + selected, + startDate, + endDate, + range + } = {}) { + // 当前日期 + this.date = this.getDate(new Date()) // 当前初入日期 + // 打点信息 + this.selected = selected || []; + // 范围开始 + this.startDate = startDate + // 范围结束 + this.endDate = endDate + this.range = range + // 多选状态 + this.cleanMultipleStatus() + // 每周日期 + this.weeks = {} + // this._getWeek(this.date.fullDate) + } + /** + * 设置日期 + * @param {Object} date + */ + setDate(date) { + this.selectDate = this.getDate(date) + this._getWeek(this.selectDate.fullDate) + } + + /** + * 清理多选状态 + */ + cleanMultipleStatus() { + this.multipleStatus = { + before: '', + after: '', + data: [] + } + } + + /** + * 重置开始日期 + */ + resetSatrtDate(startDate) { + // 范围开始 + this.startDate = startDate + + } + + /** + * 重置结束日期 + */ + resetEndDate(endDate) { + // 范围结束 + this.endDate = endDate + } + + /** + * 获取任意时间 + */ + getDate(date, AddDayCount = 0, str = 'day') { + if (!date) { + date = new Date() + } + if (typeof date !== 'object') { + date = date.replace(/-/g, '/') + } + const dd = new Date(date) + switch (str) { + case 'day': + dd.setDate(dd.getDate() + AddDayCount) // 获取AddDayCount天后的日期 + break + case 'month': + if (dd.getDate() === 31 && AddDayCount>0) { + dd.setDate(dd.getDate() + AddDayCount) + } else { + const preMonth = dd.getMonth() + dd.setMonth(preMonth + AddDayCount) // 获取AddDayCount天后的日期 + const nextMonth = dd.getMonth() + // 处理 pre 切换月份目标月份为2月没有当前日(30 31) 切换错误问题 + if(AddDayCount<0 && preMonth!==0 && nextMonth-preMonth>AddDayCount){ + dd.setMonth(nextMonth+(nextMonth-preMonth+AddDayCount)) + } + // 处理 next 切换月份目标月份为2月没有当前日(30 31) 切换错误问题 + if(AddDayCount>0 && nextMonth-preMonth>AddDayCount){ + dd.setMonth(nextMonth-(nextMonth-preMonth-AddDayCount)) + } + } + break + case 'year': + dd.setFullYear(dd.getFullYear() + AddDayCount) // 获取AddDayCount天后的日期 + break + } + const y = dd.getFullYear() + const m = dd.getMonth() + 1 < 10 ? '0' + (dd.getMonth() + 1) : dd.getMonth() + 1 // 获取当前月份的日期，不足10补0 + const d = dd.getDate() < 10 ? '0' + dd.getDate() : dd.getDate() // 获取当前几号，不足10补0 + return { + fullDate: y + '-' + m + '-' + d, + year: y, + month: m, + date: d, + day: dd.getDay() + } + } + + + /** + * 获取上月剩余天数 + */ + _getLastMonthDays(firstDay, full) { + let dateArr = [] + for (let i = firstDay; i > 0; i--) { + const beforeDate = new Date(full.year, full.month - 1, -i + 1).getDate() + dateArr.push({ + date: beforeDate, + month: full.month - 1, + lunar: this.getlunar(full.year, full.month - 1, beforeDate), + disable: true + }) + } + return dateArr + } + /** + * 获取本月天数 + */ + _currentMonthDys(dateData, full) { + let dateArr = [] + let fullDate = this.date.fullDate + for (let i = 1; i <= dateData; i++) { + let nowDate = full.year + '-' + (full.month < 10 ? + full.month : full.month) + '-' + (i < 10 ? + '0' + i : i) + // 是否今天 + let isDay = fullDate === nowDate + // 获取打点信息 + let info = this.selected && this.selected.find((item) => { + if (this.dateEqual(nowDate, item.date)) { + return item + } + }) + + // 日期禁用 + let disableBefore = true + let disableAfter = true + if (this.startDate) { + // let dateCompBefore = this.dateCompare(this.startDate, fullDate) + // disableBefore = this.dateCompare(dateCompBefore ? this.startDate : fullDate, nowDate) + disableBefore = this.dateCompare(this.startDate, nowDate) + } + + if (this.endDate) { + // let dateCompAfter = this.dateCompare(fullDate, this.endDate) + // disableAfter = this.dateCompare(nowDate, dateCompAfter ? this.endDate : fullDate) + disableAfter = this.dateCompare(nowDate, this.endDate) + } + let multiples = this.multipleStatus.data + let checked = false + let multiplesStatus = -1 + if (this.range) { + if (multiples) { + multiplesStatus = multiples.findIndex((item) => { + return this.dateEqual(item, nowDate) + }) + } + if (multiplesStatus !== -1) { + checked = true + } + } + let data = { + fullDate: nowDate, + year: full.year, + date: i, + multiple: this.range ? checked : false, + beforeMultiple: this.dateEqual(this.multipleStatus.before, nowDate), + afterMultiple: this.dateEqual(this.multipleStatus.after, nowDate), + month: full.month, + lunar: this.getlunar(full.year, full.month, i), + disable: !(disableBefore && disableAfter), + isDay + } + if (info) { + data.extraInfo = info + } + + dateArr.push(data) + } + return dateArr + } + /** + * 获取下月天数 + */ + _getNextMonthDays(surplus, full) { + let dateArr = [] + for (let i = 1; i < surplus + 1; i++) { + dateArr.push({ + date: i, + month: Number(full.month) + 1, + lunar: this.getlunar(full.year, Number(full.month) + 1, i), + disable: true + }) + } + return dateArr + } + + /** + * 获取当前日期详情 + * @param {Object} date + */ + getInfo(date) { + if (!date) { + date = new Date() + } + const dateInfo = this.canlender.find(item => item.fullDate === this.getDate(date).fullDate) + return dateInfo + } + + /** + * 比较时间大小 + */ + dateCompare(startDate, endDate) { + // 计算截止时间 + startDate = new Date(startDate.replace('-', '/').replace('-', '/')) + // 计算详细项的截止时间 + endDate = new Date(endDate.replace('-', '/').replace('-', '/')) + if (startDate <= endDate) { + return true + } else { + return false + } + } + + /** + * 比较时间是否相等 + */ + dateEqual(before, after) { + // 计算截止时间 + before = new Date(before.replace('-', '/').replace('-', '/')) + // 计算详细项的截止时间 + after = new Date(after.replace('-', '/').replace('-', '/')) + if (before.getTime() - after.getTime() === 0) { + return true + } else { + return false + } + } + + + /** + * 获取日期范围内所有日期 + * @param {Object} begin + * @param {Object} end + */ + geDateAll(begin, end) { + var arr = [] + var ab = begin.split('-') + var ae = end.split('-') + var db = new Date() + db.setFullYear(ab[0], ab[1] - 1, ab[2]) + var de = new Date() + de.setFullYear(ae[0], ae[1] - 1, ae[2]) + var unixDb = db.getTime() - 24 * 60 * 60 * 1000 + var unixDe = de.getTime() - 24 * 60 * 60 * 1000 + for (var k = unixDb; k <= unixDe;) { + k = k + 24 * 60 * 60 * 1000 + arr.push(this.getDate(new Date(parseInt(k))).fullDate) + } + return arr + } + /** + * 计算阴历日期显示 + */ + getlunar(year, month, date) { + return CALENDAR.solar2lunar(year, month, date) + } + /** + * 设置打点 + */ + setSelectInfo(data, value) { + this.selected = value + this._getWeek(data) + } + + /** + * 获取多选状态 + */ + setMultiple(fullDate) { + let { + before, + after + } = this.multipleStatus + + if (!this.range) return + if (before && after) { + this.multipleStatus.before = fullDate + this.multipleStatus.after = '' + this.multipleStatus.data = [] + } else { + if (!before) { + this.multipleStatus.before = fullDate + } else { + this.multipleStatus.after = fullDate + if (this.dateCompare(this.multipleStatus.before, this.multipleStatus.after)) { + this.multipleStatus.data = this.geDateAll(this.multipleStatus.before, this.multipleStatus.after); + } else { + this.multipleStatus.data = this.geDateAll(this.multipleStatus.after, this.multipleStatus.before); + } + } + } + this._getWeek(fullDate) + } + + /** + * 获取每周数据 + * @param {Object} dateData + */ + _getWeek(dateData) { + const { + year, + month + } = this.getDate(dateData) + let firstDay = new Date(year, month - 1, 1).getDay() + let currentDay = new Date(year, month, 0).getDate() + let dates = { + lastMonthDays: this._getLastMonthDays(firstDay, this.getDate(dateData)), // 上个月末尾几天 + currentMonthDys: this._currentMonthDys(currentDay, this.getDate(dateData)), // 本月天数 + nextMonthDays: [], // 下个月开始几天 + weeks: [] + } + let canlender = [] + const surplus = 42 - (dates.lastMonthDays.length + dates.currentMonthDys.length) + dates.nextMonthDays = this._getNextMonthDays(surplus, this.getDate(dateData)) + canlender = canlender.concat(dates.lastMonthDays, dates.currentMonthDys, dates.nextMonthDays) + let weeks = {} + // 拼接数组 上个月开始几天 + 本月天数+ 下个月开始几天 + for (let i = 0; i < canlender.length; i++) { + if (i % 7 === 0) { + weeks[parseInt(i / 7)] = new Array(7) + } + weeks[parseInt(i / 7)][i % 7] = canlender[i] + } + this.canlender = canlender + this.weeks = weeks + } + + //静态方法 + // static init(date) { + // if (!this.instance) { + // this.instance = new Calendar(date); + // } + // return this.instance; + // } +} + + +export default Calendar diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-card/uni-card.vue b/node_modules/@dcloudio/uni-ui/lib/uni-card/uni-card.vue new file mode 100644 index 0000000..38cf594 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-card/uni-card.vue @@ -0,0 +1,270 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-col/uni-col.vue b/node_modules/@dcloudio/uni-ui/lib/uni-col/uni-col.vue new file mode 100644 index 0000000..84e2deb --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-col/uni-col.vue @@ -0,0 +1,317 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-collapse-item/uni-collapse-item.vue b/node_modules/@dcloudio/uni-ui/lib/uni-collapse-item/uni-collapse-item.vue new file mode 100644 index 0000000..2f0862e --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-collapse-item/uni-collapse-item.vue @@ -0,0 +1,402 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-collapse/uni-collapse.vue b/node_modules/@dcloudio/uni-ui/lib/uni-collapse/uni-collapse.vue new file mode 100644 index 0000000..384c39a --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-collapse/uni-collapse.vue @@ -0,0 +1,147 @@ + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-combox/uni-combox.vue b/node_modules/@dcloudio/uni-ui/lib/uni-combox/uni-combox.vue new file mode 100644 index 0000000..cc702c2 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-combox/uni-combox.vue @@ -0,0 +1,284 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-countdown/i18n/en.json b/node_modules/@dcloudio/uni-ui/lib/uni-countdown/i18n/en.json new file mode 100644 index 0000000..06309cb --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-countdown/i18n/en.json @@ -0,0 +1,6 @@ +{ + "uni-countdown.day": "day", + "uni-countdown.h": "h", + "uni-countdown.m": "m", + "uni-countdown.s": "s" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-countdown/i18n/index.js b/node_modules/@dcloudio/uni-ui/lib/uni-countdown/i18n/index.js new file mode 100644 index 0000000..de7509c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-countdown/i18n/index.js @@ -0,0 +1,8 @@ +import en from './en.json' +import zhHans from './zh-Hans.json' +import zhHant from './zh-Hant.json' +export default { + en, + 'zh-Hans': zhHans, + 'zh-Hant': zhHant +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-countdown/i18n/zh-Hans.json b/node_modules/@dcloudio/uni-ui/lib/uni-countdown/i18n/zh-Hans.json new file mode 100644 index 0000000..358cdd1 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-countdown/i18n/zh-Hans.json @@ -0,0 +1,6 @@ +{ + "uni-countdown.day": "天", + "uni-countdown.h": "时", + "uni-countdown.m": "分", + "uni-countdown.s": "秒" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-countdown/i18n/zh-Hant.json b/node_modules/@dcloudio/uni-ui/lib/uni-countdown/i18n/zh-Hant.json new file mode 100644 index 0000000..e5a63de --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-countdown/i18n/zh-Hant.json @@ -0,0 +1,6 @@ +{ + "uni-countdown.day": "天", + "uni-countdown.h": "時", + "uni-countdown.m": "分", + "uni-countdown.s": "秒" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-countdown/uni-countdown.vue b/node_modules/@dcloudio/uni-ui/lib/uni-countdown/uni-countdown.vue new file mode 100644 index 0000000..94a90ae --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-countdown/uni-countdown.vue @@ -0,0 +1,276 @@ + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-data-checkbox/uni-data-checkbox.vue b/node_modules/@dcloudio/uni-ui/lib/uni-data-checkbox/uni-data-checkbox.vue new file mode 100644 index 0000000..81d3f07 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-data-checkbox/uni-data-checkbox.vue @@ -0,0 +1,849 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-data-picker/keypress.js b/node_modules/@dcloudio/uni-ui/lib/uni-data-picker/keypress.js new file mode 100644 index 0000000..6ef26a2 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-data-picker/keypress.js @@ -0,0 +1,45 @@ +// #ifdef H5 +export default { + name: 'Keypress', + props: { + disable: { + type: Boolean, + default: false + } + }, + mounted () { + const keyNames = { + esc: ['Esc', 'Escape'], + tab: 'Tab', + enter: 'Enter', + space: [' ', 'Spacebar'], + up: ['Up', 'ArrowUp'], + left: ['Left', 'ArrowLeft'], + right: ['Right', 'ArrowRight'], + down: ['Down', 'ArrowDown'], + delete: ['Backspace', 'Delete', 'Del'] + } + const listener = ($event) => { + if (this.disable) { + return + } + const keyName = Object.keys(keyNames).find(key => { + const keyName = $event.key + const value = keyNames[key] + return value === keyName || (Array.isArray(value) && value.includes(keyName)) + }) + if (keyName) { + // 避免和其他按键事件冲突 + setTimeout(() => { + this.$emit(keyName, {}) + }, 0) + } + } + document.addEventListener('keyup', listener) + this.$once('hook:beforeDestroy', () => { + document.removeEventListener('keyup', listener) + }) + }, + render: () => {} +} +// #endif diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-data-picker/uni-data-picker.uvue b/node_modules/@dcloudio/uni-ui/lib/uni-data-picker/uni-data-picker.uvue new file mode 100644 index 0000000..82031e1 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-data-picker/uni-data-picker.uvue @@ -0,0 +1,380 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-data-picker/uni-data-picker.vue b/node_modules/@dcloudio/uni-ui/lib/uni-data-picker/uni-data-picker.vue new file mode 100644 index 0000000..179a4e0 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-data-picker/uni-data-picker.vue @@ -0,0 +1,551 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/loading.uts b/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/loading.uts new file mode 100644 index 0000000..baa0dff --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/loading.uts @@ -0,0 +1 @@ +export const imgbase : string = 'data:image/png;base64,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' \ No newline at end of file diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/uni-data-picker.js b/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/uni-data-picker.js new file mode 100644 index 0000000..cfae22a --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/uni-data-picker.js @@ -0,0 +1,622 @@ +export default { + props: { + localdata: { + type: [Array, Object], + default () { + return [] + } + }, + spaceInfo: { + type: Object, + default () { + return {} + } + }, + collection: { + type: String, + default: '' + }, + action: { + type: String, + default: '' + }, + field: { + type: String, + default: '' + }, + orderby: { + type: String, + default: '' + }, + where: { + type: [String, Object], + default: '' + }, + pageData: { + type: String, + default: 'add' + }, + pageCurrent: { + type: Number, + default: 1 + }, + pageSize: { + type: Number, + default: 500 + }, + getcount: { + type: [Boolean, String], + default: false + }, + getone: { + type: [Boolean, String], + default: false + }, + gettree: { + type: [Boolean, String], + default: false + }, + manual: { + type: Boolean, + default: false + }, + value: { + type: [Array, String, Number], + default () { + return [] + } + }, + modelValue: { + type: [Array, String, Number], + default () { + return [] + } + }, + preload: { + type: Boolean, + default: false + }, + stepSearh: { + type: Boolean, + default: true + }, + selfField: { + type: String, + default: '' + }, + parentField: { + type: String, + default: '' + }, + multiple: { + type: Boolean, + default: false + }, + map: { + type: Object, + default () { + return { + text: "text", + value: "value" + } + } + } + }, + data() { + return { + loading: false, + errorMessage: '', + loadMore: { + contentdown: '', + contentrefresh: '', + contentnomore: '' + }, + dataList: [], + selected: [], + selectedIndex: 0, + page: { + current: this.pageCurrent, + size: this.pageSize, + count: 0 + } + } + }, + computed: { + isLocalData() { + return !this.collection.length; + }, + isCloudData() { + return this.collection.length > 0; + }, + isCloudDataList() { + return (this.isCloudData && (!this.parentField && !this.selfField)); + }, + isCloudDataTree() { + return (this.isCloudData && this.parentField && this.selfField); + }, + dataValue() { + let isModelValue = Array.isArray(this.modelValue) ? (this.modelValue.length > 0) : (this.modelValue !== null || + this.modelValue !== undefined); + return isModelValue ? this.modelValue : this.value; + }, + hasValue() { + if (typeof this.dataValue === 'number') { + return true + } + return (this.dataValue != null) && (this.dataValue.length > 0) + } + }, + created() { + this.$watch(() => { + var al = []; + ['pageCurrent', + 'pageSize', + 'spaceInfo', + 'value', + 'modelValue', + 'localdata', + 'collection', + 'action', + 'field', + 'orderby', + 'where', + 'getont', + 'getcount', + 'gettree' + ].forEach(key => { + al.push(this[key]) + }); + return al + }, (newValue, oldValue) => { + let needReset = false + for (let i = 2; i < newValue.length; i++) { + if (newValue[i] != oldValue[i]) { + needReset = true + break + } + } + if (newValue[0] != oldValue[0]) { + this.page.current = this.pageCurrent + } + this.page.size = this.pageSize + + this.onPropsChange() + }) + this._treeData = [] + }, + methods: { + onPropsChange() { + this._treeData = []; + }, + + // 填充 pickview 数据 + async loadData() { + if (this.isLocalData) { + this.loadLocalData(); + } else if (this.isCloudDataList) { + this.loadCloudDataList(); + } else if (this.isCloudDataTree) { + this.loadCloudDataTree(); + } + }, + + // 加载本地数据 + async loadLocalData() { + this._treeData = []; + this._extractTree(this.localdata, this._treeData); + + let inputValue = this.dataValue; + if (inputValue === undefined) { + return; + } + + if (Array.isArray(inputValue)) { + inputValue = inputValue[inputValue.length - 1]; + if (typeof inputValue === 'object' && inputValue[this.map.value]) { + inputValue = inputValue[this.map.value]; + } + } + + this.selected = this._findNodePath(inputValue, this.localdata); + }, + + // 加载 Cloud 数据 (单列) + async loadCloudDataList() { + if (this.loading) { + return; + } + this.loading = true; + + try { + let response = await this.getCommand(); + let responseData = response.result.data; + + this._treeData = responseData; + + this._updateBindData(); + this._updateSelected(); + + this.onDataChange(); + } catch (e) { + this.errorMessage = e; + } finally { + this.loading = false; + } + }, + + // 加载 Cloud 数据 (树形) + async loadCloudDataTree() { + if (this.loading) { + return; + } + this.loading = true; + + try { + let commandOptions = { + field: this._cloudDataPostField(), + where: this._cloudDataTreeWhere() + }; + if (this.gettree) { + commandOptions.startwith = `${this.selfField}=='${this.dataValue}'`; + } + + let response = await this.getCommand(commandOptions); + let responseData = response.result.data; + + this._treeData = responseData; + this._updateBindData(); + this._updateSelected(); + + this.onDataChange(); + } catch (e) { + this.errorMessage = e; + } finally { + this.loading = false; + } + }, + + // 加载 Cloud 数据 (节点) + async loadCloudDataNode(callback) { + if (this.loading) { + return; + } + this.loading = true; + + try { + let commandOptions = { + field: this._cloudDataPostField(), + where: this._cloudDataNodeWhere() + }; + + let response = await this.getCommand(commandOptions); + let responseData = response.result.data; + + callback(responseData); + } catch (e) { + this.errorMessage = e; + } finally { + this.loading = false; + } + }, + + // 回显 Cloud 数据 + getCloudDataValue() { + if (this.isCloudDataList) { + return this.getCloudDataListValue(); + } + + if (this.isCloudDataTree) { + return this.getCloudDataTreeValue(); + } + }, + + // 回显 Cloud 数据 (单列) + getCloudDataListValue() { + // 根据 field's as value标识匹配 where 条件 + let where = []; + let whereField = this._getForeignKeyByField(); + if (whereField) { + where.push(`${whereField} == '${this.dataValue}'`) + } + + where = where.join(' || '); + + if (this.where) { + where = `(${this.where}) && (${where})` + } + + return this.getCommand({ + field: this._cloudDataPostField(), + where + }).then((res) => { + this.selected = res.result.data; + return res.result.data; + }); + }, + + // 回显 Cloud 数据 (树形) + getCloudDataTreeValue() { + return this.getCommand({ + field: this._cloudDataPostField(), + getTreePath: { + startWith: `${this.selfField}=='${this.dataValue}'` + } + }).then((res) => { + let treePath = []; + this._extractTreePath(res.result.data, treePath); + this.selected = treePath; + return treePath; + }); + }, + + getCommand(options = {}) { + /* eslint-disable no-undef */ + let db = uniCloud.database(this.spaceInfo) + + const action = options.action || this.action + if (action) { + db = db.action(action) + } + + const collection = options.collection || this.collection + db = db.collection(collection) + + const where = options.where || this.where + if (!(!where || !Object.keys(where).length)) { + db = db.where(where) + } + + const field = options.field || this.field + if (field) { + db = db.field(field) + } + + const orderby = options.orderby || this.orderby + if (orderby) { + db = db.orderBy(orderby) + } + + const current = options.pageCurrent !== undefined ? options.pageCurrent : this.page.current + const size = options.pageSize !== undefined ? options.pageSize : this.page.size + const getCount = options.getcount !== undefined ? options.getcount : this.getcount + const getTree = options.gettree !== undefined ? options.gettree : this.gettree + + const getOptions = { + getCount, + getTree + } + if (options.getTreePath) { + getOptions.getTreePath = options.getTreePath + } + + db = db.skip(size * (current - 1)).limit(size).get(getOptions) + + return db + }, + + _cloudDataPostField() { + let fields = [this.field]; + if (this.parentField) { + fields.push(`${this.parentField} as parent_value`); + } + return fields.join(','); + }, + + _cloudDataTreeWhere() { + let result = [] + let selected = this.selected + let parentField = this.parentField + if (parentField) { + result.push(`${parentField} == null || ${parentField} == ""`) + } + if (selected.length) { + for (var i = 0; i < selected.length - 1; i++) { + result.push(`${parentField} == '${selected[i].value}'`) + } + } + + let where = [] + if (this.where) { + where.push(`(${this.where})`) + } + + if (result.length) { + where.push(`(${result.join(' || ')})`) + } + + return where.join(' && ') + }, + + _cloudDataNodeWhere() { + let where = [] + let selected = this.selected; + if (selected.length) { + where.push(`${this.parentField} == '${selected[selected.length - 1].value}'`); + } + + where = where.join(' || '); + + if (this.where) { + return `(${this.where}) && (${where})` + } + + return where + }, + + _getWhereByForeignKey() { + let result = [] + let whereField = this._getForeignKeyByField(); + if (whereField) { + result.push(`${whereField} == '${this.dataValue}'`) + } + + if (this.where) { + return `(${this.where}) && (${result.join(' || ')})` + } + + return result.join(' || ') + }, + + _getForeignKeyByField() { + let fields = this.field.split(','); + let whereField = null; + for (let i = 0; i < fields.length; i++) { + const items = fields[i].split('as'); + if (items.length < 2) { + continue; + } + if (items[1].trim() === 'value') { + whereField = items[0].trim(); + break; + } + } + return whereField; + }, + + _updateBindData(node) { + const { + dataList, + hasNodes + } = this._filterData(this._treeData, this.selected) + + let isleaf = this._stepSearh === false && !hasNodes + + if (node) { + node.isleaf = isleaf + } + + this.dataList = dataList + this.selectedIndex = dataList.length - 1 + + if (!isleaf && this.selected.length < dataList.length) { + this.selected.push({ + value: null, + text: "请选择" + }) + } + + return { + isleaf, + hasNodes + } + }, + + _updateSelected() { + let dl = this.dataList + let sl = this.selected + let textField = this.map.text + let valueField = this.map.value + for (let i = 0; i < sl.length; i++) { + let value = sl[i].value + let dl2 = dl[i] + for (let j = 0; j < dl2.length; j++) { + let item2 = dl2[j] + if (item2[valueField] === value) { + sl[i].text = item2[textField] + break + } + } + } + }, + + _filterData(data, paths) { + let dataList = [] + let hasNodes = true + + dataList.push(data.filter((item) => { + return (item.parent_value === null || item.parent_value === undefined || item.parent_value === '') + })) + for (let i = 0; i < paths.length; i++) { + let value = paths[i].value + let nodes = data.filter((item) => { + return item.parent_value === value + }) + + if (nodes.length) { + dataList.push(nodes) + } else { + hasNodes = false + } + } + + return { + dataList, + hasNodes + } + }, + + _extractTree(nodes, result, parent_value) { + let list = result || [] + let valueField = this.map.value + for (let i = 0; i < nodes.length; i++) { + let node = nodes[i] + + let child = {} + for (let key in node) { + if (key !== 'children') { + child[key] = node[key] + } + } + if (parent_value !== null && parent_value !== undefined && parent_value !== '') { + child.parent_value = parent_value + } + result.push(child) + + let children = node.children + if (children) { + this._extractTree(children, result, node[valueField]) + } + } + }, + + _extractTreePath(nodes, result) { + let list = result || [] + for (let i = 0; i < nodes.length; i++) { + let node = nodes[i] + + let child = {} + for (let key in node) { + if (key !== 'children') { + child[key] = node[key] + } + } + result.push(child) + + let children = node.children + if (children) { + this._extractTreePath(children, result) + } + } + }, + + _findNodePath(key, nodes, path = []) { + let textField = this.map.text + let valueField = this.map.value + for (let i = 0; i < nodes.length; i++) { + let node = nodes[i] + let children = node.children + let text = node[textField] + let value = node[valueField] + + path.push({ + value, + text + }) + + if (value === key) { + return path + } + + if (children) { + const p = this._findNodePath(key, children, path) + if (p.length) { + return p + } + } + + path.pop() + } + return [] + } + } +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/uni-data-picker.uts b/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/uni-data-picker.uts new file mode 100644 index 0000000..372795d --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/uni-data-picker.uts @@ -0,0 +1,693 @@ +export type PaginationType = { + current : number, + size : number, + count : number +} + +export type LoadMoreType = { + contentdown : string, + contentrefresh : string, + contentnomore : string +} + +export type SelectedItemType = { + name : string, + value : string, +} + +export type GetCommandOptions = { + collection ?: UTSJSONObject, + field ?: string, + orderby ?: string, + where ?: any, + pageData ?: string, + pageCurrent ?: number, + pageSize ?: number, + getCount ?: boolean, + getTree ?: any, + getTreePath ?: UTSJSONObject, + startwith ?: string, + limitlevel ?: number, + groupby ?: string, + groupField ?: string, + distinct ?: boolean, + pageIndistinct ?: boolean, + foreignKey ?: string, + loadtime ?: string, + manual ?: boolean +} + +const DefaultSelectedNode = { + text: '请选择', + value: '' +} + +export const dataPicker = defineMixin({ + props: { + localdata: { + type: Array as PropType>, + default: [] as Array + }, + collection: { + type: Object, + default: '' + }, + field: { + type: String, + default: '' + }, + orderby: { + type: String, + default: '' + }, + where: { + type: Object, + default: '' + }, + pageData: { + type: String, + default: 'add' + }, + pageCurrent: { + type: Number, + default: 1 + }, + pageSize: { + type: Number, + default: 20 + }, + getcount: { + type: Boolean, + default: false + }, + gettree: { + type: Object, + default: '' + }, + gettreepath: { + type: Object, + default: '' + }, + startwith: { + type: String, + default: '' + }, + limitlevel: { + type: Number, + default: 10 + }, + groupby: { + type: String, + default: '' + }, + groupField: { + type: String, + default: '' + }, + distinct: { + type: Boolean, + default: false + }, + pageIndistinct: { + type: Boolean, + default: false + }, + foreignKey: { + type: String, + default: '' + }, + loadtime: { + type: String, + default: 'auto' + }, + manual: { + type: Boolean, + default: false + }, + preload: { + type: Boolean, + default: false + }, + stepSearh: { + type: Boolean, + default: true + }, + selfField: { + type: String, + default: '' + }, + parentField: { + type: String, + default: '' + }, + multiple: { + type: Boolean, + default: false + }, + value: { + type: Object, + default: '' + }, + modelValue: { + type: Object, + default: '' + }, + defaultProps: { + type: Object as PropType, + } + }, + data() { + return { + loading: false, + error: null as UniCloudError | null, + treeData: [] as Array, + selectedIndex: 0, + selectedNodes: [] as Array, + selectedPages: [] as Array[], + selectedValue: '', + selectedPaths: [] as Array, + pagination: { + current: 1, + size: 20, + count: 0 + } as PaginationType + } + }, + computed: { + mappingTextName() : string { + // TODO + return (this.defaultProps != null) ? this.defaultProps!.getString('text', 'text') : 'text' + }, + mappingValueName() : string { + // TODO + return (this.defaultProps != null) ? this.defaultProps!.getString('value', 'value') : 'value' + }, + currentDataList() : Array { + if (this.selectedIndex > this.selectedPages.length - 1) { + return [] as Array + } + return this.selectedPages[this.selectedIndex] + }, + isLocalData() : boolean { + return this.localdata.length > 0 + }, + isCloudData() : boolean { + return this._checkIsNotNull(this.collection) + }, + isCloudDataList() : boolean { + return (this.isCloudData && (this.parentField.length == 0 && this.selfField.length == 0)) + }, + isCloudDataTree() : boolean { + return (this.isCloudData && this.parentField.length > 0 && this.selfField.length > 0) + }, + dataValue() : any { + return this.hasModelValue ? this.modelValue : this.value + }, + hasCloudTreeData() : boolean { + return this.treeData.length > 0 + }, + hasModelValue() : boolean { + if (typeof this.modelValue == 'string') { + const valueString = this.modelValue as string + return (valueString.length > 0) + } else if (Array.isArray(this.modelValue)) { + const valueArray = this.modelValue as Array + return (valueArray.length > 0) + } + return false + }, + hasCloudDataValue() : boolean { + if (typeof this.dataValue == 'string') { + const valueString = this.dataValue as string + return (valueString.length > 0) + } + return false + } + }, + created() { + this.pagination.current = this.pageCurrent + this.pagination.size = this.pageSize + + this.$watch( + () : any => [ + this.pageCurrent, + this.pageSize, + this.localdata, + this.value, + this.collection, + this.field, + this.getcount, + this.orderby, + this.where, + this.groupby, + this.groupField, + this.distinct + ], + (newValue : Array, oldValue : Array) => { + this.pagination.size = this.pageSize + if (newValue[0] !== oldValue[0]) { + this.pagination.current = this.pageCurrent + } + + this.onPropsChange() + } + ) + }, + methods: { + onPropsChange() { + this.selectedIndex = 0 + this.treeData.length = 0 + this.selectedNodes.length = 0 + this.selectedPages.length = 0 + this.selectedPaths.length = 0 + + // 加载数据 + this.$nextTick(() => { + this.loadData() + }) + }, + + onTabSelect(index : number) { + this.selectedIndex = index + }, + + onNodeClick(nodeData : UTSJSONObject) { + if (nodeData.getBoolean('disable', false)) { + return + } + + const isLeaf = this._checkIsLeafNode(nodeData) + + this._trimSelectedNodes(nodeData) + + this.$emit('nodeclick', nodeData) + + if (this.isLocalData) { + if (isLeaf || !this._checkHasChildren(nodeData)) { + this.onFinish() + } + } else if (this.isCloudDataList) { + this.onFinish() + } else if (this.isCloudDataTree) { + if (isLeaf) { + this.onFinish() + } else if (!this._checkHasChildren(nodeData)) { + // 尝试请求一次，如果没有返回数据标记为叶子节点 + this.loadCloudDataNode(nodeData) + } + } + }, + + getChangeNodes(): Array { + const nodes: Array = [] + this.selectedNodes.forEach((node : UTSJSONObject) => { + const newNode: UTSJSONObject = {} + newNode[this.mappingTextName] = node.getString(this.mappingTextName) + newNode[this.mappingValueName] = node.getString(this.mappingValueName) + nodes.push(newNode) + }) + return nodes + }, + + onFinish() { }, + + // 加载数据(自动判定环境) + loadData() { + if (this.isLocalData) { + this.loadLocalData() + } else if (this.isCloudDataList) { + this.loadCloudDataList() + } else if (this.isCloudDataTree) { + this.loadCloudDataTree() + } + }, + + // 加载本地数据 + loadLocalData() { + this.treeData = this.localdata + if (Array.isArray(this.dataValue)) { + const value = this.dataValue as Array + this.selectedPaths = value.slice(0) + this._pushSelectedTreeNodes(value, this.localdata) + } else { + this._pushSelectedNodes(this.localdata) + } + }, + + // 加载 Cloud 数据 (单列) + loadCloudDataList() { + this._loadCloudData(null, (data : Array) => { + this.treeData = data + this._pushSelectedNodes(data) + }) + }, + + // 加载 Cloud 数据 (树形) + loadCloudDataTree() { + let commandOptions = { + field: this._cloudDataPostField(), + where: this._cloudDataTreeWhere(), + getTree: true + } as GetCommandOptions + if (this._checkIsNotNull(this.gettree)) { + commandOptions.startwith = `${this.selfField}=='${this.dataValue as string}'` + } + this._loadCloudData(commandOptions, (data : Array) => { + this.treeData = data + if (this.selectedPaths.length > 0) { + this._pushSelectedTreeNodes(this.selectedPaths, data) + } else { + this._pushSelectedNodes(data) + } + }) + }, + + // 加载 Cloud 数据 (节点) + loadCloudDataNode(nodeData : UTSJSONObject) { + const commandOptions = { + field: this._cloudDataPostField(), + where: this._cloudDataNodeWhere() + } as GetCommandOptions + this._loadCloudData(commandOptions, (data : Array) => { + nodeData['children'] = data + if (data.length == 0) { + nodeData['isleaf'] = true + this.onFinish() + } else { + this._pushSelectedNodes(data) + } + }) + }, + + // 回显 Cloud Tree Path + loadCloudDataPath() { + if (!this.hasCloudDataValue) { + return + } + + const command : GetCommandOptions = {} + + // 单列 + if (this.isCloudDataList) { + // 根据 field's as value标识匹配 where 条件 + let where : Array = []; + let whereField = this._getForeignKeyByField(); + if (whereField.length > 0) { + where.push(`${whereField} == '${this.dataValue as string}'`) + } + + let whereString = where.join(' || ') + if (this._checkIsNotNull(this.where)) { + whereString = `(${this.where}) && (${whereString})` + } + + command.field = this._cloudDataPostField() + command.where = whereString + } + + // 树形 + if (this.isCloudDataTree) { + command.field = this._cloudDataPostField() + command.getTreePath = { + startWith: `${this.selfField}=='${this.dataValue as string}'` + } + } + + this._loadCloudData(command, (data : Array) => { + this._extractTreePath(data, this.selectedPaths) + }) + }, + + _loadCloudData(options ?: GetCommandOptions, callback ?: ((data : Array) => void)) { + if (this.loading) { + return + } + this.loading = true + + this.error = null + + this._getCommand(options).then((response : UniCloudDBGetResult) => { + callback?.(response.data) + }).catch((err : any | null) => { + this.error = err as UniCloudError + }).finally(() => { + this.loading = false + }) + }, + + _cloudDataPostField() : string { + let fields = [this.field]; + if (this.parentField.length > 0) { + fields.push(`${this.parentField} as parent_value`) + } + return fields.join(',') + }, + + _cloudDataTreeWhere() : string { + let result : Array = [] + let selectedNodes = this.selectedNodes.length > 0 ? this.selectedNodes : this.selectedPaths + let parentField = this.parentField + if (parentField.length > 0) { + result.push(`${parentField} == null || ${parentField} == ""`) + } + if (selectedNodes.length > 0) { + for (var i = 0; i < selectedNodes.length - 1; i++) { + const parentFieldValue = selectedNodes[i].getString('value', '') + result.push(`${parentField} == '${parentFieldValue}'`) + } + } + + let where : Array = [] + if (this._checkIsNotNull(this.where)) { + where.push(`(${this.where as string})`) + } + + if (result.length > 0) { + where.push(`(${result.join(' || ')})`) + } + + return where.join(' && ') + }, + + _cloudDataNodeWhere() : string { + const where : Array = [] + if (this.selectedNodes.length > 0) { + const value = this.selectedNodes[this.selectedNodes.length - 1].getString('value', '') + where.push(`${this.parentField} == '${value}'`) + } + + let whereString = where.join(' || ') + if (this._checkIsNotNull(this.where)) { + return `(${this.where as string}) && (${whereString})` + } + + return whereString + }, + + _getWhereByForeignKey() : string { + let result : Array = [] + let whereField = this._getForeignKeyByField(); + if (whereField.length > 0) { + result.push(`${whereField} == '${this.dataValue as string}'`) + } + + if (this._checkIsNotNull(this.where)) { + return `(${this.where}) && (${result.join(' || ')})` + } + + return result.join(' || ') + }, + + _getForeignKeyByField() : string { + const fields = this.field.split(',') + let whereField = '' + for (let i = 0; i < fields.length; i++) { + const items = fields[i].split('as') + if (items.length < 2) { + continue + } + if (items[1].trim() === 'value') { + whereField = items[0].trim() + break + } + } + return whereField + }, + + _getCommand(options ?: GetCommandOptions) : Promise { + let db = uniCloud.databaseForJQL() + + let collection = Array.isArray(this.collection) ? db.collection(...(this.collection as Array)) : db.collection(this.collection) + + let filter : UniCloudDBFilter | null = null + if (this.foreignKey.length > 0) { + filter = collection.foreignKey(this.foreignKey) + } + + const where : any = options?.where ?? this.where + if (typeof where == 'string') { + const whereString = where as string + if (whereString.length > 0) { + filter = (filter != null) ? filter.where(where) : collection.where(where) + } + } else { + filter = (filter != null) ? filter.where(where) : collection.where(where) + } + + let query : UniCloudDBQuery | null = null + if (this.field.length > 0) { + query = (filter != null) ? filter.field(this.field) : collection.field(this.field) + } + if (this.groupby.length > 0) { + if (query != null) { + query = query.groupBy(this.groupby) + } else if (filter != null) { + query = filter.groupBy(this.groupby) + } + } + if (this.groupField.length > 0) { + if (query != null) { + query = query.groupField(this.groupField) + } else if (filter != null) { + query = filter.groupField(this.groupField) + } + } + if (this.distinct == true) { + if (query != null) { + query = query.distinct(this.field) + } else if (filter != null) { + query = filter.distinct(this.field) + } + } + if (this.orderby.length > 0) { + if (query != null) { + query = query.orderBy(this.orderby) + } else if (filter != null) { + query = filter.orderBy(this.orderby) + } + } + + const size = this.pagination.size + const current = this.pagination.current + if (query != null) { + query = query.skip(size * (current - 1)).limit(size) + } else if (filter != null) { + query = filter.skip(size * (current - 1)).limit(size) + } else { + query = collection.skip(size * (current - 1)).limit(size) + } + + const getOptions = {} + const treeOptions = { + limitLevel: this.limitlevel, + startWith: this.startwith + } + if (this.getcount == true) { + getOptions['getCount'] = this.getcount + } + + const getTree : any = options?.getTree ?? this.gettree + if (typeof getTree == 'string') { + const getTreeString = getTree as string + if (getTreeString.length > 0) { + getOptions['getTree'] = treeOptions + } + } else if (typeof getTree == 'object') { + getOptions['getTree'] = treeOptions + } else { + getOptions['getTree'] = getTree + } + + const getTreePath = options?.getTreePath ?? this.gettreepath + if (typeof getTreePath == 'string') { + const getTreePathString = getTreePath as string + if (getTreePathString.length > 0) { + getOptions['getTreePath'] = getTreePath + } + } else { + getOptions['getTreePath'] = getTreePath + } + + return query.get(getOptions) + }, + + _checkIsNotNull(value : any) : boolean { + if (typeof value == 'string') { + const valueString = value as string + return (valueString.length > 0) + } else if (value instanceof UTSJSONObject) { + return true + } + return false + }, + + _checkIsLeafNode(nodeData : UTSJSONObject) : boolean { + if (this.selectedIndex >= this.limitlevel) { + return true + } + + if (nodeData.getBoolean('isleaf', false)) { + return true + } + + return false + }, + + _checkHasChildren(nodeData : UTSJSONObject) : boolean { + const children = nodeData.getArray('children') ?? ([] as Array) + return children.length > 0 + }, + + _pushSelectedNodes(nodes : Array) { + this.selectedNodes.push(DefaultSelectedNode) + this.selectedPages.push(nodes) + this.selectedIndex = this.selectedPages.length - 1 + }, + + _trimSelectedNodes(nodeData : UTSJSONObject) { + this.selectedNodes.splice(this.selectedIndex) + this.selectedNodes.push(nodeData) + + if (this.selectedPages.length > 0) { + this.selectedPages.splice(this.selectedIndex + 1) + } + + const children = nodeData.getArray('children') ?? ([] as Array) + if (children.length > 0) { + this.selectedNodes.push(DefaultSelectedNode) + this.selectedPages.push(children) + } + + this.selectedIndex = this.selectedPages.length - 1 + }, + + _pushSelectedTreeNodes(paths : Array, nodes : Array) { + let children : Array = nodes + paths.forEach((node : UTSJSONObject) => { + const findNode = children.find((item : UTSJSONObject) : boolean => { + return (item.getString(this.mappingValueName) == node.getString(this.mappingValueName)) + }) + if (findNode != null) { + this.selectedPages.push(children) + this.selectedNodes.push(node) + children = findNode.getArray('children') ?? ([] as Array) + } + }) + this.selectedIndex = this.selectedPages.length - 1 + }, + + _extractTreePath(nodes : Array, result : Array) { + if (nodes.length == 0) { + return + } + + const node = nodes[0] + result.push(node) + + const children = node.getArray('children') + if (Array.isArray(children) && children!.length > 0) { + this._extractTreePath(children, result) + } + } + } +}) diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/uni-data-pickerview.css b/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/uni-data-pickerview.css new file mode 100644 index 0000000..39fe1c3 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/uni-data-pickerview.css @@ -0,0 +1,76 @@ +.uni-data-pickerview { + position: relative; + flex-direction: column; + overflow: hidden; +} + +.loading-cover { + position: absolute; + left: 0; + top: 0; + right: 0; + bottom: 0; + align-items: center; + justify-content: center; + background-color: rgba(150, 150, 150, .1); +} + +.error { + background-color: #fff; + padding: 15px; +} + +.error-text { + color: #DD524D; +} + +.selected-node-list { + flex-direction: row; + flex-wrap: nowrap; +} + +.selected-node-item { + margin-left: 10px; + margin-right: 10px; + padding: 8px 10px 8px 10px; + border-bottom: 2px solid transparent; +} + +.selected-node-item-active { + color: #007aff; + border-bottom-color: #007aff; +} + +.list-view { + flex: 1; +} + +.list-item { + flex-direction: row; + justify-content: space-between; + padding: 12px 15px; + border-bottom: 1px solid #f0f0f0; +} + +.item-text { + color: #333333; +} + +.item-text-disabled { + opacity: .5; +} + +.item-text-overflow { + overflow: hidden; +} + +.check { + margin-right: 5px; + border: 2px solid #007aff; + border-left: 0; + border-top: 0; + height: 12px; + width: 6px; + transform-origin: center; + transform: rotate(45deg); +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/uni-data-pickerview.uvue b/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/uni-data-pickerview.uvue new file mode 100644 index 0000000..f4780f3 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/uni-data-pickerview.uvue @@ -0,0 +1,69 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/uni-data-pickerview.vue b/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/uni-data-pickerview.vue new file mode 100644 index 0000000..6ebced9 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-data-pickerview/uni-data-pickerview.vue @@ -0,0 +1,323 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-data-select/uni-data-select.vue b/node_modules/@dcloudio/uni-ui/lib/uni-data-select/uni-data-select.vue new file mode 100644 index 0000000..81ec116 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-data-select/uni-data-select.vue @@ -0,0 +1,560 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-dateformat/date-format.js b/node_modules/@dcloudio/uni-ui/lib/uni-dateformat/date-format.js new file mode 100644 index 0000000..e00d559 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-dateformat/date-format.js @@ -0,0 +1,200 @@ +// yyyy-MM-dd hh:mm:ss.SSS 所有支持的类型 +function pad(str, length = 2) { + str += '' + while (str.length < length) { + str = '0' + str + } + return str.slice(-length) +} + +const parser = { + yyyy: (dateObj) => { + return pad(dateObj.year, 4) + }, + yy: (dateObj) => { + return pad(dateObj.year) + }, + MM: (dateObj) => { + return pad(dateObj.month) + }, + M: (dateObj) => { + return dateObj.month + }, + dd: (dateObj) => { + return pad(dateObj.day) + }, + d: (dateObj) => { + return dateObj.day + }, + hh: (dateObj) => { + return pad(dateObj.hour) + }, + h: (dateObj) => { + return dateObj.hour + }, + mm: (dateObj) => { + return pad(dateObj.minute) + }, + m: (dateObj) => { + return dateObj.minute + }, + ss: (dateObj) => { + return pad(dateObj.second) + }, + s: (dateObj) => { + return dateObj.second + }, + SSS: (dateObj) => { + return pad(dateObj.millisecond, 3) + }, + S: (dateObj) => { + return dateObj.millisecond + }, +} + +// 这都n年了iOS依然不认识2020-12-12，需要转换为2020/12/12 +function getDate(time) { + if (time instanceof Date) { + return time + } + switch (typeof time) { + case 'string': + { + // 2020-12-12T12:12:12.000Z、2020-12-12T12:12:12.000 + if (time.indexOf('T') > -1) { + return new Date(time) + } + return new Date(time.replace(/-/g, '/')) + } + default: + return new Date(time) + } +} + +export function formatDate(date, format = 'yyyy/MM/dd hh:mm:ss') { + if (!date && date !== 0) { + return '' + } + date = getDate(date) + const dateObj = { + year: date.getFullYear(), + month: date.getMonth() + 1, + day: date.getDate(), + hour: date.getHours(), + minute: date.getMinutes(), + second: date.getSeconds(), + millisecond: date.getMilliseconds() + } + const tokenRegExp = /yyyy|yy|MM|M|dd|d|hh|h|mm|m|ss|s|SSS|SS|S/ + let flag = true + let result = format + while (flag) { + flag = false + result = result.replace(tokenRegExp, function(matched) { + flag = true + return parser[matched](dateObj) + }) + } + return result +} + +export function friendlyDate(time, { + locale = 'zh', + threshold = [60000, 3600000], + format = 'yyyy/MM/dd hh:mm:ss' +}) { + if (time === '-') { + return time + } + if (!time && time !== 0) { + return '' + } + const localeText = { + zh: { + year: '年', + month: '月', + day: '天', + hour: '小时', + minute: '分钟', + second: '秒', + ago: '前', + later: '后', + justNow: '刚刚', + soon: '马上', + template: '{num}{unit}{suffix}' + }, + en: { + year: 'year', + month: 'month', + day: 'day', + hour: 'hour', + minute: 'minute', + second: 'second', + ago: 'ago', + later: 'later', + justNow: 'just now', + soon: 'soon', + template: '{num} {unit} {suffix}' + } + } + const text = localeText[locale] || localeText.zh + let date = getDate(time) + let ms = date.getTime() - Date.now() + let absMs = Math.abs(ms) + if (absMs < threshold[0]) { + return ms < 0 ? text.justNow : text.soon + } + if (absMs >= threshold[1]) { + return formatDate(date, format) + } + let num + let unit + let suffix = text.later + if (ms < 0) { + suffix = text.ago + ms = -ms + } + const seconds = Math.floor((ms) / 1000) + const minutes = Math.floor(seconds / 60) + const hours = Math.floor(minutes / 60) + const days = Math.floor(hours / 24) + const months = Math.floor(days / 30) + const years = Math.floor(months / 12) + switch (true) { + case years > 0: + num = years + unit = text.year + break + case months > 0: + num = months + unit = text.month + break + case days > 0: + num = days + unit = text.day + break + case hours > 0: + num = hours + unit = text.hour + break + case minutes > 0: + num = minutes + unit = text.minute + break + default: + num = seconds + unit = text.second + break + } + + if (locale === 'en') { + if (num === 1) { + num = 'a' + } else { + unit += 's' + } + } + + return text.template.replace(/{\s*num\s*}/g, num + '').replace(/{\s*unit\s*}/g, unit).replace(/{\s*suffix\s*}/g, + suffix) +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-dateformat/uni-dateformat.vue b/node_modules/@dcloudio/uni-ui/lib/uni-dateformat/uni-dateformat.vue new file mode 100644 index 0000000..c5ed030 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-dateformat/uni-dateformat.vue @@ -0,0 +1,88 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/calendar-item.vue b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/calendar-item.vue new file mode 100644 index 0000000..dba9887 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/calendar-item.vue @@ -0,0 +1,177 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/calendar.vue b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/calendar.vue new file mode 100644 index 0000000..0f9e121 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/calendar.vue @@ -0,0 +1,947 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/i18n/en.json b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/i18n/en.json new file mode 100644 index 0000000..024f22f --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/i18n/en.json @@ -0,0 +1,22 @@ +{ + "uni-datetime-picker.selectDate": "select date", + "uni-datetime-picker.selectTime": "select time", + "uni-datetime-picker.selectDateTime": "select date and time", + "uni-datetime-picker.startDate": "start date", + "uni-datetime-picker.endDate": "end date", + "uni-datetime-picker.startTime": "start time", + "uni-datetime-picker.endTime": "end time", + "uni-datetime-picker.ok": "ok", + "uni-datetime-picker.clear": "clear", + "uni-datetime-picker.cancel": "cancel", + "uni-datetime-picker.year": "-", + "uni-datetime-picker.month": "", + "uni-calender.MON": "MON", + "uni-calender.TUE": "TUE", + "uni-calender.WED": "WED", + "uni-calender.THU": "THU", + "uni-calender.FRI": "FRI", + "uni-calender.SAT": "SAT", + "uni-calender.SUN": "SUN", + "uni-calender.confirm": "confirm" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/i18n/index.js b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/i18n/index.js new file mode 100644 index 0000000..de7509c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/i18n/index.js @@ -0,0 +1,8 @@ +import en from './en.json' +import zhHans from './zh-Hans.json' +import zhHant from './zh-Hant.json' +export default { + en, + 'zh-Hans': zhHans, + 'zh-Hant': zhHant +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/i18n/zh-Hans.json b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/i18n/zh-Hans.json new file mode 100644 index 0000000..d2df5e7 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/i18n/zh-Hans.json @@ -0,0 +1,22 @@ +{ + "uni-datetime-picker.selectDate": "选择日期", + "uni-datetime-picker.selectTime": "选择时间", + "uni-datetime-picker.selectDateTime": "选择日期时间", + "uni-datetime-picker.startDate": "开始日期", + "uni-datetime-picker.endDate": "结束日期", + "uni-datetime-picker.startTime": "开始时间", + "uni-datetime-picker.endTime": "结束时间", + "uni-datetime-picker.ok": "确定", + "uni-datetime-picker.clear": "清除", + "uni-datetime-picker.cancel": "取消", + "uni-datetime-picker.year": "年", + "uni-datetime-picker.month": "月", + "uni-calender.SUN": "日", + "uni-calender.MON": "一", + "uni-calender.TUE": "二", + "uni-calender.WED": "三", + "uni-calender.THU": "四", + "uni-calender.FRI": "五", + "uni-calender.SAT": "六", + "uni-calender.confirm": "确认" +} \ No newline at end of file diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/i18n/zh-Hant.json b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/i18n/zh-Hant.json new file mode 100644 index 0000000..d23fa3c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/i18n/zh-Hant.json @@ -0,0 +1,22 @@ +{ + "uni-datetime-picker.selectDate": "選擇日期", + "uni-datetime-picker.selectTime": "選擇時間", + "uni-datetime-picker.selectDateTime": "選擇日期時間", + "uni-datetime-picker.startDate": "開始日期", + "uni-datetime-picker.endDate": "結束日期", + "uni-datetime-picker.startTime": "開始时间", + "uni-datetime-picker.endTime": "結束时间", + "uni-datetime-picker.ok": "確定", + "uni-datetime-picker.clear": "清除", + "uni-datetime-picker.cancel": "取消", + "uni-datetime-picker.year": "年", + "uni-datetime-picker.month": "月", + "uni-calender.SUN": "日", + "uni-calender.MON": "一", + "uni-calender.TUE": "二", + "uni-calender.WED": "三", + "uni-calender.THU": "四", + "uni-calender.FRI": "五", + "uni-calender.SAT": "六", + "uni-calender.confirm": "確認" +} \ No newline at end of file diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/time-picker.vue b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/time-picker.vue new file mode 100644 index 0000000..1817692 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/time-picker.vue @@ -0,0 +1,940 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/uni-datetime-picker.vue b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/uni-datetime-picker.vue new file mode 100644 index 0000000..6843e80 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/uni-datetime-picker.vue @@ -0,0 +1,1064 @@ + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/util.js b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/util.js new file mode 100644 index 0000000..6e9f47d --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-datetime-picker/util.js @@ -0,0 +1,421 @@ +class Calendar { + constructor({ + selected, + startDate, + endDate, + range, + } = {}) { + // 当前日期 + this.date = this.getDateObj(new Date()) // 当前初入日期 + // 打点信息 + this.selected = selected || []; + // 起始时间 + this.startDate = startDate + // 终止时间 + this.endDate = endDate + // 是否范围选择 + this.range = range + // 多选状态 + this.cleanMultipleStatus() + // 每周日期 + this.weeks = {} + this.lastHover = false + } + /** + * 设置日期 + * @param {Object} date + */ + setDate(date) { + const selectDate = this.getDateObj(date) + this.getWeeks(selectDate.fullDate) + } + + /** + * 清理多选状态 + */ + cleanMultipleStatus() { + this.multipleStatus = { + before: '', + after: '', + data: [] + } + } + + setStartDate(startDate) { + this.startDate = startDate + } + + setEndDate(endDate) { + this.endDate = endDate + } + + getPreMonthObj(date) { + date = fixIosDateFormat(date) + date = new Date(date) + + const oldMonth = date.getMonth() + date.setMonth(oldMonth - 1) + const newMonth = date.getMonth() + if (oldMonth !== 0 && newMonth - oldMonth === 0) { + date.setMonth(newMonth - 1) + } + return this.getDateObj(date) + } + getNextMonthObj(date) { + date = fixIosDateFormat(date) + date = new Date(date) + + const oldMonth = date.getMonth() + date.setMonth(oldMonth + 1) + const newMonth = date.getMonth() + if (newMonth - oldMonth > 1) { + date.setMonth(newMonth - 1) + } + return this.getDateObj(date) + } + + /** + * 获取指定格式Date对象 + */ + getDateObj(date) { + date = fixIosDateFormat(date) + date = new Date(date) + + return { + fullDate: getDate(date), + year: date.getFullYear(), + month: addZero(date.getMonth() + 1), + date: addZero(date.getDate()), + day: date.getDay() + } + } + + /** + * 获取上一个月日期集合 + */ + getPreMonthDays(amount, dateObj) { + const result = [] + for (let i = amount - 1; i >= 0; i--) { + const month = dateObj.month - 1 + result.push({ + date: new Date(dateObj.year, month, -i).getDate(), + month, + disable: true + }) + } + return result + } + /** + * 获取本月日期集合 + */ + getCurrentMonthDays(amount, dateObj) { + const result = [] + const fullDate = this.date.fullDate + for (let i = 1; i <= amount; i++) { + const currentDate = `${dateObj.year}-${dateObj.month}-${addZero(i)}` + const isToday = fullDate === currentDate + // 获取打点信息 + const info = this.selected && this.selected.find((item) => { + if (this.dateEqual(currentDate, item.date)) { + return item + } + }) + + // 日期禁用 + let disableBefore = true + let disableAfter = true + if (this.startDate) { + disableBefore = dateCompare(this.startDate, currentDate) + } + + if (this.endDate) { + disableAfter = dateCompare(currentDate, this.endDate) + } + + let multiples = this.multipleStatus.data + let multiplesStatus = -1 + if (this.range && multiples) { + multiplesStatus = multiples.findIndex((item) => { + return this.dateEqual(item, currentDate) + }) + } + const checked = multiplesStatus !== -1 + + result.push({ + fullDate: currentDate, + year: dateObj.year, + date: i, + multiple: this.range ? checked : false, + beforeMultiple: this.isLogicBefore(currentDate, this.multipleStatus.before, this.multipleStatus.after), + afterMultiple: this.isLogicAfter(currentDate, this.multipleStatus.before, this.multipleStatus.after), + month: dateObj.month, + disable: (this.startDate && !dateCompare(this.startDate, currentDate)) || (this.endDate && !dateCompare( + currentDate, this.endDate)), + isToday, + userChecked: false, + extraInfo: info + }) + } + return result + } + /** + * 获取下一个月日期集合 + */ + _getNextMonthDays(amount, dateObj) { + const result = [] + const month = dateObj.month + 1 + for (let i = 1; i <= amount; i++) { + result.push({ + date: i, + month, + disable: true + }) + } + return result + } + + /** + * 获取当前日期详情 + * @param {Object} date + */ + getInfo(date) { + if (!date) { + date = new Date() + } + const res = this.calendar.find(item => item.fullDate === this.getDateObj(date).fullDate) + return res ? res : this.getDateObj(date) + } + + /** + * 比较时间是否相等 + */ + dateEqual(before, after) { + before = new Date(fixIosDateFormat(before)) + after = new Date(fixIosDateFormat(after)) + return before.valueOf() === after.valueOf() + } + + /** + * 比较真实起始日期 + */ + + isLogicBefore(currentDate, before, after) { + let logicBefore = before + if (before && after) { + logicBefore = dateCompare(before, after) ? before : after + } + return this.dateEqual(logicBefore, currentDate) + } + + isLogicAfter(currentDate, before, after) { + let logicAfter = after + if (before && after) { + logicAfter = dateCompare(before, after) ? after : before + } + return this.dateEqual(logicAfter, currentDate) + } + + /** + * 获取日期范围内所有日期 + * @param {Object} begin + * @param {Object} end + */ + geDateAll(begin, end) { + var arr = [] + var ab = begin.split('-') + var ae = end.split('-') + var db = new Date() + db.setFullYear(ab[0], ab[1] - 1, ab[2]) + var de = new Date() + de.setFullYear(ae[0], ae[1] - 1, ae[2]) + var unixDb = db.getTime() - 24 * 60 * 60 * 1000 + var unixDe = de.getTime() - 24 * 60 * 60 * 1000 + for (var k = unixDb; k <= unixDe;) { + k = k + 24 * 60 * 60 * 1000 + arr.push(this.getDateObj(new Date(parseInt(k))).fullDate) + } + return arr + } + + /** + * 获取多选状态 + */ + setMultiple(fullDate) { + if (!this.range) return + + let { + before, + after + } = this.multipleStatus + if (before && after) { + if (!this.lastHover) { + this.lastHover = true + return + } + this.multipleStatus.before = fullDate + this.multipleStatus.after = '' + this.multipleStatus.data = [] + this.multipleStatus.fulldate = '' + this.lastHover = false + } else { + if (!before) { + this.multipleStatus.before = fullDate + this.multipleStatus.after = undefined; + this.lastHover = false + } else { + this.multipleStatus.after = fullDate + if (dateCompare(this.multipleStatus.before, this.multipleStatus.after)) { + this.multipleStatus.data = this.geDateAll(this.multipleStatus.before, this.multipleStatus + .after); + } else { + this.multipleStatus.data = this.geDateAll(this.multipleStatus.after, this.multipleStatus + .before); + } + this.lastHover = true + } + } + this.getWeeks(fullDate) + } + + /** + * 鼠标 hover 更新多选状态 + */ + setHoverMultiple(fullDate) { + //抖音小程序点击会触发hover事件，需要避免一下 + // #ifndef MP-TOUTIAO + if (!this.range || this.lastHover) return + const { + before + } = this.multipleStatus + + if (!before) { + this.multipleStatus.before = fullDate + } else { + this.multipleStatus.after = fullDate + if (dateCompare(this.multipleStatus.before, this.multipleStatus.after)) { + this.multipleStatus.data = this.geDateAll(this.multipleStatus.before, this.multipleStatus.after); + } else { + this.multipleStatus.data = this.geDateAll(this.multipleStatus.after, this.multipleStatus.before); + } + } + this.getWeeks(fullDate) + // #endif + + } + + /** + * 更新默认值多选状态 + */ + setDefaultMultiple(before, after) { + this.multipleStatus.before = before + this.multipleStatus.after = after + if (before && after) { + if (dateCompare(before, after)) { + this.multipleStatus.data = this.geDateAll(before, after); + this.getWeeks(after) + } else { + this.multipleStatus.data = this.geDateAll(after, before); + this.getWeeks(before) + } + } + } + + /** + * 获取每周数据 + * @param {Object} dateData + */ + getWeeks(dateData) { + const { + year, + month, + } = this.getDateObj(dateData) + + const preMonthDayAmount = new Date(year, month - 1, 1).getDay() + const preMonthDays = this.getPreMonthDays(preMonthDayAmount, this.getDateObj(dateData)) + + const currentMonthDayAmount = new Date(year, month, 0).getDate() + const currentMonthDays = this.getCurrentMonthDays(currentMonthDayAmount, this.getDateObj(dateData)) + + const nextMonthDayAmount = 42 - preMonthDayAmount - currentMonthDayAmount + const nextMonthDays = this._getNextMonthDays(nextMonthDayAmount, this.getDateObj(dateData)) + + const calendarDays = [...preMonthDays, ...currentMonthDays, ...nextMonthDays] + + const weeks = new Array(6) + for (let i = 0; i < calendarDays.length; i++) { + const index = Math.floor(i / 7) + if (!weeks[index]) { + weeks[index] = new Array(7) + } + weeks[index][i % 7] = calendarDays[i] + } + + this.calendar = calendarDays + this.weeks = weeks + } +} + +function getDateTime(date, hideSecond) { + return `${getDate(date)} ${getTime(date, hideSecond)}` +} + +function getDate(date) { + date = fixIosDateFormat(date) + date = new Date(date) + const year = date.getFullYear() + const month = date.getMonth() + 1 + const day = date.getDate() + return `${year}-${addZero(month)}-${addZero(day)}` +} + +function getTime(date, hideSecond) { + date = fixIosDateFormat(date) + date = new Date(date) + const hour = date.getHours() + const minute = date.getMinutes() + const second = date.getSeconds() + return hideSecond ? `${addZero(hour)}:${addZero(minute)}` : `${addZero(hour)}:${addZero(minute)}:${addZero(second)}` +} + +function addZero(num) { + if (num < 10) { + num = `0${num}` + } + return num +} + +function getDefaultSecond(hideSecond) { + return hideSecond ? '00:00' : '00:00:00' +} + +function dateCompare(startDate, endDate) { + startDate = new Date(fixIosDateFormat(startDate)) + endDate = new Date(fixIosDateFormat(endDate)) + return startDate <= endDate +} + +function checkDate(date) { + const dateReg = /((19|20)\d{2})(-|\/)\d{1,2}(-|\/)\d{1,2}/g + return date.match(dateReg) +} +//ios低版本15及以下，无法匹配 没有 ’秒‘ 时的情况，所以需要在末尾 秒 加上 问号 +const dateTimeReg = /^\d{4}-(0?[1-9]|1[012])-(0?[1-9]|[12][0-9]|3[01])( [0-5]?[0-9]:[0-5]?[0-9](:[0-5]?[0-9])?)?$/; + +function fixIosDateFormat(value) { + if (typeof value === 'string' && dateTimeReg.test(value)) { + value = value.replace(/-/g, '/') + } + return value +} + +export { + Calendar, + getDateTime, + getDate, + getTime, + addZero, + getDefaultSecond, + dateCompare, + checkDate, + fixIosDateFormat +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-drawer/keypress.js b/node_modules/@dcloudio/uni-ui/lib/uni-drawer/keypress.js new file mode 100644 index 0000000..62dda46 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-drawer/keypress.js @@ -0,0 +1,45 @@ +// #ifdef H5 +export default { + name: 'Keypress', + props: { + disable: { + type: Boolean, + default: false + } + }, + mounted () { + const keyNames = { + esc: ['Esc', 'Escape'], + tab: 'Tab', + enter: 'Enter', + space: [' ', 'Spacebar'], + up: ['Up', 'ArrowUp'], + left: ['Left', 'ArrowLeft'], + right: ['Right', 'ArrowRight'], + down: ['Down', 'ArrowDown'], + delete: ['Backspace', 'Delete', 'Del'] + } + const listener = ($event) => { + if (this.disable) { + return + } + const keyName = Object.keys(keyNames).find(key => { + const keyName = $event.key + const value = keyNames[key] + return value === keyName || (Array.isArray(value) && value.includes(keyName)) + }) + if (keyName) { + // 避免和其他按键事件冲突 + setTimeout(() => { + this.$emit(keyName, {}) + }, 0) + } + } + document.addEventListener('keyup', listener) + // this.$once('hook:beforeDestroy', () => { + // document.removeEventListener('keyup', listener) + // }) + }, + render: () => {} +} +// #endif diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-drawer/uni-drawer.vue b/node_modules/@dcloudio/uni-ui/lib/uni-drawer/uni-drawer.vue new file mode 100644 index 0000000..2471521 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-drawer/uni-drawer.vue @@ -0,0 +1,183 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-easyinput/common.js b/node_modules/@dcloudio/uni-ui/lib/uni-easyinput/common.js new file mode 100644 index 0000000..fde8d3c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-easyinput/common.js @@ -0,0 +1,54 @@ +/** + * @desc 函数防抖 + * @param func 目标函数 + * @param wait 延迟执行毫秒数 + * @param immediate true - 立即执行， false - 延迟执行 + */ +export const debounce = function(func, wait = 1000, immediate = true) { + let timer; + return function() { + let context = this, + args = arguments; + if (timer) clearTimeout(timer); + if (immediate) { + let callNow = !timer; + timer = setTimeout(() => { + timer = null; + }, wait); + if (callNow) func.apply(context, args); + } else { + timer = setTimeout(() => { + func.apply(context, args); + }, wait) + } + } +} +/** + * @desc 函数节流 + * @param func 函数 + * @param wait 延迟执行毫秒数 + * @param type 1 使用表时间戳，在时间段开始的时候触发 2 使用表定时器，在时间段结束的时候触发 + */ +export const throttle = (func, wait = 1000, type = 1) => { + let previous = 0; + let timeout; + return function() { + let context = this; + let args = arguments; + if (type === 1) { + let now = Date.now(); + + if (now - previous > wait) { + func.apply(context, args); + previous = now; + } + } else if (type === 2) { + if (!timeout) { + timeout = setTimeout(() => { + timeout = null; + func.apply(context, args) + }, wait) + } + } + } +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-easyinput/uni-easyinput.vue b/node_modules/@dcloudio/uni-ui/lib/uni-easyinput/uni-easyinput.vue new file mode 100644 index 0000000..93506d6 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-easyinput/uni-easyinput.vue @@ -0,0 +1,676 @@ + + + + + \ No newline at end of file diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-fab/uni-fab.vue b/node_modules/@dcloudio/uni-ui/lib/uni-fab/uni-fab.vue new file mode 100644 index 0000000..492b5d1 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-fab/uni-fab.vue @@ -0,0 +1,491 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-fav/i18n/en.json b/node_modules/@dcloudio/uni-ui/lib/uni-fav/i18n/en.json new file mode 100644 index 0000000..9a0759e --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-fav/i18n/en.json @@ -0,0 +1,4 @@ +{ + "uni-fav.collect": "collect", + "uni-fav.collected": "collected" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-fav/i18n/index.js b/node_modules/@dcloudio/uni-ui/lib/uni-fav/i18n/index.js new file mode 100644 index 0000000..de7509c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-fav/i18n/index.js @@ -0,0 +1,8 @@ +import en from './en.json' +import zhHans from './zh-Hans.json' +import zhHant from './zh-Hant.json' +export default { + en, + 'zh-Hans': zhHans, + 'zh-Hant': zhHant +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-fav/i18n/zh-Hans.json b/node_modules/@dcloudio/uni-ui/lib/uni-fav/i18n/zh-Hans.json new file mode 100644 index 0000000..67c89bf --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-fav/i18n/zh-Hans.json @@ -0,0 +1,4 @@ +{ + "uni-fav.collect": "收藏", + "uni-fav.collected": "已收藏" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-fav/i18n/zh-Hant.json b/node_modules/@dcloudio/uni-ui/lib/uni-fav/i18n/zh-Hant.json new file mode 100644 index 0000000..67c89bf --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-fav/i18n/zh-Hant.json @@ -0,0 +1,4 @@ +{ + "uni-fav.collect": "收藏", + "uni-fav.collected": "已收藏" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-fav/uni-fav.vue b/node_modules/@dcloudio/uni-ui/lib/uni-fav/uni-fav.vue new file mode 100644 index 0000000..d2c58df --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-fav/uni-fav.vue @@ -0,0 +1,161 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-file-picker/choose-and-upload-file.js b/node_modules/@dcloudio/uni-ui/lib/uni-file-picker/choose-and-upload-file.js new file mode 100644 index 0000000..9c6bcdf --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-file-picker/choose-and-upload-file.js @@ -0,0 +1,287 @@ +'use strict'; + +const ERR_MSG_OK = 'chooseAndUploadFile:ok'; +const ERR_MSG_FAIL = 'chooseAndUploadFile:fail'; + +function chooseImage(opts) { + const { + count, + sizeType = ['original', 'compressed'], + sourceType, + extension + } = opts + return new Promise((resolve, reject) => { + // 微信由于旧接口不再维护，针对微信小程序平台改用chooseMedia接口 + // #ifdef MP-WEIXIN + uni.chooseMedia({ + count, + sizeType, + sourceType, + mediaType: ['image'], + extension, + success(res) { + res.tempFiles.forEach(item => { + item.path = item.tempFilePath; + }) + resolve(normalizeChooseAndUploadFileRes(res, 'image')); + }, + fail(res) { + reject({ + errMsg: res.errMsg.replace('chooseImage:fail', ERR_MSG_FAIL), + }); + }, + }) + // #endif + // #ifndef MP-WEIXIN + uni.chooseImage({ + count, + sizeType, + sourceType, + extension, + success(res) { + resolve(normalizeChooseAndUploadFileRes(res, 'image')); + }, + fail(res) { + reject({ + errMsg: res.errMsg.replace('chooseImage:fail', ERR_MSG_FAIL), + }); + }, + }); + // #endif + + }); +} + +function chooseVideo(opts) { + const { + count, + camera, + compressed, + maxDuration, + sourceType, + extension + } = opts; + return new Promise((resolve, reject) => { + // 微信由于旧接口不再维护，针对微信小程序平台改用chooseMedia接口 + // #ifdef MP-WEIXIN + uni.chooseMedia({ + count, + compressed, + maxDuration, + sourceType, + extension, + mediaType: ['video'], + success(res) { + const { + tempFiles, + } = res; + resolve(normalizeChooseAndUploadFileRes({ + errMsg: 'chooseVideo:ok', + tempFiles: tempFiles.map(item => { + return { + name: item.name || '', + path: item.tempFilePath, + thumbTempFilePath: item.thumbTempFilePath, + size:item.size, + type: (res.tempFile && res.tempFile.type) || '', + width:item.width, + height:item.height, + duration:item.duration, + fileType: 'video', + cloudPath: '', + } + }), + }, 'video')); + }, + fail(res) { + reject({ + errMsg: res.errMsg.replace('chooseVideo:fail', ERR_MSG_FAIL), + }); + }, + }) + // #endif + // #ifndef MP-WEIXIN + uni.chooseVideo({ + camera, + compressed, + maxDuration, + sourceType, + extension, + success(res) { + const { + tempFilePath, + duration, + size, + height, + width + } = res; + resolve(normalizeChooseAndUploadFileRes({ + errMsg: 'chooseVideo:ok', + tempFilePaths: [tempFilePath], + tempFiles: [{ + name: (res.tempFile && res.tempFile.name) || '', + path: tempFilePath, + size, + type: (res.tempFile && res.tempFile.type) || '', + width, + height, + duration, + fileType: 'video', + cloudPath: '', + }, ], + }, 'video')); + }, + fail(res) { + reject({ + errMsg: res.errMsg.replace('chooseVideo:fail', ERR_MSG_FAIL), + }); + }, + }); + // #endif + }); +} + +function chooseAll(opts) { + const { + count, + extension + } = opts; + return new Promise((resolve, reject) => { + let chooseFile = uni.chooseFile; + if (typeof wx !== 'undefined' && + typeof wx.chooseMessageFile === 'function') { + chooseFile = wx.chooseMessageFile; + } + if (typeof chooseFile !== 'function') { + return reject({ + errMsg: ERR_MSG_FAIL + ' 请指定 type 类型，该平台仅支持选择 image 或 video。', + }); + } + chooseFile({ + type: 'all', + count, + extension, + success(res) { + resolve(normalizeChooseAndUploadFileRes(res)); + }, + fail(res) { + reject({ + errMsg: res.errMsg.replace('chooseFile:fail', ERR_MSG_FAIL), + }); + }, + }); + }); +} + +function normalizeChooseAndUploadFileRes(res, fileType) { + res.tempFiles.forEach((item, index) => { + if (!item.name) { + item.name = item.path.substring(item.path.lastIndexOf('/') + 1); + } + if (fileType) { + item.fileType = fileType; + } + item.cloudPath = + Date.now() + '_' + index + item.name.substring(item.name.lastIndexOf('.')); + }); + if (!res.tempFilePaths) { + res.tempFilePaths = res.tempFiles.map((file) => file.path); + } + return res; +} + +function uploadCloudFiles(files, max = 5, onUploadProgress) { + files = JSON.parse(JSON.stringify(files)) + const len = files.length + let count = 0 + let self = this + return new Promise(resolve => { + while (count < max) { + next() + } + + function next() { + let cur = count++ + if (cur >= len) { + !files.find(item => !item.url && !item.errMsg) && resolve(files) + return + } + const fileItem = files[cur] + const index = self.files.findIndex(v => v.uuid === fileItem.uuid) + fileItem.url = '' + delete fileItem.errMsg + + uniCloud + .uploadFile({ + filePath: fileItem.path, + cloudPath: fileItem.cloudPath, + fileType: fileItem.fileType, + onUploadProgress: res => { + res.index = index + onUploadProgress && onUploadProgress(res) + } + }) + .then(res => { + fileItem.url = res.fileID + fileItem.index = index + if (cur < len) { + next() + } + }) + .catch(res => { + fileItem.errMsg = res.errMsg || res.message + fileItem.index = index + if (cur < len) { + next() + } + }) + } + }) +} + + + + + +function uploadFiles(choosePromise, { + onChooseFile, + onUploadProgress +}) { + return choosePromise + .then((res) => { + if (onChooseFile) { + const customChooseRes = onChooseFile(res); + if (typeof customChooseRes !== 'undefined') { + return Promise.resolve(customChooseRes).then((chooseRes) => typeof chooseRes === 'undefined' ? + res : chooseRes); + } + } + return res; + }) + .then((res) => { + if (res === false) { + return { + errMsg: ERR_MSG_OK, + tempFilePaths: [], + tempFiles: [], + }; + } + return res + }) +} + +function chooseAndUploadFile(opts = { + type: 'all' +}) { + if (opts.type === 'image') { + return uploadFiles(chooseImage(opts), opts); + } else if (opts.type === 'video') { + return uploadFiles(chooseVideo(opts), opts); + } + return uploadFiles(chooseAll(opts), opts); +} + +export { + chooseAndUploadFile, + uploadCloudFiles +}; diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-file-picker/uni-file-picker.vue b/node_modules/@dcloudio/uni-ui/lib/uni-file-picker/uni-file-picker.vue new file mode 100644 index 0000000..785c7eb --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-file-picker/uni-file-picker.vue @@ -0,0 +1,668 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-file-picker/upload-file.vue b/node_modules/@dcloudio/uni-ui/lib/uni-file-picker/upload-file.vue new file mode 100644 index 0000000..625d92e --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-file-picker/upload-file.vue @@ -0,0 +1,325 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-file-picker/upload-image.vue b/node_modules/@dcloudio/uni-ui/lib/uni-file-picker/upload-image.vue new file mode 100644 index 0000000..2a29bc2 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-file-picker/upload-image.vue @@ -0,0 +1,292 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-file-picker/utils.js b/node_modules/@dcloudio/uni-ui/lib/uni-file-picker/utils.js new file mode 100644 index 0000000..1bc9259 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-file-picker/utils.js @@ -0,0 +1,110 @@ +/** + * 获取文件名和后缀 + * @param {String} name + */ +export const get_file_ext = (name) => { + const last_len = name.lastIndexOf('.') + const len = name.length + return { + name: name.substring(0, last_len), + ext: name.substring(last_len + 1, len) + } +} + +/** + * 获取扩展名 + * @param {Array} fileExtname + */ +export const get_extname = (fileExtname) => { + if (!Array.isArray(fileExtname)) { + let extname = fileExtname.replace(/(\[|\])/g, '') + return extname.split(',') + } else { + return fileExtname + } + return [] +} + +/** + * 获取文件和检测是否可选 + */ +export const get_files_and_is_max = (res, _extname) => { + let filePaths = [] + let files = [] + if(!_extname || _extname.length === 0){ + return { + filePaths, + files + } + } + res.tempFiles.forEach(v => { + let fileFullName = get_file_ext(v.name) + const extname = fileFullName.ext.toLowerCase() + if (_extname.indexOf(extname) !== -1) { + files.push(v) + filePaths.push(v.path) + } + }) + if (files.length !== res.tempFiles.length) { + uni.showToast({ + title: `当前选择了${res.tempFiles.length}个文件 ，${res.tempFiles.length - files.length} 个文件格式不正确`, + icon: 'none', + duration: 5000 + }) + } + + return { + filePaths, + files + } +} + + +/** + * 获取图片信息 + * @param {Object} filepath + */ +export const get_file_info = (filepath) => { + return new Promise((resolve, reject) => { + uni.getImageInfo({ + src: filepath, + success(res) { + resolve(res) + }, + fail(err) { + reject(err) + } + }) + }) +} +/** + * 获取封装数据 + */ +export const get_file_data = async (files, type = 'image') => { + // 最终需要上传数据库的数据 + let fileFullName = get_file_ext(files.name) + const extname = fileFullName.ext.toLowerCase() + let filedata = { + name: files.name, + uuid: files.uuid, + extname: extname || '', + cloudPath: files.cloudPath, + fileType: files.fileType, + thumbTempFilePath: files.thumbTempFilePath, + url: files.path || files.path, + size: files.size, //单位是字节 + image: {}, + path: files.path, + video: {} + } + if (type === 'image') { + const imageinfo = await get_file_info(files.path) + delete filedata.video + filedata.image.width = imageinfo.width + filedata.image.height = imageinfo.height + filedata.image.location = imageinfo.path + } else { + delete filedata.image + } + return filedata +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-forms-item/uni-forms-item.vue b/node_modules/@dcloudio/uni-ui/lib/uni-forms-item/uni-forms-item.vue new file mode 100644 index 0000000..c924882 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-forms-item/uni-forms-item.vue @@ -0,0 +1,632 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-forms/uni-forms.vue b/node_modules/@dcloudio/uni-ui/lib/uni-forms/uni-forms.vue new file mode 100644 index 0000000..d061313 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-forms/uni-forms.vue @@ -0,0 +1,404 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-forms/utils.js b/node_modules/@dcloudio/uni-ui/lib/uni-forms/utils.js new file mode 100644 index 0000000..6da2421 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-forms/utils.js @@ -0,0 +1,293 @@ +/** + * 简单处理对象拷贝 + * @param {Obejct} 被拷贝对象 + * @@return {Object} 拷贝对象 + */ +export const deepCopy = (val) => { + return JSON.parse(JSON.stringify(val)) +} +/** + * 过滤数字类型 + * @param {String} format 数字类型 + * @@return {Boolean} 返回是否为数字类型 + */ +export const typeFilter = (format) => { + return format === 'int' || format === 'double' || format === 'number' || format === 'timestamp'; +} + +/** + * 把 value 转换成指定的类型，用于处理初始值，原因是初始值需要入库不能为 undefined + * @param {String} key 字段名 + * @param {any} value 字段值 + * @param {Object} rules 表单校验规则 + */ +export const getValue = (key, value, rules) => { + const isRuleNumType = rules.find(val => val.format && typeFilter(val.format)); + const isRuleBoolType = rules.find(val => (val.format && val.format === 'boolean') || val.format === 'bool'); + // 输入类型为 number + if (!!isRuleNumType) { + if (!value && value !== 0) { + value = null + } else { + value = isNumber(Number(value)) ? Number(value) : value + } + } + + // 输入类型为 boolean + if (!!isRuleBoolType) { + value = isBoolean(value) ? value : false + } + + return value; +} + +/** + * 获取表单数据 + * @param {String|Array} name 真实名称，需要使用 realName 获取 + * @param {Object} data 原始数据 + * @param {any} value 需要设置的值 + */ +export const setDataValue = (field, formdata, value) => { + formdata[field] = value + return value || '' +} + +/** + * 获取表单数据 + * @param {String|Array} field 真实名称，需要使用 realName 获取 + * @param {Object} data 原始数据 + */ +export const getDataValue = (field, data) => { + return objGet(data, field) +} + +/** + * 获取表单类型 + * @param {String|Array} field 真实名称，需要使用 realName 获取 + */ +export const getDataValueType = (field, data) => { + const value = getDataValue(field, data) + return { + type: type(value), + value + } +} + +/** + * 获取表单可用的真实name + * @param {String|Array} name 表单name + * @@return {String} 表单可用的真实name + */ +export const realName = (name, data = {}) => { + const base_name = _basePath(name) + if (typeof base_name === 'object' && Array.isArray(base_name) && base_name.length > 1) { + const realname = base_name.reduce((a, b) => a += `#${b}`, '_formdata_') + return realname + } + return base_name[0] || name +} + +/** + * 判断是否表单可用的真实name + * @param {String|Array} name 表单name + * @@return {String} 表单可用的真实name + */ +export const isRealName = (name) => { + const reg = /^_formdata_#*/ + return reg.test(name) +} + +/** + * 获取表单数据的原始格式 + * @@return {Object|Array} object 需要解析的数据 + */ +export const rawData = (object = {}, name) => { + let newData = JSON.parse(JSON.stringify(object)) + let formData = {} + for(let i in newData){ + let path = name2arr(i) + objSet(formData,path,newData[i]) + } + return formData +} + +/** + * 真实name还原为 array + * @param {*} name + */ +export const name2arr = (name) => { + let field = name.replace('_formdata_#', '') + field = field.split('#').map(v => (isNumber(v) ? Number(v) : v)) + return field +} + +/** + * 对象中设置值 + * @param {Object|Array} object 源数据 + * @param {String| Array} path 'a.b.c' 或 ['a',0,'b','c'] + * @param {String} value 需要设置的值 + */ +export const objSet = (object, path, value) => { + if (typeof object !== 'object') return object; + _basePath(path).reduce((o, k, i, _) => { + if (i === _.length - 1) { + // 若遍历结束直接赋值 + o[k] = value + return null + } else if (k in o) { + // 若存在对应路径，则返回找到的对象，进行下一次遍历 + return o[k] + } else { + // 若不存在对应路径，则创建对应对象，若下一路径是数字，新对象赋值为空数组，否则赋值为空对象 + o[k] = /^[0-9]{1,}$/.test(_[i + 1]) ? [] : {} + return o[k] + } + }, object) + // 返回object + return object; +} + +// 处理 path， path有三种形式：'a[0].b.c'、'a.0.b.c' 和 ['a','0','b','c']，需要统一处理成数组，便于后续使用 +function _basePath(path) { + // 若是数组，则直接返回 + if (Array.isArray(path)) return path + // 若有 '[',']'，则替换成将 '[' 替换成 '.',去掉 ']' + return path.replace(/\[/g, '.').replace(/\]/g, '').split('.') +} + +/** + * 从对象中获取值 + * @param {Object|Array} object 源数据 + * @param {String| Array} path 'a.b.c' 或 ['a',0,'b','c'] + * @param {String} defaultVal 如果无法从调用链中获取值的默认值 + */ +export const objGet = (object, path, defaultVal = 'undefined') => { + // 先将path处理成统一格式 + let newPath = _basePath(path) + // 递归处理，返回最后结果 + let val = newPath.reduce((o, k) => { + return (o || {})[k] + }, object); + return !val || val !== undefined ? val : defaultVal +} + + +/** + * 是否为 number 类型 + * @param {any} num 需要判断的值 + * @return {Boolean} 是否为 number + */ +export const isNumber = (num) => { + return !isNaN(Number(num)) +} + +/** + * 是否为 boolean 类型 + * @param {any} bool 需要判断的值 + * @return {Boolean} 是否为 boolean + */ +export const isBoolean = (bool) => { + return (typeof bool === 'boolean') +} +/** + * 是否有必填字段 + * @param {Object} rules 规则 + * @return {Boolean} 是否有必填字段 + */ +export const isRequiredField = (rules) => { + let isNoField = false; + for (let i = 0; i < rules.length; i++) { + const ruleData = rules[i]; + if (ruleData.required) { + isNoField = true; + break; + } + } + return isNoField; +} + + +/** + * 获取数据类型 + * @param {Any} obj 需要获取数据类型的值 + */ +export const type = (obj) => { + var class2type = {}; + + // 生成class2type映射 + "Boolean Number String Function Array Date RegExp Object Error".split(" ").map(function(item, index) { + class2type["[object " + item + "]"] = item.toLowerCase(); + }) + if (obj == null) { + return obj + ""; + } + return typeof obj === "object" || typeof obj === "function" ? + class2type[Object.prototype.toString.call(obj)] || "object" : + typeof obj; +} + +/** + * 判断两个值是否相等 + * @param {any} a 值 + * @param {any} b 值 + * @return {Boolean} 是否相等 + */ +export const isEqual = (a, b) => { + //如果a和b本来就全等 + if (a === b) { + //判断是否为0和-0 + return a !== 0 || 1 / a === 1 / b; + } + //判断是否为null和undefined + if (a == null || b == null) { + return a === b; + } + //接下来判断a和b的数据类型 + var classNameA = toString.call(a), + classNameB = toString.call(b); + //如果数据类型不相等，则返回false + if (classNameA !== classNameB) { + return false; + } + //如果数据类型相等，再根据不同数据类型分别判断 + switch (classNameA) { + case '[object RegExp]': + case '[object String]': + //进行字符串转换比较 + return '' + a === '' + b; + case '[object Number]': + //进行数字转换比较,判断是否为NaN + if (+a !== +a) { + return +b !== +b; + } + //判断是否为0或-0 + return +a === 0 ? 1 / +a === 1 / b : +a === +b; + case '[object Date]': + case '[object Boolean]': + return +a === +b; + } + //如果是对象类型 + if (classNameA == '[object Object]') { + //获取a和b的属性长度 + var propsA = Object.getOwnPropertyNames(a), + propsB = Object.getOwnPropertyNames(b); + if (propsA.length != propsB.length) { + return false; + } + for (var i = 0; i < propsA.length; i++) { + var propName = propsA[i]; + //如果对应属性对应值不相等，则返回false + if (a[propName] !== b[propName]) { + return false; + } + } + return true; + } + //如果是数组类型 + if (classNameA == '[object Array]') { + if (a.toString() == b.toString()) { + return true; + } + return false; + } +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-forms/validate.js b/node_modules/@dcloudio/uni-ui/lib/uni-forms/validate.js new file mode 100644 index 0000000..1834c6c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-forms/validate.js @@ -0,0 +1,486 @@ +var pattern = { + email: /^\S+?@\S+?\.\S+?$/, + idcard: /^[1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/, + url: new RegExp( + "^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$", + 'i') +}; + +const FORMAT_MAPPING = { + "int": 'integer', + "bool": 'boolean', + "double": 'number', + "long": 'number', + "password": 'string' + // "fileurls": 'array' +} + +function formatMessage(args, resources = '') { + var defaultMessage = ['label'] + defaultMessage.forEach((item) => { + if (args[item] === undefined) { + args[item] = '' + } + }) + + let str = resources + for (let key in args) { + let reg = new RegExp('{' + key + '}') + str = str.replace(reg, args[key]) + } + return str +} + +function isEmptyValue(value, type) { + if (value === undefined || value === null) { + return true; + } + + if (typeof value === 'string' && !value) { + return true; + } + + if (Array.isArray(value) && !value.length) { + return true; + } + + if (type === 'object' && !Object.keys(value).length) { + return true; + } + + return false; +} + +const types = { + integer(value) { + return types.number(value) && parseInt(value, 10) === value; + }, + string(value) { + return typeof value === 'string'; + }, + number(value) { + if (isNaN(value)) { + return false; + } + return typeof value === 'number'; + }, + "boolean": function(value) { + return typeof value === 'boolean'; + }, + "float": function(value) { + return types.number(value) && !types.integer(value); + }, + array(value) { + return Array.isArray(value); + }, + object(value) { + return typeof value === 'object' && !types.array(value); + }, + date(value) { + return value instanceof Date; + }, + timestamp(value) { + if (!this.integer(value) || Math.abs(value).toString().length > 16) { + return false + } + return true; + }, + file(value) { + return typeof value.url === 'string'; + }, + email(value) { + return typeof value === 'string' && !!value.match(pattern.email) && value.length < 255; + }, + url(value) { + return typeof value === 'string' && !!value.match(pattern.url); + }, + pattern(reg, value) { + try { + return new RegExp(reg).test(value); + } catch (e) { + return false; + } + }, + method(value) { + return typeof value === 'function'; + }, + idcard(value) { + return typeof value === 'string' && !!value.match(pattern.idcard); + }, + 'url-https'(value) { + return this.url(value) && value.startsWith('https://'); + }, + 'url-scheme'(value) { + return value.startsWith('://'); + }, + 'url-web'(value) { + return false; + } +} + +class RuleValidator { + + constructor(message) { + this._message = message + } + + async validateRule(fieldKey, fieldValue, value, data, allData) { + var result = null + + let rules = fieldValue.rules + + let hasRequired = rules.findIndex((item) => { + return item.required + }) + if (hasRequired < 0) { + if (value === null || value === undefined) { + return result + } + if (typeof value === 'string' && !value.length) { + return result + } + } + + var message = this._message + + if (rules === undefined) { + return message['default'] + } + + for (var i = 0; i < rules.length; i++) { + let rule = rules[i] + let vt = this._getValidateType(rule) + + Object.assign(rule, { + label: fieldValue.label || `["${fieldKey}"]` + }) + + if (RuleValidatorHelper[vt]) { + result = RuleValidatorHelper[vt](rule, value, message) + if (result != null) { + break + } + } + + if (rule.validateExpr) { + let now = Date.now() + let resultExpr = rule.validateExpr(value, allData, now) + if (resultExpr === false) { + result = this._getMessage(rule, rule.errorMessage || this._message['default']) + break + } + } + + if (rule.validateFunction) { + result = await this.validateFunction(rule, value, data, allData, vt) + if (result !== null) { + break + } + } + } + + if (result !== null) { + result = message.TAG + result + } + + return result + } + + async validateFunction(rule, value, data, allData, vt) { + let result = null + try { + let callbackMessage = null + const res = await rule.validateFunction(rule, value, allData || data, (message) => { + callbackMessage = message + }) + if (callbackMessage || (typeof res === 'string' && res) || res === false) { + result = this._getMessage(rule, callbackMessage || res, vt) + } + } catch (e) { + result = this._getMessage(rule, e.message, vt) + } + return result + } + + _getMessage(rule, message, vt) { + return formatMessage(rule, message || rule.errorMessage || this._message[vt] || message['default']) + } + + _getValidateType(rule) { + var result = '' + if (rule.required) { + result = 'required' + } else if (rule.format) { + result = 'format' + } else if (rule.arrayType) { + result = 'arrayTypeFormat' + } else if (rule.range) { + result = 'range' + } else if (rule.maximum !== undefined || rule.minimum !== undefined) { + result = 'rangeNumber' + } else if (rule.maxLength !== undefined || rule.minLength !== undefined) { + result = 'rangeLength' + } else if (rule.pattern) { + result = 'pattern' + } else if (rule.validateFunction) { + result = 'validateFunction' + } + return result + } +} + +const RuleValidatorHelper = { + required(rule, value, message) { + if (rule.required && isEmptyValue(value, rule.format || typeof value)) { + return formatMessage(rule, rule.errorMessage || message.required); + } + + return null + }, + + range(rule, value, message) { + const { + range, + errorMessage + } = rule; + + let list = new Array(range.length); + for (let i = 0; i < range.length; i++) { + const item = range[i]; + if (types.object(item) && item.value !== undefined) { + list[i] = item.value; + } else { + list[i] = item; + } + } + + let result = false + if (Array.isArray(value)) { + result = (new Set(value.concat(list)).size === list.length); + } else { + if (list.indexOf(value) > -1) { + result = true; + } + } + + if (!result) { + return formatMessage(rule, errorMessage || message['enum']); + } + + return null + }, + + rangeNumber(rule, value, message) { + if (!types.number(value)) { + return formatMessage(rule, rule.errorMessage || message.pattern.mismatch); + } + + let { + minimum, + maximum, + exclusiveMinimum, + exclusiveMaximum + } = rule; + let min = exclusiveMinimum ? value <= minimum : value < minimum; + let max = exclusiveMaximum ? value >= maximum : value > maximum; + + if (minimum !== undefined && min) { + return formatMessage(rule, rule.errorMessage || message['number'][exclusiveMinimum ? + 'exclusiveMinimum' : 'minimum' + ]) + } else if (maximum !== undefined && max) { + return formatMessage(rule, rule.errorMessage || message['number'][exclusiveMaximum ? + 'exclusiveMaximum' : 'maximum' + ]) + } else if (minimum !== undefined && maximum !== undefined && (min || max)) { + return formatMessage(rule, rule.errorMessage || message['number'].range) + } + + return null + }, + + rangeLength(rule, value, message) { + if (!types.string(value) && !types.array(value)) { + return formatMessage(rule, rule.errorMessage || message.pattern.mismatch); + } + + let min = rule.minLength; + let max = rule.maxLength; + let val = value.length; + + if (min !== undefined && val < min) { + return formatMessage(rule, rule.errorMessage || message['length'].minLength) + } else if (max !== undefined && val > max) { + return formatMessage(rule, rule.errorMessage || message['length'].maxLength) + } else if (min !== undefined && max !== undefined && (val < min || val > max)) { + return formatMessage(rule, rule.errorMessage || message['length'].range) + } + + return null + }, + + pattern(rule, value, message) { + if (!types['pattern'](rule.pattern, value)) { + return formatMessage(rule, rule.errorMessage || message.pattern.mismatch); + } + + return null + }, + + format(rule, value, message) { + var customTypes = Object.keys(types); + var format = FORMAT_MAPPING[rule.format] ? FORMAT_MAPPING[rule.format] : (rule.format || rule.arrayType); + + if (customTypes.indexOf(format) > -1) { + if (!types[format](value)) { + return formatMessage(rule, rule.errorMessage || message.typeError); + } + } + + return null + }, + + arrayTypeFormat(rule, value, message) { + if (!Array.isArray(value)) { + return formatMessage(rule, rule.errorMessage || message.typeError); + } + + for (let i = 0; i < value.length; i++) { + const element = value[i]; + let formatResult = this.format(rule, element, message) + if (formatResult !== null) { + return formatResult + } + } + + return null + } +} + +class SchemaValidator extends RuleValidator { + + constructor(schema, options) { + super(SchemaValidator.message); + + this._schema = schema + this._options = options || null + } + + updateSchema(schema) { + this._schema = schema + } + + async validate(data, allData) { + let result = this._checkFieldInSchema(data) + if (!result) { + result = await this.invokeValidate(data, false, allData) + } + return result.length ? result[0] : null + } + + async validateAll(data, allData) { + let result = this._checkFieldInSchema(data) + if (!result) { + result = await this.invokeValidate(data, true, allData) + } + return result + } + + async validateUpdate(data, allData) { + let result = this._checkFieldInSchema(data) + if (!result) { + result = await this.invokeValidateUpdate(data, false, allData) + } + return result.length ? result[0] : null + } + + async invokeValidate(data, all, allData) { + let result = [] + let schema = this._schema + for (let key in schema) { + let value = schema[key] + let errorMessage = await this.validateRule(key, value, data[key], data, allData) + if (errorMessage != null) { + result.push({ + key, + errorMessage + }) + if (!all) break + } + } + return result + } + + async invokeValidateUpdate(data, all, allData) { + let result = [] + for (let key in data) { + let errorMessage = await this.validateRule(key, this._schema[key], data[key], data, allData) + if (errorMessage != null) { + result.push({ + key, + errorMessage + }) + if (!all) break + } + } + return result + } + + _checkFieldInSchema(data) { + var keys = Object.keys(data) + var keys2 = Object.keys(this._schema) + if (new Set(keys.concat(keys2)).size === keys2.length) { + return '' + } + + var noExistFields = keys.filter((key) => { + return keys2.indexOf(key) < 0; + }) + var errorMessage = formatMessage({ + field: JSON.stringify(noExistFields) + }, SchemaValidator.message.TAG + SchemaValidator.message['defaultInvalid']) + return [{ + key: 'invalid', + errorMessage + }] + } +} + +function Message() { + return { + TAG: "", + default: '验证错误', + defaultInvalid: '提交的字段{field}在数据库中并不存在', + validateFunction: '验证无效', + required: '{label}必填', + 'enum': '{label}超出范围', + timestamp: '{label}格式无效', + whitespace: '{label}不能为空', + typeError: '{label}类型无效', + date: { + format: '{label}日期{value}格式无效', + parse: '{label}日期无法解析,{value}无效', + invalid: '{label}日期{value}无效' + }, + length: { + minLength: '{label}长度不能少于{minLength}', + maxLength: '{label}长度不能超过{maxLength}', + range: '{label}必须介于{minLength}和{maxLength}之间' + }, + number: { + minimum: '{label}不能小于{minimum}', + maximum: '{label}不能大于{maximum}', + exclusiveMinimum: '{label}不能小于等于{minimum}', + exclusiveMaximum: '{label}不能大于等于{maximum}', + range: '{label}必须介于{minimum}and{maximum}之间' + }, + pattern: { + mismatch: '{label}格式不匹配' + } + }; +} + + +SchemaValidator.message = new Message(); + +export default SchemaValidator diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-goods-nav/i18n/en.json b/node_modules/@dcloudio/uni-ui/lib/uni-goods-nav/i18n/en.json new file mode 100644 index 0000000..dcdba41 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-goods-nav/i18n/en.json @@ -0,0 +1,6 @@ +{ + "uni-goods-nav.options.shop": "shop", + "uni-goods-nav.options.cart": "cart", + "uni-goods-nav.buttonGroup.addToCart": "add to cart", + "uni-goods-nav.buttonGroup.buyNow": "buy now" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-goods-nav/i18n/index.js b/node_modules/@dcloudio/uni-ui/lib/uni-goods-nav/i18n/index.js new file mode 100644 index 0000000..de7509c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-goods-nav/i18n/index.js @@ -0,0 +1,8 @@ +import en from './en.json' +import zhHans from './zh-Hans.json' +import zhHant from './zh-Hant.json' +export default { + en, + 'zh-Hans': zhHans, + 'zh-Hant': zhHant +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-goods-nav/i18n/zh-Hans.json b/node_modules/@dcloudio/uni-ui/lib/uni-goods-nav/i18n/zh-Hans.json new file mode 100644 index 0000000..48ee344 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-goods-nav/i18n/zh-Hans.json @@ -0,0 +1,6 @@ +{ + "uni-goods-nav.options.shop": "店铺", + "uni-goods-nav.options.cart": "购物车", + "uni-goods-nav.buttonGroup.addToCart": "加入购物车", + "uni-goods-nav.buttonGroup.buyNow": "立即购买" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-goods-nav/i18n/zh-Hant.json b/node_modules/@dcloudio/uni-ui/lib/uni-goods-nav/i18n/zh-Hant.json new file mode 100644 index 0000000..d0a0255 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-goods-nav/i18n/zh-Hant.json @@ -0,0 +1,6 @@ +{ + "uni-goods-nav.options.shop": "店鋪", + "uni-goods-nav.options.cart": "購物車", + "uni-goods-nav.buttonGroup.addToCart": "加入購物車", + "uni-goods-nav.buttonGroup.buyNow": "立即購買" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-goods-nav/uni-goods-nav.vue b/node_modules/@dcloudio/uni-ui/lib/uni-goods-nav/uni-goods-nav.vue new file mode 100644 index 0000000..e79a0fa --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-goods-nav/uni-goods-nav.vue @@ -0,0 +1,231 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-grid-item/uni-grid-item.vue b/node_modules/@dcloudio/uni-ui/lib/uni-grid-item/uni-grid-item.vue new file mode 100644 index 0000000..19c08d7 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-grid-item/uni-grid-item.vue @@ -0,0 +1,127 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-grid/uni-grid.vue b/node_modules/@dcloudio/uni-ui/lib/uni-grid/uni-grid.vue new file mode 100644 index 0000000..0edc7ff --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-grid/uni-grid.vue @@ -0,0 +1,142 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-group/uni-group.vue b/node_modules/@dcloudio/uni-ui/lib/uni-group/uni-group.vue new file mode 100644 index 0000000..3425ecd --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-group/uni-group.vue @@ -0,0 +1,134 @@ + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-icons/uni-icons.uvue b/node_modules/@dcloudio/uni-ui/lib/uni-icons/uni-icons.uvue new file mode 100644 index 0000000..398678e --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-icons/uni-icons.uvue @@ -0,0 +1,91 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-icons/uni-icons.vue b/node_modules/@dcloudio/uni-ui/lib/uni-icons/uni-icons.vue new file mode 100644 index 0000000..7da5356 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-icons/uni-icons.vue @@ -0,0 +1,110 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-icons/uniicons.css b/node_modules/@dcloudio/uni-ui/lib/uni-icons/uniicons.css new file mode 100644 index 0000000..0a6b6fe --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-icons/uniicons.css @@ -0,0 +1,664 @@ + +.uniui-cart-filled:before { + content: "\e6d0"; +} + +.uniui-gift-filled:before { + content: "\e6c4"; +} + +.uniui-color:before { + content: "\e6cf"; +} + +.uniui-wallet:before { + content: "\e6b1"; +} + +.uniui-settings-filled:before { + content: "\e6ce"; +} + +.uniui-auth-filled:before { + content: "\e6cc"; +} + +.uniui-shop-filled:before { + content: "\e6cd"; +} + +.uniui-staff-filled:before { + content: "\e6cb"; +} + +.uniui-vip-filled:before { + content: "\e6c6"; +} + +.uniui-plus-filled:before { + content: "\e6c7"; +} + +.uniui-folder-add-filled:before { + content: "\e6c8"; +} + +.uniui-color-filled:before { + content: "\e6c9"; +} + +.uniui-tune-filled:before { + content: "\e6ca"; +} + +.uniui-calendar-filled:before { + content: "\e6c0"; +} + +.uniui-notification-filled:before { + content: "\e6c1"; +} + +.uniui-wallet-filled:before { + content: "\e6c2"; +} + +.uniui-medal-filled:before { + content: "\e6c3"; +} + +.uniui-fire-filled:before { + content: "\e6c5"; +} + +.uniui-refreshempty:before { + content: "\e6bf"; +} + +.uniui-location-filled:before { + content: "\e6af"; +} + +.uniui-person-filled:before { + content: "\e69d"; +} + +.uniui-personadd-filled:before { + content: "\e698"; +} + +.uniui-arrowthinleft:before { + content: "\e6d2"; +} + +.uniui-arrowthinup:before { + content: "\e6d3"; +} + +.uniui-arrowthindown:before { + content: "\e6d4"; +} + +.uniui-back:before { + content: "\e6b9"; +} + +.uniui-forward:before { + content: "\e6ba"; +} + +.uniui-arrow-right:before { + content: "\e6bb"; +} + +.uniui-arrow-left:before { + content: "\e6bc"; +} + +.uniui-arrow-up:before { + content: "\e6bd"; +} + +.uniui-arrow-down:before { + content: "\e6be"; +} + +.uniui-arrowthinright:before { + content: "\e6d1"; +} + +.uniui-down:before { + content: "\e6b8"; +} + +.uniui-bottom:before { + content: "\e6b8"; +} + +.uniui-arrowright:before { + content: "\e6d5"; +} + +.uniui-right:before { + content: "\e6b5"; +} + +.uniui-up:before { + content: "\e6b6"; +} + +.uniui-top:before { + content: "\e6b6"; +} + +.uniui-left:before { + content: "\e6b7"; +} + +.uniui-arrowup:before { + content: "\e6d6"; +} + +.uniui-eye:before { + content: "\e651"; +} + +.uniui-eye-filled:before { + content: "\e66a"; +} + +.uniui-eye-slash:before { + content: "\e6b3"; +} + +.uniui-eye-slash-filled:before { + content: "\e6b4"; +} + +.uniui-info-filled:before { + content: "\e649"; +} + +.uniui-reload:before { + content: "\e6b2"; +} + +.uniui-micoff-filled:before { + content: "\e6b0"; +} + +.uniui-map-pin-ellipse:before { + content: "\e6ac"; +} + +.uniui-map-pin:before { + content: "\e6ad"; +} + +.uniui-location:before { + content: "\e6ae"; +} + +.uniui-starhalf:before { + content: "\e683"; +} + +.uniui-star:before { + content: "\e688"; +} + +.uniui-star-filled:before { + content: "\e68f"; +} + +.uniui-calendar:before { + content: "\e6a0"; +} + +.uniui-fire:before { + content: "\e6a1"; +} + +.uniui-medal:before { + content: "\e6a2"; +} + +.uniui-font:before { + content: "\e6a3"; +} + +.uniui-gift:before { + content: "\e6a4"; +} + +.uniui-link:before { + content: "\e6a5"; +} + +.uniui-notification:before { + content: "\e6a6"; +} + +.uniui-staff:before { + content: "\e6a7"; +} + +.uniui-vip:before { + content: "\e6a8"; +} + +.uniui-folder-add:before { + content: "\e6a9"; +} + +.uniui-tune:before { + content: "\e6aa"; +} + +.uniui-auth:before { + content: "\e6ab"; +} + +.uniui-person:before { + content: "\e699"; +} + +.uniui-email-filled:before { + content: "\e69a"; +} + +.uniui-phone-filled:before { + content: "\e69b"; +} + +.uniui-phone:before { + content: "\e69c"; +} + +.uniui-email:before { + content: "\e69e"; +} + +.uniui-personadd:before { + content: "\e69f"; +} + +.uniui-chatboxes-filled:before { + content: "\e692"; +} + +.uniui-contact:before { + content: "\e693"; +} + +.uniui-chatbubble-filled:before { + content: "\e694"; +} + +.uniui-contact-filled:before { + content: "\e695"; +} + +.uniui-chatboxes:before { + content: "\e696"; +} + +.uniui-chatbubble:before { + content: "\e697"; +} + +.uniui-upload-filled:before { + content: "\e68e"; +} + +.uniui-upload:before { + content: "\e690"; +} + +.uniui-weixin:before { + content: "\e691"; +} + +.uniui-compose:before { + content: "\e67f"; +} + +.uniui-qq:before { + content: "\e680"; +} + +.uniui-download-filled:before { + content: "\e681"; +} + +.uniui-pyq:before { + content: "\e682"; +} + +.uniui-sound:before { + content: "\e684"; +} + +.uniui-trash-filled:before { + content: "\e685"; +} + +.uniui-sound-filled:before { + content: "\e686"; +} + +.uniui-trash:before { + content: "\e687"; +} + +.uniui-videocam-filled:before { + content: "\e689"; +} + +.uniui-spinner-cycle:before { + content: "\e68a"; +} + +.uniui-weibo:before { + content: "\e68b"; +} + +.uniui-videocam:before { + content: "\e68c"; +} + +.uniui-download:before { + content: "\e68d"; +} + +.uniui-help:before { + content: "\e679"; +} + +.uniui-navigate-filled:before { + content: "\e67a"; +} + +.uniui-plusempty:before { + content: "\e67b"; +} + +.uniui-smallcircle:before { + content: "\e67c"; +} + +.uniui-minus-filled:before { + content: "\e67d"; +} + +.uniui-micoff:before { + content: "\e67e"; +} + +.uniui-closeempty:before { + content: "\e66c"; +} + +.uniui-clear:before { + content: "\e66d"; +} + +.uniui-navigate:before { + content: "\e66e"; +} + +.uniui-minus:before { + content: "\e66f"; +} + +.uniui-image:before { + content: "\e670"; +} + +.uniui-mic:before { + content: "\e671"; +} + +.uniui-paperplane:before { + content: "\e672"; +} + +.uniui-close:before { + content: "\e673"; +} + +.uniui-help-filled:before { + content: "\e674"; +} + +.uniui-paperplane-filled:before { + content: "\e675"; +} + +.uniui-plus:before { + content: "\e676"; +} + +.uniui-mic-filled:before { + content: "\e677"; +} + +.uniui-image-filled:before { + content: "\e678"; +} + +.uniui-locked-filled:before { + content: "\e668"; +} + +.uniui-info:before { + content: "\e669"; +} + +.uniui-locked:before { + content: "\e66b"; +} + +.uniui-camera-filled:before { + content: "\e658"; +} + +.uniui-chat-filled:before { + content: "\e659"; +} + +.uniui-camera:before { + content: "\e65a"; +} + +.uniui-circle:before { + content: "\e65b"; +} + +.uniui-checkmarkempty:before { + content: "\e65c"; +} + +.uniui-chat:before { + content: "\e65d"; +} + +.uniui-circle-filled:before { + content: "\e65e"; +} + +.uniui-flag:before { + content: "\e65f"; +} + +.uniui-flag-filled:before { + content: "\e660"; +} + +.uniui-gear-filled:before { + content: "\e661"; +} + +.uniui-home:before { + content: "\e662"; +} + +.uniui-home-filled:before { + content: "\e663"; +} + +.uniui-gear:before { + content: "\e664"; +} + +.uniui-smallcircle-filled:before { + content: "\e665"; +} + +.uniui-map-filled:before { + content: "\e666"; +} + +.uniui-map:before { + content: "\e667"; +} + +.uniui-refresh-filled:before { + content: "\e656"; +} + +.uniui-refresh:before { + content: "\e657"; +} + +.uniui-cloud-upload:before { + content: "\e645"; +} + +.uniui-cloud-download-filled:before { + content: "\e646"; +} + +.uniui-cloud-download:before { + content: "\e647"; +} + +.uniui-cloud-upload-filled:before { + content: "\e648"; +} + +.uniui-redo:before { + content: "\e64a"; +} + +.uniui-images-filled:before { + content: "\e64b"; +} + +.uniui-undo-filled:before { + content: "\e64c"; +} + +.uniui-more:before { + content: "\e64d"; +} + +.uniui-more-filled:before { + content: "\e64e"; +} + +.uniui-undo:before { + content: "\e64f"; +} + +.uniui-images:before { + content: "\e650"; +} + +.uniui-paperclip:before { + content: "\e652"; +} + +.uniui-settings:before { + content: "\e653"; +} + +.uniui-search:before { + content: "\e654"; +} + +.uniui-redo-filled:before { + content: "\e655"; +} + +.uniui-list:before { + content: "\e644"; +} + +.uniui-mail-open-filled:before { + content: "\e63a"; +} + +.uniui-hand-down-filled:before { + content: "\e63c"; +} + +.uniui-hand-down:before { + content: "\e63d"; +} + +.uniui-hand-up-filled:before { + content: "\e63e"; +} + +.uniui-hand-up:before { + content: "\e63f"; +} + +.uniui-heart-filled:before { + content: "\e641"; +} + +.uniui-mail-open:before { + content: "\e643"; +} + +.uniui-heart:before { + content: "\e639"; +} + +.uniui-loop:before { + content: "\e633"; +} + +.uniui-pulldown:before { + content: "\e632"; +} + +.uniui-scan:before { + content: "\e62a"; +} + +.uniui-bars:before { + content: "\e627"; +} + +.uniui-checkbox:before { + content: "\e62b"; +} + +.uniui-checkbox-filled:before { + content: "\e62c"; +} + +.uniui-shop:before { + content: "\e62f"; +} + +.uniui-headphones:before { + content: "\e630"; +} + +.uniui-cart:before { + content: "\e631"; +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-icons/uniicons.ttf b/node_modules/@dcloudio/uni-ui/lib/uni-icons/uniicons.ttf new file mode 100644 index 0000000..14696d0 Binary files /dev/null and b/node_modules/@dcloudio/uni-ui/lib/uni-icons/uniicons.ttf differ diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-icons/uniicons_file.ts b/node_modules/@dcloudio/uni-ui/lib/uni-icons/uniicons_file.ts new file mode 100644 index 0000000..98e93aa --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-icons/uniicons_file.ts @@ -0,0 +1,664 @@ + +export type IconsData = { + id : string + name : string + font_family : string + css_prefix_text : string + description : string + glyphs : Array +} + +export type IconsDataItem = { + font_class : string + unicode : string +} + + +export const fontData = [ + { + "font_class": "arrow-down", + "unicode": "\ue6be" + }, + { + "font_class": "arrow-left", + "unicode": "\ue6bc" + }, + { + "font_class": "arrow-right", + "unicode": "\ue6bb" + }, + { + "font_class": "arrow-up", + "unicode": "\ue6bd" + }, + { + "font_class": "auth", + "unicode": "\ue6ab" + }, + { + "font_class": "auth-filled", + "unicode": "\ue6cc" + }, + { + "font_class": "back", + "unicode": "\ue6b9" + }, + { + "font_class": "bars", + "unicode": "\ue627" + }, + { + "font_class": "calendar", + "unicode": "\ue6a0" + }, + { + "font_class": "calendar-filled", + "unicode": "\ue6c0" + }, + { + "font_class": "camera", + "unicode": "\ue65a" + }, + { + "font_class": "camera-filled", + "unicode": "\ue658" + }, + { + "font_class": "cart", + "unicode": "\ue631" + }, + { + "font_class": "cart-filled", + "unicode": "\ue6d0" + }, + { + "font_class": "chat", + "unicode": "\ue65d" + }, + { + "font_class": "chat-filled", + "unicode": "\ue659" + }, + { + "font_class": "chatboxes", + "unicode": "\ue696" + }, + { + "font_class": "chatboxes-filled", + "unicode": "\ue692" + }, + { + "font_class": "chatbubble", + "unicode": "\ue697" + }, + { + "font_class": "chatbubble-filled", + "unicode": "\ue694" + }, + { + "font_class": "checkbox", + "unicode": "\ue62b" + }, + { + "font_class": "checkbox-filled", + "unicode": "\ue62c" + }, + { + "font_class": "checkmarkempty", + "unicode": "\ue65c" + }, + { + "font_class": "circle", + "unicode": "\ue65b" + }, + { + "font_class": "circle-filled", + "unicode": "\ue65e" + }, + { + "font_class": "clear", + "unicode": "\ue66d" + }, + { + "font_class": "close", + "unicode": "\ue673" + }, + { + "font_class": "closeempty", + "unicode": "\ue66c" + }, + { + "font_class": "cloud-download", + "unicode": "\ue647" + }, + { + "font_class": "cloud-download-filled", + "unicode": "\ue646" + }, + { + "font_class": "cloud-upload", + "unicode": "\ue645" + }, + { + "font_class": "cloud-upload-filled", + "unicode": "\ue648" + }, + { + "font_class": "color", + "unicode": "\ue6cf" + }, + { + "font_class": "color-filled", + "unicode": "\ue6c9" + }, + { + "font_class": "compose", + "unicode": "\ue67f" + }, + { + "font_class": "contact", + "unicode": "\ue693" + }, + { + "font_class": "contact-filled", + "unicode": "\ue695" + }, + { + "font_class": "down", + "unicode": "\ue6b8" + }, + { + "font_class": "bottom", + "unicode": "\ue6b8" + }, + { + "font_class": "download", + "unicode": "\ue68d" + }, + { + "font_class": "download-filled", + "unicode": "\ue681" + }, + { + "font_class": "email", + "unicode": "\ue69e" + }, + { + "font_class": "email-filled", + "unicode": "\ue69a" + }, + { + "font_class": "eye", + "unicode": "\ue651" + }, + { + "font_class": "eye-filled", + "unicode": "\ue66a" + }, + { + "font_class": "eye-slash", + "unicode": "\ue6b3" + }, + { + "font_class": "eye-slash-filled", + "unicode": "\ue6b4" + }, + { + "font_class": "fire", + "unicode": "\ue6a1" + }, + { + "font_class": "fire-filled", + "unicode": "\ue6c5" + }, + { + "font_class": "flag", + "unicode": "\ue65f" + }, + { + "font_class": "flag-filled", + "unicode": "\ue660" + }, + { + "font_class": "folder-add", + "unicode": "\ue6a9" + }, + { + "font_class": "folder-add-filled", + "unicode": "\ue6c8" + }, + { + "font_class": "font", + "unicode": "\ue6a3" + }, + { + "font_class": "forward", + "unicode": "\ue6ba" + }, + { + "font_class": "gear", + "unicode": "\ue664" + }, + { + "font_class": "gear-filled", + "unicode": "\ue661" + }, + { + "font_class": "gift", + "unicode": "\ue6a4" + }, + { + "font_class": "gift-filled", + "unicode": "\ue6c4" + }, + { + "font_class": "hand-down", + "unicode": "\ue63d" + }, + { + "font_class": "hand-down-filled", + "unicode": "\ue63c" + }, + { + "font_class": "hand-up", + "unicode": "\ue63f" + }, + { + "font_class": "hand-up-filled", + "unicode": "\ue63e" + }, + { + "font_class": "headphones", + "unicode": "\ue630" + }, + { + "font_class": "heart", + "unicode": "\ue639" + }, + { + "font_class": "heart-filled", + "unicode": "\ue641" + }, + { + "font_class": "help", + "unicode": "\ue679" + }, + { + "font_class": "help-filled", + "unicode": "\ue674" + }, + { + "font_class": "home", + "unicode": "\ue662" + }, + { + "font_class": "home-filled", + "unicode": "\ue663" + }, + { + "font_class": "image", + "unicode": "\ue670" + }, + { + "font_class": "image-filled", + "unicode": "\ue678" + }, + { + "font_class": "images", + "unicode": "\ue650" + }, + { + "font_class": "images-filled", + "unicode": "\ue64b" + }, + { + "font_class": "info", + "unicode": "\ue669" + }, + { + "font_class": "info-filled", + "unicode": "\ue649" + }, + { + "font_class": "left", + "unicode": "\ue6b7" + }, + { + "font_class": "link", + "unicode": "\ue6a5" + }, + { + "font_class": "list", + "unicode": "\ue644" + }, + { + "font_class": "location", + "unicode": "\ue6ae" + }, + { + "font_class": "location-filled", + "unicode": "\ue6af" + }, + { + "font_class": "locked", + "unicode": "\ue66b" + }, + { + "font_class": "locked-filled", + "unicode": "\ue668" + }, + { + "font_class": "loop", + "unicode": "\ue633" + }, + { + "font_class": "mail-open", + "unicode": "\ue643" + }, + { + "font_class": "mail-open-filled", + "unicode": "\ue63a" + }, + { + "font_class": "map", + "unicode": "\ue667" + }, + { + "font_class": "map-filled", + "unicode": "\ue666" + }, + { + "font_class": "map-pin", + "unicode": "\ue6ad" + }, + { + "font_class": "map-pin-ellipse", + "unicode": "\ue6ac" + }, + { + "font_class": "medal", + "unicode": "\ue6a2" + }, + { + "font_class": "medal-filled", + "unicode": "\ue6c3" + }, + { + "font_class": "mic", + "unicode": "\ue671" + }, + { + "font_class": "mic-filled", + "unicode": "\ue677" + }, + { + "font_class": "micoff", + "unicode": "\ue67e" + }, + { + "font_class": "micoff-filled", + "unicode": "\ue6b0" + }, + { + "font_class": "minus", + "unicode": "\ue66f" + }, + { + "font_class": "minus-filled", + "unicode": "\ue67d" + }, + { + "font_class": "more", + "unicode": "\ue64d" + }, + { + "font_class": "more-filled", + "unicode": "\ue64e" + }, + { + "font_class": "navigate", + "unicode": "\ue66e" + }, + { + "font_class": "navigate-filled", + "unicode": "\ue67a" + }, + { + "font_class": "notification", + "unicode": "\ue6a6" + }, + { + "font_class": "notification-filled", + "unicode": "\ue6c1" + }, + { + "font_class": "paperclip", + "unicode": "\ue652" + }, + { + "font_class": "paperplane", + "unicode": "\ue672" + }, + { + "font_class": "paperplane-filled", + "unicode": "\ue675" + }, + { + "font_class": "person", + "unicode": "\ue699" + }, + { + "font_class": "person-filled", + "unicode": "\ue69d" + }, + { + "font_class": "personadd", + "unicode": "\ue69f" + }, + { + "font_class": "personadd-filled", + "unicode": "\ue698" + }, + { + "font_class": "personadd-filled-copy", + "unicode": "\ue6d1" + }, + { + "font_class": "phone", + "unicode": "\ue69c" + }, + { + "font_class": "phone-filled", + "unicode": "\ue69b" + }, + { + "font_class": "plus", + "unicode": "\ue676" + }, + { + "font_class": "plus-filled", + "unicode": "\ue6c7" + }, + { + "font_class": "plusempty", + "unicode": "\ue67b" + }, + { + "font_class": "pulldown", + "unicode": "\ue632" + }, + { + "font_class": "pyq", + "unicode": "\ue682" + }, + { + "font_class": "qq", + "unicode": "\ue680" + }, + { + "font_class": "redo", + "unicode": "\ue64a" + }, + { + "font_class": "redo-filled", + "unicode": "\ue655" + }, + { + "font_class": "refresh", + "unicode": "\ue657" + }, + { + "font_class": "refresh-filled", + "unicode": "\ue656" + }, + { + "font_class": "refreshempty", + "unicode": "\ue6bf" + }, + { + "font_class": "reload", + "unicode": "\ue6b2" + }, + { + "font_class": "right", + "unicode": "\ue6b5" + }, + { + "font_class": "scan", + "unicode": "\ue62a" + }, + { + "font_class": "search", + "unicode": "\ue654" + }, + { + "font_class": "settings", + "unicode": "\ue653" + }, + { + "font_class": "settings-filled", + "unicode": "\ue6ce" + }, + { + "font_class": "shop", + "unicode": "\ue62f" + }, + { + "font_class": "shop-filled", + "unicode": "\ue6cd" + }, + { + "font_class": "smallcircle", + "unicode": "\ue67c" + }, + { + "font_class": "smallcircle-filled", + "unicode": "\ue665" + }, + { + "font_class": "sound", + "unicode": "\ue684" + }, + { + "font_class": "sound-filled", + "unicode": "\ue686" + }, + { + "font_class": "spinner-cycle", + "unicode": "\ue68a" + }, + { + "font_class": "staff", + "unicode": "\ue6a7" + }, + { + "font_class": "staff-filled", + "unicode": "\ue6cb" + }, + { + "font_class": "star", + "unicode": "\ue688" + }, + { + "font_class": "star-filled", + "unicode": "\ue68f" + }, + { + "font_class": "starhalf", + "unicode": "\ue683" + }, + { + "font_class": "trash", + "unicode": "\ue687" + }, + { + "font_class": "trash-filled", + "unicode": "\ue685" + }, + { + "font_class": "tune", + "unicode": "\ue6aa" + }, + { + "font_class": "tune-filled", + "unicode": "\ue6ca" + }, + { + "font_class": "undo", + "unicode": "\ue64f" + }, + { + "font_class": "undo-filled", + "unicode": "\ue64c" + }, + { + "font_class": "up", + "unicode": "\ue6b6" + }, + { + "font_class": "top", + "unicode": "\ue6b6" + }, + { + "font_class": "upload", + "unicode": "\ue690" + }, + { + "font_class": "upload-filled", + "unicode": "\ue68e" + }, + { + "font_class": "videocam", + "unicode": "\ue68c" + }, + { + "font_class": "videocam-filled", + "unicode": "\ue689" + }, + { + "font_class": "vip", + "unicode": "\ue6a8" + }, + { + "font_class": "vip-filled", + "unicode": "\ue6c6" + }, + { + "font_class": "wallet", + "unicode": "\ue6b1" + }, + { + "font_class": "wallet-filled", + "unicode": "\ue6c2" + }, + { + "font_class": "weibo", + "unicode": "\ue68b" + }, + { + "font_class": "weixin", + "unicode": "\ue691" + } +] as IconsDataItem[] + +// export const fontData = JSON.parse(fontDataJson) diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-icons/uniicons_file_vue.js b/node_modules/@dcloudio/uni-ui/lib/uni-icons/uniicons_file_vue.js new file mode 100644 index 0000000..1cd11e1 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-icons/uniicons_file_vue.js @@ -0,0 +1,649 @@ + +export const fontData = [ + { + "font_class": "arrow-down", + "unicode": "\ue6be" + }, + { + "font_class": "arrow-left", + "unicode": "\ue6bc" + }, + { + "font_class": "arrow-right", + "unicode": "\ue6bb" + }, + { + "font_class": "arrow-up", + "unicode": "\ue6bd" + }, + { + "font_class": "auth", + "unicode": "\ue6ab" + }, + { + "font_class": "auth-filled", + "unicode": "\ue6cc" + }, + { + "font_class": "back", + "unicode": "\ue6b9" + }, + { + "font_class": "bars", + "unicode": "\ue627" + }, + { + "font_class": "calendar", + "unicode": "\ue6a0" + }, + { + "font_class": "calendar-filled", + "unicode": "\ue6c0" + }, + { + "font_class": "camera", + "unicode": "\ue65a" + }, + { + "font_class": "camera-filled", + "unicode": "\ue658" + }, + { + "font_class": "cart", + "unicode": "\ue631" + }, + { + "font_class": "cart-filled", + "unicode": "\ue6d0" + }, + { + "font_class": "chat", + "unicode": "\ue65d" + }, + { + "font_class": "chat-filled", + "unicode": "\ue659" + }, + { + "font_class": "chatboxes", + "unicode": "\ue696" + }, + { + "font_class": "chatboxes-filled", + "unicode": "\ue692" + }, + { + "font_class": "chatbubble", + "unicode": "\ue697" + }, + { + "font_class": "chatbubble-filled", + "unicode": "\ue694" + }, + { + "font_class": "checkbox", + "unicode": "\ue62b" + }, + { + "font_class": "checkbox-filled", + "unicode": "\ue62c" + }, + { + "font_class": "checkmarkempty", + "unicode": "\ue65c" + }, + { + "font_class": "circle", + "unicode": "\ue65b" + }, + { + "font_class": "circle-filled", + "unicode": "\ue65e" + }, + { + "font_class": "clear", + "unicode": "\ue66d" + }, + { + "font_class": "close", + "unicode": "\ue673" + }, + { + "font_class": "closeempty", + "unicode": "\ue66c" + }, + { + "font_class": "cloud-download", + "unicode": "\ue647" + }, + { + "font_class": "cloud-download-filled", + "unicode": "\ue646" + }, + { + "font_class": "cloud-upload", + "unicode": "\ue645" + }, + { + "font_class": "cloud-upload-filled", + "unicode": "\ue648" + }, + { + "font_class": "color", + "unicode": "\ue6cf" + }, + { + "font_class": "color-filled", + "unicode": "\ue6c9" + }, + { + "font_class": "compose", + "unicode": "\ue67f" + }, + { + "font_class": "contact", + "unicode": "\ue693" + }, + { + "font_class": "contact-filled", + "unicode": "\ue695" + }, + { + "font_class": "down", + "unicode": "\ue6b8" + }, + { + "font_class": "bottom", + "unicode": "\ue6b8" + }, + { + "font_class": "download", + "unicode": "\ue68d" + }, + { + "font_class": "download-filled", + "unicode": "\ue681" + }, + { + "font_class": "email", + "unicode": "\ue69e" + }, + { + "font_class": "email-filled", + "unicode": "\ue69a" + }, + { + "font_class": "eye", + "unicode": "\ue651" + }, + { + "font_class": "eye-filled", + "unicode": "\ue66a" + }, + { + "font_class": "eye-slash", + "unicode": "\ue6b3" + }, + { + "font_class": "eye-slash-filled", + "unicode": "\ue6b4" + }, + { + "font_class": "fire", + "unicode": "\ue6a1" + }, + { + "font_class": "fire-filled", + "unicode": "\ue6c5" + }, + { + "font_class": "flag", + "unicode": "\ue65f" + }, + { + "font_class": "flag-filled", + "unicode": "\ue660" + }, + { + "font_class": "folder-add", + "unicode": "\ue6a9" + }, + { + "font_class": "folder-add-filled", + "unicode": "\ue6c8" + }, + { + "font_class": "font", + "unicode": "\ue6a3" + }, + { + "font_class": "forward", + "unicode": "\ue6ba" + }, + { + "font_class": "gear", + "unicode": "\ue664" + }, + { + "font_class": "gear-filled", + "unicode": "\ue661" + }, + { + "font_class": "gift", + "unicode": "\ue6a4" + }, + { + "font_class": "gift-filled", + "unicode": "\ue6c4" + }, + { + "font_class": "hand-down", + "unicode": "\ue63d" + }, + { + "font_class": "hand-down-filled", + "unicode": "\ue63c" + }, + { + "font_class": "hand-up", + "unicode": "\ue63f" + }, + { + "font_class": "hand-up-filled", + "unicode": "\ue63e" + }, + { + "font_class": "headphones", + "unicode": "\ue630" + }, + { + "font_class": "heart", + "unicode": "\ue639" + }, + { + "font_class": "heart-filled", + "unicode": "\ue641" + }, + { + "font_class": "help", + "unicode": "\ue679" + }, + { + "font_class": "help-filled", + "unicode": "\ue674" + }, + { + "font_class": "home", + "unicode": "\ue662" + }, + { + "font_class": "home-filled", + "unicode": "\ue663" + }, + { + "font_class": "image", + "unicode": "\ue670" + }, + { + "font_class": "image-filled", + "unicode": "\ue678" + }, + { + "font_class": "images", + "unicode": "\ue650" + }, + { + "font_class": "images-filled", + "unicode": "\ue64b" + }, + { + "font_class": "info", + "unicode": "\ue669" + }, + { + "font_class": "info-filled", + "unicode": "\ue649" + }, + { + "font_class": "left", + "unicode": "\ue6b7" + }, + { + "font_class": "link", + "unicode": "\ue6a5" + }, + { + "font_class": "list", + "unicode": "\ue644" + }, + { + "font_class": "location", + "unicode": "\ue6ae" + }, + { + "font_class": "location-filled", + "unicode": "\ue6af" + }, + { + "font_class": "locked", + "unicode": "\ue66b" + }, + { + "font_class": "locked-filled", + "unicode": "\ue668" + }, + { + "font_class": "loop", + "unicode": "\ue633" + }, + { + "font_class": "mail-open", + "unicode": "\ue643" + }, + { + "font_class": "mail-open-filled", + "unicode": "\ue63a" + }, + { + "font_class": "map", + "unicode": "\ue667" + }, + { + "font_class": "map-filled", + "unicode": "\ue666" + }, + { + "font_class": "map-pin", + "unicode": "\ue6ad" + }, + { + "font_class": "map-pin-ellipse", + "unicode": "\ue6ac" + }, + { + "font_class": "medal", + "unicode": "\ue6a2" + }, + { + "font_class": "medal-filled", + "unicode": "\ue6c3" + }, + { + "font_class": "mic", + "unicode": "\ue671" + }, + { + "font_class": "mic-filled", + "unicode": "\ue677" + }, + { + "font_class": "micoff", + "unicode": "\ue67e" + }, + { + "font_class": "micoff-filled", + "unicode": "\ue6b0" + }, + { + "font_class": "minus", + "unicode": "\ue66f" + }, + { + "font_class": "minus-filled", + "unicode": "\ue67d" + }, + { + "font_class": "more", + "unicode": "\ue64d" + }, + { + "font_class": "more-filled", + "unicode": "\ue64e" + }, + { + "font_class": "navigate", + "unicode": "\ue66e" + }, + { + "font_class": "navigate-filled", + "unicode": "\ue67a" + }, + { + "font_class": "notification", + "unicode": "\ue6a6" + }, + { + "font_class": "notification-filled", + "unicode": "\ue6c1" + }, + { + "font_class": "paperclip", + "unicode": "\ue652" + }, + { + "font_class": "paperplane", + "unicode": "\ue672" + }, + { + "font_class": "paperplane-filled", + "unicode": "\ue675" + }, + { + "font_class": "person", + "unicode": "\ue699" + }, + { + "font_class": "person-filled", + "unicode": "\ue69d" + }, + { + "font_class": "personadd", + "unicode": "\ue69f" + }, + { + "font_class": "personadd-filled", + "unicode": "\ue698" + }, + { + "font_class": "personadd-filled-copy", + "unicode": "\ue6d1" + }, + { + "font_class": "phone", + "unicode": "\ue69c" + }, + { + "font_class": "phone-filled", + "unicode": "\ue69b" + }, + { + "font_class": "plus", + "unicode": "\ue676" + }, + { + "font_class": "plus-filled", + "unicode": "\ue6c7" + }, + { + "font_class": "plusempty", + "unicode": "\ue67b" + }, + { + "font_class": "pulldown", + "unicode": "\ue632" + }, + { + "font_class": "pyq", + "unicode": "\ue682" + }, + { + "font_class": "qq", + "unicode": "\ue680" + }, + { + "font_class": "redo", + "unicode": "\ue64a" + }, + { + "font_class": "redo-filled", + "unicode": "\ue655" + }, + { + "font_class": "refresh", + "unicode": "\ue657" + }, + { + "font_class": "refresh-filled", + "unicode": "\ue656" + }, + { + "font_class": "refreshempty", + "unicode": "\ue6bf" + }, + { + "font_class": "reload", + "unicode": "\ue6b2" + }, + { + "font_class": "right", + "unicode": "\ue6b5" + }, + { + "font_class": "scan", + "unicode": "\ue62a" + }, + { + "font_class": "search", + "unicode": "\ue654" + }, + { + "font_class": "settings", + "unicode": "\ue653" + }, + { + "font_class": "settings-filled", + "unicode": "\ue6ce" + }, + { + "font_class": "shop", + "unicode": "\ue62f" + }, + { + "font_class": "shop-filled", + "unicode": "\ue6cd" + }, + { + "font_class": "smallcircle", + "unicode": "\ue67c" + }, + { + "font_class": "smallcircle-filled", + "unicode": "\ue665" + }, + { + "font_class": "sound", + "unicode": "\ue684" + }, + { + "font_class": "sound-filled", + "unicode": "\ue686" + }, + { + "font_class": "spinner-cycle", + "unicode": "\ue68a" + }, + { + "font_class": "staff", + "unicode": "\ue6a7" + }, + { + "font_class": "staff-filled", + "unicode": "\ue6cb" + }, + { + "font_class": "star", + "unicode": "\ue688" + }, + { + "font_class": "star-filled", + "unicode": "\ue68f" + }, + { + "font_class": "starhalf", + "unicode": "\ue683" + }, + { + "font_class": "trash", + "unicode": "\ue687" + }, + { + "font_class": "trash-filled", + "unicode": "\ue685" + }, + { + "font_class": "tune", + "unicode": "\ue6aa" + }, + { + "font_class": "tune-filled", + "unicode": "\ue6ca" + }, + { + "font_class": "undo", + "unicode": "\ue64f" + }, + { + "font_class": "undo-filled", + "unicode": "\ue64c" + }, + { + "font_class": "up", + "unicode": "\ue6b6" + }, + { + "font_class": "top", + "unicode": "\ue6b6" + }, + { + "font_class": "upload", + "unicode": "\ue690" + }, + { + "font_class": "upload-filled", + "unicode": "\ue68e" + }, + { + "font_class": "videocam", + "unicode": "\ue68c" + }, + { + "font_class": "videocam-filled", + "unicode": "\ue689" + }, + { + "font_class": "vip", + "unicode": "\ue6a8" + }, + { + "font_class": "vip-filled", + "unicode": "\ue6c6" + }, + { + "font_class": "wallet", + "unicode": "\ue6b1" + }, + { + "font_class": "wallet-filled", + "unicode": "\ue6c2" + }, + { + "font_class": "weibo", + "unicode": "\ue68b" + }, + { + "font_class": "weixin", + "unicode": "\ue691" + } +] + +// export const fontData = JSON.parse(fontDataJson) diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-indexed-list/uni-indexed-list-item.vue b/node_modules/@dcloudio/uni-ui/lib/uni-indexed-list/uni-indexed-list-item.vue new file mode 100644 index 0000000..19284bd --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-indexed-list/uni-indexed-list-item.vue @@ -0,0 +1,144 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-indexed-list/uni-indexed-list.vue b/node_modules/@dcloudio/uni-ui/lib/uni-indexed-list/uni-indexed-list.vue new file mode 100644 index 0000000..ee3a7ec --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-indexed-list/uni-indexed-list.vue @@ -0,0 +1,367 @@ + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-link/uni-link.vue b/node_modules/@dcloudio/uni-ui/lib/uni-link/uni-link.vue new file mode 100644 index 0000000..27c5468 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-link/uni-link.vue @@ -0,0 +1,128 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-list-ad/uni-list-ad.vue b/node_modules/@dcloudio/uni-ui/lib/uni-list-ad/uni-list-ad.vue new file mode 100644 index 0000000..b9349c2 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-list-ad/uni-list-ad.vue @@ -0,0 +1,107 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-list-chat/uni-list-chat.scss b/node_modules/@dcloudio/uni-ui/lib/uni-list-chat/uni-list-chat.scss new file mode 100644 index 0000000..311f8d9 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-list-chat/uni-list-chat.scss @@ -0,0 +1,58 @@ +/** + * 这里是 uni-list 组件内置的常用样式变量 + * 如果需要覆盖样式，这里提供了基本的组件样式变量，您可以尝试修改这里的变量，去完成样式替换，而不用去修改源码 + * + */ + +// 背景色 +$background-color : #fff; +// 分割线颜色 +$divide-line-color : #e5e5e5; + +// 默认头像大小，如需要修改此值，注意同步修改 js 中的值 const avatarWidth = xx ，目前只支持方形头像 +// nvue 页面不支持修改头像大小 +$avatar-width : 45px ; + +// 头像边框 +$avatar-border-radius: 5px; +$avatar-border-color: #eee; +$avatar-border-width: 1px; + +// 标题文字样式 +$title-size : 16px; +$title-color : #3b4144; +$title-weight : normal; + +// 描述文字样式 +$note-size : 12px; +$note-color : #999; +$note-weight : normal; + +// 右侧额外内容默认样式 +$right-text-size : 12px; +$right-text-color : #999; +$right-text-weight : normal; + +// 角标样式 +// nvue 页面不支持修改圆点位置以及大小 +// 角标在左侧时，角标的位置，默认为 0 ，负数左/下移动，正数右/上移动 +$badge-left: 0px; +$badge-top: 0px; + +// 显示圆点时，圆点大小 +$dot-width: 10px; +$dot-height: 10px; + +// 显示角标时，角标大小和字体大小 +$badge-size : 18px; +$badge-font : 12px; +// 显示角标时，角标前景色 +$badge-color : #fff; +// 显示角标时，角标背景色 +$badge-background-color : #ff5a5f; +// 显示角标时，角标左右间距 +$badge-space : 6px; + +// 状态样式 +// 选中颜色 +$hover : #f5f5f5; diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-list-chat/uni-list-chat.vue b/node_modules/@dcloudio/uni-ui/lib/uni-list-chat/uni-list-chat.vue new file mode 100644 index 0000000..d49fd7c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-list-chat/uni-list-chat.vue @@ -0,0 +1,593 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-list-item/uni-list-item.vue b/node_modules/@dcloudio/uni-ui/lib/uni-list-item/uni-list-item.vue new file mode 100644 index 0000000..6402508 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-list-item/uni-list-item.vue @@ -0,0 +1,534 @@ + + + + + \ No newline at end of file diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-list/uni-list.vue b/node_modules/@dcloudio/uni-ui/lib/uni-list/uni-list.vue new file mode 100644 index 0000000..6ef5972 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-list/uni-list.vue @@ -0,0 +1,123 @@ + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-list/uni-refresh.vue b/node_modules/@dcloudio/uni-ui/lib/uni-list/uni-refresh.vue new file mode 100644 index 0000000..3b4c5a2 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-list/uni-refresh.vue @@ -0,0 +1,65 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-list/uni-refresh.wxs b/node_modules/@dcloudio/uni-ui/lib/uni-list/uni-refresh.wxs new file mode 100644 index 0000000..818a6b7 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-list/uni-refresh.wxs @@ -0,0 +1,87 @@ +var pullDown = { + threshold: 95, + maxHeight: 200, + callRefresh: 'onrefresh', + callPullingDown: 'onpullingdown', + refreshSelector: '.uni-refresh' +}; + +function ready(newValue, oldValue, ownerInstance, instance) { + var state = instance.getState() + state.canPullDown = newValue; + // console.log(newValue); +} + +function touchStart(e, instance) { + var state = instance.getState(); + state.refreshInstance = instance.selectComponent(pullDown.refreshSelector); + state.canPullDown = (state.refreshInstance != null && state.refreshInstance != undefined); + if (!state.canPullDown) { + return + } + + // console.log("touchStart"); + + state.height = 0; + state.touchStartY = e.touches[0].pageY || e.changedTouches[0].pageY; + state.refreshInstance.setStyle({ + 'height': 0 + }); + state.refreshInstance.callMethod("onchange", true); +} + +function touchMove(e, ownerInstance) { + var instance = e.instance; + var state = instance.getState(); + if (!state.canPullDown) { + return + } + + var oldHeight = state.height; + var endY = e.touches[0].pageY || e.changedTouches[0].pageY; + var height = endY - state.touchStartY; + if (height > pullDown.maxHeight) { + return; + } + + var refreshInstance = state.refreshInstance; + refreshInstance.setStyle({ + 'height': height + 'px' + }); + + height = height < pullDown.maxHeight ? height : pullDown.maxHeight; + state.height = height; + refreshInstance.callMethod(pullDown.callPullingDown, { + height: height + }); +} + +function touchEnd(e, ownerInstance) { + var state = e.instance.getState(); + if (!state.canPullDown) { + return + } + + state.refreshInstance.callMethod("onchange", false); + + var refreshInstance = state.refreshInstance; + if (state.height > pullDown.threshold) { + refreshInstance.callMethod(pullDown.callRefresh); + return; + } + + refreshInstance.setStyle({ + 'height': 0 + }); +} + +function propObserver(newValue, oldValue, instance) { + pullDown = newValue; +} + +module.exports = { + touchmove: touchMove, + touchstart: touchStart, + touchend: touchEnd, + propObserver: propObserver +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-load-more/i18n/en.json b/node_modules/@dcloudio/uni-ui/lib/uni-load-more/i18n/en.json new file mode 100644 index 0000000..a4f14a5 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-load-more/i18n/en.json @@ -0,0 +1,5 @@ +{ + "uni-load-more.contentdown": "Pull up to show more", + "uni-load-more.contentrefresh": "loading...", + "uni-load-more.contentnomore": "No more data" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-load-more/i18n/index.js b/node_modules/@dcloudio/uni-ui/lib/uni-load-more/i18n/index.js new file mode 100644 index 0000000..de7509c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-load-more/i18n/index.js @@ -0,0 +1,8 @@ +import en from './en.json' +import zhHans from './zh-Hans.json' +import zhHant from './zh-Hant.json' +export default { + en, + 'zh-Hans': zhHans, + 'zh-Hant': zhHant +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-load-more/i18n/zh-Hans.json b/node_modules/@dcloudio/uni-ui/lib/uni-load-more/i18n/zh-Hans.json new file mode 100644 index 0000000..f15d510 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-load-more/i18n/zh-Hans.json @@ -0,0 +1,5 @@ +{ + "uni-load-more.contentdown": "上拉显示更多", + "uni-load-more.contentrefresh": "正在加载...", + "uni-load-more.contentnomore": "没有更多数据了" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-load-more/i18n/zh-Hant.json b/node_modules/@dcloudio/uni-ui/lib/uni-load-more/i18n/zh-Hant.json new file mode 100644 index 0000000..a255c6d --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-load-more/i18n/zh-Hant.json @@ -0,0 +1,5 @@ +{ + "uni-load-more.contentdown": "上拉顯示更多", + "uni-load-more.contentrefresh": "正在加載...", + "uni-load-more.contentnomore": "沒有更多數據了" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-load-more/uni-load-more.vue b/node_modules/@dcloudio/uni-ui/lib/uni-load-more/uni-load-more.vue new file mode 100644 index 0000000..a203417 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-load-more/uni-load-more.vue @@ -0,0 +1,404 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-nav-bar/uni-nav-bar.vue b/node_modules/@dcloudio/uni-ui/lib/uni-nav-bar/uni-nav-bar.vue new file mode 100644 index 0000000..46806c1 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-nav-bar/uni-nav-bar.vue @@ -0,0 +1,357 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-nav-bar/uni-status-bar.vue b/node_modules/@dcloudio/uni-ui/lib/uni-nav-bar/uni-status-bar.vue new file mode 100644 index 0000000..6185446 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-nav-bar/uni-status-bar.vue @@ -0,0 +1,30 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-notice-bar/uni-notice-bar.vue b/node_modules/@dcloudio/uni-ui/lib/uni-notice-bar/uni-notice-bar.vue new file mode 100644 index 0000000..47fb9b3 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-notice-bar/uni-notice-bar.vue @@ -0,0 +1,431 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-number-box/uni-number-box.vue b/node_modules/@dcloudio/uni-ui/lib/uni-number-box/uni-number-box.vue new file mode 100644 index 0000000..4e203cc --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-number-box/uni-number-box.vue @@ -0,0 +1,232 @@ + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/en.json b/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/en.json new file mode 100644 index 0000000..d6e2897 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/en.json @@ -0,0 +1,5 @@ +{ + "uni-pagination.prevText": "prev", + "uni-pagination.nextText": "next", + "uni-pagination.piecePerPage": "piece/page" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/es.json b/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/es.json new file mode 100644 index 0000000..604a113 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/es.json @@ -0,0 +1,5 @@ +{ + "uni-pagination.prevText": "anterior", + "uni-pagination.nextText": "prxima", + "uni-pagination.piecePerPage": "Artculo/Pgina" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/fr.json b/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/fr.json new file mode 100644 index 0000000..a7a0c77 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/fr.json @@ -0,0 +1,5 @@ +{ + "uni-pagination.prevText": "précédente", + "uni-pagination.nextText": "suivante", + "uni-pagination.piecePerPage": "Articles/Pages" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/index.js b/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/index.js new file mode 100644 index 0000000..2469dd0 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/index.js @@ -0,0 +1,12 @@ +import en from './en.json' +import es from './es.json' +import fr from './fr.json' +import zhHans from './zh-Hans.json' +import zhHant from './zh-Hant.json' +export default { + en, + es, + fr, + 'zh-Hans': zhHans, + 'zh-Hant': zhHant +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/zh-Hans.json b/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/zh-Hans.json new file mode 100644 index 0000000..782bbe4 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/zh-Hans.json @@ -0,0 +1,5 @@ +{ + "uni-pagination.prevText": "上一页", + "uni-pagination.nextText": "下一页", + "uni-pagination.piecePerPage": "条/页" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/zh-Hant.json b/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/zh-Hant.json new file mode 100644 index 0000000..180fddb --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-pagination/i18n/zh-Hant.json @@ -0,0 +1,5 @@ +{ + "uni-pagination.prevText": "上一頁", + "uni-pagination.nextText": "下一頁", + "uni-pagination.piecePerPage": "條/頁" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-pagination/uni-pagination.vue b/node_modules/@dcloudio/uni-ui/lib/uni-pagination/uni-pagination.vue new file mode 100644 index 0000000..5305b5f --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-pagination/uni-pagination.vue @@ -0,0 +1,465 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-popup-dialog/keypress.js b/node_modules/@dcloudio/uni-ui/lib/uni-popup-dialog/keypress.js new file mode 100644 index 0000000..6ef26a2 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-popup-dialog/keypress.js @@ -0,0 +1,45 @@ +// #ifdef H5 +export default { + name: 'Keypress', + props: { + disable: { + type: Boolean, + default: false + } + }, + mounted () { + const keyNames = { + esc: ['Esc', 'Escape'], + tab: 'Tab', + enter: 'Enter', + space: [' ', 'Spacebar'], + up: ['Up', 'ArrowUp'], + left: ['Left', 'ArrowLeft'], + right: ['Right', 'ArrowRight'], + down: ['Down', 'ArrowDown'], + delete: ['Backspace', 'Delete', 'Del'] + } + const listener = ($event) => { + if (this.disable) { + return + } + const keyName = Object.keys(keyNames).find(key => { + const keyName = $event.key + const value = keyNames[key] + return value === keyName || (Array.isArray(value) && value.includes(keyName)) + }) + if (keyName) { + // 避免和其他按键事件冲突 + setTimeout(() => { + this.$emit(keyName, {}) + }, 0) + } + } + document.addEventListener('keyup', listener) + this.$once('hook:beforeDestroy', () => { + document.removeEventListener('keyup', listener) + }) + }, + render: () => {} +} +// #endif diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-popup-dialog/uni-popup-dialog.vue b/node_modules/@dcloudio/uni-ui/lib/uni-popup-dialog/uni-popup-dialog.vue new file mode 100644 index 0000000..08707d4 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-popup-dialog/uni-popup-dialog.vue @@ -0,0 +1,316 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-popup-message/uni-popup-message.vue b/node_modules/@dcloudio/uni-ui/lib/uni-popup-message/uni-popup-message.vue new file mode 100644 index 0000000..91370a8 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-popup-message/uni-popup-message.vue @@ -0,0 +1,143 @@ + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-popup-share/uni-popup-share.vue b/node_modules/@dcloudio/uni-ui/lib/uni-popup-share/uni-popup-share.vue new file mode 100644 index 0000000..f7e667c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-popup-share/uni-popup-share.vue @@ -0,0 +1,187 @@ + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-popup/i18n/en.json b/node_modules/@dcloudio/uni-ui/lib/uni-popup/i18n/en.json new file mode 100644 index 0000000..7f1bd06 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-popup/i18n/en.json @@ -0,0 +1,7 @@ +{ + "uni-popup.cancel": "cancel", + "uni-popup.ok": "ok", + "uni-popup.placeholder": "pleace enter", + "uni-popup.title": "Hint", + "uni-popup.shareTitle": "Share to" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-popup/i18n/index.js b/node_modules/@dcloudio/uni-ui/lib/uni-popup/i18n/index.js new file mode 100644 index 0000000..de7509c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-popup/i18n/index.js @@ -0,0 +1,8 @@ +import en from './en.json' +import zhHans from './zh-Hans.json' +import zhHant from './zh-Hant.json' +export default { + en, + 'zh-Hans': zhHans, + 'zh-Hant': zhHant +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-popup/i18n/zh-Hans.json b/node_modules/@dcloudio/uni-ui/lib/uni-popup/i18n/zh-Hans.json new file mode 100644 index 0000000..5e3003c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-popup/i18n/zh-Hans.json @@ -0,0 +1,7 @@ +{ + "uni-popup.cancel": "取消", + "uni-popup.ok": "确定", + "uni-popup.placeholder": "请输入", + "uni-popup.title": "提示", + "uni-popup.shareTitle": "分享到" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-popup/i18n/zh-Hant.json b/node_modules/@dcloudio/uni-ui/lib/uni-popup/i18n/zh-Hant.json new file mode 100644 index 0000000..13e39eb --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-popup/i18n/zh-Hant.json @@ -0,0 +1,7 @@ +{ + "uni-popup.cancel": "取消", + "uni-popup.ok": "確定", + "uni-popup.placeholder": "請輸入", + "uni-popup.title": "提示", + "uni-popup.shareTitle": "分享到" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-popup/keypress.js b/node_modules/@dcloudio/uni-ui/lib/uni-popup/keypress.js new file mode 100644 index 0000000..62dda46 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-popup/keypress.js @@ -0,0 +1,45 @@ +// #ifdef H5 +export default { + name: 'Keypress', + props: { + disable: { + type: Boolean, + default: false + } + }, + mounted () { + const keyNames = { + esc: ['Esc', 'Escape'], + tab: 'Tab', + enter: 'Enter', + space: [' ', 'Spacebar'], + up: ['Up', 'ArrowUp'], + left: ['Left', 'ArrowLeft'], + right: ['Right', 'ArrowRight'], + down: ['Down', 'ArrowDown'], + delete: ['Backspace', 'Delete', 'Del'] + } + const listener = ($event) => { + if (this.disable) { + return + } + const keyName = Object.keys(keyNames).find(key => { + const keyName = $event.key + const value = keyNames[key] + return value === keyName || (Array.isArray(value) && value.includes(keyName)) + }) + if (keyName) { + // 避免和其他按键事件冲突 + setTimeout(() => { + this.$emit(keyName, {}) + }, 0) + } + } + document.addEventListener('keyup', listener) + // this.$once('hook:beforeDestroy', () => { + // document.removeEventListener('keyup', listener) + // }) + }, + render: () => {} +} +// #endif diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-popup/popup.js b/node_modules/@dcloudio/uni-ui/lib/uni-popup/popup.js new file mode 100644 index 0000000..c4e5781 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-popup/popup.js @@ -0,0 +1,26 @@ + +export default { + data() { + return { + + } + }, + created(){ + this.popup = this.getParent() + }, + methods:{ + /** + * 获取父元素实例 + */ + getParent(name = 'uniPopup') { + let parent = this.$parent; + let parentName = parent.$options.name; + while (parentName !== name) { + parent = parent.$parent; + if (!parent) return false + parentName = parent.$options.name; + } + return parent; + }, + } +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-popup/uni-popup.uvue b/node_modules/@dcloudio/uni-ui/lib/uni-popup/uni-popup.uvue new file mode 100644 index 0000000..5eb8d5b --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-popup/uni-popup.uvue @@ -0,0 +1,90 @@ + + + + + \ No newline at end of file diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-popup/uni-popup.vue b/node_modules/@dcloudio/uni-ui/lib/uni-popup/uni-popup.vue new file mode 100644 index 0000000..5af55e0 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-popup/uni-popup.vue @@ -0,0 +1,518 @@ + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-rate/uni-rate.vue b/node_modules/@dcloudio/uni-ui/lib/uni-rate/uni-rate.vue new file mode 100644 index 0000000..857f5f9 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-rate/uni-rate.vue @@ -0,0 +1,361 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-row/uni-row.vue b/node_modules/@dcloudio/uni-ui/lib/uni-row/uni-row.vue new file mode 100644 index 0000000..f8e8542 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-row/uni-row.vue @@ -0,0 +1,190 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-scss/changelog.md b/node_modules/@dcloudio/uni-ui/lib/uni-scss/changelog.md new file mode 100644 index 0000000..b863bb0 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-scss/changelog.md @@ -0,0 +1,8 @@ +## 1.0.3（2022-01-21） +- 优化 组件示例 +## 1.0.2（2021-11-22） +- 修复 / 符号在 vue 不同版本兼容问题引起的报错问题 +## 1.0.1（2021-11-22） +- 修复 vue3中scss语法兼容问题 +## 1.0.0（2021-11-18） +- init diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-scss/index.scss b/node_modules/@dcloudio/uni-ui/lib/uni-scss/index.scss new file mode 100644 index 0000000..1744a5f --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-scss/index.scss @@ -0,0 +1 @@ +@import './styles/index.scss'; diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-scss/package.json b/node_modules/@dcloudio/uni-ui/lib/uni-scss/package.json new file mode 100644 index 0000000..7cc0ccb --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-scss/package.json @@ -0,0 +1,82 @@ +{ + "id": "uni-scss", + "displayName": "uni-scss 辅助样式", + "version": "1.0.3", + "description": "uni-sass是uni-ui提供的一套全局样式 ，通过一些简单的类名和sass变量，实现简单的页面布局操作，比如颜色、边距、圆角等。", + "keywords": [ + "uni-scss", + "uni-ui", + "辅助样式" +], + "repository": "https://github.com/dcloudio/uni-ui", + "engines": { + "HBuilderX": "^3.1.0" + }, + "dcloudext": { + "category": [ + "JS SDK", + "通用 SDK" + ], + "sale": { + "regular": { + "price": "0.00" + }, + "sourcecode": { + "price": "0.00" + } + }, + "contact": { + "qq": "" + }, + "declaration": { + "ads": "无", + "data": "无", + "permissions": "无" + }, + "npmurl": "https://www.npmjs.com/package/@dcloudio/uni-ui" + }, + "uni_modules": { + "dependencies": [], + "encrypt": [], + "platforms": { + "cloud": { + "tcb": "y", + "aliyun": "y" + }, + "client": { + "App": { + "app-vue": "y", + "app-nvue": "u" + }, + "H5-mobile": { + "Safari": "y", + "Android Browser": "y", + "微信浏览器(Android)": "y", + "QQ浏览器(Android)": "y" + }, + "H5-pc": { + "Chrome": "y", + "IE": "y", + "Edge": "y", + "Firefox": "y", + "Safari": "y" + }, + "小程序": { + "微信": "y", + "阿里": "y", + "百度": "y", + "字节跳动": "y", + "QQ": "y" + }, + "快应用": { + "华为": "n", + "联盟": "n" + }, + "Vue": { + "vue2": "y", + "vue3": "y" + } + } + } + } +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-scss/readme.md b/node_modules/@dcloudio/uni-ui/lib/uni-scss/readme.md new file mode 100644 index 0000000..b7d1c25 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-scss/readme.md @@ -0,0 +1,4 @@ +`uni-sass` 是 `uni-ui`提供的一套全局样式 ，通过一些简单的类名和`sass`变量，实现简单的页面布局操作，比如颜色、边距、圆角等。 + +### [查看文档](https://uniapp.dcloud.io/component/uniui/uni-sass) +#### 如使用过程中有任何问题，或者您对uni-ui有一些好的建议，欢迎加入 uni-ui 交流群：871950839 \ No newline at end of file diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/index.scss b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/index.scss new file mode 100644 index 0000000..ffac4fe --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/index.scss @@ -0,0 +1,7 @@ +@import './setting/_variables.scss'; +@import './setting/_border.scss'; +@import './setting/_color.scss'; +@import './setting/_space.scss'; +@import './setting/_radius.scss'; +@import './setting/_text.scss'; +@import './setting/_styles.scss'; diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_border.scss b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_border.scss new file mode 100644 index 0000000..12a11c3 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_border.scss @@ -0,0 +1,3 @@ +.uni-border { + border: 1px $uni-border-1 solid; +} \ No newline at end of file diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_color.scss b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_color.scss new file mode 100644 index 0000000..1ededd9 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_color.scss @@ -0,0 +1,66 @@ + +// TODO 暂时不需要 class ，需要用户使用变量实现 ，如果使用类名其实并不推荐 +// @mixin get-styles($k,$c) { +// @if $k == size or $k == weight{ +// font-#{$k}:#{$c} +// }@else{ +// #{$k}:#{$c} +// } +// } +$uni-ui-color:( + // 主色 + primary: $uni-primary, + primary-disable: $uni-primary-disable, + primary-light: $uni-primary-light, + // 辅助色 + success: $uni-success, + success-disable: $uni-success-disable, + success-light: $uni-success-light, + warning: $uni-warning, + warning-disable: $uni-warning-disable, + warning-light: $uni-warning-light, + error: $uni-error, + error-disable: $uni-error-disable, + error-light: $uni-error-light, + info: $uni-info, + info-disable: $uni-info-disable, + info-light: $uni-info-light, + // 中性色 + main-color: $uni-main-color, + base-color: $uni-base-color, + secondary-color: $uni-secondary-color, + extra-color: $uni-extra-color, + // 背景色 + bg-color: $uni-bg-color, + // 边框颜色 + border-1: $uni-border-1, + border-2: $uni-border-2, + border-3: $uni-border-3, + border-4: $uni-border-4, + // 黑色 + black:$uni-black, + // 白色 + white:$uni-white, + // 透明 + transparent:$uni-transparent +) !default; +@each $key, $child in $uni-ui-color { + .uni-#{"" + $key} { + color: $child; + } + .uni-#{"" + $key}-bg { + background-color: $child; + } +} +.uni-shadow-sm { + box-shadow: $uni-shadow-sm; +} +.uni-shadow-base { + box-shadow: $uni-shadow-base; +} +.uni-shadow-lg { + box-shadow: $uni-shadow-lg; +} +.uni-mask { + background-color:$uni-mask; +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_radius.scss b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_radius.scss new file mode 100644 index 0000000..9a0428b --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_radius.scss @@ -0,0 +1,55 @@ +@mixin radius($r,$d:null ,$important: false){ + $radius-value:map-get($uni-radius, $r) if($important, !important, null); + // Key exists within the $uni-radius variable + @if (map-has-key($uni-radius, $r) and $d){ + @if $d == t { + border-top-left-radius:$radius-value; + border-top-right-radius:$radius-value; + }@else if $d == r { + border-top-right-radius:$radius-value; + border-bottom-right-radius:$radius-value; + }@else if $d == b { + border-bottom-left-radius:$radius-value; + border-bottom-right-radius:$radius-value; + }@else if $d == l { + border-top-left-radius:$radius-value; + border-bottom-left-radius:$radius-value; + }@else if $d == tl { + border-top-left-radius:$radius-value; + }@else if $d == tr { + border-top-right-radius:$radius-value; + }@else if $d == br { + border-bottom-right-radius:$radius-value; + }@else if $d == bl { + border-bottom-left-radius:$radius-value; + } + }@else{ + border-radius:$radius-value; + } +} + +@each $key, $child in $uni-radius { + @if($key){ + .uni-radius-#{"" + $key} { + @include radius($key) + } + }@else{ + .uni-radius { + @include radius($key) + } + } +} + +@each $direction in t, r, b, l,tl, tr, br, bl { + @each $key, $child in $uni-radius { + @if($key){ + .uni-radius-#{"" + $direction}-#{"" + $key} { + @include radius($key,$direction,false) + } + }@else{ + .uni-radius-#{$direction} { + @include radius($key,$direction,false) + } + } + } +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_space.scss b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_space.scss new file mode 100644 index 0000000..3c89528 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_space.scss @@ -0,0 +1,56 @@ + +@mixin fn($space,$direction,$size,$n) { + @if $n { + #{$space}-#{$direction}: #{$size*$uni-space-root}px + } @else { + #{$space}-#{$direction}: #{-$size*$uni-space-root}px + } +} +@mixin get-styles($direction,$i,$space,$n){ + @if $direction == t { + @include fn($space, top,$i,$n); + } + @if $direction == r { + @include fn($space, right,$i,$n); + } + @if $direction == b { + @include fn($space, bottom,$i,$n); + } + @if $direction == l { + @include fn($space, left,$i,$n); + } + @if $direction == x { + @include fn($space, left,$i,$n); + @include fn($space, right,$i,$n); + } + @if $direction == y { + @include fn($space, top,$i,$n); + @include fn($space, bottom,$i,$n); + } + @if $direction == a { + @if $n { + #{$space}:#{$i*$uni-space-root}px; + } @else { + #{$space}:#{-$i*$uni-space-root}px; + } + } +} + +@each $orientation in m,p { + $space: margin; + @if $orientation == m { + $space: margin; + } @else { + $space: padding; + } + @for $i from 0 through 16 { + @each $direction in t, r, b, l, x, y, a { + .uni-#{$orientation}#{$direction}-#{$i} { + @include get-styles($direction,$i,$space,true); + } + .uni-#{$orientation}#{$direction}-n#{$i} { + @include get-styles($direction,$i,$space,false); + } + } + } +} \ No newline at end of file diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_styles.scss b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_styles.scss new file mode 100644 index 0000000..689afec --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_styles.scss @@ -0,0 +1,167 @@ +/* #ifndef APP-NVUE */ + +$-color-white:#fff; +$-color-black:#000; +@mixin base-style($color) { + color: #fff; + background-color: $color; + border-color: mix($-color-black, $color, 8%); + &:not([hover-class]):active { + background: mix($-color-black, $color, 10%); + border-color: mix($-color-black, $color, 20%); + color: $-color-white; + outline: none; + } +} +@mixin is-color($color) { + @include base-style($color); + &[loading] { + @include base-style($color); + &::before { + margin-right:5px; + } + } + &[disabled] { + &, + &[loading], + &:not([hover-class]):active { + color: $-color-white; + border-color: mix(darken($color,10%), $-color-white); + background-color: mix($color, $-color-white); + } + } + +} +@mixin base-plain-style($color) { + color:$color; + background-color: mix($-color-white, $color, 90%); + border-color: mix($-color-white, $color, 70%); + &:not([hover-class]):active { + background: mix($-color-white, $color, 80%); + color: $color; + outline: none; + border-color: mix($-color-white, $color, 50%); + } +} +@mixin is-plain($color){ + &[plain] { + @include base-plain-style($color); + &[loading] { + @include base-plain-style($color); + &::before { + margin-right:5px; + } + } + &[disabled] { + &, + &:active { + color: mix($-color-white, $color, 40%); + background-color: mix($-color-white, $color, 90%); + border-color: mix($-color-white, $color, 80%); + } + } + } +} + + +.uni-btn { + margin: 5px; + color: #393939; + border:1px solid #ccc; + font-size: 16px; + font-weight: 200; + background-color: #F9F9F9; + // TODO 暂时处理边框隐藏一边的问题 + overflow: visible; + &::after{ + border: none; + } + + &:not([type]),&[type=default] { + color: #999; + &[loading] { + background: none; + &::before { + margin-right:5px; + } + } + + + + &[disabled]{ + color: mix($-color-white, #999, 60%); + &, + &[loading], + &:active { + color: mix($-color-white, #999, 60%); + background-color: mix($-color-white,$-color-black , 98%); + border-color: mix($-color-white, #999, 85%); + } + } + + &[plain] { + color: #999; + background: none; + border-color: $uni-border-1; + &:not([hover-class]):active { + background: none; + color: mix($-color-white, $-color-black, 80%); + border-color: mix($-color-white, $-color-black, 90%); + outline: none; + } + &[disabled]{ + &, + &[loading], + &:active { + background: none; + color: mix($-color-white, #999, 60%); + border-color: mix($-color-white, #999, 85%); + } + } + } + } + + &:not([hover-class]):active { + color: mix($-color-white, $-color-black, 50%); + } + + &[size=mini] { + font-size: 16px; + font-weight: 200; + border-radius: 8px; + } + + + + &.uni-btn-small { + font-size: 14px; + } + &.uni-btn-mini { + font-size: 12px; + } + + &.uni-btn-radius { + border-radius: 999px; + } + &[type=primary] { + @include is-color($uni-primary); + @include is-plain($uni-primary) + } + &[type=success] { + @include is-color($uni-success); + @include is-plain($uni-success) + } + &[type=error] { + @include is-color($uni-error); + @include is-plain($uni-error) + } + &[type=warning] { + @include is-color($uni-warning); + @include is-plain($uni-warning) + } + &[type=info] { + @include is-color($uni-info); + @include is-plain($uni-info) + } +} +/* #endif */ diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_text.scss b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_text.scss new file mode 100644 index 0000000..a34d08f --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_text.scss @@ -0,0 +1,24 @@ +@mixin get-styles($k,$c) { + @if $k == size or $k == weight{ + font-#{$k}:#{$c} + }@else{ + #{$k}:#{$c} + } +} + +@each $key, $child in $uni-headings { + /* #ifndef APP-NVUE */ + .uni-#{$key} { + @each $k, $c in $child { + @include get-styles($k,$c) + } + } + /* #endif */ + /* #ifdef APP-NVUE */ + .container .uni-#{$key} { + @each $k, $c in $child { + @include get-styles($k,$c) + } + } + /* #endif */ +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_variables.scss b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_variables.scss new file mode 100644 index 0000000..557d3d7 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/setting/_variables.scss @@ -0,0 +1,146 @@ +// @use "sass:math"; +@import '../tools/functions.scss'; +// 间距基础倍数 +$uni-space-root: 2 !default; +// 边框半径默认值 +$uni-radius-root:5px !default; +$uni-radius: () !default; +// 边框半径断点 +$uni-radius: map-deep-merge( + ( + 0: 0, + // TODO 当前版本暂时不支持 sm 属性 + // 'sm': math.div($uni-radius-root, 2), + null: $uni-radius-root, + 'lg': $uni-radius-root * 2, + 'xl': $uni-radius-root * 6, + 'pill': 9999px, + 'circle': 50% + ), + $uni-radius +); +// 字体家族 +$body-font-family: 'Roboto', sans-serif !default; +// 文本 +$heading-font-family: $body-font-family !default; +$uni-headings: () !default; +$letterSpacing: -0.01562em; +$uni-headings: map-deep-merge( + ( + 'h1': ( + size: 32px, + weight: 300, + line-height: 50px, + // letter-spacing:-0.01562em + ), + 'h2': ( + size: 28px, + weight: 300, + line-height: 40px, + // letter-spacing: -0.00833em + ), + 'h3': ( + size: 24px, + weight: 400, + line-height: 32px, + // letter-spacing: normal + ), + 'h4': ( + size: 20px, + weight: 400, + line-height: 30px, + // letter-spacing: 0.00735em + ), + 'h5': ( + size: 16px, + weight: 400, + line-height: 24px, + // letter-spacing: normal + ), + 'h6': ( + size: 14px, + weight: 500, + line-height: 18px, + // letter-spacing: 0.0125em + ), + 'subtitle': ( + size: 12px, + weight: 400, + line-height: 20px, + // letter-spacing: 0.00937em + ), + 'body': ( + font-size: 14px, + font-weight: 400, + line-height: 22px, + // letter-spacing: 0.03125em + ), + 'caption': ( + 'size': 12px, + 'weight': 400, + 'line-height': 20px, + // 'letter-spacing': 0.03333em, + // 'text-transform': false + ) + ), + $uni-headings +); + + + +// 主色 +$uni-primary: #2979ff !default; +$uni-primary-disable:lighten($uni-primary,20%) !default; +$uni-primary-light: lighten($uni-primary,25%) !default; + +// 辅助色 +// 除了主色外的场景色，需要在不同的场景中使用（例如危险色表示危险的操作）。 +$uni-success: #18bc37 !default; +$uni-success-disable:lighten($uni-success,20%) !default; +$uni-success-light: lighten($uni-success,25%) !default; + +$uni-warning: #f3a73f !default; +$uni-warning-disable:lighten($uni-warning,20%) !default; +$uni-warning-light: lighten($uni-warning,25%) !default; + +$uni-error: #e43d33 !default; +$uni-error-disable:lighten($uni-error,20%) !default; +$uni-error-light: lighten($uni-error,25%) !default; + +$uni-info: #8f939c !default; +$uni-info-disable:lighten($uni-info,20%) !default; +$uni-info-light: lighten($uni-info,25%) !default; + +// 中性色 +// 中性色用于文本、背景和边框颜色。通过运用不同的中性色，来表现层次结构。 +$uni-main-color: #3a3a3a !default; // 主要文字 +$uni-base-color: #6a6a6a !default; // 常规文字 +$uni-secondary-color: #909399 !default; // 次要文字 +$uni-extra-color: #c7c7c7 !default; // 辅助说明 + +// 边框颜色 +$uni-border-1: #F0F0F0 !default; +$uni-border-2: #EDEDED !default; +$uni-border-3: #DCDCDC !default; +$uni-border-4: #B9B9B9 !default; + +// 常规色 +$uni-black: #000000 !default; +$uni-white: #ffffff !default; +$uni-transparent: rgba($color: #000000, $alpha: 0) !default; + +// 背景色 +$uni-bg-color: #f7f7f7 !default; + +/* 水平间距 */ +$uni-spacing-sm: 8px !default; +$uni-spacing-base: 15px !default; +$uni-spacing-lg: 30px !default; + +// 阴影 +$uni-shadow-sm:0 0 5px rgba($color: #d8d8d8, $alpha: 0.5) !default; +$uni-shadow-base:0 1px 8px 1px rgba($color: #a5a5a5, $alpha: 0.2) !default; +$uni-shadow-lg:0px 1px 10px 2px rgba($color: #a5a4a4, $alpha: 0.5) !default; + +// 蒙版 +$uni-mask: rgba($color: #000000, $alpha: 0.4) !default; diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/tools/functions.scss b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/tools/functions.scss new file mode 100644 index 0000000..ac6f63e --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-scss/styles/tools/functions.scss @@ -0,0 +1,19 @@ +// 合并 map +@function map-deep-merge($parent-map, $child-map){ + $result: $parent-map; + @each $key, $child in $child-map { + $parent-has-key: map-has-key($result, $key); + $parent-value: map-get($result, $key); + $parent-type: type-of($parent-value); + $child-type: type-of($child); + $parent-is-map: $parent-type == map; + $child-is-map: $child-type == map; + + @if (not $parent-has-key) or ($parent-type != $child-type) or (not ($parent-is-map and $child-is-map)){ + $result: map-merge($result, ( $key: $child )); + }@else { + $result: map-merge($result, ( $key: map-deep-merge($parent-value, $child) )); + } + } + @return $result; +}; diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-scss/theme.scss b/node_modules/@dcloudio/uni-ui/lib/uni-scss/theme.scss new file mode 100644 index 0000000..80ee62f --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-scss/theme.scss @@ -0,0 +1,31 @@ +// 间距基础倍数 +$uni-space-root: 2; +// 边框半径默认值 +$uni-radius-root:5px; +// 主色 +$uni-primary: #2979ff; +// 辅助色 +$uni-success: #4cd964; +// 警告色 +$uni-warning: #f0ad4e; +// 错误色 +$uni-error: #dd524d; +// 描述色 +$uni-info: #909399; +// 中性色 +$uni-main-color: #303133; +$uni-base-color: #606266; +$uni-secondary-color: #909399; +$uni-extra-color: #C0C4CC; +// 背景色 +$uni-bg-color: #f5f5f5; +// 边框颜色 +$uni-border-1: #DCDFE6; +$uni-border-2: #E4E7ED; +$uni-border-3: #EBEEF5; +$uni-border-4: #F2F6FC; + +// 常规色 +$uni-black: #000000; +$uni-white: #ffffff; +$uni-transparent: rgba($color: #000000, $alpha: 0); diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-scss/variables.scss b/node_modules/@dcloudio/uni-ui/lib/uni-scss/variables.scss new file mode 100644 index 0000000..1c062d4 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-scss/variables.scss @@ -0,0 +1,62 @@ +@import './styles/setting/_variables.scss'; +// 间距基础倍数 +$uni-space-root: 2; +// 边框半径默认值 +$uni-radius-root:5px; + +// 主色 +$uni-primary: #2979ff; +$uni-primary-disable:mix(#fff,$uni-primary,50%); +$uni-primary-light: mix(#fff,$uni-primary,80%); + +// 辅助色 +// 除了主色外的场景色，需要在不同的场景中使用（例如危险色表示危险的操作）。 +$uni-success: #18bc37; +$uni-success-disable:mix(#fff,$uni-success,50%); +$uni-success-light: mix(#fff,$uni-success,80%); + +$uni-warning: #f3a73f; +$uni-warning-disable:mix(#fff,$uni-warning,50%); +$uni-warning-light: mix(#fff,$uni-warning,80%); + +$uni-error: #e43d33; +$uni-error-disable:mix(#fff,$uni-error,50%); +$uni-error-light: mix(#fff,$uni-error,80%); + +$uni-info: #8f939c; +$uni-info-disable:mix(#fff,$uni-info,50%); +$uni-info-light: mix(#fff,$uni-info,80%); + +// 中性色 +// 中性色用于文本、背景和边框颜色。通过运用不同的中性色，来表现层次结构。 +$uni-main-color: #3a3a3a; // 主要文字 +$uni-base-color: #6a6a6a; // 常规文字 +$uni-secondary-color: #909399; // 次要文字 +$uni-extra-color: #c7c7c7; // 辅助说明 + +// 边框颜色 +$uni-border-1: #F0F0F0; +$uni-border-2: #EDEDED; +$uni-border-3: #DCDCDC; +$uni-border-4: #B9B9B9; + +// 常规色 +$uni-black: #000000; +$uni-white: #ffffff; +$uni-transparent: rgba($color: #000000, $alpha: 0); + +// 背景色 +$uni-bg-color: #f7f7f7; + +/* 水平间距 */ +$uni-spacing-sm: 8px; +$uni-spacing-base: 15px; +$uni-spacing-lg: 30px; + +// 阴影 +$uni-shadow-sm:0 0 5px rgba($color: #d8d8d8, $alpha: 0.5); +$uni-shadow-base:0 1px 8px 1px rgba($color: #a5a5a5, $alpha: 0.2); +$uni-shadow-lg:0px 1px 10px 2px rgba($color: #a5a4a4, $alpha: 0.5); + +// 蒙版 +$uni-mask: rgba($color: #000000, $alpha: 0.4); diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-search-bar/i18n/en.json b/node_modules/@dcloudio/uni-ui/lib/uni-search-bar/i18n/en.json new file mode 100644 index 0000000..dd083a5 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-search-bar/i18n/en.json @@ -0,0 +1,4 @@ +{ + "uni-search-bar.cancel": "cancel", + "uni-search-bar.placeholder": "Search enter content" +} \ No newline at end of file diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-search-bar/i18n/index.js b/node_modules/@dcloudio/uni-ui/lib/uni-search-bar/i18n/index.js new file mode 100644 index 0000000..de7509c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-search-bar/i18n/index.js @@ -0,0 +1,8 @@ +import en from './en.json' +import zhHans from './zh-Hans.json' +import zhHant from './zh-Hant.json' +export default { + en, + 'zh-Hans': zhHans, + 'zh-Hant': zhHant +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-search-bar/i18n/zh-Hans.json b/node_modules/@dcloudio/uni-ui/lib/uni-search-bar/i18n/zh-Hans.json new file mode 100644 index 0000000..d2a1ced --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-search-bar/i18n/zh-Hans.json @@ -0,0 +1,4 @@ +{ + "uni-search-bar.cancel": "取消", + "uni-search-bar.placeholder": "请输入搜索内容" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-search-bar/i18n/zh-Hant.json b/node_modules/@dcloudio/uni-ui/lib/uni-search-bar/i18n/zh-Hant.json new file mode 100644 index 0000000..f1c96bc --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-search-bar/i18n/zh-Hant.json @@ -0,0 +1,4 @@ +{ + "uni-search-bar.cancel": "取消", + "uni-search-bar.placeholder": "請輸入搜索內容" +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-search-bar/uni-search-bar.vue b/node_modules/@dcloudio/uni-ui/lib/uni-search-bar/uni-search-bar.vue new file mode 100644 index 0000000..6b9b9c1 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-search-bar/uni-search-bar.vue @@ -0,0 +1,309 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-section/uni-section.vue b/node_modules/@dcloudio/uni-ui/lib/uni-section/uni-section.vue new file mode 100644 index 0000000..9a52e0b --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-section/uni-section.vue @@ -0,0 +1,167 @@ + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-segmented-control/uni-segmented-control.vue b/node_modules/@dcloudio/uni-ui/lib/uni-segmented-control/uni-segmented-control.vue new file mode 100644 index 0000000..a69366a --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-segmented-control/uni-segmented-control.vue @@ -0,0 +1,146 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-steps/uni-steps.vue b/node_modules/@dcloudio/uni-ui/lib/uni-steps/uni-steps.vue new file mode 100644 index 0000000..81017fc --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-steps/uni-steps.vue @@ -0,0 +1,280 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/bindingx.js b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/bindingx.js new file mode 100644 index 0000000..707e432 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/bindingx.js @@ -0,0 +1,302 @@ +let bindIngXMixins = {} + +// #ifdef APP-NVUE +const BindingX = uni.requireNativePlugin('bindingx'); +const dom = uni.requireNativePlugin('dom'); +const animation = uni.requireNativePlugin('animation'); + +bindIngXMixins = { + data() { + return {} + }, + + watch: { + show(newVal) { + if (this.autoClose) return + if (this.stop) return + this.stop = true + if (newVal) { + this.open(newVal) + } else { + this.close() + } + }, + leftOptions() { + this.getSelectorQuery() + this.init() + }, + rightOptions(newVal) { + this.init() + } + }, + created() { + this.swipeaction = this.getSwipeAction() + if (this.swipeaction && Array.isArray(this.swipeaction.children)) { + this.swipeaction.children.push(this) + } + }, + mounted() { + this.box = this.getEl(this.$refs['selector-box--hock']) + this.selector = this.getEl(this.$refs['selector-content--hock']); + this.leftButton = this.getEl(this.$refs['selector-left-button--hock']); + this.rightButton = this.getEl(this.$refs['selector-right-button--hock']); + this.init() + }, + // beforeDestroy() { + // this.swipeaction.children.forEach((item, index) => { + // if (item === this) { + // this.swipeaction.children.splice(index, 1) + // } + // }) + // }, + methods: { + init() { + this.$nextTick(() => { + this.x = 0 + this.button = { + show: false + } + setTimeout(() => { + this.getSelectorQuery() + }, 200) + }) + }, + onClick(index, item, position) { + this.$emit('click', { + content: item, + index, + position + }) + }, + touchstart(e) { + // fix by mehaotian 禁止滑动 + if (this.disabled) return + // 每次只触发一次，避免多次监听造成闪烁 + if (this.stop) return + this.stop = true + if (this.autoClose && this.swipeaction) { + this.swipeaction.closeOther(this) + } + + const leftWidth = this.button.left.width + const rightWidth = this.button.right.width + let expression = this.range(this.x, -rightWidth, leftWidth) + let leftExpression = this.range(this.x - leftWidth, -leftWidth, 0) + let rightExpression = this.range(this.x + rightWidth, 0, rightWidth) + + this.eventpan = BindingX.bind({ + anchor: this.box, + eventType: 'pan', + props: [{ + element: this.selector, + property: 'transform.translateX', + expression + }, { + element: this.leftButton, + property: 'transform.translateX', + expression: leftExpression + }, { + element: this.rightButton, + property: 'transform.translateX', + expression: rightExpression + }, ] + }, (e) => { + // nope + if (e.state === 'end') { + this.x = e.deltaX + this.x; + this.isclick = true + this.bindTiming(e.deltaX) + } + }); + }, + touchend(e) { + if (this.isopen !== 'none' && !this.isclick) { + this.open('none') + } + }, + bindTiming(x) { + const left = this.x + const leftWidth = this.button.left.width + const rightWidth = this.button.right.width + const threshold = this.threshold + if (!this.isopen || this.isopen === 'none') { + if (left > threshold) { + this.open('left') + } else if (left < -threshold) { + this.open('right') + } else { + this.open('none') + } + } else { + if ((x > -leftWidth && x < 0) || x > rightWidth) { + if ((x > -threshold && x < 0) || (x - rightWidth > threshold)) { + this.open('left') + } else { + this.open('none') + } + } else { + if ((x < threshold && x > 0) || (x + leftWidth < -threshold)) { + this.open('right') + } else { + this.open('none') + } + } + } + }, + + /** + * 移动范围 + * @param {Object} num + * @param {Object} mix + * @param {Object} max + */ + range(num, mix, max) { + return `min(max(x+${num}, ${mix}), ${max})` + }, + + /** + * 开启swipe + */ + open(type) { + this.animation(type) + }, + + /** + * 关闭swipe + */ + close() { + this.animation('none') + }, + + /** + * 开启关闭动画 + * @param {Object} type + */ + animation(type) { + const time = 300 + const leftWidth = this.button.left.width + const rightWidth = this.button.right.width + if (this.eventpan && this.eventpan.token) { + BindingX.unbind({ + token: this.eventpan.token, + eventType: 'pan' + }) + } + + switch (type) { + case 'left': + Promise.all([ + this.move(this.selector, leftWidth), + this.move(this.leftButton, 0), + this.move(this.rightButton, rightWidth * 2) + ]).then(() => { + this.setEmit(leftWidth, type) + }) + break + case 'right': + Promise.all([ + this.move(this.selector, -rightWidth), + this.move(this.leftButton, -leftWidth * 2), + this.move(this.rightButton, 0) + ]).then(() => { + this.setEmit(-rightWidth, type) + }) + break + default: + Promise.all([ + this.move(this.selector, 0), + this.move(this.leftButton, -leftWidth), + this.move(this.rightButton, rightWidth) + ]).then(() => { + this.setEmit(0, type) + }) + + } + }, + setEmit(x, type) { + const leftWidth = this.button.left.width + const rightWidth = this.button.right.width + this.isopen = this.isopen || 'none' + this.stop = false + this.isclick = false + // 只有状态不一致才会返回结果 + if (this.isopen !== type && this.x !== x) { + if (type === 'left' && leftWidth > 0) { + this.$emit('change', 'left') + } + if (type === 'right' && rightWidth > 0) { + this.$emit('change', 'right') + } + if (type === 'none') { + this.$emit('change', 'none') + } + } + this.x = x + this.isopen = type + }, + move(ref, value) { + return new Promise((resolve, reject) => { + animation.transition(ref, { + styles: { + transform: `translateX(${value})`, + }, + duration: 150, //ms + timingFunction: 'linear', + needLayout: false, + delay: 0 //ms + }, function(res) { + resolve(res) + }) + }) + + }, + + /** + * 获取ref + * @param {Object} el + */ + getEl(el) { + return el.ref + }, + /** + * 获取节点信息 + */ + getSelectorQuery() { + Promise.all([ + this.getDom('left'), + this.getDom('right'), + ]).then((data) => { + let show = 'none' + if (this.autoClose) { + show = 'none' + } else { + show = this.show + } + + if (show === 'none') { + // this.close() + } else { + this.open(show) + } + + }) + + }, + getDom(str) { + return new Promise((resolve, reject) => { + dom.getComponentRect(this.$refs[`selector-${str}-button--hock`], (data) => { + if (data) { + this.button[str] = data.size + resolve(data) + } else { + reject() + } + }) + }) + } + } +} + +// #endif + +export default bindIngXMixins diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/isPC.js b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/isPC.js new file mode 100644 index 0000000..917cb48 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/isPC.js @@ -0,0 +1,12 @@ +export function isPC() { + var userAgentInfo = navigator.userAgent; + var Agents = ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"]; + var flag = true; + for (let v = 0; v < Agents.length - 1; v++) { + if (userAgentInfo.indexOf(Agents[v]) > 0) { + flag = false; + break; + } + } + return flag; +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/mpalipay.js b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/mpalipay.js new file mode 100644 index 0000000..35c796b --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/mpalipay.js @@ -0,0 +1,195 @@ +export default { + data() { + return { + x: 0, + transition: false, + width: 0, + viewWidth: 0, + swipeShow: 0 + } + }, + watch: { + show(newVal) { + if (this.autoClose) return + if (newVal && newVal !== 'none') { + this.transition = true + this.open(newVal) + } else { + this.close() + } + } + }, + created() { + this.swipeaction = this.getSwipeAction() + if (this.swipeaction && Array.isArray(this.swipeaction.children)) { + this.swipeaction.children.push(this) + } + }, + mounted() { + this.isopen = false + setTimeout(() => { + this.getQuerySelect() + }, 50) + }, + methods: { + appTouchStart(e) { + const { + clientX + } = e.changedTouches[0] + this.clientX = clientX + this.timestamp = new Date().getTime() + }, + appTouchEnd(e, index, item, position) { + const { + clientX + } = e.changedTouches[0] + // fixed by xxxx 模拟点击事件，解决 ios 13 点击区域错位的问题 + let diff = Math.abs(this.clientX - clientX) + let time = (new Date().getTime()) - this.timestamp + if (diff < 40 && time < 300) { + this.$emit('click', { + content: item, + index, + position + }) + } + }, + /** + * 移动触发 + * @param {Object} e + */ + onChange(e) { + this.moveX = e.detail.x + this.isclose = false + }, + touchstart(e) { + this.transition = false + this.isclose = true + if (this.autoClose && this.swipeaction) { + this.swipeaction.closeOther(this) + } + }, + touchmove(e) {}, + touchend(e) { + // 0的位置什么都不执行 + if (this.isclose && this.isopen === 'none') return + if (this.isclose && this.isopen !== 'none') { + this.transition = true + this.close() + } else { + this.move(this.moveX + this.leftWidth) + } + }, + + /** + * 移动 + * @param {Object} moveX + */ + move(moveX) { + // 打开关闭的处理逻辑不太一样 + this.transition = true + // 未打开状态 + if (!this.isopen || this.isopen === 'none') { + if (moveX > this.threshold) { + this.open('left') + } else if (moveX < -this.threshold) { + this.open('right') + } else { + this.close() + } + } else { + if (moveX < 0 && moveX < this.rightWidth) { + const rightX = this.rightWidth + moveX + if (rightX < this.threshold) { + this.open('right') + } else { + this.close() + } + } else if (moveX > 0 && moveX < this.leftWidth) { + const leftX = this.leftWidth - moveX + if (leftX < this.threshold) { + this.open('left') + } else { + this.close() + } + } + + } + + }, + + /** + * 打开 + */ + open(type) { + this.x = this.moveX + this.animation(type) + }, + + /** + * 关闭 + */ + close() { + this.x = this.moveX + // TODO 解决 x 值不更新的问题，所以会多触发一次 nextTick ，待优化 + this.$nextTick(() => { + this.x = -this.leftWidth + if (this.isopen !== 'none') { + this.$emit('change', 'none') + } + this.isopen = 'none' + }) + }, + + /** + * 执行结束动画 + * @param {Object} type + */ + animation(type) { + this.$nextTick(() => { + if (type === 'left') { + this.x = 0 + } else { + this.x = -this.rightWidth - this.leftWidth + } + + if (this.isopen !== type) { + this.$emit('change', type) + } + this.isopen = type + }) + + }, + getSlide(x) {}, + getQuerySelect() { + const query = uni.createSelectorQuery().in(this); + query.selectAll('.movable-view--hock').boundingClientRect(data => { + this.leftWidth = data[1].width + this.rightWidth = data[2].width + this.width = data[0].width + this.viewWidth = this.width + this.rightWidth + this.leftWidth + if (this.leftWidth === 0) { + // TODO 疑似bug ,初始化的时候如果x 是0，会导致移动位置错误，所以让元素超出一点 + this.x = -0.1 + } else { + this.x = -this.leftWidth + } + this.moveX = this.x + this.$nextTick(() => { + this.swipeShow = 1 + }) + + if (!this.buttonWidth) { + this.disabledView = true + } + + if (this.autoClose) return + if (this.show !== 'none') { + this.transition = true + this.open(this.shows) + } + }).exec(); + + } + } +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/mpother.js b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/mpother.js new file mode 100644 index 0000000..d389bce --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/mpother.js @@ -0,0 +1,260 @@ +let otherMixins = {} + +// #ifndef APP-PLUS|| MP-WEIXIN || H5 +const MIN_DISTANCE = 10; +otherMixins = { + data() { + // TODO 随机生生元素ID，解决百度小程序获取同一个元素位置信息的bug + const elClass = `Uni_${Math.ceil(Math.random() * 10e5).toString(36)}` + return { + uniShow: false, + left: 0, + buttonShow: 'none', + ani: false, + moveLeft: '', + elClass + } + }, + watch: { + show(newVal) { + if (this.autoClose) return + this.openState(newVal) + }, + left() { + this.moveLeft = `translateX(${this.left}px)` + }, + buttonShow(newVal) { + if (this.autoClose) return + this.openState(newVal) + }, + leftOptions() { + this.init() + }, + rightOptions() { + this.init() + } + }, + mounted() { + this.swipeaction = this.getSwipeAction() + if (this.swipeaction && Array.isArray(this.swipeaction.children)) { + this.swipeaction.children.push(this) + } + this.init() + }, + methods: { + init() { + clearTimeout(this.timer) + this.timer = setTimeout(() => { + this.getSelectorQuery() + }, 100) + // 移动距离 + this.left = 0 + this.x = 0 + }, + + closeSwipe(e) { + if (this.autoClose && this.swipeaction) { + this.swipeaction.closeOther(this) + } + }, + appTouchStart(e) { + const { + clientX + } = e.changedTouches[0] + this.clientX = clientX + this.timestamp = new Date().getTime() + }, + appTouchEnd(e, index, item, position) { + const { + clientX + } = e.changedTouches[0] + // fixed by xxxx 模拟点击事件，解决 ios 13 点击区域错位的问题 + let diff = Math.abs(this.clientX - clientX) + let time = (new Date().getTime()) - this.timestamp + if (diff < 40 && time < 300) { + this.$emit('click', { + content: item, + index, + position + }) + } + }, + touchstart(e) { + if (this.disabled) return + this.ani = false + this.x = this.left || 0 + this.stopTouchStart(e) + this.autoClose && this.closeSwipe() + }, + touchmove(e) { + if (this.disabled) return + // 是否可以滑动页面 + this.stopTouchMove(e); + if (this.direction !== 'horizontal') { + return; + } + this.move(this.x + this.deltaX) + return false + }, + touchend() { + if (this.disabled) return + this.moveDirection(this.left) + }, + /** + * 设置移动距离 + * @param {Object} value + */ + move(value) { + value = value || 0 + const leftWidth = this.leftWidth + const rightWidth = this.rightWidth + // 获取可滑动范围 + this.left = this.range(value, -rightWidth, leftWidth); + }, + + /** + * 获取范围 + * @param {Object} num + * @param {Object} min + * @param {Object} max + */ + range(num, min, max) { + return Math.min(Math.max(num, min), max); + }, + /** + * 移动方向判断 + * @param {Object} left + * @param {Object} value + */ + moveDirection(left) { + const threshold = this.threshold + const isopen = this.isopen || 'none' + const leftWidth = this.leftWidth + const rightWidth = this.rightWidth + if (this.deltaX === 0) { + this.openState('none') + return + } + if ((isopen === 'none' && rightWidth > 0 && -left > threshold) || (isopen !== 'none' && rightWidth > + 0 && rightWidth + + left < threshold)) { + // right + this.openState('right') + } else if ((isopen === 'none' && leftWidth > 0 && left > threshold) || (isopen !== 'none' && leftWidth > + 0 && + leftWidth - left < threshold)) { + // left + this.openState('left') + } else { + // default + this.openState('none') + } + }, + + /** + * 开启状态 + * @param {Boolean} type + */ + openState(type) { + const leftWidth = this.leftWidth + const rightWidth = this.rightWidth + let left = '' + this.isopen = this.isopen ? this.isopen : 'none' + switch (type) { + case "left": + left = leftWidth + break + case "right": + left = -rightWidth + break + default: + left = 0 + } + + + if (this.isopen !== type) { + this.throttle = true + this.$emit('change', type) + } + + this.isopen = type + // 添加动画类 + this.ani = true + this.$nextTick(() => { + this.move(left) + }) + // 设置最终移动位置,理论上只要进入到这个函数，肯定是要打开的 + }, + close() { + this.openState('none') + }, + getDirection(x, y) { + if (x > y && x > MIN_DISTANCE) { + return 'horizontal'; + } + if (y > x && y > MIN_DISTANCE) { + return 'vertical'; + } + return ''; + }, + + /** + * 重置滑动状态 + * @param {Object} event + */ + resetTouchStatus() { + this.direction = ''; + this.deltaX = 0; + this.deltaY = 0; + this.offsetX = 0; + this.offsetY = 0; + }, + + /** + * 设置滑动开始位置 + * @param {Object} event + */ + stopTouchStart(event) { + this.resetTouchStatus(); + const touch = event.touches[0]; + this.startX = touch.clientX; + this.startY = touch.clientY; + }, + + /** + * 滑动中，是否禁止打开 + * @param {Object} event + */ + stopTouchMove(event) { + const touch = event.touches[0]; + this.deltaX = touch.clientX - this.startX; + this.deltaY = touch.clientY - this.startY; + this.offsetX = Math.abs(this.deltaX); + this.offsetY = Math.abs(this.deltaY); + this.direction = this.direction || this.getDirection(this.offsetX, this.offsetY); + }, + + getSelectorQuery() { + const views = uni.createSelectorQuery().in(this) + views + .selectAll('.' + this.elClass) + .boundingClientRect(data => { + if (data.length === 0) return + let show = 'none' + if (this.autoClose) { + show = 'none' + } else { + show = this.show + } + this.leftWidth = data[0].width || 0 + this.rightWidth = data[1].width || 0 + this.buttonShow = show + }) + .exec() + } + } +} + +// #endif + +export default otherMixins diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/mpwxs.js b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/mpwxs.js new file mode 100644 index 0000000..08de1c9 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/mpwxs.js @@ -0,0 +1,84 @@ +let mpMixins = {} +let is_pc = null +// #ifdef H5 +import { + isPC +} from "./isPC" +is_pc = isPC() +// #endif +// #ifdef APP-VUE|| MP-WEIXIN || H5 + +mpMixins = { + data() { + return { + is_show: 'none' + } + }, + watch: { + show(newVal) { + this.is_show = this.show + } + }, + created() { + this.swipeaction = this.getSwipeAction() + if (this.swipeaction && Array.isArray(this.swipeaction.children)) { + this.swipeaction.children.push(this) + } + }, + mounted() { + this.is_show = this.show + }, + methods: { + // wxs 中调用 + closeSwipe(e) { + if (this.autoClose && this.swipeaction) { + this.swipeaction.closeOther(this) + } + }, + + change(e) { + this.$emit('change', e.open) + if (this.is_show !== e.open) { + this.is_show = e.open + } + }, + + appTouchStart(e) { + if (is_pc) return + const { + clientX + } = e.changedTouches[0] + this.clientX = clientX + this.timestamp = new Date().getTime() + }, + appTouchEnd(e, index, item, position) { + if (is_pc) return + const { + clientX + } = e.changedTouches[0] + // fixed by xxxx 模拟点击事件，解决 ios 13 点击区域错位的问题 + let diff = Math.abs(this.clientX - clientX) + let time = (new Date().getTime()) - this.timestamp + if (diff < 40 && time < 300) { + this.$emit('click', { + content: item, + index, + position + }) + } + }, + onClickForPC(index, item, position) { + if (!is_pc) return + // #ifdef H5 + this.$emit('click', { + content: item, + index, + position + }) + // #endif + } + } +} + +// #endif +export default mpMixins diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/render.js b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/render.js new file mode 100644 index 0000000..78f0ec6 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/render.js @@ -0,0 +1,270 @@ +const MIN_DISTANCE = 10; +export default { + showWatch(newVal, oldVal, ownerInstance, instance, self) { + var state = self.state + var $el = ownerInstance.$el || ownerInstance.$vm && ownerInstance.$vm.$el + if (!$el) return + this.getDom(instance, ownerInstance, self) + if (newVal && newVal !== 'none') { + this.openState(newVal, instance, ownerInstance, self) + return + } + + if (state.left) { + this.openState('none', instance, ownerInstance, self) + } + this.resetTouchStatus(instance, self) + }, + + /** + * 开始触摸操作 + * @param {Object} e + * @param {Object} ins + */ + touchstart(e, ownerInstance, self) { + let instance = e.instance; + let disabled = instance.getDataset().disabled + let state = self.state; + this.getDom(instance, ownerInstance, self) + // fix by mehaotian, TODO 兼容 app-vue 获取dataset为字符串 , h5 获取 为 undefined 的问题,待框架修复 + disabled = this.getDisabledType(disabled) + if (disabled) return + // 开始触摸时移除动画类 + instance.requestAnimationFrame(function() { + instance.removeClass('ani'); + ownerInstance.callMethod('closeSwipe'); + }) + + // 记录上次的位置 + state.x = state.left || 0 + // 计算滑动开始位置 + this.stopTouchStart(e, ownerInstance, self) + }, + + /** + * 开始滑动操作 + * @param {Object} e + * @param {Object} ownerInstance + */ + touchmove(e, ownerInstance, self) { + let instance = e.instance; + // 删除之后已经那不到实例了 + if (!instance) return; + let disabled = instance.getDataset().disabled + let state = self.state + // fix by mehaotian, TODO 兼容 app-vue 获取dataset为字符串 , h5 获取 为 undefined 的问题,待框架修复 + disabled = this.getDisabledType(disabled) + if (disabled) return + // 是否可以滑动页面 + this.stopTouchMove(e, self); + if (state.direction !== 'horizontal') { + return; + } + if (e.preventDefault) { + // 阻止页面滚动 + e.preventDefault() + } + let x = state.x + state.deltaX + this.move(x, instance, ownerInstance, self) + }, + + /** + * 结束触摸操作 + * @param {Object} e + * @param {Object} ownerInstance + */ + touchend(e, ownerInstance, self) { + let instance = e.instance; + let disabled = instance.getDataset().disabled + let state = self.state + // fix by mehaotian, TODO 兼容 app-vue 获取dataset为字符串 , h5 获取 为 undefined 的问题,待框架修复 + disabled = this.getDisabledType(disabled) + + if (disabled) return + // 滑动过程中触摸结束,通过阙值判断是开启还是关闭 + // fixed by mehaotian 定时器解决点击按钮，touchend 触发比 click 事件时机早的问题 ，主要是 ios13 + this.moveDirection(state.left, instance, ownerInstance, self) + + }, + + /** + * 设置移动距离 + * @param {Object} value + * @param {Object} instance + * @param {Object} ownerInstance + */ + move(value, instance, ownerInstance, self) { + value = value || 0 + let state = self.state + let leftWidth = state.leftWidth + let rightWidth = state.rightWidth + // 获取可滑动范围 + state.left = this.range(value, -rightWidth, leftWidth); + instance.requestAnimationFrame(function() { + instance.setStyle({ + transform: 'translateX(' + state.left + 'px)', + '-webkit-transform': 'translateX(' + state.left + 'px)' + }) + }) + + }, + + /** + * 获取元素信息 + * @param {Object} instance + * @param {Object} ownerInstance + */ + getDom(instance, ownerInstance, self) { + var state = self.state + var $el = ownerInstance.$el || ownerInstance.$vm && ownerInstance.$vm.$el + var leftDom = $el.querySelector('.button-group--left') + var rightDom = $el.querySelector('.button-group--right') + + state.leftWidth = leftDom.offsetWidth || 0 + state.rightWidth = rightDom.offsetWidth || 0 + state.threshold = instance.getDataset().threshold + }, + + getDisabledType(value) { + return (typeof(value) === 'string' ? JSON.parse(value) : value) || false; + }, + + /** + * 获取范围 + * @param {Object} num + * @param {Object} min + * @param {Object} max + */ + range(num, min, max) { + return Math.min(Math.max(num, min), max); + }, + + + /** + * 移动方向判断 + * @param {Object} left + * @param {Object} value + * @param {Object} ownerInstance + * @param {Object} ins + */ + moveDirection(left, ins, ownerInstance, self) { + var state = self.state + var threshold = state.threshold + var position = state.position + var isopen = state.isopen || 'none' + var leftWidth = state.leftWidth + var rightWidth = state.rightWidth + if (state.deltaX === 0) { + this.openState('none', ins, ownerInstance, self) + return + } + if ((isopen === 'none' && rightWidth > 0 && -left > threshold) || (isopen !== 'none' && rightWidth > 0 && + rightWidth + + left < threshold)) { + // right + this.openState('right', ins, ownerInstance, self) + } else if ((isopen === 'none' && leftWidth > 0 && left > threshold) || (isopen !== 'none' && leftWidth > 0 && + leftWidth - left < threshold)) { + // left + this.openState('left', ins, ownerInstance, self) + } else { + // default + this.openState('none', ins, ownerInstance, self) + } + }, + + + /** + * 开启状态 + * @param {Boolean} type + * @param {Object} ins + * @param {Object} ownerInstance + */ + openState(type, ins, ownerInstance, self) { + let state = self.state + let leftWidth = state.leftWidth + let rightWidth = state.rightWidth + let left = '' + state.isopen = state.isopen ? state.isopen : 'none' + switch (type) { + case "left": + left = leftWidth + break + case "right": + left = -rightWidth + break + default: + left = 0 + } + + // && !state.throttle + + if (state.isopen !== type) { + state.throttle = true + ownerInstance.callMethod('change', { + open: type + }) + + } + + state.isopen = type + // 添加动画类 + ins.requestAnimationFrame(() => { + ins.addClass('ani'); + this.move(left, ins, ownerInstance, self) + }) + }, + + + getDirection(x, y) { + if (x > y && x > MIN_DISTANCE) { + return 'horizontal'; + } + if (y > x && y > MIN_DISTANCE) { + return 'vertical'; + } + return ''; + }, + + /** + * 重置滑动状态 + * @param {Object} event + */ + resetTouchStatus(instance, self) { + let state = self.state; + state.direction = ''; + state.deltaX = 0; + state.deltaY = 0; + state.offsetX = 0; + state.offsetY = 0; + }, + + /** + * 设置滑动开始位置 + * @param {Object} event + */ + stopTouchStart(event, ownerInstance, self) { + let instance = event.instance; + let state = self.state + this.resetTouchStatus(instance, self); + var touch = event.touches[0]; + state.startX = touch.clientX; + state.startY = touch.clientY; + }, + + /** + * 滑动中，是否禁止打开 + * @param {Object} event + */ + stopTouchMove(event, self) { + let instance = event.instance; + let state = self.state; + let touch = event.touches[0]; + + state.deltaX = touch.clientX - state.startX; + state.deltaY = touch.clientY - state.startY; + state.offsetY = Math.abs(state.deltaY); + state.offsetX = Math.abs(state.deltaX); + state.direction = state.direction || this.getDirection(state.offsetX, state.offsetY); + } +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/uni-swipe-action-item.vue b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/uni-swipe-action-item.vue new file mode 100644 index 0000000..7538671 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/uni-swipe-action-item.vue @@ -0,0 +1,348 @@ + + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/wx.wxs b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/wx.wxs new file mode 100644 index 0000000..b394244 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action-item/wx.wxs @@ -0,0 +1,341 @@ +var MIN_DISTANCE = 10; + +/** + * 判断当前是否为H5、app-vue + */ +var IS_HTML5 = false +if (typeof window === 'object') IS_HTML5 = true + +/** + * 监听页面内值的变化,主要用于动态开关swipe-action + * @param {Object} newValue + * @param {Object} oldValue + * @param {Object} ownerInstance + * @param {Object} instance + */ +function showWatch(newVal, oldVal, ownerInstance, instance) { + var state = instance.getState() + getDom(instance, ownerInstance) + if (newVal && newVal !== 'none') { + openState(newVal, instance, ownerInstance) + return + } + + if (state.left) { + openState('none', instance, ownerInstance) + } + resetTouchStatus(instance) +} + +/** + * 开始触摸操作 + * @param {Object} e + * @param {Object} ins + */ +function touchstart(e, ownerInstance) { + var instance = e.instance; + var disabled = instance.getDataset().disabled + var state = instance.getState(); + getDom(instance, ownerInstance) + // fix by mehaotian, TODO 兼容 app-vue 获取dataset为字符串 , h5 获取 为 undefined 的问题,待框架修复 + disabled = (typeof(disabled) === 'string' ? JSON.parse(disabled) : disabled) || false; + if (disabled) return + // 开始触摸时移除动画类 + instance.requestAnimationFrame(function() { + instance.removeClass('ani'); + ownerInstance.callMethod('closeSwipe'); + }) + + // 记录上次的位置 + state.x = state.left || 0 + // 计算滑动开始位置 + stopTouchStart(e, ownerInstance) +} + +/** + * 开始滑动操作 + * @param {Object} e + * @param {Object} ownerInstance + */ +function touchmove(e, ownerInstance) { + var instance = e.instance; + var disabled = instance.getDataset().disabled + var state = instance.getState() + // fix by mehaotian, TODO 兼容 app-vue 获取dataset为字符串 , h5 获取 为 undefined 的问题,待框架修复 + disabled = (typeof(disabled) === 'string' ? JSON.parse(disabled) : disabled) || false; + if (disabled) return + // 是否可以滑动页面 + stopTouchMove(e); + if (state.direction !== 'horizontal') { + return; + } + + if (e.preventDefault) { + // 阻止页面滚动 + e.preventDefault() + } + + move(state.x + state.deltaX, instance, ownerInstance) +} + +/** + * 结束触摸操作 + * @param {Object} e + * @param {Object} ownerInstance + */ +function touchend(e, ownerInstance) { + var instance = e.instance; + var disabled = instance.getDataset().disabled + var state = instance.getState() + // fix by mehaotian, TODO 兼容 app-vue 获取dataset为字符串 , h5 获取 为 undefined 的问题,待框架修复 + disabled = (typeof(disabled) === 'string' ? JSON.parse(disabled) : disabled) || false; + + if (disabled) return + // 滑动过程中触摸结束,通过阙值判断是开启还是关闭 + // fixed by mehaotian 定时器解决点击按钮，touchend 触发比 click 事件时机早的问题 ，主要是 ios13 + moveDirection(state.left, instance, ownerInstance) + +} + +/** + * 设置移动距离 + * @param {Object} value + * @param {Object} instance + * @param {Object} ownerInstance + */ +function move(value, instance, ownerInstance) { + value = value || 0 + var state = instance.getState() + var leftWidth = state.leftWidth + var rightWidth = state.rightWidth + // 获取可滑动范围 + state.left = range(value, -rightWidth, leftWidth); + instance.requestAnimationFrame(function() { + instance.setStyle({ + transform: 'translateX(' + state.left + 'px)', + '-webkit-transform': 'translateX(' + state.left + 'px)' + }) + }) + +} + +/** + * 获取元素信息 + * @param {Object} instance + * @param {Object} ownerInstance + */ +function getDom(instance, ownerInstance) { + var state = instance.getState() + var leftDom = ownerInstance.selectComponent('.button-group--left') + var rightDom = ownerInstance.selectComponent('.button-group--right') + var leftStyles = { + width: 0 + } + var rightStyles = { + width: 0 + } + leftStyles = leftDom.getBoundingClientRect() + rightStyles = rightDom.getBoundingClientRect() + + state.leftWidth = leftStyles.width || 0 + state.rightWidth = rightStyles.width || 0 + state.threshold = instance.getDataset().threshold +} + +/** + * 获取范围 + * @param {Object} num + * @param {Object} min + * @param {Object} max + */ +function range(num, min, max) { + return Math.min(Math.max(num, min), max); +} + + +/** + * 移动方向判断 + * @param {Object} left + * @param {Object} value + * @param {Object} ownerInstance + * @param {Object} ins + */ +function moveDirection(left, ins, ownerInstance) { + var state = ins.getState() + var threshold = state.threshold + var position = state.position + var isopen = state.isopen || 'none' + var leftWidth = state.leftWidth + var rightWidth = state.rightWidth + if (state.deltaX === 0) { + openState('none', ins, ownerInstance) + return + } + if ((isopen === 'none' && rightWidth > 0 && -left > threshold) || (isopen !== 'none' && rightWidth > 0 && + rightWidth + + left < threshold)) { + // right + openState('right', ins, ownerInstance) + } else if ((isopen === 'none' && leftWidth > 0 && left > threshold) || (isopen !== 'none' && leftWidth > 0 && + leftWidth - left < threshold)) { + // left + openState('left', ins, ownerInstance) + } else { + // default + openState('none', ins, ownerInstance) + } +} + + +/** + * 开启状态 + * @param {Boolean} type + * @param {Object} ins + * @param {Object} ownerInstance + */ +function openState(type, ins, ownerInstance) { + var state = ins.getState() + var leftWidth = state.leftWidth + var rightWidth = state.rightWidth + var left = '' + state.isopen = state.isopen ? state.isopen : 'none' + switch (type) { + case "left": + left = leftWidth + break + case "right": + left = -rightWidth + break + default: + left = 0 + } + + // && !state.throttle + + if (state.isopen !== type) { + state.throttle = true + ownerInstance.callMethod('change', { + open: type + }) + + } + + state.isopen = type + // 添加动画类 + ins.requestAnimationFrame(function() { + ins.addClass('ani'); + move(left, ins, ownerInstance) + }) + // 设置最终移动位置,理论上只要进入到这个函数，肯定是要打开的 +} + + +function getDirection(x, y) { + if (x > y && x > MIN_DISTANCE) { + return 'horizontal'; + } + if (y > x && y > MIN_DISTANCE) { + return 'vertical'; + } + return ''; +} + +/** + * 重置滑动状态 + * @param {Object} event + */ +function resetTouchStatus(instance) { + var state = instance.getState(); + state.direction = ''; + state.deltaX = 0; + state.deltaY = 0; + state.offsetX = 0; + state.offsetY = 0; +} + +/** + * 设置滑动开始位置 + * @param {Object} event + */ +function stopTouchStart(event) { + var instance = event.instance; + var state = instance.getState(); + resetTouchStatus(instance); + var touch = event.touches[0]; + if (IS_HTML5 && isPC()) { + touch = event; + } + state.startX = touch.clientX; + state.startY = touch.clientY; +} + +/** + * 滑动中，是否禁止打开 + * @param {Object} event + */ +function stopTouchMove(event) { + var instance = event.instance; + var state = instance.getState(); + var touch = event.touches[0]; + if (IS_HTML5 && isPC()) { + touch = event; + } + state.deltaX = touch.clientX - state.startX; + state.deltaY = touch.clientY - state.startY; + state.offsetY = Math.abs(state.deltaY); + state.offsetX = Math.abs(state.deltaX); + state.direction = state.direction || getDirection(state.offsetX, state.offsetY); +} + +function isPC() { + var userAgentInfo = navigator.userAgent; + var Agents = ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"]; + var flag = true; + for (var v = 0; v < Agents.length - 1; v++) { + if (userAgentInfo.indexOf(Agents[v]) > 0) { + flag = false; + break; + } + } + return flag; +} + +var movable = false + +function mousedown(e, ins) { + if (!IS_HTML5) return + if (!isPC()) return + touchstart(e, ins) + movable = true +} + +function mousemove(e, ins) { + if (!IS_HTML5) return + if (!isPC()) return + if (!movable) return + touchmove(e, ins) +} + +function mouseup(e, ins) { + if (!IS_HTML5) return + if (!isPC()) return + touchend(e, ins) + movable = false +} + +function mouseleave(e, ins) { + if (!IS_HTML5) return + if (!isPC()) return + movable = false +} + +module.exports = { + showWatch: showWatch, + touchstart: touchstart, + touchmove: touchmove, + touchend: touchend, + mousedown: mousedown, + mousemove: mousemove, + mouseup: mouseup, + mouseleave: mouseleave +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action/uni-swipe-action.vue b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action/uni-swipe-action.vue new file mode 100644 index 0000000..4971782 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-swipe-action/uni-swipe-action.vue @@ -0,0 +1,60 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-swiper-dot/uni-swiper-dot.vue b/node_modules/@dcloudio/uni-ui/lib/uni-swiper-dot/uni-swiper-dot.vue new file mode 100644 index 0000000..e66b6c7 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-swiper-dot/uni-swiper-dot.vue @@ -0,0 +1,218 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-table/uni-table.vue b/node_modules/@dcloudio/uni-ui/lib/uni-table/uni-table.vue new file mode 100644 index 0000000..3ab0496 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-table/uni-table.vue @@ -0,0 +1,460 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-tag/uni-tag.vue b/node_modules/@dcloudio/uni-ui/lib/uni-tag/uni-tag.vue new file mode 100644 index 0000000..7274436 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-tag/uni-tag.vue @@ -0,0 +1,252 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-tbody/uni-tbody.vue b/node_modules/@dcloudio/uni-ui/lib/uni-tbody/uni-tbody.vue new file mode 100644 index 0000000..130f626 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-tbody/uni-tbody.vue @@ -0,0 +1,34 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-td/uni-td.vue b/node_modules/@dcloudio/uni-ui/lib/uni-td/uni-td.vue new file mode 100644 index 0000000..69e5e8a --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-td/uni-td.vue @@ -0,0 +1,95 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-th/filter-dropdown.vue b/node_modules/@dcloudio/uni-ui/lib/uni-th/filter-dropdown.vue new file mode 100644 index 0000000..df22a71 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-th/filter-dropdown.vue @@ -0,0 +1,511 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-th/uni-th.vue b/node_modules/@dcloudio/uni-ui/lib/uni-th/uni-th.vue new file mode 100644 index 0000000..a39ae6c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-th/uni-th.vue @@ -0,0 +1,295 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-thead/uni-thead.vue b/node_modules/@dcloudio/uni-ui/lib/uni-thead/uni-thead.vue new file mode 100644 index 0000000..53b5c4c --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-thead/uni-thead.vue @@ -0,0 +1,137 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-title/uni-title.vue b/node_modules/@dcloudio/uni-ui/lib/uni-title/uni-title.vue new file mode 100644 index 0000000..bf4f926 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-title/uni-title.vue @@ -0,0 +1,171 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-tooltip/uni-tooltip.vue b/node_modules/@dcloudio/uni-ui/lib/uni-tooltip/uni-tooltip.vue new file mode 100644 index 0000000..cda3754 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-tooltip/uni-tooltip.vue @@ -0,0 +1,109 @@ + + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-tr/table-checkbox.vue b/node_modules/@dcloudio/uni-ui/lib/uni-tr/table-checkbox.vue new file mode 100644 index 0000000..1089187 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-tr/table-checkbox.vue @@ -0,0 +1,179 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-tr/uni-tr.vue b/node_modules/@dcloudio/uni-ui/lib/uni-tr/uni-tr.vue new file mode 100644 index 0000000..3fb76f4 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-tr/uni-tr.vue @@ -0,0 +1,184 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-transition/createAnimation.js b/node_modules/@dcloudio/uni-ui/lib/uni-transition/createAnimation.js new file mode 100644 index 0000000..8f89b18 --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-transition/createAnimation.js @@ -0,0 +1,131 @@ +// const defaultOption = { +// duration: 300, +// timingFunction: 'linear', +// delay: 0, +// transformOrigin: '50% 50% 0' +// } +// #ifdef APP-NVUE +const nvueAnimation = uni.requireNativePlugin('animation') +// #endif +class MPAnimation { + constructor(options, _this) { + this.options = options + // 在iOS10+QQ小程序平台下，传给原生的对象一定是个普通对象而不是Proxy对象，否则会报parameter should be Object instead of ProxyObject的错误 + this.animation = uni.createAnimation({ + ...options + }) + this.currentStepAnimates = {} + this.next = 0 + this.$ = _this + + } + + _nvuePushAnimates(type, args) { + let aniObj = this.currentStepAnimates[this.next] + let styles = {} + if (!aniObj) { + styles = { + styles: {}, + config: {} + } + } else { + styles = aniObj + } + if (animateTypes1.includes(type)) { + if (!styles.styles.transform) { + styles.styles.transform = '' + } + let unit = '' + if(type === 'rotate'){ + unit = 'deg' + } + styles.styles.transform += `${type}(${args+unit}) ` + } else { + styles.styles[type] = `${args}` + } + this.currentStepAnimates[this.next] = styles + } + _animateRun(styles = {}, config = {}) { + let ref = this.$.$refs['ani'].ref + if (!ref) return + return new Promise((resolve, reject) => { + nvueAnimation.transition(ref, { + styles, + ...config + }, res => { + resolve() + }) + }) + } + + _nvueNextAnimate(animates, step = 0, fn) { + let obj = animates[step] + if (obj) { + let { + styles, + config + } = obj + this._animateRun(styles, config).then(() => { + step += 1 + this._nvueNextAnimate(animates, step, fn) + }) + } else { + this.currentStepAnimates = {} + typeof fn === 'function' && fn() + this.isEnd = true + } + } + + step(config = {}) { + // #ifndef APP-NVUE + this.animation.step(config) + // #endif + // #ifdef APP-NVUE + this.currentStepAnimates[this.next].config = Object.assign({}, this.options, config) + this.currentStepAnimates[this.next].styles.transformOrigin = this.currentStepAnimates[this.next].config.transformOrigin + this.next++ + // #endif + return this + } + + run(fn) { + // #ifndef APP-NVUE + this.$.animationData = this.animation.export() + this.$.timer = setTimeout(() => { + typeof fn === 'function' && fn() + }, this.$.durationTime) + // #endif + // #ifdef APP-NVUE + this.isEnd = false + let ref = this.$.$refs['ani'] && this.$.$refs['ani'].ref + if(!ref) return + this._nvueNextAnimate(this.currentStepAnimates, 0, fn) + this.next = 0 + // #endif + } +} + + +const animateTypes1 = ['matrix', 'matrix3d', 'rotate', 'rotate3d', 'rotateX', 'rotateY', 'rotateZ', 'scale', 'scale3d', + 'scaleX', 'scaleY', 'scaleZ', 'skew', 'skewX', 'skewY', 'translate', 'translate3d', 'translateX', 'translateY', + 'translateZ' +] +const animateTypes2 = ['opacity', 'backgroundColor'] +const animateTypes3 = ['width', 'height', 'left', 'right', 'top', 'bottom'] +animateTypes1.concat(animateTypes2, animateTypes3).forEach(type => { + MPAnimation.prototype[type] = function(...args) { + // #ifndef APP-NVUE + this.animation[type](...args) + // #endif + // #ifdef APP-NVUE + this._nvuePushAnimates(type, args) + // #endif + return this + } +}) + +export function createAnimation(option, _this) { + if(!_this) return + clearTimeout(_this.timer) + return new MPAnimation(option, _this) +} diff --git a/node_modules/@dcloudio/uni-ui/lib/uni-transition/uni-transition.vue b/node_modules/@dcloudio/uni-ui/lib/uni-transition/uni-transition.vue new file mode 100644 index 0000000..f3ddd1f --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/lib/uni-transition/uni-transition.vue @@ -0,0 +1,286 @@ + + + + + diff --git a/node_modules/@dcloudio/uni-ui/package.json b/node_modules/@dcloudio/uni-ui/package.json new file mode 100644 index 0000000..a3ca9ec --- /dev/null +++ b/node_modules/@dcloudio/uni-ui/package.json @@ -0,0 +1,17 @@ +{ + "name": "@dcloudio/uni-ui", + "version": "1.5.7", + "description": "", + "author": "", + "license": "Apache-2.0", + "repository": { + "type": "git", + "url": "https://github.com/dcloudio/uni-ui" + }, + "dependencies": {}, + "devDependencies": {}, + "browserslist": [ + "Android >= 4", + "ios >= 8" + ] +} \ No newline at end of file diff --git a/node_modules/@parcel/watcher-win32-x64/LICENSE b/node_modules/@parcel/watcher-win32-x64/LICENSE new file mode 100644 index 0000000..7fb9bc9 --- /dev/null +++ b/node_modules/@parcel/watcher-win32-x64/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017-present Devon Govett + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/node_modules/@parcel/watcher-win32-x64/README.md b/node_modules/@parcel/watcher-win32-x64/README.md new file mode 100644 index 0000000..7620831 --- /dev/null +++ b/node_modules/@parcel/watcher-win32-x64/README.md @@ -0,0 +1 @@ +This is the win32-x64 build of @parcel/watcher. See https://github.com/parcel-bundler/watcher for details. \ No newline at end of file diff --git a/node_modules/@parcel/watcher-win32-x64/package.json b/node_modules/@parcel/watcher-win32-x64/package.json new file mode 100644 index 0000000..dbbc6d1 --- /dev/null +++ b/node_modules/@parcel/watcher-win32-x64/package.json @@ -0,0 +1,30 @@ +{ + "name": "@parcel/watcher-win32-x64", + "version": "2.5.1", + "main": "watcher.node", + "repository": { + "type": "git", + "url": "https://github.com/parcel-bundler/watcher.git" + }, + "description": "A native C++ Node module for querying and subscribing to filesystem events. Used by Parcel 2.", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + }, + "files": [ + "watcher.node" + ], + "engines": { + "node": ">= 10.0.0" + }, + "os": [ + "win32" + ], + "cpu": [ + "x64" + ] +} diff --git a/node_modules/@parcel/watcher-win32-x64/watcher.node b/node_modules/@parcel/watcher-win32-x64/watcher.node new file mode 100644 index 0000000..3264889 Binary files /dev/null and b/node_modules/@parcel/watcher-win32-x64/watcher.node differ diff --git a/node_modules/@parcel/watcher/LICENSE b/node_modules/@parcel/watcher/LICENSE new file mode 100644 index 0000000..7fb9bc9 --- /dev/null +++ b/node_modules/@parcel/watcher/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017-present Devon Govett + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/node_modules/@parcel/watcher/README.md b/node_modules/@parcel/watcher/README.md new file mode 100644 index 0000000..d212b93 --- /dev/null +++ b/node_modules/@parcel/watcher/README.md @@ -0,0 +1,135 @@ +# @parcel/watcher + +A native C++ Node module for querying and subscribing to filesystem events. Used by [Parcel 2](https://github.com/parcel-bundler/parcel). + +## Features + +- **Watch** - subscribe to realtime recursive directory change notifications when files or directories are created, updated, or deleted. +- **Query** - performantly query for historical change events in a directory, even when your program is not running. +- **Native** - implemented in C++ for performance and low-level integration with the operating system. +- **Cross platform** - includes backends for macOS, Linux, Windows, FreeBSD, and Watchman. +- **Performant** - events are throttled in C++ so the JavaScript thread is not overwhelmed during large filesystem changes (e.g. `git checkout` or `npm install`). +- **Scalable** - tens of thousands of files can be watched or queried at once with good performance. + +## Example + +```javascript +const watcher = require('@parcel/watcher'); +const path = require('path'); + +// Subscribe to events +let subscription = await watcher.subscribe(process.cwd(), (err, events) => { + console.log(events); +}); + +// later on... +await subscription.unsubscribe(); + +// Get events since some saved snapshot in the past +let snapshotPath = path.join(process.cwd(), 'snapshot.txt'); +let events = await watcher.getEventsSince(process.cwd(), snapshotPath); + +// Save a snapshot for later +await watcher.writeSnapshot(process.cwd(), snapshotPath); +``` + +## Watching + +`@parcel/watcher` supports subscribing to realtime notifications of changes in a directory. It works recursively, so changes in sub-directories will also be emitted. + +Events are throttled and coalesced for performance during large changes like `git checkout` or `npm install`, and a single notification will be emitted with all of the events at the end. + +Only one notification will be emitted per file. For example, if a file was both created and updated since the last event, you'll get only a `create` event. If a file is both created and deleted, you will not be notifed of that file. Renames cause two events: a `delete` for the old name, and a `create` for the new name. + +```javascript +let subscription = await watcher.subscribe(process.cwd(), (err, events) => { + console.log(events); +}); +``` + +Events have two properties: + +- `type` - the event type: `create`, `update`, or `delete`. +- `path` - the absolute path to the file or directory. + +To unsubscribe from change notifications, call the `unsubscribe` method on the returned subscription object. + +```javascript +await subscription.unsubscribe(); +``` + +`@parcel/watcher` has the following watcher backends, listed in priority order: + +- [FSEvents](https://developer.apple.com/documentation/coreservices/file_system_events) on macOS +- [Watchman](https://facebook.github.io/watchman/) if installed +- [inotify](http://man7.org/linux/man-pages/man7/inotify.7.html) on Linux +- [ReadDirectoryChangesW](https://msdn.microsoft.com/en-us/library/windows/desktop/aa365465%28v%3Dvs.85%29.aspx) on Windows +- [kqueue](https://man.freebsd.org/cgi/man.cgi?kqueue) on FreeBSD, or as an alternative to FSEvents on macOS + +You can specify the exact backend you wish to use by passing the `backend` option. If that backend is not available on the current platform, the default backend will be used instead. See below for the list of backend names that can be passed to the options. + +## Querying + +`@parcel/watcher` also supports querying for historical changes made in a directory, even when your program is not running. This makes it easy to invalidate a cache and re-build only the files that have changed, for example. It can be **significantly** faster than traversing the entire filesystem to determine what files changed, depending on the platform. + +In order to query for historical changes, you first need a previous snapshot to compare to. This can be saved to a file with the `writeSnapshot` function, e.g. just before your program exits. + +```javascript +await watcher.writeSnapshot(dirPath, snapshotPath); +``` + +When your program starts up, you can query for changes that have occurred since that snapshot using the `getEventsSince` function. + +```javascript +let events = await watcher.getEventsSince(dirPath, snapshotPath); +``` + +The events returned are exactly the same as the events that would be passed to the `subscribe` callback (see above). + +`@parcel/watcher` has the following watcher backends, listed in priority order: + +- [FSEvents](https://developer.apple.com/documentation/coreservices/file_system_events) on macOS +- [Watchman](https://facebook.github.io/watchman/) if installed +- [fts](http://man7.org/linux/man-pages/man3/fts.3.html) (brute force) on Linux and FreeBSD +- [FindFirstFile](https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-findfirstfilea) (brute force) on Windows + +The FSEvents (macOS) and Watchman backends are significantly more performant than the brute force backends used by default on Linux and Windows, for example returning results in miliseconds instead of seconds for large directory trees. This is because a background daemon monitoring filesystem changes on those platforms allows us to query cached data rather than traversing the filesystem manually (brute force). + +macOS has good performance with FSEvents by default. For the best performance on other platforms, install [Watchman](https://facebook.github.io/watchman/) and it will be used by `@parcel/watcher` automatically. + +You can specify the exact backend you wish to use by passing the `backend` option. If that backend is not available on the current platform, the default backend will be used instead. See below for the list of backend names that can be passed to the options. + +## Options + +All of the APIs in `@parcel/watcher` support the following options, which are passed as an object as the last function argument. + +- `ignore` - an array of paths or glob patterns to ignore. uses [`is-glob`](https://github.com/micromatch/is-glob) to distinguish paths from globs. glob patterns are parsed with [`micromatch`](https://github.com/micromatch/micromatch) (see [features](https://github.com/micromatch/micromatch#matching-features)). + - paths can be relative or absolute and can either be files or directories. No events will be emitted about these files or directories or their children. + - glob patterns match on relative paths from the root that is watched. No events will be emitted for matching paths. +- `backend` - the name of an explicitly chosen backend to use. Allowed options are `"fs-events"`, `"watchman"`, `"inotify"`, `"kqueue"`, `"windows"`, or `"brute-force"` (only for querying). If the specified backend is not available on the current platform, the default backend will be used instead. + +## WASM + +The `@parcel/watcher-wasm` package can be used in place of `@parcel/watcher` on unsupported platforms. It relies on the Node `fs` module, so in non-Node environments such as browsers, an `fs` polyfill will be needed. + +**Note**: the WASM implementation is significantly less efficient than the native implementations because it must crawl the file system to watch each directory individually. Use the native `@parcel/watcher` package wherever possible. + +```js +import {subscribe} from '@parcel/watcher-wasm'; + +// Use the module as documented above. +subscribe(/* ... */); +``` + +## Who is using this? + +- [Parcel 2](https://parceljs.org/) +- [VSCode](https://code.visualstudio.com/updates/v1_62#_file-watching-changes) +- [Tailwind CSS Intellisense](https://github.com/tailwindlabs/tailwindcss-intellisense) +- [Gatsby Cloud](https://twitter.com/chatsidhartha/status/1435647412828196867) +- [Nx](https://nx.dev) +- [Nuxt](https://nuxt.com) + +## License + +MIT diff --git a/node_modules/@parcel/watcher/binding.gyp b/node_modules/@parcel/watcher/binding.gyp new file mode 100644 index 0000000..9b8f6ff --- /dev/null +++ b/node_modules/@parcel/watcher/binding.gyp @@ -0,0 +1,93 @@ +{ + "targets": [ + { + "target_name": "watcher", + "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ], + "sources": [ "src/binding.cc", "src/Watcher.cc", "src/Backend.cc", "src/DirTree.cc", "src/Glob.cc", "src/Debounce.cc" ], + "include_dirs" : [" unknown; + export interface AsyncSubscription { + unsubscribe(): Promise; + } + export interface Event { + path: FilePath; + type: EventType; + } + export function getEventsSince( + dir: FilePath, + snapshot: FilePath, + opts?: Options + ): Promise; + export function subscribe( + dir: FilePath, + fn: SubscribeCallback, + opts?: Options + ): Promise; + export function unsubscribe( + dir: FilePath, + fn: SubscribeCallback, + opts?: Options + ): Promise; + export function writeSnapshot( + dir: FilePath, + snapshot: FilePath, + opts?: Options + ): Promise; +} + +export = ParcelWatcher; \ No newline at end of file diff --git a/node_modules/@parcel/watcher/index.js b/node_modules/@parcel/watcher/index.js new file mode 100644 index 0000000..8afb2b1 --- /dev/null +++ b/node_modules/@parcel/watcher/index.js @@ -0,0 +1,41 @@ +const {createWrapper} = require('./wrapper'); + +let name = `@parcel/watcher-${process.platform}-${process.arch}`; +if (process.platform === 'linux') { + const { MUSL, family } = require('detect-libc'); + if (family === MUSL) { + name += '-musl'; + } else { + name += '-glibc'; + } +} + +let binding; +try { + binding = require(name); +} catch (err) { + handleError(err); + try { + binding = require('./build/Release/watcher.node'); + } catch (err) { + handleError(err); + try { + binding = require('./build/Debug/watcher.node'); + } catch (err) { + handleError(err); + throw new Error(`No prebuild or local build of @parcel/watcher found. Tried ${name}. Please ensure it is installed (don't use --no-optional when installing with npm). Otherwise it is possible we don't support your platform yet. If this is the case, please report an issue to https://github.com/parcel-bundler/watcher.`); + } + } +} + +function handleError(err) { + if (err?.code !== 'MODULE_NOT_FOUND') { + throw err; + } +} + +const wrapper = createWrapper(binding); +exports.writeSnapshot = wrapper.writeSnapshot; +exports.getEventsSince = wrapper.getEventsSince; +exports.subscribe = wrapper.subscribe; +exports.unsubscribe = wrapper.unsubscribe; diff --git a/node_modules/@parcel/watcher/index.js.flow b/node_modules/@parcel/watcher/index.js.flow new file mode 100644 index 0000000..d75da93 --- /dev/null +++ b/node_modules/@parcel/watcher/index.js.flow @@ -0,0 +1,48 @@ +// @flow +declare type FilePath = string; +declare type GlobPattern = string; + +export type BackendType = + | 'fs-events' + | 'watchman' + | 'inotify' + | 'windows' + | 'brute-force'; +export type EventType = 'create' | 'update' | 'delete'; +export interface Options { + ignore?: Array, + backend?: BackendType +} +export type SubscribeCallback = ( + err: ?Error, + events: Array +) => mixed; +export interface AsyncSubscription { + unsubscribe(): Promise +} +export interface Event { + path: FilePath, + type: EventType +} +declare module.exports: { + getEventsSince( + dir: FilePath, + snapshot: FilePath, + opts?: Options + ): Promise>, + subscribe( + dir: FilePath, + fn: SubscribeCallback, + opts?: Options + ): Promise, + unsubscribe( + dir: FilePath, + fn: SubscribeCallback, + opts?: Options + ): Promise, + writeSnapshot( + dir: FilePath, + snapshot: FilePath, + opts?: Options + ): Promise +} \ No newline at end of file diff --git a/node_modules/@parcel/watcher/package.json b/node_modules/@parcel/watcher/package.json new file mode 100644 index 0000000..dc41500 --- /dev/null +++ b/node_modules/@parcel/watcher/package.json @@ -0,0 +1,88 @@ +{ + "name": "@parcel/watcher", + "version": "2.5.1", + "main": "index.js", + "types": "index.d.ts", + "repository": { + "type": "git", + "url": "https://github.com/parcel-bundler/watcher.git" + }, + "description": "A native C++ Node module for querying and subscribing to filesystem events. Used by Parcel 2.", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + }, + "files": [ + "index.js", + "index.js.flow", + "index.d.ts", + "wrapper.js", + "package.json", + "README.md", + "LICENSE", + "src", + "scripts/build-from-source.js", + "binding.gyp" + ], + "scripts": { + "prebuild": "prebuildify --napi --strip --tag-libc", + "format": "prettier --write \"./**/*.{js,json,md}\"", + "build": "node-gyp rebuild", + "install": "node scripts/build-from-source.js", + "test": "mocha" + }, + "engines": { + "node": ">= 10.0.0" + }, + "husky": { + "hooks": { + "pre-commit": "lint-staged" + } + }, + "lint-staged": { + "*.{js,json,md}": [ + "prettier --write", + "git add" + ] + }, + "dependencies": { + "detect-libc": "^1.0.3", + "is-glob": "^4.0.3", + "micromatch": "^4.0.5", + "node-addon-api": "^7.0.0" + }, + "devDependencies": { + "esbuild": "^0.19.8", + "fs-extra": "^10.0.0", + "husky": "^7.0.2", + "lint-staged": "^11.1.2", + "mocha": "^9.1.1", + "napi-wasm": "^1.1.0", + "prebuildify": "^6.0.1", + "prettier": "^2.3.2" + }, + "binary": { + "napi_versions": [ + 3 + ] + }, + "optionalDependencies": { + "@parcel/watcher-darwin-x64": "2.5.1", + "@parcel/watcher-darwin-arm64": "2.5.1", + "@parcel/watcher-win32-x64": "2.5.1", + "@parcel/watcher-win32-arm64": "2.5.1", + "@parcel/watcher-win32-ia32": "2.5.1", + "@parcel/watcher-linux-x64-glibc": "2.5.1", + "@parcel/watcher-linux-x64-musl": "2.5.1", + "@parcel/watcher-linux-arm64-glibc": "2.5.1", + "@parcel/watcher-linux-arm64-musl": "2.5.1", + "@parcel/watcher-linux-arm-glibc": "2.5.1", + "@parcel/watcher-linux-arm-musl": "2.5.1", + "@parcel/watcher-android-arm64": "2.5.1", + "@parcel/watcher-freebsd-x64": "2.5.1" + } +} diff --git a/node_modules/@parcel/watcher/scripts/build-from-source.js b/node_modules/@parcel/watcher/scripts/build-from-source.js new file mode 100644 index 0000000..4602008 --- /dev/null +++ b/node_modules/@parcel/watcher/scripts/build-from-source.js @@ -0,0 +1,13 @@ +#!/usr/bin/env node + +const {spawn} = require('child_process'); + +if (process.env.npm_config_build_from_source === 'true') { + build(); +} + +function build() { + spawn('node-gyp', ['rebuild'], { stdio: 'inherit', shell: true }).on('exit', function (code) { + process.exit(code); + }); +} diff --git a/node_modules/@parcel/watcher/src/Backend.cc b/node_modules/@parcel/watcher/src/Backend.cc new file mode 100644 index 0000000..fcf5544 --- /dev/null +++ b/node_modules/@parcel/watcher/src/Backend.cc @@ -0,0 +1,182 @@ +#ifdef FS_EVENTS +#include "macos/FSEventsBackend.hh" +#endif +#ifdef WATCHMAN +#include "watchman/WatchmanBackend.hh" +#endif +#ifdef WINDOWS +#include "windows/WindowsBackend.hh" +#endif +#ifdef INOTIFY +#include "linux/InotifyBackend.hh" +#endif +#ifdef KQUEUE +#include "kqueue/KqueueBackend.hh" +#endif +#ifdef __wasm32__ +#include "wasm/WasmBackend.hh" +#endif +#include "shared/BruteForceBackend.hh" + +#include "Backend.hh" +#include + +static std::unordered_map> sharedBackends; + +std::shared_ptr getBackend(std::string backend) { + // Use FSEvents on macOS by default. + // Use watchman by default if available on other platforms. + // Fall back to brute force. + #ifdef FS_EVENTS + if (backend == "fs-events" || backend == "default") { + return std::make_shared(); + } + #endif + #ifdef WATCHMAN + if ((backend == "watchman" || backend == "default") && WatchmanBackend::checkAvailable()) { + return std::make_shared(); + } + #endif + #ifdef WINDOWS + if (backend == "windows" || backend == "default") { + return std::make_shared(); + } + #endif + #ifdef INOTIFY + if (backend == "inotify" || backend == "default") { + return std::make_shared(); + } + #endif + #ifdef KQUEUE + if (backend == "kqueue" || backend == "default") { + return std::make_shared(); + } + #endif + #ifdef __wasm32__ + if (backend == "wasm" || backend == "default") { + return std::make_shared(); + } + #endif + if (backend == "brute-force" || backend == "default") { + return std::make_shared(); + } + + return nullptr; +} + +std::shared_ptr Backend::getShared(std::string backend) { + auto found = sharedBackends.find(backend); + if (found != sharedBackends.end()) { + return found->second; + } + + auto result = getBackend(backend); + if (!result) { + return getShared("default"); + } + + result->run(); + sharedBackends.emplace(backend, result); + return result; +} + +void removeShared(Backend *backend) { + for (auto it = sharedBackends.begin(); it != sharedBackends.end(); it++) { + if (it->second.get() == backend) { + sharedBackends.erase(it); + break; + } + } + + // Free up memory. + if (sharedBackends.size() == 0) { + sharedBackends.rehash(0); + } +} + +void Backend::run() { + #ifndef __wasm32__ + mThread = std::thread([this] () { + try { + start(); + } catch (std::exception &err) { + handleError(err); + } + }); + + if (mThread.joinable()) { + mStartedSignal.wait(); + } + #else + try { + start(); + } catch (std::exception &err) { + handleError(err); + } + #endif +} + +void Backend::notifyStarted() { + mStartedSignal.notify(); +} + +void Backend::start() { + notifyStarted(); +} + +Backend::~Backend() { + #ifndef __wasm32__ + // Wait for thread to stop + if (mThread.joinable()) { + // If the backend is being destroyed from the thread itself, detach, otherwise join. + if (mThread.get_id() == std::this_thread::get_id()) { + mThread.detach(); + } else { + mThread.join(); + } + } + #endif +} + +void Backend::watch(WatcherRef watcher) { + std::unique_lock lock(mMutex); + auto res = mSubscriptions.find(watcher); + if (res == mSubscriptions.end()) { + try { + this->subscribe(watcher); + mSubscriptions.insert(watcher); + } catch (std::exception &err) { + unref(); + throw; + } + } +} + +void Backend::unwatch(WatcherRef watcher) { + std::unique_lock lock(mMutex); + size_t deleted = mSubscriptions.erase(watcher); + if (deleted > 0) { + this->unsubscribe(watcher); + unref(); + } +} + +void Backend::unref() { + if (mSubscriptions.size() == 0) { + removeShared(this); + } +} + +void Backend::handleWatcherError(WatcherError &err) { + unwatch(err.mWatcher); + err.mWatcher->notifyError(err); +} + +void Backend::handleError(std::exception &err) { + std::unique_lock lock(mMutex); + for (auto it = mSubscriptions.begin(); it != mSubscriptions.end(); it++) { + (*it)->notifyError(err); + } + + removeShared(this); +} diff --git a/node_modules/@parcel/watcher/src/Backend.hh b/node_modules/@parcel/watcher/src/Backend.hh new file mode 100644 index 0000000..d673bd1 --- /dev/null +++ b/node_modules/@parcel/watcher/src/Backend.hh @@ -0,0 +1,37 @@ +#ifndef BACKEND_H +#define BACKEND_H + +#include "Event.hh" +#include "Watcher.hh" +#include "Signal.hh" +#include + +class Backend { +public: + virtual ~Backend(); + void run(); + void notifyStarted(); + + virtual void start(); + virtual void writeSnapshot(WatcherRef watcher, std::string *snapshotPath) = 0; + virtual void getEventsSince(WatcherRef watcher, std::string *snapshotPath) = 0; + virtual void subscribe(WatcherRef watcher) = 0; + virtual void unsubscribe(WatcherRef watcher) = 0; + + static std::shared_ptr getShared(std::string backend); + + void watch(WatcherRef watcher); + void unwatch(WatcherRef watcher); + void unref(); + void handleWatcherError(WatcherError &err); + + std::mutex mMutex; + std::thread mThread; +private: + std::unordered_set mSubscriptions; + Signal mStartedSignal; + + void handleError(std::exception &err); +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/Debounce.cc b/node_modules/@parcel/watcher/src/Debounce.cc new file mode 100644 index 0000000..be07e78 --- /dev/null +++ b/node_modules/@parcel/watcher/src/Debounce.cc @@ -0,0 +1,113 @@ +#include "Debounce.hh" + +#ifdef __wasm32__ +extern "C" void on_timeout(void *ctx) { + Debounce *debounce = (Debounce *)ctx; + debounce->notify(); +} +#endif + +std::shared_ptr Debounce::getShared() { + static std::weak_ptr sharedInstance; + std::shared_ptr shared = sharedInstance.lock(); + if (!shared) { + shared = std::make_shared(); + sharedInstance = shared; + } + + return shared; +} + +Debounce::Debounce() { + mRunning = true; + #ifndef __wasm32__ + mThread = std::thread([this] () { + loop(); + }); + #endif +} + +Debounce::~Debounce() { + mRunning = false; + #ifndef __wasm32__ + mWaitSignal.notify(); + mThread.join(); + #endif +} + +void Debounce::add(void *key, std::function cb) { + std::unique_lock lock(mMutex); + mCallbacks.emplace(key, cb); +} + +void Debounce::remove(void *key) { + std::unique_lock lock(mMutex); + mCallbacks.erase(key); +} + +void Debounce::trigger() { + std::unique_lock lock(mMutex); + #ifdef __wasm32__ + notifyIfReady(); + #else + mWaitSignal.notify(); + #endif +} + +#ifndef __wasm32__ +void Debounce::loop() { + while (mRunning) { + mWaitSignal.wait(); + if (!mRunning) { + break; + } + + notifyIfReady(); + } +} +#endif + +void Debounce::notifyIfReady() { + if (!mRunning) { + return; + } + + // If we haven't seen an event in more than the maximum wait time, notify callbacks immediately + // to ensure that we don't wait forever. Otherwise, wait for the minimum wait time and batch + // subsequent fast changes. This also means the first file change in a batch is notified immediately, + // separately from the rest of the batch. This seems like an acceptable tradeoff if the common case + // is that only a single file was updated at a time. + auto time = std::chrono::steady_clock::now(); + if ((time - mLastTime) > std::chrono::milliseconds(MAX_WAIT_TIME)) { + mLastTime = time; + notify(); + } else { + wait(); + } +} + +void Debounce::wait() { + #ifdef __wasm32__ + clear_timeout(mTimeout); + mTimeout = set_timeout(MIN_WAIT_TIME, this); + #else + auto status = mWaitSignal.waitFor(std::chrono::milliseconds(MIN_WAIT_TIME)); + if (mRunning && (status == std::cv_status::timeout)) { + notify(); + } + #endif +} + +void Debounce::notify() { + std::unique_lock lock(mMutex); + + mLastTime = std::chrono::steady_clock::now(); + for (auto it = mCallbacks.begin(); it != mCallbacks.end(); it++) { + auto cb = it->second; + cb(); + } + + #ifndef __wasm32__ + mWaitSignal.reset(); + #endif +} diff --git a/node_modules/@parcel/watcher/src/Debounce.hh b/node_modules/@parcel/watcher/src/Debounce.hh new file mode 100644 index 0000000..a17fdef --- /dev/null +++ b/node_modules/@parcel/watcher/src/Debounce.hh @@ -0,0 +1,49 @@ +#ifndef DEBOUNCE_H +#define DEBOUNCE_H + +#include +#include +#include +#include "Signal.hh" + +#define MIN_WAIT_TIME 50 +#define MAX_WAIT_TIME 500 + +#ifdef __wasm32__ +extern "C" { + int set_timeout(int ms, void *ctx); + void clear_timeout(int timeout); + void on_timeout(void *ctx); +}; +#endif + +class Debounce { +public: + static std::shared_ptr getShared(); + + Debounce(); + ~Debounce(); + + void add(void *key, std::function cb); + void remove(void *key); + void trigger(); + void notify(); + +private: + bool mRunning; + std::mutex mMutex; + #ifdef __wasm32__ + int mTimeout; + #else + Signal mWaitSignal; + std::thread mThread; + #endif + std::unordered_map> mCallbacks; + std::chrono::time_point mLastTime; + + void loop(); + void notifyIfReady(); + void wait(); +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/DirTree.cc b/node_modules/@parcel/watcher/src/DirTree.cc new file mode 100644 index 0000000..ac17c15 --- /dev/null +++ b/node_modules/@parcel/watcher/src/DirTree.cc @@ -0,0 +1,152 @@ +#include "DirTree.hh" +#include + +static std::mutex mDirCacheMutex; +static std::unordered_map> dirTreeCache; + +struct DirTreeDeleter { + void operator()(DirTree *tree) { + std::lock_guard lock(mDirCacheMutex); + dirTreeCache.erase(tree->root); + delete tree; + + // Free up memory. + if (dirTreeCache.size() == 0) { + dirTreeCache.rehash(0); + } + } +}; + +std::shared_ptr DirTree::getCached(std::string root) { + std::lock_guard lock(mDirCacheMutex); + + auto found = dirTreeCache.find(root); + std::shared_ptr tree; + + // Use cached tree, or create an empty one. + if (found != dirTreeCache.end()) { + tree = found->second.lock(); + } else { + tree = std::shared_ptr(new DirTree(root), DirTreeDeleter()); + dirTreeCache.emplace(root, tree); + } + + return tree; +} + +DirTree::DirTree(std::string root, FILE *f) : root(root), isComplete(true) { + size_t size; + if (fscanf(f, "%zu", &size)) { + for (size_t i = 0; i < size; i++) { + DirEntry entry(f); + entries.emplace(entry.path, entry); + } + } +} + +// Internal find method that has no lock +DirEntry *DirTree::_find(std::string path) { + auto found = entries.find(path); + if (found == entries.end()) { + return NULL; + } + + return &found->second; +} + +DirEntry *DirTree::add(std::string path, uint64_t mtime, bool isDir) { + std::lock_guard lock(mMutex); + + DirEntry entry(path, mtime, isDir); + auto it = entries.emplace(entry.path, entry); + return &it.first->second; +} + +DirEntry *DirTree::find(std::string path) { + std::lock_guard lock(mMutex); + return _find(path); +} + +DirEntry *DirTree::update(std::string path, uint64_t mtime) { + std::lock_guard lock(mMutex); + + DirEntry *found = _find(path); + if (found) { + found->mtime = mtime; + } + + return found; +} + +void DirTree::remove(std::string path) { + std::lock_guard lock(mMutex); + + DirEntry *found = _find(path); + + // Remove all sub-entries if this is a directory + if (found && found->isDir) { + std::string pathStart = path + DIR_SEP; + for (auto it = entries.begin(); it != entries.end();) { + if (it->first.rfind(pathStart, 0) == 0) { + it = entries.erase(it); + } else { + it++; + } + } + } + + entries.erase(path); +} + +void DirTree::write(FILE *f) { + std::lock_guard lock(mMutex); + + fprintf(f, "%zu\n", entries.size()); + for (auto it = entries.begin(); it != entries.end(); it++) { + it->second.write(f); + } +} + +void DirTree::getChanges(DirTree *snapshot, EventList &events) { + std::lock_guard lock(mMutex); + std::lock_guard snapshotLock(snapshot->mMutex); + + for (auto it = entries.begin(); it != entries.end(); it++) { + auto found = snapshot->entries.find(it->first); + if (found == snapshot->entries.end()) { + events.create(it->second.path); + } else if (found->second.mtime != it->second.mtime && !found->second.isDir && !it->second.isDir) { + events.update(it->second.path); + } + } + + for (auto it = snapshot->entries.begin(); it != snapshot->entries.end(); it++) { + size_t count = entries.count(it->first); + if (count == 0) { + events.remove(it->second.path); + } + } +} + +DirEntry::DirEntry(std::string p, uint64_t t, bool d) { + path = p; + mtime = t; + isDir = d; + state = NULL; +} + +DirEntry::DirEntry(FILE *f) { + size_t size; + if (fscanf(f, "%zu", &size)) { + path.resize(size); + if (fread(&path[0], sizeof(char), size, f)) { + int d = 0; + fscanf(f, "%" PRIu64 " %d\n", &mtime, &d); + isDir = d == 1; + } + } +} + +void DirEntry::write(FILE *f) const { + fprintf(f, "%zu%s%" PRIu64 " %d\n", path.size(), path.c_str(), mtime, isDir); +} diff --git a/node_modules/@parcel/watcher/src/DirTree.hh b/node_modules/@parcel/watcher/src/DirTree.hh new file mode 100644 index 0000000..328f469 --- /dev/null +++ b/node_modules/@parcel/watcher/src/DirTree.hh @@ -0,0 +1,50 @@ +#ifndef DIR_TREE_H +#define DIR_TREE_H + +#include +#include +#include +#include "Event.hh" + +#ifdef _WIN32 +#define DIR_SEP "\\" +#else +#define DIR_SEP "/" +#endif + +struct DirEntry { + std::string path; + uint64_t mtime; + bool isDir; + mutable void *state; + + DirEntry(std::string p, uint64_t t, bool d); + DirEntry(FILE *f); + void write(FILE *f) const; + bool operator==(const DirEntry &other) const { + return path == other.path; + } +}; + +class DirTree { +public: + static std::shared_ptr getCached(std::string root); + DirTree(std::string root) : root(root), isComplete(false) {} + DirTree(std::string root, FILE *f); + DirEntry *add(std::string path, uint64_t mtime, bool isDir); + DirEntry *find(std::string path); + DirEntry *update(std::string path, uint64_t mtime); + void remove(std::string path); + void write(FILE *f); + void getChanges(DirTree *snapshot, EventList &events); + + std::mutex mMutex; + std::string root; + bool isComplete; + std::unordered_map entries; + +private: + DirEntry *_find(std::string path); +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/Event.hh b/node_modules/@parcel/watcher/src/Event.hh new file mode 100644 index 0000000..8d09712 --- /dev/null +++ b/node_modules/@parcel/watcher/src/Event.hh @@ -0,0 +1,109 @@ +#ifndef EVENT_H +#define EVENT_H + +#include +#include +#include "wasm/include.h" +#include +#include +#include +#include + +using namespace Napi; + +struct Event { + std::string path; + bool isCreated; + bool isDeleted; + Event(std::string path) : path(path), isCreated(false), isDeleted(false) {} + + Value toJS(const Env& env) { + EscapableHandleScope scope(env); + Object res = Object::New(env); + std::string type = isCreated ? "create" : isDeleted ? "delete" : "update"; + res.Set(String::New(env, "path"), String::New(env, path.c_str())); + res.Set(String::New(env, "type"), String::New(env, type.c_str())); + return scope.Escape(res); + } +}; + +class EventList { +public: + void create(std::string path) { + std::lock_guard l(mMutex); + Event *event = internalUpdate(path); + if (event->isDeleted) { + // Assume update event when rapidly removed and created + // https://github.com/parcel-bundler/watcher/issues/72 + event->isDeleted = false; + } else { + event->isCreated = true; + } + } + + Event *update(std::string path) { + std::lock_guard l(mMutex); + return internalUpdate(path); + } + + void remove(std::string path) { + std::lock_guard l(mMutex); + Event *event = internalUpdate(path); + event->isDeleted = true; + } + + size_t size() { + std::lock_guard l(mMutex); + return mEvents.size(); + } + + std::vector getEvents() { + std::lock_guard l(mMutex); + std::vector eventsCloneVector; + for(auto it = mEvents.begin(); it != mEvents.end(); ++it) { + if (!(it->second.isCreated && it->second.isDeleted)) { + eventsCloneVector.push_back(it->second); + } + } + return eventsCloneVector; + } + + void clear() { + std::lock_guard l(mMutex); + mEvents.clear(); + mError.reset(); + } + + void error(std::string err) { + std::lock_guard l(mMutex); + if (!mError.has_value()) { + mError.emplace(err); + } + } + + bool hasError() { + std::lock_guard l(mMutex); + return mError.has_value(); + } + + std::string getError() { + std::lock_guard l(mMutex); + return mError.value_or(""); + } + +private: + mutable std::mutex mMutex; + std::map mEvents; + std::optional mError; + Event *internalUpdate(std::string path) { + auto found = mEvents.find(path); + if (found == mEvents.end()) { + auto it = mEvents.emplace(path, Event(path)); + return &it.first->second; + } + + return &found->second; + } +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/Glob.cc b/node_modules/@parcel/watcher/src/Glob.cc new file mode 100644 index 0000000..a4a1722 --- /dev/null +++ b/node_modules/@parcel/watcher/src/Glob.cc @@ -0,0 +1,22 @@ +#include "Glob.hh" + +#ifdef __wasm32__ +extern "C" bool wasm_regex_match(const char *s, const char *regex); +#endif + +Glob::Glob(std::string raw) { + mRaw = raw; + mHash = std::hash()(raw); + #ifndef __wasm32__ + mRegex = std::regex(raw); + #endif +} + +bool Glob::isIgnored(std::string relative_path) const { + // Use native JS regex engine for wasm to reduce binary size. + #ifdef __wasm32__ + return wasm_regex_match(relative_path.c_str(), mRaw.c_str()); + #else + return std::regex_match(relative_path, mRegex); + #endif +} diff --git a/node_modules/@parcel/watcher/src/Glob.hh b/node_modules/@parcel/watcher/src/Glob.hh new file mode 100644 index 0000000..6e049e6 --- /dev/null +++ b/node_modules/@parcel/watcher/src/Glob.hh @@ -0,0 +1,34 @@ +#ifndef GLOB_H +#define GLOB_H + +#include +#include + +struct Glob { + std::size_t mHash; + std::string mRaw; + #ifndef __wasm32__ + std::regex mRegex; + #endif + + Glob(std::string raw); + + bool operator==(const Glob &other) const { + return mHash == other.mHash; + } + + bool isIgnored(std::string relative_path) const; +}; + +namespace std +{ + template <> + struct hash + { + size_t operator()(const Glob& g) const { + return g.mHash; + } + }; +} + +#endif diff --git a/node_modules/@parcel/watcher/src/PromiseRunner.hh b/node_modules/@parcel/watcher/src/PromiseRunner.hh new file mode 100644 index 0000000..4ca3bb6 --- /dev/null +++ b/node_modules/@parcel/watcher/src/PromiseRunner.hh @@ -0,0 +1,101 @@ +#ifndef PROMISE_RUNNER_H +#define PROMISE_RUNNER_H + +#include +#include "wasm/include.h" +#include + +using namespace Napi; + +class PromiseRunner { +public: + const Env env; + Promise::Deferred deferred; + + PromiseRunner(Env env) : env(env), deferred(Promise::Deferred::New(env)) { + napi_status status = napi_create_async_work(env, nullptr, env.Undefined(), + onExecute, onWorkComplete, this, &work); + if (status != napi_ok) { + work = nullptr; + const napi_extended_error_info *error_info = 0; + napi_get_last_error_info(env, &error_info); + if (error_info->error_message) { + Error::New(env, error_info->error_message).ThrowAsJavaScriptException(); + } else { + Error::New(env).ThrowAsJavaScriptException(); + } + } + } + + virtual ~PromiseRunner() {} + + Value queue() { + if (work) { + napi_status status = napi_queue_async_work(env, work); + if (status != napi_ok) { + onError(Error::New(env)); + } + } + + return deferred.Promise(); + } + +private: + napi_async_work work; + std::string error; + + static void onExecute(napi_env env, void *this_pointer) { + PromiseRunner* self = (PromiseRunner*) this_pointer; + try { + self->execute(); + } catch (std::exception &err) { + self->error = err.what(); + } + } + + static void onWorkComplete(napi_env env, napi_status status, void *this_pointer) { + PromiseRunner* self = (PromiseRunner*) this_pointer; + if (status != napi_cancelled) { + HandleScope scope(self->env); + if (status == napi_ok) { + status = napi_delete_async_work(self->env, self->work); + if (status == napi_ok) { + if (self->error.size() == 0) { + self->onOK(); + } else { + self->onError(Error::New(self->env, self->error)); + } + delete self; + return; + } + } + } + + // fallthrough for error handling + const napi_extended_error_info *error_info = 0; + napi_get_last_error_info(env, &error_info); + if (error_info->error_message){ + self->onError(Error::New(env, error_info->error_message)); + } else { + self->onError(Error::New(env)); + } + delete self; + } + + virtual void execute() {} + virtual Value getResult() { + return env.Null(); + } + + void onOK() { + HandleScope scope(env); + Value result = getResult(); + deferred.Resolve(result); + } + + void onError(const Error &e) { + deferred.Reject(e.Value()); + } +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/Signal.hh b/node_modules/@parcel/watcher/src/Signal.hh new file mode 100644 index 0000000..e577319 --- /dev/null +++ b/node_modules/@parcel/watcher/src/Signal.hh @@ -0,0 +1,46 @@ +#ifndef SIGNAL_H +#define SIGNAL_H + +#include +#include + +class Signal { +public: + Signal() : mFlag(false), mWaiting(false) {} + void wait() { + std::unique_lock lock(mMutex); + while (!mFlag) { + mWaiting = true; + mCond.wait(lock); + } + } + + std::cv_status waitFor(std::chrono::milliseconds ms) { + std::unique_lock lock(mMutex); + return mCond.wait_for(lock, ms); + } + + void notify() { + std::unique_lock lock(mMutex); + mFlag = true; + mCond.notify_all(); + } + + void reset() { + std::unique_lock lock(mMutex); + mFlag = false; + mWaiting = false; + } + + bool isWaiting() { + return mWaiting; + } + +private: + bool mFlag; + bool mWaiting; + std::mutex mMutex; + std::condition_variable mCond; +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/Watcher.cc b/node_modules/@parcel/watcher/src/Watcher.cc new file mode 100644 index 0000000..e9d7676 --- /dev/null +++ b/node_modules/@parcel/watcher/src/Watcher.cc @@ -0,0 +1,237 @@ +#include "Watcher.hh" +#include + +using namespace Napi; + +struct WatcherHash { + std::size_t operator() (WatcherRef const &k) const { + return std::hash()(k->mDir); + } +}; + +struct WatcherCompare { + size_t operator() (WatcherRef const &a, WatcherRef const &b) const { + return *a == *b; + } +}; + +static std::unordered_set sharedWatchers; + +WatcherRef Watcher::getShared(std::string dir, std::unordered_set ignorePaths, std::unordered_set ignoreGlobs) { + WatcherRef watcher = std::make_shared(dir, ignorePaths, ignoreGlobs); + auto found = sharedWatchers.find(watcher); + if (found != sharedWatchers.end()) { + return *found; + } + + sharedWatchers.insert(watcher); + return watcher; +} + +void removeShared(Watcher *watcher) { + for (auto it = sharedWatchers.begin(); it != sharedWatchers.end(); it++) { + if (it->get() == watcher) { + sharedWatchers.erase(it); + break; + } + } + + // Free up memory. + if (sharedWatchers.size() == 0) { + sharedWatchers.rehash(0); + } +} + +Watcher::Watcher(std::string dir, std::unordered_set ignorePaths, std::unordered_set ignoreGlobs) + : mDir(dir), + mIgnorePaths(ignorePaths), + mIgnoreGlobs(ignoreGlobs) { + mDebounce = Debounce::getShared(); + mDebounce->add(this, [this] () { + triggerCallbacks(); + }); + } + +Watcher::~Watcher() { + mDebounce->remove(this); +} + +void Watcher::wait() { + std::unique_lock lk(mMutex); + mCond.wait(lk); +} + +void Watcher::notify() { + std::unique_lock lk(mMutex); + mCond.notify_all(); + + if (mCallbacks.size() > 0 && mEvents.size() > 0) { + // We must release our lock before calling into the debouncer + // to avoid a deadlock: the debouncer thread itself will require + // our lock from its thread when calling into `triggerCallbacks` + // while holding its own debouncer lock. + lk.unlock(); + mDebounce->trigger(); + } +} + +struct CallbackData { + std::string error; + std::vector events; + CallbackData(std::string error, std::vector events) : error(error), events(events) {} +}; + +Value callbackEventsToJS(const Env &env, std::vector &events) { + EscapableHandleScope scope(env); + Array arr = Array::New(env, events.size()); + size_t currentEventIndex = 0; + for (auto eventIterator = events.begin(); eventIterator != events.end(); eventIterator++) { + arr.Set(currentEventIndex++, eventIterator->toJS(env)); + } + return scope.Escape(arr); +} + +void callJSFunction(Napi::Env env, Function jsCallback, CallbackData *data) { + HandleScope scope(env); + auto err = data->error.size() > 0 ? Error::New(env, data->error).Value() : env.Null(); + auto events = callbackEventsToJS(env, data->events); + jsCallback.Call({err, events}); + delete data; + + // Throw errors from the callback as fatal exceptions + // If we don't handle these node segfaults... + if (env.IsExceptionPending()) { + Napi::Error err = env.GetAndClearPendingException(); + napi_fatal_exception(env, err.Value()); + } +} + +void Watcher::notifyError(std::exception &err) { + std::unique_lock lk(mMutex); + for (auto it = mCallbacks.begin(); it != mCallbacks.end(); it++) { + CallbackData *data = new CallbackData(err.what(), {}); + it->tsfn.BlockingCall(data, callJSFunction); + } + + clearCallbacks(); +} + +// This function is called from the debounce thread. +void Watcher::triggerCallbacks() { + std::unique_lock lk(mMutex); + if (mCallbacks.size() > 0 && (mEvents.size() > 0 || mEvents.hasError())) { + auto error = mEvents.getError(); + auto events = mEvents.getEvents(); + mEvents.clear(); + + for (auto it = mCallbacks.begin(); it != mCallbacks.end(); it++) { + it->tsfn.BlockingCall(new CallbackData(error, events), callJSFunction); + } + } +} + +// This should be called from the JavaScript thread. +bool Watcher::watch(Function callback) { + std::unique_lock lk(mMutex); + + auto it = findCallback(callback); + if (it != mCallbacks.end()) { + return false; + } + + auto tsfn = ThreadSafeFunction::New( + callback.Env(), + callback, + "Watcher callback", + 0, // Unlimited queue + 1 // Initial thread count + ); + + mCallbacks.push_back(Callback { + tsfn, + Napi::Persistent(callback), + std::this_thread::get_id() + }); + + return true; +} + +// This should be called from the JavaScript thread. +std::vector::iterator Watcher::findCallback(Function callback) { + for (auto it = mCallbacks.begin(); it != mCallbacks.end(); it++) { + // Only consider callbacks created by the same thread, or V8 will panic. + if (it->threadId == std::this_thread::get_id() && it->ref.Value() == callback) { + return it; + } + } + + return mCallbacks.end(); +} + +// This should be called from the JavaScript thread. +bool Watcher::unwatch(Function callback) { + std::unique_lock lk(mMutex); + + bool removed = false; + auto it = findCallback(callback); + if (it != mCallbacks.end()) { + it->tsfn.Release(); + it->ref.Unref(); + mCallbacks.erase(it); + removed = true; + } + + if (removed && mCallbacks.size() == 0) { + unref(); + return true; + } + + return false; +} + +void Watcher::unref() { + if (mCallbacks.size() == 0) { + removeShared(this); + } +} + +void Watcher::destroy() { + std::unique_lock lk(mMutex); + clearCallbacks(); +} + +// Private because it doesn't lock. +void Watcher::clearCallbacks() { + for (auto it = mCallbacks.begin(); it != mCallbacks.end(); it++) { + it->tsfn.Release(); + it->ref.Unref(); + } + + mCallbacks.clear(); + unref(); +} + +bool Watcher::isIgnored(std::string path) { + for (auto it = mIgnorePaths.begin(); it != mIgnorePaths.end(); it++) { + auto dir = *it + DIR_SEP; + if (*it == path || path.compare(0, dir.size(), dir) == 0) { + return true; + } + } + + auto basePath = mDir + DIR_SEP; + + if (path.rfind(basePath, 0) != 0) { + return false; + } + + auto relativePath = path.substr(basePath.size()); + + for (auto it = mIgnoreGlobs.begin(); it != mIgnoreGlobs.end(); it++) { + if (it->isIgnored(relativePath)) { + return true; + } + } + + return false; +} diff --git a/node_modules/@parcel/watcher/src/Watcher.hh b/node_modules/@parcel/watcher/src/Watcher.hh new file mode 100644 index 0000000..f89e9f5 --- /dev/null +++ b/node_modules/@parcel/watcher/src/Watcher.hh @@ -0,0 +1,73 @@ +#ifndef WATCHER_H +#define WATCHER_H + +#include +#include +#include +#include +#include "Glob.hh" +#include "Event.hh" +#include "Debounce.hh" +#include "DirTree.hh" +#include "Signal.hh" + +using namespace Napi; + +struct Watcher; +using WatcherRef = std::shared_ptr; + +struct Callback { + Napi::ThreadSafeFunction tsfn; + Napi::FunctionReference ref; + std::thread::id threadId; +}; + +class WatcherState { +public: + virtual ~WatcherState() = default; +}; + +struct Watcher { + std::string mDir; + std::unordered_set mIgnorePaths; + std::unordered_set mIgnoreGlobs; + EventList mEvents; + std::shared_ptr state; + + Watcher(std::string dir, std::unordered_set ignorePaths, std::unordered_set ignoreGlobs); + ~Watcher(); + + bool operator==(const Watcher &other) const { + return mDir == other.mDir && mIgnorePaths == other.mIgnorePaths && mIgnoreGlobs == other.mIgnoreGlobs; + } + + void wait(); + void notify(); + void notifyError(std::exception &err); + bool watch(Function callback); + bool unwatch(Function callback); + void unref(); + bool isIgnored(std::string path); + void destroy(); + + static WatcherRef getShared(std::string dir, std::unordered_set ignorePaths, std::unordered_set ignoreGlobs); + +private: + std::mutex mMutex; + std::condition_variable mCond; + std::vector mCallbacks; + std::shared_ptr mDebounce; + + std::vector::iterator findCallback(Function callback); + void clearCallbacks(); + void triggerCallbacks(); +}; + +class WatcherError : public std::runtime_error { +public: + WatcherRef mWatcher; + WatcherError(std::string msg, WatcherRef watcher) : std::runtime_error(msg), mWatcher(watcher) {} + WatcherError(const char *msg, WatcherRef watcher) : std::runtime_error(msg), mWatcher(watcher) {} +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/binding.cc b/node_modules/@parcel/watcher/src/binding.cc new file mode 100644 index 0000000..e1506bc --- /dev/null +++ b/node_modules/@parcel/watcher/src/binding.cc @@ -0,0 +1,268 @@ +#include +#include +#include "wasm/include.h" +#include +#include "Glob.hh" +#include "Event.hh" +#include "Backend.hh" +#include "Watcher.hh" +#include "PromiseRunner.hh" + +using namespace Napi; + +std::unordered_set getIgnorePaths(Env env, Value opts) { + std::unordered_set result; + + if (opts.IsObject()) { + Value v = opts.As().Get(String::New(env, "ignorePaths")); + if (v.IsArray()) { + Array items = v.As(); + for (size_t i = 0; i < items.Length(); i++) { + Value item = items.Get(Number::New(env, i)); + if (item.IsString()) { + result.insert(std::string(item.As().Utf8Value().c_str())); + } + } + } + } + + return result; +} + +std::unordered_set getIgnoreGlobs(Env env, Value opts) { + std::unordered_set result; + + if (opts.IsObject()) { + Value v = opts.As().Get(String::New(env, "ignoreGlobs")); + if (v.IsArray()) { + Array items = v.As(); + for (size_t i = 0; i < items.Length(); i++) { + Value item = items.Get(Number::New(env, i)); + if (item.IsString()) { + auto key = item.As().Utf8Value(); + try { + result.emplace(key); + } catch (const std::regex_error& e) { + Error::New(env, e.what()).ThrowAsJavaScriptException(); + } + } + } + } + } + + return result; +} + +std::shared_ptr getBackend(Env env, Value opts) { + Value b = opts.As().Get(String::New(env, "backend")); + std::string backendName; + if (b.IsString()) { + backendName = std::string(b.As().Utf8Value().c_str()); + } + + return Backend::getShared(backendName); +} + +class WriteSnapshotRunner : public PromiseRunner { +public: + WriteSnapshotRunner(Env env, Value dir, Value snap, Value opts) + : PromiseRunner(env), + snapshotPath(std::string(snap.As().Utf8Value().c_str())) { + watcher = Watcher::getShared( + std::string(dir.As().Utf8Value().c_str()), + getIgnorePaths(env, opts), + getIgnoreGlobs(env, opts) + ); + + backend = getBackend(env, opts); + } + + ~WriteSnapshotRunner() { + watcher->unref(); + backend->unref(); + } +private: + std::shared_ptr backend; + WatcherRef watcher; + std::string snapshotPath; + + void execute() override { + backend->writeSnapshot(watcher, &snapshotPath); + } +}; + +class GetEventsSinceRunner : public PromiseRunner { +public: + GetEventsSinceRunner(Env env, Value dir, Value snap, Value opts) + : PromiseRunner(env), + snapshotPath(std::string(snap.As().Utf8Value().c_str())) { + watcher = std::make_shared( + std::string(dir.As().Utf8Value().c_str()), + getIgnorePaths(env, opts), + getIgnoreGlobs(env, opts) + ); + + backend = getBackend(env, opts); + } + + ~GetEventsSinceRunner() { + watcher->unref(); + backend->unref(); + } +private: + std::shared_ptr backend; + WatcherRef watcher; + std::string snapshotPath; + + void execute() override { + backend->getEventsSince(watcher, &snapshotPath); + if (watcher->mEvents.hasError()) { + throw std::runtime_error(watcher->mEvents.getError()); + } + } + + Value getResult() override { + std::vector events = watcher->mEvents.getEvents(); + Array eventsArray = Array::New(env, events.size()); + size_t i = 0; + for (auto it = events.begin(); it != events.end(); it++) { + eventsArray.Set(i++, it->toJS(env)); + } + return eventsArray; + } +}; + +template +Value queueSnapshotWork(const CallbackInfo& info) { + Env env = info.Env(); + if (info.Length() < 1 || !info[0].IsString()) { + TypeError::New(env, "Expected a string").ThrowAsJavaScriptException(); + return env.Null(); + } + + if (info.Length() < 2 || !info[1].IsString()) { + TypeError::New(env, "Expected a string").ThrowAsJavaScriptException(); + return env.Null(); + } + + if (info.Length() >= 3 && !info[2].IsObject()) { + TypeError::New(env, "Expected an object").ThrowAsJavaScriptException(); + return env.Null(); + } + + Runner *runner = new Runner(info.Env(), info[0], info[1], info[2]); + return runner->queue(); +} + +Value writeSnapshot(const CallbackInfo& info) { + return queueSnapshotWork(info); +} + +Value getEventsSince(const CallbackInfo& info) { + return queueSnapshotWork(info); +} + +class SubscribeRunner : public PromiseRunner { +public: + SubscribeRunner(Env env, Value dir, Value fn, Value opts) : PromiseRunner(env) { + watcher = Watcher::getShared( + std::string(dir.As().Utf8Value().c_str()), + getIgnorePaths(env, opts), + getIgnoreGlobs(env, opts) + ); + + backend = getBackend(env, opts); + watcher->watch(fn.As()); + } + +private: + WatcherRef watcher; + std::shared_ptr backend; + FunctionReference callback; + + void execute() override { + try { + backend->watch(watcher); + } catch (std::exception &err) { + watcher->destroy(); + throw; + } + } +}; + +class UnsubscribeRunner : public PromiseRunner { +public: + UnsubscribeRunner(Env env, Value dir, Value fn, Value opts) : PromiseRunner(env) { + watcher = Watcher::getShared( + std::string(dir.As().Utf8Value().c_str()), + getIgnorePaths(env, opts), + getIgnoreGlobs(env, opts) + ); + + backend = getBackend(env, opts); + shouldUnwatch = watcher->unwatch(fn.As()); + } + +private: + WatcherRef watcher; + std::shared_ptr backend; + bool shouldUnwatch; + + void execute() override { + if (shouldUnwatch) { + backend->unwatch(watcher); + } + } +}; + +template +Value queueSubscriptionWork(const CallbackInfo& info) { + Env env = info.Env(); + if (info.Length() < 1 || !info[0].IsString()) { + TypeError::New(env, "Expected a string").ThrowAsJavaScriptException(); + return env.Null(); + } + + if (info.Length() < 2 || !info[1].IsFunction()) { + TypeError::New(env, "Expected a function").ThrowAsJavaScriptException(); + return env.Null(); + } + + if (info.Length() >= 3 && !info[2].IsObject()) { + TypeError::New(env, "Expected an object").ThrowAsJavaScriptException(); + return env.Null(); + } + + Runner *runner = new Runner(info.Env(), info[0], info[1], info[2]); + return runner->queue(); +} + +Value subscribe(const CallbackInfo& info) { + return queueSubscriptionWork(info); +} + +Value unsubscribe(const CallbackInfo& info) { + return queueSubscriptionWork(info); +} + +Object Init(Env env, Object exports) { + exports.Set( + String::New(env, "writeSnapshot"), + Function::New(env, writeSnapshot) + ); + exports.Set( + String::New(env, "getEventsSince"), + Function::New(env, getEventsSince) + ); + exports.Set( + String::New(env, "subscribe"), + Function::New(env, subscribe) + ); + exports.Set( + String::New(env, "unsubscribe"), + Function::New(env, unsubscribe) + ); + return exports; +} + +NODE_API_MODULE(watcher, Init) diff --git a/node_modules/@parcel/watcher/src/kqueue/KqueueBackend.cc b/node_modules/@parcel/watcher/src/kqueue/KqueueBackend.cc new file mode 100644 index 0000000..2991c32 --- /dev/null +++ b/node_modules/@parcel/watcher/src/kqueue/KqueueBackend.cc @@ -0,0 +1,306 @@ +#include +#include +#include +#include +#include +#include +#include +#include "KqueueBackend.hh" + +#if __APPLE__ +#define st_mtim st_mtimespec +#endif + +#if !defined(O_EVTONLY) +#define O_EVTONLY O_RDONLY +#endif + +#define CONVERT_TIME(ts) ((uint64_t)ts.tv_sec * 1000000000 + ts.tv_nsec) + +void KqueueBackend::start() { + if ((mKqueue = kqueue()) < 0) { + throw std::runtime_error(std::string("Unable to open kqueue: ") + strerror(errno)); + } + + // Create a pipe that we will write to when we want to end the thread. + int err = pipe(mPipe); + if (err == -1) { + throw std::runtime_error(std::string("Unable to open pipe: ") + strerror(errno)); + } + + // Subscribe kqueue to this pipe. + struct kevent ev; + EV_SET( + &ev, + mPipe[0], + EVFILT_READ, + EV_ADD | EV_CLEAR, + 0, + 0, + 0 + ); + + if (kevent(mKqueue, &ev, 1, NULL, 0, 0)) { + close(mPipe[0]); + close(mPipe[1]); + throw std::runtime_error(std::string("Unable to watch pipe: ") + strerror(errno)); + } + + notifyStarted(); + + struct kevent events[128]; + + while (true) { + int event_count = kevent(mKqueue, NULL, 0, events, 128, 0); + if (event_count < 0 || events[0].flags == EV_ERROR) { + throw std::runtime_error(std::string("kevent error: ") + strerror(errno)); + } + + // Track all of the watchers that are touched so we can notify them at the end of the events. + std::unordered_set watchers; + + for (int i = 0; i < event_count; i++) { + int flags = events[i].fflags; + int fd = events[i].ident; + if (fd == mPipe[0]) { + // pipe was written to. break out of the loop. + goto done; + } + + auto it = mFdToEntry.find(fd); + if (it == mFdToEntry.end()) { + // If fd wasn't in our map, we may have already stopped watching it. Ignore the event. + continue; + } + + DirEntry *entry = it->second; + + if (flags & NOTE_WRITE && entry && entry->isDir) { + // If a write occurred on a directory, we have to diff the contents of that + // directory to determine what file was added/deleted. + compareDir(fd, entry->path, watchers); + } else { + std::vector subs = findSubscriptions(entry->path); + for (auto it = subs.begin(); it != subs.end(); it++) { + KqueueSubscription *sub = *it; + watchers.insert(sub->watcher); + if (flags & (NOTE_DELETE | NOTE_RENAME | NOTE_REVOKE)) { + sub->watcher->mEvents.remove(sub->path); + sub->tree->remove(sub->path); + mFdToEntry.erase((int)(size_t)entry->state); + mSubscriptions.erase(sub->path); + } else if (flags & (NOTE_WRITE | NOTE_ATTRIB | NOTE_EXTEND)) { + struct stat st; + lstat(sub->path.c_str(), &st); + if (entry->mtime != CONVERT_TIME(st.st_mtim)) { + entry->mtime = CONVERT_TIME(st.st_mtim); + sub->watcher->mEvents.update(sub->path); + } + } + } + } + } + + for (auto it = watchers.begin(); it != watchers.end(); it++) { + (*it)->notify(); + } + } + +done: + close(mPipe[0]); + close(mPipe[1]); + mEndedSignal.notify(); +} + +KqueueBackend::~KqueueBackend() { + write(mPipe[1], "X", 1); + mEndedSignal.wait(); +} + +void KqueueBackend::subscribe(WatcherRef watcher) { + // Build a full directory tree recursively, and watch each directory. + std::shared_ptr tree = getTree(watcher); + + for (auto it = tree->entries.begin(); it != tree->entries.end(); it++) { + bool success = watchDir(watcher, it->second.path, tree); + if (!success) { + throw WatcherError(std::string("error watching " + watcher->mDir + ": " + strerror(errno)), watcher); + } + } +} + +bool KqueueBackend::watchDir(WatcherRef watcher, std::string path, std::shared_ptr tree) { + if (watcher->isIgnored(path)) { + return false; + } + + DirEntry *entry = tree->find(path); + if (!entry) { + return false; + } + + KqueueSubscription sub = { + .watcher = watcher, + .path = path, + .tree = tree + }; + + if (!entry->state) { + int fd = open(path.c_str(), O_EVTONLY); + if (fd <= 0) { + return false; + } + + struct kevent event; + EV_SET( + &event, + fd, + EVFILT_VNODE, + EV_ADD | EV_CLEAR | EV_ENABLE, + NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | NOTE_RENAME | NOTE_REVOKE, + 0, + 0 + ); + + if (kevent(mKqueue, &event, 1, NULL, 0, 0)) { + close(fd); + return false; + } + + entry->state = (void *)(size_t)fd; + mFdToEntry.emplace(fd, entry); + } + + sub.fd = (int)(size_t)entry->state; + mSubscriptions.emplace(path, sub); + return true; +} + +std::vector KqueueBackend::findSubscriptions(std::string &path) { + // Find the subscriptions affected by this path. + // Copy pointers to them into a vector so that modifying mSubscriptions doesn't invalidate the iterator. + auto range = mSubscriptions.equal_range(path); + std::vector subs; + for (auto it = range.first; it != range.second; it++) { + subs.push_back(&it->second); + } + + return subs; +} + +bool KqueueBackend::compareDir(int fd, std::string &path, std::unordered_set &watchers) { + // macOS doesn't support fdclosedir, so we have to duplicate the file descriptor + // to ensure the closedir doesn't also stop watching. + #if __APPLE__ + fd = dup(fd); + #endif + + DIR *dir = fdopendir(fd); + if (dir == NULL) { + return false; + } + + // fdopendir doesn't rewind to the beginning. + rewinddir(dir); + + std::vector subs = findSubscriptions(path); + std::string dirStart = path + DIR_SEP; + + std::unordered_set> trees; + for (auto it = subs.begin(); it != subs.end(); it++) { + trees.emplace((*it)->tree); + } + + std::unordered_set entries; + struct dirent *entry; + while ((entry = readdir(dir))) { + if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) { + continue; + } + + std::string fullpath = dirStart + entry->d_name; + entries.emplace(fullpath); + + for (auto it = trees.begin(); it != trees.end(); it++) { + std::shared_ptr tree = *it; + if (!tree->find(fullpath)) { + struct stat st; + fstatat(fd, entry->d_name, &st, AT_SYMLINK_NOFOLLOW); + tree->add(fullpath, CONVERT_TIME(st.st_mtim), S_ISDIR(st.st_mode)); + + // Notify all watchers with the same tree. + for (auto i = subs.begin(); i != subs.end(); i++) { + KqueueSubscription *sub = *i; + if (sub->tree == tree) { + if (sub->watcher->isIgnored(fullpath)) { + continue; + } + + sub->watcher->mEvents.create(fullpath); + watchers.emplace(sub->watcher); + + bool success = watchDir(sub->watcher, fullpath, sub->tree); + if (!success) { + sub->tree->remove(fullpath); + return false; + } + } + } + } + } + } + + for (auto it = trees.begin(); it != trees.end(); it++) { + std::shared_ptr tree = *it; + for (auto entry = tree->entries.begin(); entry != tree->entries.end();) { + + if ( + entry->first.rfind(dirStart, 0) == 0 && + entry->first.find(DIR_SEP, dirStart.length()) == std::string::npos && + entries.count(entry->first) == 0 + ) { + // Notify all watchers with the same tree. + for (auto i = subs.begin(); i != subs.end(); i++) { + if ((*i)->tree == tree) { + KqueueSubscription *sub = *i; + if (!sub->watcher->isIgnored(entry->first)) { + sub->watcher->mEvents.remove(entry->first); + watchers.emplace(sub->watcher); + } + } + } + + mFdToEntry.erase((int)(size_t)entry->second.state); + mSubscriptions.erase(entry->first); + entry = tree->entries.erase(entry); + } else { + entry++; + } + } + } + + #if __APPLE__ + closedir(dir); + #else + fdclosedir(dir); + #endif + + return true; +} + +void KqueueBackend::unsubscribe(WatcherRef watcher) { + // Find any subscriptions pointing to this watcher, and remove them. + for (auto it = mSubscriptions.begin(); it != mSubscriptions.end();) { + if (it->second.watcher.get() == watcher.get()) { + if (mSubscriptions.count(it->first) == 1) { + // Closing the file descriptor automatically unwatches it in the kqueue. + close(it->second.fd); + mFdToEntry.erase(it->second.fd); + } + + it = mSubscriptions.erase(it); + } else { + it++; + } + } +} diff --git a/node_modules/@parcel/watcher/src/kqueue/KqueueBackend.hh b/node_modules/@parcel/watcher/src/kqueue/KqueueBackend.hh new file mode 100644 index 0000000..3c6a9cd --- /dev/null +++ b/node_modules/@parcel/watcher/src/kqueue/KqueueBackend.hh @@ -0,0 +1,35 @@ +#ifndef KQUEUE_H +#define KQUEUE_H + +#include +#include +#include "../shared/BruteForceBackend.hh" +#include "../DirTree.hh" +#include "../Signal.hh" + +struct KqueueSubscription { + WatcherRef watcher; + std::string path; + std::shared_ptr tree; + int fd; +}; + +class KqueueBackend : public BruteForceBackend { +public: + void start() override; + ~KqueueBackend(); + void subscribe(WatcherRef watcher) override; + void unsubscribe(WatcherRef watcher) override; +private: + int mKqueue; + int mPipe[2]; + std::unordered_multimap mSubscriptions; + std::unordered_map mFdToEntry; + Signal mEndedSignal; + + bool watchDir(WatcherRef watcher, std::string path, std::shared_ptr tree); + bool compareDir(int fd, std::string &dir, std::unordered_set &watchers); + std::vector findSubscriptions(std::string &path); +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/linux/InotifyBackend.cc b/node_modules/@parcel/watcher/src/linux/InotifyBackend.cc new file mode 100644 index 0000000..ec92691 --- /dev/null +++ b/node_modules/@parcel/watcher/src/linux/InotifyBackend.cc @@ -0,0 +1,232 @@ +#include +#include +#include +#include +#include +#include "InotifyBackend.hh" + +#define INOTIFY_MASK \ + IN_ATTRIB | IN_CREATE | IN_DELETE | \ + IN_DELETE_SELF | IN_MODIFY | IN_MOVE_SELF | IN_MOVED_FROM | \ + IN_MOVED_TO | IN_DONT_FOLLOW | IN_ONLYDIR | IN_EXCL_UNLINK +#define BUFFER_SIZE 8192 +#define CONVERT_TIME(ts) ((uint64_t)ts.tv_sec * 1000000000 + ts.tv_nsec) + +void InotifyBackend::start() { + // Create a pipe that we will write to when we want to end the thread. + int err = pipe2(mPipe, O_CLOEXEC | O_NONBLOCK); + if (err == -1) { + throw std::runtime_error(std::string("Unable to open pipe: ") + strerror(errno)); + } + + // Init inotify file descriptor. + mInotify = inotify_init1(IN_NONBLOCK | IN_CLOEXEC); + if (mInotify == -1) { + throw std::runtime_error(std::string("Unable to initialize inotify: ") + strerror(errno)); + } + + pollfd pollfds[2]; + pollfds[0].fd = mPipe[0]; + pollfds[0].events = POLLIN; + pollfds[0].revents = 0; + pollfds[1].fd = mInotify; + pollfds[1].events = POLLIN; + pollfds[1].revents = 0; + + notifyStarted(); + + // Loop until we get an event from the pipe. + while (true) { + int result = poll(pollfds, 2, 500); + if (result < 0) { + throw std::runtime_error(std::string("Unable to poll: ") + strerror(errno)); + } + + if (pollfds[0].revents) { + break; + } + + if (pollfds[1].revents) { + handleEvents(); + } + } + + close(mPipe[0]); + close(mPipe[1]); + close(mInotify); + + mEndedSignal.notify(); +} + +InotifyBackend::~InotifyBackend() { + write(mPipe[1], "X", 1); + mEndedSignal.wait(); +} + +// This function is called by Backend::watch which takes a lock on mMutex +void InotifyBackend::subscribe(WatcherRef watcher) { + // Build a full directory tree recursively, and watch each directory. + std::shared_ptr tree = getTree(watcher); + + for (auto it = tree->entries.begin(); it != tree->entries.end(); it++) { + if (it->second.isDir) { + bool success = watchDir(watcher, it->second.path, tree); + if (!success) { + throw WatcherError(std::string("inotify_add_watch on '") + it->second.path + std::string("' failed: ") + strerror(errno), watcher); + } + } + } +} + +bool InotifyBackend::watchDir(WatcherRef watcher, std::string path, std::shared_ptr tree) { + int wd = inotify_add_watch(mInotify, path.c_str(), INOTIFY_MASK); + if (wd == -1) { + return false; + } + + std::shared_ptr sub = std::make_shared(); + sub->tree = tree; + sub->path = path; + sub->watcher = watcher; + mSubscriptions.emplace(wd, sub); + + return true; +} + +void InotifyBackend::handleEvents() { + char buf[BUFFER_SIZE] __attribute__ ((aligned(__alignof__(struct inotify_event))));; + struct inotify_event *event; + + // Track all of the watchers that are touched so we can notify them at the end of the events. + std::unordered_set watchers; + + while (true) { + int n = read(mInotify, &buf, BUFFER_SIZE); + if (n < 0) { + if (errno == EAGAIN || errno == EWOULDBLOCK) { + break; + } + + throw std::runtime_error(std::string("Error reading from inotify: ") + strerror(errno)); + } + + if (n == 0) { + break; + } + + for (char *ptr = buf; ptr < buf + n; ptr += sizeof(*event) + event->len) { + event = (struct inotify_event *)ptr; + + if ((event->mask & IN_Q_OVERFLOW) == IN_Q_OVERFLOW) { + // overflow + continue; + } + + handleEvent(event, watchers); + } + } + + for (auto it = watchers.begin(); it != watchers.end(); it++) { + (*it)->notify(); + } +} + +void InotifyBackend::handleEvent(struct inotify_event *event, std::unordered_set &watchers) { + std::unique_lock lock(mMutex); + + // Find the subscriptions for this watch descriptor + auto range = mSubscriptions.equal_range(event->wd); + std::unordered_set> set; + for (auto it = range.first; it != range.second; it++) { + set.insert(it->second); + } + + for (auto it = set.begin(); it != set.end(); it++) { + if (handleSubscription(event, *it)) { + watchers.insert((*it)->watcher); + } + } +} + +bool InotifyBackend::handleSubscription(struct inotify_event *event, std::shared_ptr sub) { + // Build full path and check if its in our ignore list. + std::shared_ptr watcher = sub->watcher; + std::string path = std::string(sub->path); + bool isDir = event->mask & IN_ISDIR; + + if (event->len > 0) { + path += "/" + std::string(event->name); + } + + if (watcher->isIgnored(path)) { + return false; + } + + // If this is a create, check if it's a directory and start watching if it is. + // In any case, keep the directory tree up to date. + if (event->mask & (IN_CREATE | IN_MOVED_TO)) { + watcher->mEvents.create(path); + + struct stat st; + // Use lstat to avoid resolving symbolic links that we cannot watch anyway + // https://github.com/parcel-bundler/watcher/issues/76 + lstat(path.c_str(), &st); + DirEntry *entry = sub->tree->add(path, CONVERT_TIME(st.st_mtim), S_ISDIR(st.st_mode)); + + if (entry->isDir) { + bool success = watchDir(watcher, path, sub->tree); + if (!success) { + sub->tree->remove(path); + return false; + } + } + } else if (event->mask & (IN_MODIFY | IN_ATTRIB)) { + watcher->mEvents.update(path); + + struct stat st; + stat(path.c_str(), &st); + sub->tree->update(path, CONVERT_TIME(st.st_mtim)); + } else if (event->mask & (IN_DELETE | IN_DELETE_SELF | IN_MOVED_FROM | IN_MOVE_SELF)) { + bool isSelfEvent = (event->mask & (IN_DELETE_SELF | IN_MOVE_SELF)); + // Ignore delete/move self events unless this is the recursive watch root + if (isSelfEvent && path != watcher->mDir) { + return false; + } + + // If the entry being deleted/moved is a directory, remove it from the list of subscriptions + // XXX: self events don't have the IN_ISDIR mask + if (isSelfEvent || isDir) { + for (auto it = mSubscriptions.begin(); it != mSubscriptions.end();) { + if (it->second->path == path) { + it = mSubscriptions.erase(it); + } else { + ++it; + } + } + } + + watcher->mEvents.remove(path); + sub->tree->remove(path); + } + + return true; +} + +// This function is called by Backend::unwatch which takes a lock on mMutex +void InotifyBackend::unsubscribe(WatcherRef watcher) { + // Find any subscriptions pointing to this watcher, and remove them. + for (auto it = mSubscriptions.begin(); it != mSubscriptions.end();) { + if (it->second->watcher.get() == watcher.get()) { + if (mSubscriptions.count(it->first) == 1) { + int err = inotify_rm_watch(mInotify, it->first); + if (err == -1) { + throw WatcherError(std::string("Unable to remove watcher: ") + strerror(errno), watcher); + } + } + + it = mSubscriptions.erase(it); + } else { + it++; + } + } +} diff --git a/node_modules/@parcel/watcher/src/linux/InotifyBackend.hh b/node_modules/@parcel/watcher/src/linux/InotifyBackend.hh new file mode 100644 index 0000000..f34cd1f --- /dev/null +++ b/node_modules/@parcel/watcher/src/linux/InotifyBackend.hh @@ -0,0 +1,34 @@ +#ifndef INOTIFY_H +#define INOTIFY_H + +#include +#include +#include "../shared/BruteForceBackend.hh" +#include "../DirTree.hh" +#include "../Signal.hh" + +struct InotifySubscription { + std::shared_ptr tree; + std::string path; + WatcherRef watcher; +}; + +class InotifyBackend : public BruteForceBackend { +public: + void start() override; + ~InotifyBackend(); + void subscribe(WatcherRef watcher) override; + void unsubscribe(WatcherRef watcher) override; +private: + int mPipe[2]; + int mInotify; + std::unordered_multimap> mSubscriptions; + Signal mEndedSignal; + + bool watchDir(WatcherRef watcher, std::string path, std::shared_ptr tree); + void handleEvents(); + void handleEvent(struct inotify_event *event, std::unordered_set &watchers); + bool handleSubscription(struct inotify_event *event, std::shared_ptr sub); +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/macos/FSEventsBackend.cc b/node_modules/@parcel/watcher/src/macos/FSEventsBackend.cc new file mode 100644 index 0000000..cfda962 --- /dev/null +++ b/node_modules/@parcel/watcher/src/macos/FSEventsBackend.cc @@ -0,0 +1,338 @@ +#include +#include +#include +#include +#include +#include "../Event.hh" +#include "../Backend.hh" +#include "./FSEventsBackend.hh" +#include "../Watcher.hh" + +#define CONVERT_TIME(ts) ((uint64_t)ts.tv_sec * 1000000000 + ts.tv_nsec) +#define IGNORED_FLAGS (kFSEventStreamEventFlagItemIsHardlink | kFSEventStreamEventFlagItemIsLastHardlink | kFSEventStreamEventFlagItemIsSymlink | kFSEventStreamEventFlagItemIsDir | kFSEventStreamEventFlagItemIsFile) + +void stopStream(FSEventStreamRef stream, CFRunLoopRef runLoop) { + FSEventStreamStop(stream); + FSEventStreamUnscheduleFromRunLoop(stream, runLoop, kCFRunLoopDefaultMode); + FSEventStreamInvalidate(stream); + FSEventStreamRelease(stream); +} + +// macOS has a case insensitive file system by default. In order to detect +// file renames that only affect case, we need to get the canonical path +// and compare it with the input path to determine if a file was created or deleted. +bool pathExists(char *path) { + int fd = open(path, O_RDONLY | O_SYMLINK); + if (fd == -1) { + return false; + } + + char buf[PATH_MAX]; + if (fcntl(fd, F_GETPATH, buf) == -1) { + close(fd); + return false; + } + + bool res = strncmp(path, buf, PATH_MAX) == 0; + close(fd); + return res; +} + +class State: public WatcherState { +public: + FSEventStreamRef stream; + std::shared_ptr tree; + uint64_t since; +}; + +void FSEventsCallback( + ConstFSEventStreamRef streamRef, + void *clientCallBackInfo, + size_t numEvents, + void *eventPaths, + const FSEventStreamEventFlags eventFlags[], + const FSEventStreamEventId eventIds[] +) { + char **paths = (char **)eventPaths; + std::shared_ptr& watcher = *static_cast *>(clientCallBackInfo); + + EventList& list = watcher->mEvents; + if (watcher->state == nullptr) { + return; + } + + auto stateGuard = watcher->state; + auto* state = static_cast(stateGuard.get()); + uint64_t since = state->since; + bool deletedRoot = false; + + for (size_t i = 0; i < numEvents; ++i) { + bool isCreated = (eventFlags[i] & kFSEventStreamEventFlagItemCreated) == kFSEventStreamEventFlagItemCreated; + bool isRemoved = (eventFlags[i] & kFSEventStreamEventFlagItemRemoved) == kFSEventStreamEventFlagItemRemoved; + bool isModified = (eventFlags[i] & kFSEventStreamEventFlagItemModified) == kFSEventStreamEventFlagItemModified || + (eventFlags[i] & kFSEventStreamEventFlagItemInodeMetaMod) == kFSEventStreamEventFlagItemInodeMetaMod || + (eventFlags[i] & kFSEventStreamEventFlagItemFinderInfoMod) == kFSEventStreamEventFlagItemFinderInfoMod || + (eventFlags[i] & kFSEventStreamEventFlagItemChangeOwner) == kFSEventStreamEventFlagItemChangeOwner || + (eventFlags[i] & kFSEventStreamEventFlagItemXattrMod) == kFSEventStreamEventFlagItemXattrMod; + bool isRenamed = (eventFlags[i] & kFSEventStreamEventFlagItemRenamed) == kFSEventStreamEventFlagItemRenamed; + bool isDone = (eventFlags[i] & kFSEventStreamEventFlagHistoryDone) == kFSEventStreamEventFlagHistoryDone; + bool isDir = (eventFlags[i] & kFSEventStreamEventFlagItemIsDir) == kFSEventStreamEventFlagItemIsDir; + + + if (eventFlags[i] & kFSEventStreamEventFlagMustScanSubDirs) { + if (eventFlags[i] & kFSEventStreamEventFlagUserDropped) { + list.error("Events were dropped by the FSEvents client. File system must be re-scanned."); + } else if (eventFlags[i] & kFSEventStreamEventFlagKernelDropped) { + list.error("Events were dropped by the kernel. File system must be re-scanned."); + } else { + list.error("Too many events. File system must be re-scanned."); + } + } + + if (isDone) { + watcher->notify(); + break; + } + + auto ignoredFlags = IGNORED_FLAGS; + if (__builtin_available(macOS 10.13, *)) { + ignoredFlags |= kFSEventStreamEventFlagItemCloned; + } + + // If we don't care about any of the flags that are set, ignore this event. + if ((eventFlags[i] & ~ignoredFlags) == 0) { + continue; + } + + // FSEvents exclusion paths only apply to files, not directories. + if (watcher->isIgnored(paths[i])) { + continue; + } + + // Handle unambiguous events first + if (isCreated && !(isRemoved || isModified || isRenamed)) { + state->tree->add(paths[i], 0, isDir); + list.create(paths[i]); + } else if (isRemoved && !(isCreated || isModified || isRenamed)) { + state->tree->remove(paths[i]); + list.remove(paths[i]); + if (paths[i] == watcher->mDir) { + deletedRoot = true; + } + } else if (isModified && !(isCreated || isRemoved || isRenamed)) { + struct stat file; + if (stat(paths[i], &file)) { + continue; + } + + // Ignore if mtime is the same as the last event. + // This prevents duplicate events from being emitted. + // If tv_nsec is zero, the file system probably only has second-level + // granularity so allow the even through in that case. + uint64_t mtime = CONVERT_TIME(file.st_mtimespec); + DirEntry *entry = state->tree->find(paths[i]); + if (entry && mtime == entry->mtime && file.st_mtimespec.tv_nsec != 0) { + continue; + } + + if (entry) { + // Update mtime. + entry->mtime = mtime; + } else { + // Add to tree if this path has not been discovered yet. + state->tree->add(paths[i], mtime, S_ISDIR(file.st_mode)); + } + + list.update(paths[i]); + } else { + // If multiple flags were set, then we need to call `stat` to determine if the file really exists. + // This helps disambiguate creates, updates, and deletes. + struct stat file; + if (stat(paths[i], &file) || !pathExists(paths[i])) { + // File does not exist, so we have to assume it was removed. This is not exact since the + // flags set by fsevents get coalesced together (e.g. created & deleted), so there is no way to + // know whether the create and delete both happened since our snapshot (in which case + // we'd rather ignore this event completely). This will result in some extra delete events + // being emitted for files we don't know about, but that is the best we can do. + state->tree->remove(paths[i]); + list.remove(paths[i]); + if (paths[i] == watcher->mDir) { + deletedRoot = true; + } + continue; + } + + // If the file was modified, and existed before, then this is an update, otherwise a create. + uint64_t ctime = CONVERT_TIME(file.st_birthtimespec); + uint64_t mtime = CONVERT_TIME(file.st_mtimespec); + DirEntry *entry = !since ? state->tree->find(paths[i]) : NULL; + if (entry && entry->mtime == mtime && file.st_mtimespec.tv_nsec != 0) { + continue; + } + + // Some mounted file systems report a creation time of 0/unix epoch which we special case. + if (isModified && (entry || (ctime <= since && ctime != 0))) { + state->tree->update(paths[i], mtime); + list.update(paths[i]); + } else { + state->tree->add(paths[i], mtime, S_ISDIR(file.st_mode)); + list.create(paths[i]); + } + } + } + + if (!since) { + watcher->notify(); + } + + // Stop watching if the root directory was deleted. + if (deletedRoot) { + stopStream((FSEventStreamRef)streamRef, CFRunLoopGetCurrent()); + watcher->state = nullptr; + } +} + +void checkWatcher(WatcherRef watcher) { + struct stat file; + if (stat(watcher->mDir.c_str(), &file)) { + throw WatcherError(strerror(errno), watcher); + } + + if (!S_ISDIR(file.st_mode)) { + throw WatcherError(strerror(ENOTDIR), watcher); + } +} + +void FSEventsBackend::startStream(WatcherRef watcher, FSEventStreamEventId id) { + checkWatcher(watcher); + + CFAbsoluteTime latency = 0.001; + CFStringRef fileWatchPath = CFStringCreateWithCString( + NULL, + watcher->mDir.c_str(), + kCFStringEncodingUTF8 + ); + + CFArrayRef pathsToWatch = CFArrayCreate( + NULL, + (const void **)&fileWatchPath, + 1, + NULL + ); + + // Make a watcher reference we can pass into the callback. This ensures bumped ref-count. + std::shared_ptr* callbackWatcher = new std::shared_ptr (watcher); + FSEventStreamContext callbackInfo {0, static_cast (callbackWatcher), nullptr, nullptr, nullptr}; + FSEventStreamRef stream = FSEventStreamCreate( + NULL, + &FSEventsCallback, + &callbackInfo, + pathsToWatch, + id, + latency, + kFSEventStreamCreateFlagFileEvents + ); + + CFMutableArrayRef exclusions = CFArrayCreateMutable(NULL, watcher->mIgnorePaths.size(), NULL); + for (auto it = watcher->mIgnorePaths.begin(); it != watcher->mIgnorePaths.end(); it++) { + CFStringRef path = CFStringCreateWithCString( + NULL, + it->c_str(), + kCFStringEncodingUTF8 + ); + + CFArrayAppendValue(exclusions, (const void *)path); + } + + FSEventStreamSetExclusionPaths(stream, exclusions); + + FSEventStreamScheduleWithRunLoop(stream, mRunLoop, kCFRunLoopDefaultMode); + bool started = FSEventStreamStart(stream); + + CFRelease(pathsToWatch); + CFRelease(fileWatchPath); + + if (!started) { + FSEventStreamRelease(stream); + throw WatcherError("Error starting FSEvents stream", watcher); + } + + auto stateGuard = watcher->state; + State* s = static_cast(stateGuard.get()); + s->tree = std::make_shared(watcher->mDir); + s->stream = stream; +} + +void FSEventsBackend::start() { + mRunLoop = CFRunLoopGetCurrent(); + CFRetain(mRunLoop); + + // Unlock once run loop has started. + CFRunLoopPerformBlock(mRunLoop, kCFRunLoopDefaultMode, ^ { + notifyStarted(); + }); + + CFRunLoopWakeUp(mRunLoop); + CFRunLoopRun(); +} + +FSEventsBackend::~FSEventsBackend() { + std::unique_lock lock(mMutex); + CFRunLoopStop(mRunLoop); + CFRelease(mRunLoop); +} + +void FSEventsBackend::writeSnapshot(WatcherRef watcher, std::string *snapshotPath) { + std::unique_lock lock(mMutex); + checkWatcher(watcher); + + FSEventStreamEventId id = FSEventsGetCurrentEventId(); + std::ofstream ofs(*snapshotPath); + ofs << id; + ofs << "\n"; + + struct timespec now; + clock_gettime(CLOCK_REALTIME, &now); + ofs << CONVERT_TIME(now); +} + +void FSEventsBackend::getEventsSince(WatcherRef watcher, std::string *snapshotPath) { + std::unique_lock lock(mMutex); + std::ifstream ifs(*snapshotPath); + if (ifs.fail()) { + return; + } + + FSEventStreamEventId id; + uint64_t since; + ifs >> id; + ifs >> since; + + auto s = std::make_shared(); + s->since = since; + watcher->state = s; + + startStream(watcher, id); + watcher->wait(); + stopStream(s->stream, mRunLoop); + + watcher->state = nullptr; +} + +// This function is called by Backend::watch which takes a lock on mMutex +void FSEventsBackend::subscribe(WatcherRef watcher) { + auto s = std::make_shared(); + s->since = 0; + watcher->state = s; + startStream(watcher, kFSEventStreamEventIdSinceNow); +} + +// This function is called by Backend::unwatch which takes a lock on mMutex +void FSEventsBackend::unsubscribe(WatcherRef watcher) { + auto stateGuard = watcher->state; + State* s = static_cast(stateGuard.get()); + if (s != nullptr) { + stopStream(s->stream, mRunLoop); + watcher->state = nullptr; + } +} diff --git a/node_modules/@parcel/watcher/src/macos/FSEventsBackend.hh b/node_modules/@parcel/watcher/src/macos/FSEventsBackend.hh new file mode 100644 index 0000000..57ded66 --- /dev/null +++ b/node_modules/@parcel/watcher/src/macos/FSEventsBackend.hh @@ -0,0 +1,20 @@ +#ifndef FS_EVENTS_H +#define FS_EVENTS_H + +#include +#include "../Backend.hh" + +class FSEventsBackend : public Backend { +public: + void start() override; + ~FSEventsBackend(); + void writeSnapshot(WatcherRef watcher, std::string *snapshotPath) override; + void getEventsSince(WatcherRef watcher, std::string *snapshotPath) override; + void subscribe(WatcherRef watcher) override; + void unsubscribe(WatcherRef watcher) override; +private: + void startStream(WatcherRef watcher, FSEventStreamEventId id); + CFRunLoopRef mRunLoop; +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/shared/BruteForceBackend.cc b/node_modules/@parcel/watcher/src/shared/BruteForceBackend.cc new file mode 100644 index 0000000..0e9b84f --- /dev/null +++ b/node_modules/@parcel/watcher/src/shared/BruteForceBackend.cc @@ -0,0 +1,41 @@ +#include +#include "../DirTree.hh" +#include "../Event.hh" +#include "./BruteForceBackend.hh" + +std::shared_ptr BruteForceBackend::getTree(WatcherRef watcher, bool shouldRead) { + auto tree = DirTree::getCached(watcher->mDir); + + // If the tree is not complete, read it if needed. + if (!tree->isComplete && shouldRead) { + readTree(watcher, tree); + tree->isComplete = true; + } + + return tree; +} + +void BruteForceBackend::writeSnapshot(WatcherRef watcher, std::string *snapshotPath) { + std::unique_lock lock(mMutex); + auto tree = getTree(watcher); + FILE *f = fopen(snapshotPath->c_str(), "w"); + if (!f) { + throw std::runtime_error(std::string("Unable to open snapshot file: ") + strerror(errno)); + } + + tree->write(f); + fclose(f); +} + +void BruteForceBackend::getEventsSince(WatcherRef watcher, std::string *snapshotPath) { + std::unique_lock lock(mMutex); + FILE *f = fopen(snapshotPath->c_str(), "r"); + if (!f) { + throw std::runtime_error(std::string("Unable to open snapshot file: ") + strerror(errno)); + } + + DirTree snapshot{watcher->mDir, f}; + auto now = getTree(watcher); + now->getChanges(&snapshot, watcher->mEvents); + fclose(f); +} diff --git a/node_modules/@parcel/watcher/src/shared/BruteForceBackend.hh b/node_modules/@parcel/watcher/src/shared/BruteForceBackend.hh new file mode 100644 index 0000000..de7a73d --- /dev/null +++ b/node_modules/@parcel/watcher/src/shared/BruteForceBackend.hh @@ -0,0 +1,25 @@ +#ifndef BRUTE_FORCE_H +#define BRUTE_FORCE_H + +#include "../Backend.hh" +#include "../DirTree.hh" +#include "../Watcher.hh" + +class BruteForceBackend : public Backend { +public: + void writeSnapshot(WatcherRef watcher, std::string *snapshotPath) override; + void getEventsSince(WatcherRef watcher, std::string *snapshotPath) override; + void subscribe(WatcherRef watcher) override { + throw "Brute force backend doesn't support subscriptions."; + } + + void unsubscribe(WatcherRef watcher) override { + throw "Brute force backend doesn't support subscriptions."; + } + + std::shared_ptr getTree(WatcherRef watcher, bool shouldRead = true); +private: + void readTree(WatcherRef watcher, std::shared_ptr tree); +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/unix/fts.cc b/node_modules/@parcel/watcher/src/unix/fts.cc new file mode 100644 index 0000000..d50c3e4 --- /dev/null +++ b/node_modules/@parcel/watcher/src/unix/fts.cc @@ -0,0 +1,50 @@ +#include + +// weird error on linux +#ifdef __THROW +#undef __THROW +#endif +#define __THROW + +#include +#include +#include "../DirTree.hh" +#include "../shared/BruteForceBackend.hh" + +#define CONVERT_TIME(ts) ((uint64_t)ts.tv_sec * 1000000000 + ts.tv_nsec) +#if __APPLE__ +#define st_mtim st_mtimespec +#endif + +void BruteForceBackend::readTree(WatcherRef watcher, std::shared_ptr tree) { + char *paths[2] {(char *)watcher->mDir.c_str(), NULL}; + FTS *fts = fts_open(paths, FTS_NOCHDIR | FTS_PHYSICAL, NULL); + if (!fts) { + throw WatcherError(strerror(errno), watcher); + } + + FTSENT *node; + bool isRoot = true; + + while ((node = fts_read(fts)) != NULL) { + if (node->fts_errno) { + fts_close(fts); + throw WatcherError(strerror(node->fts_errno), watcher); + } + + if (isRoot && !(node->fts_info & FTS_D)) { + fts_close(fts); + throw WatcherError(strerror(ENOTDIR), watcher); + } + + if (watcher->isIgnored(std::string(node->fts_path))) { + fts_set(fts, node, FTS_SKIP); + continue; + } + + tree->add(node->fts_path, CONVERT_TIME(node->fts_statp->st_mtim), (node->fts_info & FTS_D) == FTS_D); + isRoot = false; + } + + fts_close(fts); +} diff --git a/node_modules/@parcel/watcher/src/unix/legacy.cc b/node_modules/@parcel/watcher/src/unix/legacy.cc new file mode 100644 index 0000000..60490c6 --- /dev/null +++ b/node_modules/@parcel/watcher/src/unix/legacy.cc @@ -0,0 +1,77 @@ +#include + +// weird error on linux +#ifdef __THROW +#undef __THROW +#endif +#define __THROW + +#ifdef _LIBC +# include +#else +# include +#endif +#include +#include +#include + +#include "../DirTree.hh" +#include "../shared/BruteForceBackend.hh" + +#define CONVERT_TIME(ts) ((uint64_t)ts.tv_sec * 1000000000 + ts.tv_nsec) +#if __APPLE__ +#define st_mtim st_mtimespec +#endif +#define ISDOT(a) (a[0] == '.' && (!a[1] || (a[1] == '.' && !a[2]))) + +void iterateDir(WatcherRef watcher, const std::shared_ptr tree, const char *relative, int parent_fd, const std::string &dirname) { + int open_flags = (O_RDONLY | O_CLOEXEC | O_DIRECTORY | O_NOCTTY | O_NONBLOCK | O_NOFOLLOW); + int new_fd = openat(parent_fd, relative, open_flags); + if (new_fd == -1) { + if (errno == EACCES) { + return; // ignore insufficient permissions + } + + throw WatcherError(strerror(errno), watcher); + } + + struct stat rootAttributes; + fstatat(new_fd, ".", &rootAttributes, AT_SYMLINK_NOFOLLOW); + tree->add(dirname, CONVERT_TIME(rootAttributes.st_mtim), true); + + if (DIR *dir = fdopendir(new_fd)) { + while (struct dirent *ent = (errno = 0, readdir(dir))) { + if (ISDOT(ent->d_name)) continue; + + std::string fullPath = dirname + "/" + ent->d_name; + + if (!watcher->isIgnored(fullPath)) { + struct stat attrib; + fstatat(new_fd, ent->d_name, &attrib, AT_SYMLINK_NOFOLLOW); + bool isDir = ent->d_type == DT_DIR; + + if (isDir) { + iterateDir(watcher, tree, ent->d_name, new_fd, fullPath); + } else { + tree->add(fullPath, CONVERT_TIME(attrib.st_mtim), isDir); + } + } + } + + closedir(dir); + } else { + close(new_fd); + } + + if (errno) { + throw WatcherError(strerror(errno), watcher); + } +} + +void BruteForceBackend::readTree(WatcherRef watcher, std::shared_ptr tree) { + int fd = open(watcher->mDir.c_str(), O_RDONLY); + if (fd) { + iterateDir(watcher, tree, ".", fd, watcher->mDir); + close(fd); + } +} diff --git a/node_modules/@parcel/watcher/src/wasm/WasmBackend.cc b/node_modules/@parcel/watcher/src/wasm/WasmBackend.cc new file mode 100644 index 0000000..9514109 --- /dev/null +++ b/node_modules/@parcel/watcher/src/wasm/WasmBackend.cc @@ -0,0 +1,132 @@ +#include +#include "WasmBackend.hh" + +#define CONVERT_TIME(ts) ((uint64_t)ts.tv_sec * 1000000000 + ts.tv_nsec) + +void WasmBackend::start() { + notifyStarted(); +} + +void WasmBackend::subscribe(WatcherRef watcher) { + // Build a full directory tree recursively, and watch each directory. + std::shared_ptr tree = getTree(watcher); + + for (auto it = tree->entries.begin(); it != tree->entries.end(); it++) { + if (it->second.isDir) { + watchDir(watcher, it->second.path, tree); + } + } +} + +void WasmBackend::watchDir(WatcherRef watcher, std::string path, std::shared_ptr tree) { + int wd = wasm_backend_add_watch(path.c_str(), (void *)this); + std::shared_ptr sub = std::make_shared(); + sub->tree = tree; + sub->path = path; + sub->watcher = watcher; + mSubscriptions.emplace(wd, sub); +} + +extern "C" void wasm_backend_event_handler(void *backend, int wd, int type, char *filename) { + WasmBackend *b = (WasmBackend *)(backend); + b->handleEvent(wd, type, filename); +} + +void WasmBackend::handleEvent(int wd, int type, char *filename) { + // Find the subscriptions for this watch descriptor + auto range = mSubscriptions.equal_range(wd); + std::unordered_set> set; + for (auto it = range.first; it != range.second; it++) { + set.insert(it->second); + } + + for (auto it = set.begin(); it != set.end(); it++) { + if (handleSubscription(type, filename, *it)) { + (*it)->watcher->notify(); + } + } +} + +bool WasmBackend::handleSubscription(int type, char *filename, std::shared_ptr sub) { + // Build full path and check if its in our ignore list. + WatcherRef watcher = sub->watcher; + std::string path = std::string(sub->path); + + if (filename[0] != '\0') { + path += "/" + std::string(filename); + } + + if (watcher->isIgnored(path)) { + return false; + } + + if (type == 1) { + struct stat st; + stat(path.c_str(), &st); + sub->tree->update(path, CONVERT_TIME(st.st_mtim)); + watcher->mEvents.update(path); + } else if (type == 2) { + // Determine if this is a create or delete depending on if the file exists or not. + struct stat st; + if (lstat(path.c_str(), &st)) { + // If the entry being deleted/moved is a directory, remove it from the list of subscriptions + DirEntry *entry = sub->tree->find(path); + if (!entry) { + return false; + } + + if (entry->isDir) { + std::string pathStart = path + DIR_SEP; + for (auto it = mSubscriptions.begin(); it != mSubscriptions.end();) { + if (it->second->path == path || it->second->path.rfind(pathStart, 0) == 0) { + wasm_backend_remove_watch(it->first); + it = mSubscriptions.erase(it); + } else { + ++it; + } + } + + // Remove all sub-entries + for (auto it = sub->tree->entries.begin(); it != sub->tree->entries.end();) { + if (it->first.rfind(pathStart, 0) == 0) { + watcher->mEvents.remove(it->first); + it = sub->tree->entries.erase(it); + } else { + it++; + } + } + } + + watcher->mEvents.remove(path); + sub->tree->remove(path); + } else if (sub->tree->find(path)) { + sub->tree->update(path, CONVERT_TIME(st.st_mtim)); + watcher->mEvents.update(path); + } else { + watcher->mEvents.create(path); + + // If this is a create, check if it's a directory and start watching if it is. + DirEntry *entry = sub->tree->add(path, CONVERT_TIME(st.st_mtim), S_ISDIR(st.st_mode)); + if (entry->isDir) { + watchDir(watcher, path, sub->tree); + } + } + } + + return true; +} + +void WasmBackend::unsubscribe(WatcherRef watcher) { + // Find any subscriptions pointing to this watcher, and remove them. + for (auto it = mSubscriptions.begin(); it != mSubscriptions.end();) { + if (it->second->watcher.get() == watcher.get()) { + if (mSubscriptions.count(it->first) == 1) { + wasm_backend_remove_watch(it->first); + } + + it = mSubscriptions.erase(it); + } else { + it++; + } + } +} diff --git a/node_modules/@parcel/watcher/src/wasm/WasmBackend.hh b/node_modules/@parcel/watcher/src/wasm/WasmBackend.hh new file mode 100644 index 0000000..9facac8 --- /dev/null +++ b/node_modules/@parcel/watcher/src/wasm/WasmBackend.hh @@ -0,0 +1,34 @@ +#ifndef WASM_H +#define WASM_H + +#include +#include "../shared/BruteForceBackend.hh" +#include "../DirTree.hh" + +extern "C" { + int wasm_backend_add_watch(const char *filename, void *backend); + void wasm_backend_remove_watch(int wd); + void wasm_backend_event_handler(void *backend, int wd, int type, char *filename); +}; + +struct WasmSubscription { + std::shared_ptr tree; + std::string path; + WatcherRef watcher; +}; + +class WasmBackend : public BruteForceBackend { +public: + void start() override; + void subscribe(WatcherRef watcher) override; + void unsubscribe(WatcherRef watcher) override; + void handleEvent(int wd, int type, char *filename); +private: + int mWasm; + std::unordered_multimap> mSubscriptions; + + void watchDir(WatcherRef watcher, std::string path, std::shared_ptr tree); + bool handleSubscription(int type, char *filename, std::shared_ptr sub); +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/wasm/include.h b/node_modules/@parcel/watcher/src/wasm/include.h new file mode 100644 index 0000000..60e4d65 --- /dev/null +++ b/node_modules/@parcel/watcher/src/wasm/include.h @@ -0,0 +1,74 @@ +/* +Copyright Node.js contributors. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to +deal in the Software without restriction, including without limitation the +rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +IN THE SOFTWARE. +*/ + +// Node does not include the headers for these functions when compiling for WASM, so add them here. +#ifdef __wasm32__ +extern "C" { +NAPI_EXTERN napi_status NAPI_CDECL +napi_create_threadsafe_function(napi_env env, + napi_value func, + napi_value async_resource, + napi_value async_resource_name, + size_t max_queue_size, + size_t initial_thread_count, + void* thread_finalize_data, + napi_finalize thread_finalize_cb, + void* context, + napi_threadsafe_function_call_js call_js_cb, + napi_threadsafe_function* result); + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_threadsafe_function_context( + napi_threadsafe_function func, void** result); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_call_threadsafe_function(napi_threadsafe_function func, + void* data, + napi_threadsafe_function_call_mode is_blocking); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_acquire_threadsafe_function(napi_threadsafe_function func); + +NAPI_EXTERN napi_status NAPI_CDECL napi_release_threadsafe_function( + napi_threadsafe_function func, napi_threadsafe_function_release_mode mode); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_unref_threadsafe_function(napi_env env, napi_threadsafe_function func); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_ref_threadsafe_function(napi_env env, napi_threadsafe_function func); + +NAPI_EXTERN napi_status NAPI_CDECL +napi_create_async_work(napi_env env, + napi_value async_resource, + napi_value async_resource_name, + napi_async_execute_callback execute, + napi_async_complete_callback complete, + void* data, + napi_async_work* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_delete_async_work(napi_env env, + napi_async_work work); +NAPI_EXTERN napi_status NAPI_CDECL napi_queue_async_work(napi_env env, + napi_async_work work); +NAPI_EXTERN napi_status NAPI_CDECL napi_cancel_async_work(napi_env env, + napi_async_work work); +} +#endif diff --git a/node_modules/@parcel/watcher/src/watchman/BSER.cc b/node_modules/@parcel/watcher/src/watchman/BSER.cc new file mode 100644 index 0000000..1fbcd45 --- /dev/null +++ b/node_modules/@parcel/watcher/src/watchman/BSER.cc @@ -0,0 +1,302 @@ +#include +#include "./BSER.hh" + +BSERType decodeType(std::istream &iss) { + int8_t type; + iss.read(reinterpret_cast(&type), sizeof(type)); + return (BSERType) type; +} + +void expectType(std::istream &iss, BSERType expected) { + BSERType got = decodeType(iss); + if (got != expected) { + throw std::runtime_error("Unexpected BSER type"); + } +} + +void encodeType(std::ostream &oss, BSERType type) { + int8_t t = (int8_t)type; + oss.write(reinterpret_cast(&t), sizeof(t)); +} + +template +class Value : public BSERValue { +public: + T value; + Value(T val) { + value = val; + } + + Value() {} +}; + +class BSERInteger : public Value { +public: + BSERInteger(int64_t value) : Value(value) {} + BSERInteger(std::istream &iss) { + int8_t int8; + int16_t int16; + int32_t int32; + int64_t int64; + + BSERType type = decodeType(iss); + + switch (type) { + case BSER_INT8: + iss.read(reinterpret_cast(&int8), sizeof(int8)); + value = int8; + break; + case BSER_INT16: + iss.read(reinterpret_cast(&int16), sizeof(int16)); + value = int16; + break; + case BSER_INT32: + iss.read(reinterpret_cast(&int32), sizeof(int32)); + value = int32; + break; + case BSER_INT64: + iss.read(reinterpret_cast(&int64), sizeof(int64)); + value = int64; + break; + default: + throw std::runtime_error("Invalid BSER int type"); + } + } + + int64_t intValue() override { + return value; + } + + void encode(std::ostream &oss) override { + if (value <= INT8_MAX) { + encodeType(oss, BSER_INT8); + int8_t v = (int8_t)value; + oss.write(reinterpret_cast(&v), sizeof(v)); + } else if (value <= INT16_MAX) { + encodeType(oss, BSER_INT16); + int16_t v = (int16_t)value; + oss.write(reinterpret_cast(&v), sizeof(v)); + } else if (value <= INT32_MAX) { + encodeType(oss, BSER_INT32); + int32_t v = (int32_t)value; + oss.write(reinterpret_cast(&v), sizeof(v)); + } else { + encodeType(oss, BSER_INT64); + oss.write(reinterpret_cast(&value), sizeof(value)); + } + } +}; + +class BSERArray : public Value { +public: + BSERArray() : Value() {} + BSERArray(BSER::Array value) : Value(value) {} + BSERArray(std::istream &iss) { + expectType(iss, BSER_ARRAY); + int64_t len = BSERInteger(iss).intValue(); + for (int64_t i = 0; i < len; i++) { + value.push_back(BSER(iss)); + } + } + + BSER::Array arrayValue() override { + return value; + } + + void encode(std::ostream &oss) override { + encodeType(oss, BSER_ARRAY); + BSERInteger(value.size()).encode(oss); + for (auto it = value.begin(); it != value.end(); it++) { + it->encode(oss); + } + } +}; + +class BSERString : public Value { +public: + BSERString(std::string value) : Value(value) {} + BSERString(std::istream &iss) { + expectType(iss, BSER_STRING); + int64_t len = BSERInteger(iss).intValue(); + value.resize(len); + iss.read(&value[0], len); + } + + std::string stringValue() override { + return value; + } + + void encode(std::ostream &oss) override { + encodeType(oss, BSER_STRING); + BSERInteger(value.size()).encode(oss); + oss << value; + } +}; + +class BSERObject : public Value { +public: + BSERObject() : Value() {} + BSERObject(BSER::Object value) : Value(value) {} + BSERObject(std::istream &iss) { + expectType(iss, BSER_OBJECT); + int64_t len = BSERInteger(iss).intValue(); + for (int64_t i = 0; i < len; i++) { + auto key = BSERString(iss).stringValue(); + auto val = BSER(iss); + value.emplace(key, val); + } + } + + BSER::Object objectValue() override { + return value; + } + + void encode(std::ostream &oss) override { + encodeType(oss, BSER_OBJECT); + BSERInteger(value.size()).encode(oss); + for (auto it = value.begin(); it != value.end(); it++) { + BSERString(it->first).encode(oss); + it->second.encode(oss); + } + } +}; + +class BSERDouble : public Value { +public: + BSERDouble(double value) : Value(value) {} + BSERDouble(std::istream &iss) { + expectType(iss, BSER_REAL); + iss.read(reinterpret_cast(&value), sizeof(value)); + } + + double doubleValue() override { + return value; + } + + void encode(std::ostream &oss) override { + encodeType(oss, BSER_REAL); + oss.write(reinterpret_cast(&value), sizeof(value)); + } +}; + +class BSERBoolean : public Value { +public: + BSERBoolean(bool value) : Value(value) {} + bool boolValue() override { return value; } + void encode(std::ostream &oss) override { + int8_t t = value == true ? BSER_BOOL_TRUE : BSER_BOOL_FALSE; + oss.write(reinterpret_cast(&t), sizeof(t)); + } +}; + +class BSERNull : public Value { +public: + BSERNull() : Value(false) {} + void encode(std::ostream &oss) override { + encodeType(oss, BSER_NULL); + } +}; + +std::shared_ptr decodeTemplate(std::istream &iss) { + expectType(iss, BSER_TEMPLATE); + auto keys = BSERArray(iss).arrayValue(); + auto len = BSERInteger(iss).intValue(); + std::shared_ptr arr = std::make_shared(); + for (int64_t i = 0; i < len; i++) { + BSER::Object obj; + for (auto it = keys.begin(); it != keys.end(); it++) { + if (iss.peek() == 0x0c) { + iss.ignore(1); + continue; + } + + auto val = BSER(iss); + obj.emplace(it->stringValue(), val); + } + arr->value.push_back(obj); + } + return arr; +} + +BSER::BSER(std::istream &iss) { + BSERType type = decodeType(iss); + iss.unget(); + + switch (type) { + case BSER_ARRAY: + m_ptr = std::make_shared(iss); + break; + case BSER_OBJECT: + m_ptr = std::make_shared(iss); + break; + case BSER_STRING: + m_ptr = std::make_shared(iss); + break; + case BSER_INT8: + case BSER_INT16: + case BSER_INT32: + case BSER_INT64: + m_ptr = std::make_shared(iss); + break; + case BSER_REAL: + m_ptr = std::make_shared(iss); + break; + case BSER_BOOL_TRUE: + iss.ignore(1); + m_ptr = std::make_shared(true); + break; + case BSER_BOOL_FALSE: + iss.ignore(1); + m_ptr = std::make_shared(false); + break; + case BSER_NULL: + iss.ignore(1); + m_ptr = std::make_shared(); + break; + case BSER_TEMPLATE: + m_ptr = decodeTemplate(iss); + break; + default: + throw std::runtime_error("unknown BSER type"); + } +} + +BSER::BSER() : m_ptr(std::make_shared()) {} +BSER::BSER(BSER::Array value) : m_ptr(std::make_shared(value)) {} +BSER::BSER(BSER::Object value) : m_ptr(std::make_shared(value)) {} +BSER::BSER(const char *value) : m_ptr(std::make_shared(value)) {} +BSER::BSER(std::string value) : m_ptr(std::make_shared(value)) {} +BSER::BSER(int64_t value) : m_ptr(std::make_shared(value)) {} +BSER::BSER(double value) : m_ptr(std::make_shared(value)) {} +BSER::BSER(bool value) : m_ptr(std::make_shared(value)) {} + +BSER::Array BSER::arrayValue() { return m_ptr->arrayValue(); } +BSER::Object BSER::objectValue() { return m_ptr->objectValue(); } +std::string BSER::stringValue() { return m_ptr->stringValue(); } +int64_t BSER::intValue() { return m_ptr->intValue(); } +double BSER::doubleValue() { return m_ptr->doubleValue(); } +bool BSER::boolValue() { return m_ptr->boolValue(); } +void BSER::encode(std::ostream &oss) { + m_ptr->encode(oss); +} + +int64_t BSER::decodeLength(std::istream &iss) { + char pdu[2]; + if (!iss.read(pdu, 2) || pdu[0] != 0 || pdu[1] != 1) { + throw std::runtime_error("Invalid BSER"); + } + + return BSERInteger(iss).intValue(); +} + +std::string BSER::encode() { + std::ostringstream oss(std::ios_base::binary); + encode(oss); + + std::ostringstream res(std::ios_base::binary); + res.write("\x00\x01", 2); + + BSERInteger(oss.str().size()).encode(res); + res << oss.str(); + return res.str(); +} diff --git a/node_modules/@parcel/watcher/src/watchman/BSER.hh b/node_modules/@parcel/watcher/src/watchman/BSER.hh new file mode 100644 index 0000000..6bd2025 --- /dev/null +++ b/node_modules/@parcel/watcher/src/watchman/BSER.hh @@ -0,0 +1,69 @@ +#ifndef BSER_H +#define BSER_H + +#include +#include +#include +#include +#include + +enum BSERType { + BSER_ARRAY = 0x00, + BSER_OBJECT = 0x01, + BSER_STRING = 0x02, + BSER_INT8 = 0x03, + BSER_INT16 = 0x04, + BSER_INT32 = 0x05, + BSER_INT64 = 0x06, + BSER_REAL = 0x07, + BSER_BOOL_TRUE = 0x08, + BSER_BOOL_FALSE = 0x09, + BSER_NULL = 0x0a, + BSER_TEMPLATE = 0x0b +}; + +class BSERValue; + +class BSER { +public: + typedef std::vector Array; + typedef std::unordered_map Object; + + BSER(); + BSER(BSER::Array value); + BSER(BSER::Object value); + BSER(std::string value); + BSER(const char *value); + BSER(int64_t value); + BSER(double value); + BSER(bool value); + BSER(std::istream &iss); + + BSER::Array arrayValue(); + BSER::Object objectValue(); + std::string stringValue(); + int64_t intValue(); + double doubleValue(); + bool boolValue(); + void encode(std::ostream &oss); + + static int64_t decodeLength(std::istream &iss); + std::string encode(); +private: + std::shared_ptr m_ptr; +}; + +class BSERValue { +protected: + friend class BSER; + virtual BSER::Array arrayValue() { return BSER::Array(); } + virtual BSER::Object objectValue() { return BSER::Object(); } + virtual std::string stringValue() { return std::string(); } + virtual int64_t intValue() { return 0; } + virtual double doubleValue() { return 0; } + virtual bool boolValue() { return false; } + virtual void encode(std::ostream &oss) {} + virtual ~BSERValue() {} +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/watchman/IPC.hh b/node_modules/@parcel/watcher/src/watchman/IPC.hh new file mode 100644 index 0000000..6e852c8 --- /dev/null +++ b/node_modules/@parcel/watcher/src/watchman/IPC.hh @@ -0,0 +1,175 @@ +#ifndef IPC_H +#define IPC_H + +#include +#include + +#ifdef _WIN32 +#include +#include +#else +#include +#include +#include +#endif + +class IPC { +public: + IPC(std::string path) { + mStopped = false; + #ifdef _WIN32 + while (true) { + mPipe = CreateFile( + path.data(), // pipe name + GENERIC_READ | GENERIC_WRITE, // read and write access + 0, // no sharing + NULL, // default security attributes + OPEN_EXISTING, // opens existing pipe + FILE_FLAG_OVERLAPPED, // attributes + NULL // no template file + ); + + if (mPipe != INVALID_HANDLE_VALUE) { + break; + } + + if (GetLastError() != ERROR_PIPE_BUSY) { + throw std::runtime_error("Could not open pipe"); + } + + // Wait for pipe to become available if it is busy + if (!WaitNamedPipe(path.data(), 30000)) { + throw std::runtime_error("Error waiting for pipe"); + } + } + + mReader = CreateEvent(NULL, true, false, NULL); + mWriter = CreateEvent(NULL, true, false, NULL); + #else + struct sockaddr_un addr; + memset(&addr, 0, sizeof(addr)); + addr.sun_family = AF_UNIX; + strncpy(addr.sun_path, path.c_str(), sizeof(addr.sun_path) - 1); + + mSock = socket(AF_UNIX, SOCK_STREAM, 0); + if (connect(mSock, (struct sockaddr *) &addr, sizeof(struct sockaddr_un))) { + throw std::runtime_error("Error connecting to socket"); + } + #endif + } + + ~IPC() { + mStopped = true; + #ifdef _WIN32 + CancelIo(mPipe); + CloseHandle(mPipe); + CloseHandle(mReader); + CloseHandle(mWriter); + #else + shutdown(mSock, SHUT_RDWR); + #endif + } + + void write(std::string buf) { + #ifdef _WIN32 + OVERLAPPED overlapped; + overlapped.hEvent = mWriter; + bool success = WriteFile( + mPipe, // pipe handle + buf.data(), // message + buf.size(), // message length + NULL, // bytes written + &overlapped // overlapped + ); + + if (mStopped) { + return; + } + + if (!success) { + if (GetLastError() != ERROR_IO_PENDING) { + throw std::runtime_error("Write error"); + } + } + + DWORD written; + success = GetOverlappedResult(mPipe, &overlapped, &written, true); + if (!success) { + throw std::runtime_error("GetOverlappedResult failed"); + } + + if (written != buf.size()) { + throw std::runtime_error("Wrong number of bytes written"); + } + #else + int r = 0; + for (unsigned int i = 0; i != buf.size(); i += r) { + r = ::write(mSock, &buf[i], buf.size() - i); + if (r == -1) { + if (errno == EAGAIN) { + r = 0; + } else if (mStopped) { + return; + } else { + throw std::runtime_error("Write error"); + } + } + } + #endif + } + + int read(char *buf, size_t len) { + #ifdef _WIN32 + OVERLAPPED overlapped; + overlapped.hEvent = mReader; + bool success = ReadFile( + mPipe, // pipe handle + buf, // buffer to receive reply + len, // size of buffer + NULL, // number of bytes read + &overlapped // overlapped + ); + + if (!success && !mStopped) { + if (GetLastError() != ERROR_IO_PENDING) { + throw std::runtime_error("Read error"); + } + } + + DWORD read = 0; + success = GetOverlappedResult(mPipe, &overlapped, &read, true); + if (!success && !mStopped) { + throw std::runtime_error("GetOverlappedResult failed"); + } + + return read; + #else + int r = ::read(mSock, buf, len); + if (r == 0 && !mStopped) { + throw std::runtime_error("Socket ended unexpectedly"); + } + + if (r < 0) { + if (mStopped) { + return 0; + } + + throw std::runtime_error(strerror(errno)); + } + + return r; + #endif + } + +private: + bool mStopped; + #ifdef _WIN32 + HANDLE mPipe; + HANDLE mReader; + HANDLE mWriter; + #else + int mSock; + #endif +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/watchman/WatchmanBackend.cc b/node_modules/@parcel/watcher/src/watchman/WatchmanBackend.cc new file mode 100644 index 0000000..82a23f5 --- /dev/null +++ b/node_modules/@parcel/watcher/src/watchman/WatchmanBackend.cc @@ -0,0 +1,338 @@ +#include +#include +#include +#include +#include "../DirTree.hh" +#include "../Event.hh" +#include "./BSER.hh" +#include "./WatchmanBackend.hh" + +#ifdef _WIN32 +#include "../windows/win_utils.hh" +#define S_ISDIR(mode) ((mode & _S_IFDIR) == _S_IFDIR) +#define popen _popen +#define pclose _pclose +#else +#include +#define normalizePath(dir) dir +#endif + +template +BSER readBSER(T &&do_read) { + std::stringstream oss; + char buffer[256]; + int r; + int64_t len = -1; + do { + // Start by reading a minimal amount of data in order to decode the length. + // After that, attempt to read the remaining length, up to the buffer size. + r = do_read(buffer, len == -1 ? 20 : (len < 256 ? len : 256)); + oss << std::string(buffer, r); + + if (len == -1) { + uint64_t l = BSER::decodeLength(oss); + len = l + oss.tellg(); + } + + len -= r; + } while (len > 0); + + return BSER(oss); +} + +std::string getSockPath() { + auto var = getenv("WATCHMAN_SOCK"); + if (var && *var) { + return std::string(var); + } + + FILE *fp = popen("watchman --output-encoding=bser get-sockname", "r"); + if (fp == NULL || errno == ECHILD) { + throw std::runtime_error("Failed to execute watchman"); + } + + BSER b = readBSER([fp] (char *buf, size_t len) { + return fread(buf, sizeof(char), len, fp); + }); + + pclose(fp); + + auto objValue = b.objectValue(); + auto foundSockname = objValue.find("sockname"); + if (foundSockname == objValue.end()) { + throw std::runtime_error("sockname not found"); + } + return foundSockname->second.stringValue(); +} + +std::unique_ptr watchmanConnect() { + std::string path = getSockPath(); + return std::unique_ptr(new IPC(path)); +} + +BSER watchmanRead(IPC *ipc) { + return readBSER([ipc] (char *buf, size_t len) { + return ipc->read(buf, len); + }); +} + +BSER::Object WatchmanBackend::watchmanRequest(BSER b) { + std::string cmd = b.encode(); + mIPC->write(cmd); + mRequestSignal.notify(); + + mResponseSignal.wait(); + mResponseSignal.reset(); + + if (!mError.empty()) { + std::runtime_error err = std::runtime_error(mError); + mError = std::string(); + throw err; + } + + return mResponse; +} + +void WatchmanBackend::watchmanWatch(std::string dir) { + std::vector cmd; + cmd.push_back("watch"); + cmd.push_back(normalizePath(dir)); + watchmanRequest(cmd); +} + +bool WatchmanBackend::checkAvailable() { + try { + watchmanConnect(); + return true; + } catch (std::exception &err) { + return false; + } +} + +void handleFiles(WatcherRef watcher, BSER::Object obj) { + auto found = obj.find("files"); + if (found == obj.end()) { + throw WatcherError("Error reading changes from watchman", watcher); + } + + auto files = found->second.arrayValue(); + for (auto it = files.begin(); it != files.end(); it++) { + auto file = it->objectValue(); + auto name = file.find("name")->second.stringValue(); + #ifdef _WIN32 + std::replace(name.begin(), name.end(), '/', '\\'); + #endif + auto mode = file.find("mode")->second.intValue(); + auto isNew = file.find("new")->second.boolValue(); + auto exists = file.find("exists")->second.boolValue(); + auto path = watcher->mDir + DIR_SEP + name; + if (watcher->isIgnored(path)) { + continue; + } + + if (isNew && exists) { + watcher->mEvents.create(path); + } else if (exists && !S_ISDIR(mode)) { + watcher->mEvents.update(path); + } else if (!isNew && !exists) { + watcher->mEvents.remove(path); + } + } +} + +void WatchmanBackend::handleSubscription(BSER::Object obj) { + std::unique_lock lock(mMutex); + auto subscription = obj.find("subscription")->second.stringValue(); + auto it = mSubscriptions.find(subscription); + if (it == mSubscriptions.end()) { + return; + } + + auto watcher = it->second; + try { + handleFiles(watcher, obj); + watcher->notify(); + } catch (WatcherError &err) { + handleWatcherError(err); + } +} + +void WatchmanBackend::start() { + mIPC = watchmanConnect(); + notifyStarted(); + + while (true) { + // If there are no subscriptions we are reading, wait for a request. + if (mSubscriptions.size() == 0) { + mRequestSignal.wait(); + mRequestSignal.reset(); + } + + // Break out of loop if we are stopped. + if (mStopped) { + break; + } + + // Attempt to read from the socket. + // If there is an error and we are stopped, break. + BSER b; + try { + b = watchmanRead(&*mIPC); + } catch (std::exception &err) { + if (mStopped) { + break; + } else if (mResponseSignal.isWaiting()) { + mError = err.what(); + mResponseSignal.notify(); + } else { + // Throwing causes the backend to be destroyed, but we never reach the code below to notify the signal + mEndedSignal.notify(); + throw; + } + } + + auto obj = b.objectValue(); + auto error = obj.find("error"); + if (error != obj.end()) { + mError = error->second.stringValue(); + mResponseSignal.notify(); + continue; + } + + // If this message is for a subscription, handle it, otherwise notify the request. + auto subscription = obj.find("subscription"); + if (subscription != obj.end()) { + handleSubscription(obj); + } else { + mResponse = obj; + mResponseSignal.notify(); + } + } + + mEndedSignal.notify(); +} + +WatchmanBackend::~WatchmanBackend() { + // Mark the watcher as stopped, close the socket, and trigger the lock. + // This will cause the read loop to be broken and the thread to exit. + mStopped = true; + mIPC.reset(); + mRequestSignal.notify(); + + // If not ended yet, wait. + mEndedSignal.wait(); +} + +std::string WatchmanBackend::clock(WatcherRef watcher) { + BSER::Array cmd; + cmd.push_back("clock"); + cmd.push_back(normalizePath(watcher->mDir)); + + BSER::Object obj = watchmanRequest(cmd); + auto found = obj.find("clock"); + if (found == obj.end()) { + throw WatcherError("Error reading clock from watchman", watcher); + } + + return found->second.stringValue(); +} + +void WatchmanBackend::writeSnapshot(WatcherRef watcher, std::string *snapshotPath) { + std::unique_lock lock(mMutex); + watchmanWatch(watcher->mDir); + + std::ofstream ofs(*snapshotPath); + ofs << clock(watcher); +} + +void WatchmanBackend::getEventsSince(WatcherRef watcher, std::string *snapshotPath) { + std::unique_lock lock(mMutex); + std::ifstream ifs(*snapshotPath); + if (ifs.fail()) { + return; + } + + watchmanWatch(watcher->mDir); + + std::string clock; + ifs >> clock; + + BSER::Array cmd; + cmd.push_back("since"); + cmd.push_back(normalizePath(watcher->mDir)); + cmd.push_back(clock); + + BSER::Object obj = watchmanRequest(cmd); + handleFiles(watcher, obj); +} + +std::string getId(WatcherRef watcher) { + std::ostringstream id; + id << "parcel-"; + id << static_cast(watcher.get()); + return id.str(); +} + +// This function is called by Backend::watch which takes a lock on mMutex +void WatchmanBackend::subscribe(WatcherRef watcher) { + watchmanWatch(watcher->mDir); + + std::string id = getId(watcher); + BSER::Array cmd; + cmd.push_back("subscribe"); + cmd.push_back(normalizePath(watcher->mDir)); + cmd.push_back(id); + + BSER::Array fields; + fields.push_back("name"); + fields.push_back("mode"); + fields.push_back("exists"); + fields.push_back("new"); + + BSER::Object opts; + opts.emplace("fields", fields); + opts.emplace("since", clock(watcher)); + + if (watcher->mIgnorePaths.size() > 0) { + BSER::Array ignore; + BSER::Array anyOf; + anyOf.push_back("anyof"); + + for (auto it = watcher->mIgnorePaths.begin(); it != watcher->mIgnorePaths.end(); it++) { + std::string pathStart = watcher->mDir + DIR_SEP; + if (it->rfind(pathStart, 0) == 0) { + auto relative = it->substr(pathStart.size()); + BSER::Array dirname; + dirname.push_back("dirname"); + dirname.push_back(relative); + anyOf.push_back(dirname); + } + } + + ignore.push_back("not"); + ignore.push_back(anyOf); + + opts.emplace("expression", ignore); + } + + cmd.push_back(opts); + watchmanRequest(cmd); + + mSubscriptions.emplace(id, watcher); + mRequestSignal.notify(); +} + +// This function is called by Backend::unwatch which takes a lock on mMutex +void WatchmanBackend::unsubscribe(WatcherRef watcher) { + std::string id = getId(watcher); + auto erased = mSubscriptions.erase(id); + + if (erased) { + BSER::Array cmd; + cmd.push_back("unsubscribe"); + cmd.push_back(normalizePath(watcher->mDir)); + cmd.push_back(id); + + watchmanRequest(cmd); + } +} diff --git a/node_modules/@parcel/watcher/src/watchman/WatchmanBackend.hh b/node_modules/@parcel/watcher/src/watchman/WatchmanBackend.hh new file mode 100644 index 0000000..699cded --- /dev/null +++ b/node_modules/@parcel/watcher/src/watchman/WatchmanBackend.hh @@ -0,0 +1,35 @@ +#ifndef WATCHMAN_H +#define WATCHMAN_H + +#include "../Backend.hh" +#include "./BSER.hh" +#include "../Signal.hh" +#include "./IPC.hh" + +class WatchmanBackend : public Backend { +public: + static bool checkAvailable(); + void start() override; + WatchmanBackend() : mStopped(false) {}; + ~WatchmanBackend(); + void writeSnapshot(WatcherRef watcher, std::string *snapshotPath) override; + void getEventsSince(WatcherRef watcher, std::string *snapshotPath) override; + void subscribe(WatcherRef watcher) override; + void unsubscribe(WatcherRef watcher) override; +private: + std::unique_ptr mIPC; + Signal mRequestSignal; + Signal mResponseSignal; + BSER::Object mResponse; + std::string mError; + std::unordered_map mSubscriptions; + bool mStopped; + Signal mEndedSignal; + + std::string clock(WatcherRef watcher); + void watchmanWatch(std::string dir); + BSER::Object watchmanRequest(BSER cmd); + void handleSubscription(BSER::Object obj); +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/windows/WindowsBackend.cc b/node_modules/@parcel/watcher/src/windows/WindowsBackend.cc new file mode 100644 index 0000000..eabce1e --- /dev/null +++ b/node_modules/@parcel/watcher/src/windows/WindowsBackend.cc @@ -0,0 +1,282 @@ +#include +#include +#include "../DirTree.hh" +#include "../shared/BruteForceBackend.hh" +#include "./WindowsBackend.hh" +#include "./win_utils.hh" + +#define DEFAULT_BUF_SIZE 1024 * 1024 +#define NETWORK_BUF_SIZE 64 * 1024 +#define CONVERT_TIME(ft) ULARGE_INTEGER{ft.dwLowDateTime, ft.dwHighDateTime}.QuadPart + +void BruteForceBackend::readTree(WatcherRef watcher, std::shared_ptr tree) { + std::stack directories; + + directories.push(watcher->mDir); + + while (!directories.empty()) { + HANDLE hFind = INVALID_HANDLE_VALUE; + + std::string path = directories.top(); + std::string spec = path + "\\*"; + directories.pop(); + + WIN32_FIND_DATA ffd; + hFind = FindFirstFile(spec.c_str(), &ffd); + + if (hFind == INVALID_HANDLE_VALUE) { + if (path == watcher->mDir) { + FindClose(hFind); + throw WatcherError("Error opening directory", watcher); + } + + tree->remove(path); + continue; + } + + do { + if (strcmp(ffd.cFileName, ".") != 0 && strcmp(ffd.cFileName, "..") != 0) { + std::string fullPath = path + "\\" + ffd.cFileName; + if (watcher->isIgnored(fullPath)) { + continue; + } + + tree->add(fullPath, CONVERT_TIME(ffd.ftLastWriteTime), ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY); + if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { + directories.push(fullPath); + } + } + } while (FindNextFile(hFind, &ffd) != 0); + + FindClose(hFind); + } +} + +void WindowsBackend::start() { + mRunning = true; + notifyStarted(); + + while (mRunning) { + SleepEx(INFINITE, true); + } +} + +WindowsBackend::~WindowsBackend() { + // Mark as stopped, and queue a noop function in the thread to break the loop + mRunning = false; + QueueUserAPC([](__in ULONG_PTR) {}, mThread.native_handle(), (ULONG_PTR)this); +} + +class Subscription: public WatcherState { +public: + Subscription(WindowsBackend *backend, WatcherRef watcher, std::shared_ptr tree) { + mRunning = true; + mBackend = backend; + mWatcher = watcher; + mTree = tree; + ZeroMemory(&mOverlapped, sizeof(OVERLAPPED)); + mOverlapped.hEvent = this; + mReadBuffer.resize(DEFAULT_BUF_SIZE); + mWriteBuffer.resize(DEFAULT_BUF_SIZE); + + mDirectoryHandle = CreateFileW( + utf8ToUtf16(watcher->mDir).data(), + FILE_LIST_DIRECTORY, + FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, + NULL, + OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, + NULL + ); + + if (mDirectoryHandle == INVALID_HANDLE_VALUE) { + throw WatcherError("Invalid handle", mWatcher); + } + + // Ensure that the path is a directory + BY_HANDLE_FILE_INFORMATION info; + bool success = GetFileInformationByHandle( + mDirectoryHandle, + &info + ); + + if (!success) { + throw WatcherError("Could not get file information", mWatcher); + } + + if (!(info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { + throw WatcherError("Not a directory", mWatcher); + } + } + + virtual ~Subscription() { + stop(); + } + + void run() { + try { + poll(); + } catch (WatcherError &err) { + mBackend->handleWatcherError(err); + } + } + + void stop() { + if (mRunning) { + mRunning = false; + CancelIo(mDirectoryHandle); + CloseHandle(mDirectoryHandle); + } + } + + void poll() { + if (!mRunning) { + return; + } + + // Asynchronously wait for changes. + int success = ReadDirectoryChangesW( + mDirectoryHandle, + mWriteBuffer.data(), + static_cast(mWriteBuffer.size()), + TRUE, // recursive + FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_ATTRIBUTES + | FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE, + NULL, + &mOverlapped, + [](DWORD errorCode, DWORD numBytes, LPOVERLAPPED overlapped) { + auto subscription = reinterpret_cast(overlapped->hEvent); + try { + subscription->processEvents(errorCode); + } catch (WatcherError &err) { + subscription->mBackend->handleWatcherError(err); + } + } + ); + + if (!success) { + throw WatcherError("Failed to read changes", mWatcher); + } + } + + void processEvents(DWORD errorCode) { + if (!mRunning) { + return; + } + + switch (errorCode) { + case ERROR_OPERATION_ABORTED: + return; + case ERROR_INVALID_PARAMETER: + // resize buffers to network size (64kb), and try again + mReadBuffer.resize(NETWORK_BUF_SIZE); + mWriteBuffer.resize(NETWORK_BUF_SIZE); + poll(); + return; + case ERROR_NOTIFY_ENUM_DIR: + throw WatcherError("Buffer overflow. Some events may have been lost.", mWatcher); + case ERROR_ACCESS_DENIED: { + // This can happen if the watched directory is deleted. Check if that is the case, + // and if so emit a delete event. Otherwise, fall through to default error case. + DWORD attrs = GetFileAttributesW(utf8ToUtf16(mWatcher->mDir).data()); + bool isDir = attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY); + if (!isDir) { + mWatcher->mEvents.remove(mWatcher->mDir); + mTree->remove(mWatcher->mDir); + mWatcher->notify(); + stop(); + return; + } + } + default: + if (errorCode != ERROR_SUCCESS) { + throw WatcherError("Unknown error", mWatcher); + } + } + + // Swap read and write buffers, and poll again + std::swap(mWriteBuffer, mReadBuffer); + poll(); + + // Read change events + BYTE *base = mReadBuffer.data(); + while (true) { + PFILE_NOTIFY_INFORMATION info = (PFILE_NOTIFY_INFORMATION)base; + processEvent(info); + + if (info->NextEntryOffset == 0) { + break; + } + + base += info->NextEntryOffset; + } + + mWatcher->notify(); + } + + void processEvent(PFILE_NOTIFY_INFORMATION info) { + std::string path = mWatcher->mDir + "\\" + utf16ToUtf8(info->FileName, info->FileNameLength / sizeof(WCHAR)); + if (mWatcher->isIgnored(path)) { + return; + } + + switch (info->Action) { + case FILE_ACTION_ADDED: + case FILE_ACTION_RENAMED_NEW_NAME: { + WIN32_FILE_ATTRIBUTE_DATA data; + if (GetFileAttributesExW(utf8ToUtf16(path).data(), GetFileExInfoStandard, &data)) { + mWatcher->mEvents.create(path); + mTree->add(path, CONVERT_TIME(data.ftLastWriteTime), data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY); + } + break; + } + case FILE_ACTION_MODIFIED: { + WIN32_FILE_ATTRIBUTE_DATA data; + if (GetFileAttributesExW(utf8ToUtf16(path).data(), GetFileExInfoStandard, &data)) { + mTree->update(path, CONVERT_TIME(data.ftLastWriteTime)); + if (!(data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { + mWatcher->mEvents.update(path); + } + } + break; + } + case FILE_ACTION_REMOVED: + case FILE_ACTION_RENAMED_OLD_NAME: + mWatcher->mEvents.remove(path); + mTree->remove(path); + break; + } + } + +private: + WindowsBackend *mBackend; + std::shared_ptr mWatcher; + std::shared_ptr mTree; + bool mRunning; + HANDLE mDirectoryHandle; + std::vector mReadBuffer; + std::vector mWriteBuffer; + OVERLAPPED mOverlapped; +}; + +// This function is called by Backend::watch which takes a lock on mMutex +void WindowsBackend::subscribe(WatcherRef watcher) { + // Create a subscription for this watcher + auto sub = std::make_shared(this, watcher, getTree(watcher, false)); + watcher->state = sub; + + // Queue polling for this subscription in the correct thread. + bool success = QueueUserAPC([](__in ULONG_PTR ptr) { + Subscription *sub = (Subscription *)ptr; + sub->run(); + }, mThread.native_handle(), (ULONG_PTR)sub.get()); + + if (!success) { + throw std::runtime_error("Unable to queue APC"); + } +} + +// This function is called by Backend::unwatch which takes a lock on mMutex +void WindowsBackend::unsubscribe(WatcherRef watcher) { + watcher->state = nullptr; +} diff --git a/node_modules/@parcel/watcher/src/windows/WindowsBackend.hh b/node_modules/@parcel/watcher/src/windows/WindowsBackend.hh new file mode 100644 index 0000000..d679782 --- /dev/null +++ b/node_modules/@parcel/watcher/src/windows/WindowsBackend.hh @@ -0,0 +1,18 @@ +#ifndef WINDOWS_H +#define WINDOWS_H + +#include +#include +#include "../shared/BruteForceBackend.hh" + +class WindowsBackend : public BruteForceBackend { +public: + void start() override; + ~WindowsBackend(); + void subscribe(WatcherRef watcher) override; + void unsubscribe(WatcherRef watcher) override; +private: + bool mRunning; +}; + +#endif diff --git a/node_modules/@parcel/watcher/src/windows/win_utils.cc b/node_modules/@parcel/watcher/src/windows/win_utils.cc new file mode 100644 index 0000000..986690f --- /dev/null +++ b/node_modules/@parcel/watcher/src/windows/win_utils.cc @@ -0,0 +1,44 @@ +#include "./win_utils.hh" + +std::wstring utf8ToUtf16(std::string input) { + unsigned int len = MultiByteToWideChar(CP_UTF8, 0, input.c_str(), -1, NULL, 0); + WCHAR *output = new WCHAR[len]; + MultiByteToWideChar(CP_UTF8, 0, input.c_str(), -1, output, len); + std::wstring res(output); + delete output; + return res; +} + +std::string utf16ToUtf8(const WCHAR *input, size_t length) { + unsigned int len = WideCharToMultiByte(CP_UTF8, 0, input, length, NULL, 0, NULL, NULL); + char *output = new char[len + 1]; + WideCharToMultiByte(CP_UTF8, 0, input, length, output, len, NULL, NULL); + output[len] = '\0'; + std::string res(output); + delete output; + return res; +} + +std::string normalizePath(std::string path) { + // Prevent truncation to MAX_PATH characters by adding the \\?\ prefix + std::wstring p = utf8ToUtf16("\\\\?\\" + path); + + // Get the required length for the output + unsigned int len = GetLongPathNameW(p.data(), NULL, 0); + if (!len) { + return path; + } + + // Allocate output array and get long path + WCHAR *output = new WCHAR[len]; + len = GetLongPathNameW(p.data(), output, len); + if (!len) { + delete output; + return path; + } + + // Convert back to utf8 + std::string res = utf16ToUtf8(output + 4, len - 4); + delete output; + return res; +} diff --git a/node_modules/@parcel/watcher/src/windows/win_utils.hh b/node_modules/@parcel/watcher/src/windows/win_utils.hh new file mode 100644 index 0000000..2313493 --- /dev/null +++ b/node_modules/@parcel/watcher/src/windows/win_utils.hh @@ -0,0 +1,11 @@ +#ifndef WIN_UTILS_H +#define WIN_UTILS_H + +#include +#include + +std::wstring utf8ToUtf16(std::string input); +std::string utf16ToUtf8(const WCHAR *input, size_t length); +std::string normalizePath(std::string path); + +#endif diff --git a/node_modules/@parcel/watcher/wrapper.js b/node_modules/@parcel/watcher/wrapper.js new file mode 100644 index 0000000..496d56b --- /dev/null +++ b/node_modules/@parcel/watcher/wrapper.js @@ -0,0 +1,77 @@ +const path = require('path'); +const micromatch = require('micromatch'); +const isGlob = require('is-glob'); + +function normalizeOptions(dir, opts = {}) { + const { ignore, ...rest } = opts; + + if (Array.isArray(ignore)) { + opts = { ...rest }; + + for (const value of ignore) { + if (isGlob(value)) { + if (!opts.ignoreGlobs) { + opts.ignoreGlobs = []; + } + + const regex = micromatch.makeRe(value, { + // We set `dot: true` to workaround an issue with the + // regular expression on Linux where the resulting + // negative lookahead `(?!(\\/|^)` was never matching + // in some cases. See also https://bit.ly/3UZlQDm + dot: true, + // C++ does not support lookbehind regex patterns, they + // were only added later to JavaScript engines + // (https://bit.ly/3V7S6UL) + lookbehinds: false + }); + opts.ignoreGlobs.push(regex.source); + } else { + if (!opts.ignorePaths) { + opts.ignorePaths = []; + } + + opts.ignorePaths.push(path.resolve(dir, value)); + } + } + } + + return opts; +} + +exports.createWrapper = (binding) => { + return { + writeSnapshot(dir, snapshot, opts) { + return binding.writeSnapshot( + path.resolve(dir), + path.resolve(snapshot), + normalizeOptions(dir, opts), + ); + }, + getEventsSince(dir, snapshot, opts) { + return binding.getEventsSince( + path.resolve(dir), + path.resolve(snapshot), + normalizeOptions(dir, opts), + ); + }, + async subscribe(dir, fn, opts) { + dir = path.resolve(dir); + opts = normalizeOptions(dir, opts); + await binding.subscribe(dir, fn, opts); + + return { + unsubscribe() { + return binding.unsubscribe(dir, fn, opts); + }, + }; + }, + unsubscribe(dir, fn, opts) { + return binding.unsubscribe( + path.resolve(dir), + fn, + normalizeOptions(dir, opts), + ); + } + }; +}; diff --git a/node_modules/braces/LICENSE b/node_modules/braces/LICENSE new file mode 100644 index 0000000..9af4a67 --- /dev/null +++ b/node_modules/braces/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014-present, Jon Schlinkert. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/braces/README.md b/node_modules/braces/README.md new file mode 100644 index 0000000..f59dd60 --- /dev/null +++ b/node_modules/braces/README.md @@ -0,0 +1,586 @@ +# braces [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=W8YFZ425KND68) [![NPM version](https://img.shields.io/npm/v/braces.svg?style=flat)](https://www.npmjs.com/package/braces) [![NPM monthly downloads](https://img.shields.io/npm/dm/braces.svg?style=flat)](https://npmjs.org/package/braces) [![NPM total downloads](https://img.shields.io/npm/dt/braces.svg?style=flat)](https://npmjs.org/package/braces) [![Linux Build Status](https://img.shields.io/travis/micromatch/braces.svg?style=flat&label=Travis)](https://travis-ci.org/micromatch/braces) + +> Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support for the Bash 4.3 braces specification, without sacrificing speed. + +Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support. + +## Install + +Install with [npm](https://www.npmjs.com/): + +```sh +$ npm install --save braces +``` + +## v3.0.0 Released!! + +See the [changelog](CHANGELOG.md) for details. + +## Why use braces? + +Brace patterns make globs more powerful by adding the ability to match specific ranges and sequences of characters. + +- **Accurate** - complete support for the [Bash 4.3 Brace Expansion](www.gnu.org/software/bash/) specification (passes all of the Bash braces tests) +- **[fast and performant](#benchmarks)** - Starts fast, runs fast and [scales well](#performance) as patterns increase in complexity. +- **Organized code base** - The parser and compiler are easy to maintain and update when edge cases crop up. +- **Well-tested** - Thousands of test assertions, and passes all of the Bash, minimatch, and [brace-expansion](https://github.com/juliangruber/brace-expansion) unit tests (as of the date this was written). +- **Safer** - You shouldn't have to worry about users defining aggressive or malicious brace patterns that can break your application. Braces takes measures to prevent malicious regex that can be used for DDoS attacks (see [catastrophic backtracking](https://www.regular-expressions.info/catastrophic.html)). +- [Supports lists](#lists) - (aka "sets") `a/{b,c}/d` => `['a/b/d', 'a/c/d']` +- [Supports sequences](#sequences) - (aka "ranges") `{01..03}` => `['01', '02', '03']` +- [Supports steps](#steps) - (aka "increments") `{2..10..2}` => `['2', '4', '6', '8', '10']` +- [Supports escaping](#escaping) - To prevent evaluation of special characters. + +## Usage + +The main export is a function that takes one or more brace `patterns` and `options`. + +```js +const braces = require('braces'); +// braces(patterns[, options]); + +console.log(braces(['{01..05}', '{a..e}'])); +//=> ['(0[1-5])', '([a-e])'] + +console.log(braces(['{01..05}', '{a..e}'], { expand: true })); +//=> ['01', '02', '03', '04', '05', 'a', 'b', 'c', 'd', 'e'] +``` + +### Brace Expansion vs. Compilation + +By default, brace patterns are compiled into strings that are optimized for creating regular expressions and matching. + +**Compiled** + +```js +console.log(braces('a/{x,y,z}/b')); +//=> ['a/(x|y|z)/b'] +console.log(braces(['a/{01..20}/b', 'a/{1..5}/b'])); +//=> [ 'a/(0[1-9]|1[0-9]|20)/b', 'a/([1-5])/b' ] +``` + +**Expanded** + +Enable brace expansion by setting the `expand` option to true, or by using [braces.expand()](#expand) (returns an array similar to what you'd expect from Bash, or `echo {1..5}`, or [minimatch](https://github.com/isaacs/minimatch)): + +```js +console.log(braces('a/{x,y,z}/b', { expand: true })); +//=> ['a/x/b', 'a/y/b', 'a/z/b'] + +console.log(braces.expand('{01..10}')); +//=> ['01','02','03','04','05','06','07','08','09','10'] +``` + +### Lists + +Expand lists (like Bash "sets"): + +```js +console.log(braces('a/{foo,bar,baz}/*.js')); +//=> ['a/(foo|bar|baz)/*.js'] + +console.log(braces.expand('a/{foo,bar,baz}/*.js')); +//=> ['a/foo/*.js', 'a/bar/*.js', 'a/baz/*.js'] +``` + +### Sequences + +Expand ranges of characters (like Bash "sequences"): + +```js +console.log(braces.expand('{1..3}')); // ['1', '2', '3'] +console.log(braces.expand('a/{1..3}/b')); // ['a/1/b', 'a/2/b', 'a/3/b'] +console.log(braces('{a..c}', { expand: true })); // ['a', 'b', 'c'] +console.log(braces('foo/{a..c}', { expand: true })); // ['foo/a', 'foo/b', 'foo/c'] + +// supports zero-padded ranges +console.log(braces('a/{01..03}/b')); //=> ['a/(0[1-3])/b'] +console.log(braces('a/{001..300}/b')); //=> ['a/(0{2}[1-9]|0[1-9][0-9]|[12][0-9]{2}|300)/b'] +``` + +See [fill-range](https://github.com/jonschlinkert/fill-range) for all available range-expansion options. + +### Steppped ranges + +Steps, or increments, may be used with ranges: + +```js +console.log(braces.expand('{2..10..2}')); +//=> ['2', '4', '6', '8', '10'] + +console.log(braces('{2..10..2}')); +//=> ['(2|4|6|8|10)'] +``` + +When the [.optimize](#optimize) method is used, or [options.optimize](#optionsoptimize) is set to true, sequences are passed to [to-regex-range](https://github.com/jonschlinkert/to-regex-range) for expansion. + +### Nesting + +Brace patterns may be nested. The results of each expanded string are not sorted, and left to right order is preserved. + +**"Expanded" braces** + +```js +console.log(braces.expand('a{b,c,/{x,y}}/e')); +//=> ['ab/e', 'ac/e', 'a/x/e', 'a/y/e'] + +console.log(braces.expand('a/{x,{1..5},y}/c')); +//=> ['a/x/c', 'a/1/c', 'a/2/c', 'a/3/c', 'a/4/c', 'a/5/c', 'a/y/c'] +``` + +**"Optimized" braces** + +```js +console.log(braces('a{b,c,/{x,y}}/e')); +//=> ['a(b|c|/(x|y))/e'] + +console.log(braces('a/{x,{1..5},y}/c')); +//=> ['a/(x|([1-5])|y)/c'] +``` + +### Escaping + +**Escaping braces** + +A brace pattern will not be expanded or evaluted if _either the opening or closing brace is escaped_: + +```js +console.log(braces.expand('a\\{d,c,b}e')); +//=> ['a{d,c,b}e'] + +console.log(braces.expand('a{d,c,b\\}e')); +//=> ['a{d,c,b}e'] +``` + +**Escaping commas** + +Commas inside braces may also be escaped: + +```js +console.log(braces.expand('a{b\\,c}d')); +//=> ['a{b,c}d'] + +console.log(braces.expand('a{d\\,c,b}e')); +//=> ['ad,ce', 'abe'] +``` + +**Single items** + +Following bash conventions, a brace pattern is also not expanded when it contains a single character: + +```js +console.log(braces.expand('a{b}c')); +//=> ['a{b}c'] +``` + +## Options + +### options.maxLength + +**Type**: `Number` + +**Default**: `10,000` + +**Description**: Limit the length of the input string. Useful when the input string is generated or your application allows users to pass a string, et cetera. + +```js +console.log(braces('a/{b,c}/d', { maxLength: 3 })); //=> throws an error +``` + +### options.expand + +**Type**: `Boolean` + +**Default**: `undefined` + +**Description**: Generate an "expanded" brace pattern (alternatively you can use the `braces.expand()` method, which does the same thing). + +```js +console.log(braces('a/{b,c}/d', { expand: true })); +//=> [ 'a/b/d', 'a/c/d' ] +``` + +### options.nodupes + +**Type**: `Boolean` + +**Default**: `undefined` + +**Description**: Remove duplicates from the returned array. + +### options.rangeLimit + +**Type**: `Number` + +**Default**: `1000` + +**Description**: To prevent malicious patterns from being passed by users, an error is thrown when `braces.expand()` is used or `options.expand` is true and the generated range will exceed the `rangeLimit`. + +You can customize `options.rangeLimit` or set it to `Inifinity` to disable this altogether. + +**Examples** + +```js +// pattern exceeds the "rangeLimit", so it's optimized automatically +console.log(braces.expand('{1..1000}')); +//=> ['([1-9]|[1-9][0-9]{1,2}|1000)'] + +// pattern does not exceed "rangeLimit", so it's NOT optimized +console.log(braces.expand('{1..100}')); +//=> ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', '100'] +``` + +### options.transform + +**Type**: `Function` + +**Default**: `undefined` + +**Description**: Customize range expansion. + +**Example: Transforming non-numeric values** + +```js +const alpha = braces.expand('x/{a..e}/y', { + transform(value, index) { + // When non-numeric values are passed, "value" is a character code. + return 'foo/' + String.fromCharCode(value) + '-' + index; + }, +}); +console.log(alpha); +//=> [ 'x/foo/a-0/y', 'x/foo/b-1/y', 'x/foo/c-2/y', 'x/foo/d-3/y', 'x/foo/e-4/y' ] +``` + +**Example: Transforming numeric values** + +```js +const numeric = braces.expand('{1..5}', { + transform(value) { + // when numeric values are passed, "value" is a number + return 'foo/' + value * 2; + }, +}); +console.log(numeric); +//=> [ 'foo/2', 'foo/4', 'foo/6', 'foo/8', 'foo/10' ] +``` + +### options.quantifiers + +**Type**: `Boolean` + +**Default**: `undefined` + +**Description**: In regular expressions, quanitifiers can be used to specify how many times a token can be repeated. For example, `a{1,3}` will match the letter `a` one to three times. + +Unfortunately, regex quantifiers happen to share the same syntax as [Bash lists](#lists) + +The `quantifiers` option tells braces to detect when [regex quantifiers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#quantifiers) are defined in the given pattern, and not to try to expand them as lists. + +**Examples** + +```js +const braces = require('braces'); +console.log(braces('a/b{1,3}/{x,y,z}')); +//=> [ 'a/b(1|3)/(x|y|z)' ] +console.log(braces('a/b{1,3}/{x,y,z}', { quantifiers: true })); +//=> [ 'a/b{1,3}/(x|y|z)' ] +console.log(braces('a/b{1,3}/{x,y,z}', { quantifiers: true, expand: true })); +//=> [ 'a/b{1,3}/x', 'a/b{1,3}/y', 'a/b{1,3}/z' ] +``` + +### options.keepEscaping + +**Type**: `Boolean` + +**Default**: `undefined` + +**Description**: Do not strip backslashes that were used for escaping from the result. + +## What is "brace expansion"? + +Brace expansion is a type of parameter expansion that was made popular by unix shells for generating lists of strings, as well as regex-like matching when used alongside wildcards (globs). + +In addition to "expansion", braces are also used for matching. In other words: + +- [brace expansion](#brace-expansion) is for generating new lists +- [brace matching](#brace-matching) is for filtering existing lists + +
+More about brace expansion (click to expand) + +There are two main types of brace expansion: + +1. **lists**: which are defined using comma-separated values inside curly braces: `{a,b,c}` +2. **sequences**: which are defined using a starting value and an ending value, separated by two dots: `a{1..3}b`. Optionally, a third argument may be passed to define a "step" or increment to use: `a{1..100..10}b`. These are also sometimes referred to as "ranges". + +Here are some example brace patterns to illustrate how they work: + +**Sets** + +``` +{a,b,c} => a b c +{a,b,c}{1,2} => a1 a2 b1 b2 c1 c2 +``` + +**Sequences** + +``` +{1..9} => 1 2 3 4 5 6 7 8 9 +{4..-4} => 4 3 2 1 0 -1 -2 -3 -4 +{1..20..3} => 1 4 7 10 13 16 19 +{a..j} => a b c d e f g h i j +{j..a} => j i h g f e d c b a +{a..z..3} => a d g j m p s v y +``` + +**Combination** + +Sets and sequences can be mixed together or used along with any other strings. + +``` +{a,b,c}{1..3} => a1 a2 a3 b1 b2 b3 c1 c2 c3 +foo/{a,b,c}/bar => foo/a/bar foo/b/bar foo/c/bar +``` + +The fact that braces can be "expanded" from relatively simple patterns makes them ideal for quickly generating test fixtures, file paths, and similar use cases. + +## Brace matching + +In addition to _expansion_, brace patterns are also useful for performing regular-expression-like matching. + +For example, the pattern `foo/{1..3}/bar` would match any of following strings: + +``` +foo/1/bar +foo/2/bar +foo/3/bar +``` + +But not: + +``` +baz/1/qux +baz/2/qux +baz/3/qux +``` + +Braces can also be combined with [glob patterns](https://github.com/jonschlinkert/micromatch) to perform more advanced wildcard matching. For example, the pattern `*/{1..3}/*` would match any of following strings: + +``` +foo/1/bar +foo/2/bar +foo/3/bar +baz/1/qux +baz/2/qux +baz/3/qux +``` + +## Brace matching pitfalls + +Although brace patterns offer a user-friendly way of matching ranges or sets of strings, there are also some major disadvantages and potential risks you should be aware of. + +### tldr + +**"brace bombs"** + +- brace expansion can eat up a huge amount of processing resources +- as brace patterns increase _linearly in size_, the system resources required to expand the pattern increase exponentially +- users can accidentally (or intentially) exhaust your system's resources resulting in the equivalent of a DoS attack (bonus: no programming knowledge is required!) + +For a more detailed explanation with examples, see the [geometric complexity](#geometric-complexity) section. + +### The solution + +Jump to the [performance section](#performance) to see how Braces solves this problem in comparison to other libraries. + +### Geometric complexity + +At minimum, brace patterns with sets limited to two elements have quadradic or `O(n^2)` complexity. But the complexity of the algorithm increases exponentially as the number of sets, _and elements per set_, increases, which is `O(n^c)`. + +For example, the following sets demonstrate quadratic (`O(n^2)`) complexity: + +``` +{1,2}{3,4} => (2X2) => 13 14 23 24 +{1,2}{3,4}{5,6} => (2X2X2) => 135 136 145 146 235 236 245 246 +``` + +But add an element to a set, and we get a n-fold Cartesian product with `O(n^c)` complexity: + +``` +{1,2,3}{4,5,6}{7,8,9} => (3X3X3) => 147 148 149 157 158 159 167 168 169 247 248 + 249 257 258 259 267 268 269 347 348 349 357 + 358 359 367 368 369 +``` + +Now, imagine how this complexity grows given that each element is a n-tuple: + +``` +{1..100}{1..100} => (100X100) => 10,000 elements (38.4 kB) +{1..100}{1..100}{1..100} => (100X100X100) => 1,000,000 elements (5.76 MB) +``` + +Although these examples are clearly contrived, they demonstrate how brace patterns can quickly grow out of control. + +**More information** + +Interested in learning more about brace expansion? + +- [linuxjournal/bash-brace-expansion](http://www.linuxjournal.com/content/bash-brace-expansion) +- [rosettacode/Brace_expansion](https://rosettacode.org/wiki/Brace_expansion) +- [cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) + +
+ +## Performance + +Braces is not only screaming fast, it's also more accurate the other brace expansion libraries. + +### Better algorithms + +Fortunately there is a solution to the ["brace bomb" problem](#brace-matching-pitfalls): _don't expand brace patterns into an array when they're used for matching_. + +Instead, convert the pattern into an optimized regular expression. This is easier said than done, and braces is the only library that does this currently. + +**The proof is in the numbers** + +Minimatch gets exponentially slower as patterns increase in complexity, braces does not. The following results were generated using `braces()` and `minimatch.braceExpand()`, respectively. + +| **Pattern** | **braces** | **[minimatch][]** | +| --------------------------- | ------------------- | ---------------------------- | +| `{1..9007199254740991}`[^1] | `298 B` (5ms 459μs) | N/A (freezes) | +| `{1..1000000000000000}` | `41 B` (1ms 15μs) | N/A (freezes) | +| `{1..100000000000000}` | `40 B` (890μs) | N/A (freezes) | +| `{1..10000000000000}` | `39 B` (2ms 49μs) | N/A (freezes) | +| `{1..1000000000000}` | `38 B` (608μs) | N/A (freezes) | +| `{1..100000000000}` | `37 B` (397μs) | N/A (freezes) | +| `{1..10000000000}` | `35 B` (983μs) | N/A (freezes) | +| `{1..1000000000}` | `34 B` (798μs) | N/A (freezes) | +| `{1..100000000}` | `33 B` (733μs) | N/A (freezes) | +| `{1..10000000}` | `32 B` (5ms 632μs) | `78.89 MB` (16s 388ms 569μs) | +| `{1..1000000}` | `31 B` (1ms 381μs) | `6.89 MB` (1s 496ms 887μs) | +| `{1..100000}` | `30 B` (950μs) | `588.89 kB` (146ms 921μs) | +| `{1..10000}` | `29 B` (1ms 114μs) | `48.89 kB` (14ms 187μs) | +| `{1..1000}` | `28 B` (760μs) | `3.89 kB` (1ms 453μs) | +| `{1..100}` | `22 B` (345μs) | `291 B` (196μs) | +| `{1..10}` | `10 B` (533μs) | `20 B` (37μs) | +| `{1..3}` | `7 B` (190μs) | `5 B` (27μs) | + +### Faster algorithms + +When you need expansion, braces is still much faster. + +_(the following results were generated using `braces.expand()` and `minimatch.braceExpand()`, respectively)_ + +| **Pattern** | **braces** | **[minimatch][]** | +| --------------- | --------------------------- | ---------------------------- | +| `{1..10000000}` | `78.89 MB` (2s 698ms 642μs) | `78.89 MB` (18s 601ms 974μs) | +| `{1..1000000}` | `6.89 MB` (458ms 576μs) | `6.89 MB` (1s 491ms 621μs) | +| `{1..100000}` | `588.89 kB` (20ms 728μs) | `588.89 kB` (156ms 919μs) | +| `{1..10000}` | `48.89 kB` (2ms 202μs) | `48.89 kB` (13ms 641μs) | +| `{1..1000}` | `3.89 kB` (1ms 796μs) | `3.89 kB` (1ms 958μs) | +| `{1..100}` | `291 B` (424μs) | `291 B` (211μs) | +| `{1..10}` | `20 B` (487μs) | `20 B` (72μs) | +| `{1..3}` | `5 B` (166μs) | `5 B` (27μs) | + +If you'd like to run these comparisons yourself, see [test/support/generate.js](test/support/generate.js). + +## Benchmarks + +### Running benchmarks + +Install dev dependencies: + +```bash +npm i -d && npm benchmark +``` + +### Latest results + +Braces is more accurate, without sacrificing performance. + +```bash +● expand - range (expanded) + braces x 53,167 ops/sec ±0.12% (102 runs sampled) + minimatch x 11,378 ops/sec ±0.10% (102 runs sampled) +● expand - range (optimized for regex) + braces x 373,442 ops/sec ±0.04% (100 runs sampled) + minimatch x 3,262 ops/sec ±0.18% (100 runs sampled) +● expand - nested ranges (expanded) + braces x 33,921 ops/sec ±0.09% (99 runs sampled) + minimatch x 10,855 ops/sec ±0.28% (100 runs sampled) +● expand - nested ranges (optimized for regex) + braces x 287,479 ops/sec ±0.52% (98 runs sampled) + minimatch x 3,219 ops/sec ±0.28% (101 runs sampled) +● expand - set (expanded) + braces x 238,243 ops/sec ±0.19% (97 runs sampled) + minimatch x 538,268 ops/sec ±0.31% (96 runs sampled) +● expand - set (optimized for regex) + braces x 321,844 ops/sec ±0.10% (97 runs sampled) + minimatch x 140,600 ops/sec ±0.15% (100 runs sampled) +● expand - nested sets (expanded) + braces x 165,371 ops/sec ±0.42% (96 runs sampled) + minimatch x 337,720 ops/sec ±0.28% (100 runs sampled) +● expand - nested sets (optimized for regex) + braces x 242,948 ops/sec ±0.12% (99 runs sampled) + minimatch x 87,403 ops/sec ±0.79% (96 runs sampled) +``` + +## About + +
+Contributing + +Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new). + +
+ +
+Running Tests + +Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command: + +```sh +$ npm install && npm test +``` + +
+ +
+Building docs + +_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_ + +To generate the readme, run the following command: + +```sh +$ npm install -g verbose/verb#dev verb-generate-readme && verb +``` + +
+ +### Contributors + +| **Commits** | **Contributor** | +| ----------- | ------------------------------------------------------------- | +| 197 | [jonschlinkert](https://github.com/jonschlinkert) | +| 4 | [doowb](https://github.com/doowb) | +| 1 | [es128](https://github.com/es128) | +| 1 | [eush77](https://github.com/eush77) | +| 1 | [hemanth](https://github.com/hemanth) | +| 1 | [wtgtybhertgeghgtwtg](https://github.com/wtgtybhertgeghgtwtg) | + +### Author + +**Jon Schlinkert** + +- [GitHub Profile](https://github.com/jonschlinkert) +- [Twitter Profile](https://twitter.com/jonschlinkert) +- [LinkedIn Profile](https://linkedin.com/in/jonschlinkert) + +### License + +Copyright © 2019, [Jon Schlinkert](https://github.com/jonschlinkert). +Released under the [MIT License](LICENSE). + +--- + +_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on April 08, 2019._ diff --git a/node_modules/braces/index.js b/node_modules/braces/index.js new file mode 100644 index 0000000..d222c13 --- /dev/null +++ b/node_modules/braces/index.js @@ -0,0 +1,170 @@ +'use strict'; + +const stringify = require('./lib/stringify'); +const compile = require('./lib/compile'); +const expand = require('./lib/expand'); +const parse = require('./lib/parse'); + +/** + * Expand the given pattern or create a regex-compatible string. + * + * ```js + * const braces = require('braces'); + * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)'] + * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c'] + * ``` + * @param {String} `str` + * @param {Object} `options` + * @return {String} + * @api public + */ + +const braces = (input, options = {}) => { + let output = []; + + if (Array.isArray(input)) { + for (const pattern of input) { + const result = braces.create(pattern, options); + if (Array.isArray(result)) { + output.push(...result); + } else { + output.push(result); + } + } + } else { + output = [].concat(braces.create(input, options)); + } + + if (options && options.expand === true && options.nodupes === true) { + output = [...new Set(output)]; + } + return output; +}; + +/** + * Parse the given `str` with the given `options`. + * + * ```js + * // braces.parse(pattern, [, options]); + * const ast = braces.parse('a/{b,c}/d'); + * console.log(ast); + * ``` + * @param {String} pattern Brace pattern to parse + * @param {Object} options + * @return {Object} Returns an AST + * @api public + */ + +braces.parse = (input, options = {}) => parse(input, options); + +/** + * Creates a braces string from an AST, or an AST node. + * + * ```js + * const braces = require('braces'); + * let ast = braces.parse('foo/{a,b}/bar'); + * console.log(stringify(ast.nodes[2])); //=> '{a,b}' + * ``` + * @param {String} `input` Brace pattern or AST. + * @param {Object} `options` + * @return {Array} Returns an array of expanded values. + * @api public + */ + +braces.stringify = (input, options = {}) => { + if (typeof input === 'string') { + return stringify(braces.parse(input, options), options); + } + return stringify(input, options); +}; + +/** + * Compiles a brace pattern into a regex-compatible, optimized string. + * This method is called by the main [braces](#braces) function by default. + * + * ```js + * const braces = require('braces'); + * console.log(braces.compile('a/{b,c}/d')); + * //=> ['a/(b|c)/d'] + * ``` + * @param {String} `input` Brace pattern or AST. + * @param {Object} `options` + * @return {Array} Returns an array of expanded values. + * @api public + */ + +braces.compile = (input, options = {}) => { + if (typeof input === 'string') { + input = braces.parse(input, options); + } + return compile(input, options); +}; + +/** + * Expands a brace pattern into an array. This method is called by the + * main [braces](#braces) function when `options.expand` is true. Before + * using this method it's recommended that you read the [performance notes](#performance)) + * and advantages of using [.compile](#compile) instead. + * + * ```js + * const braces = require('braces'); + * console.log(braces.expand('a/{b,c}/d')); + * //=> ['a/b/d', 'a/c/d']; + * ``` + * @param {String} `pattern` Brace pattern + * @param {Object} `options` + * @return {Array} Returns an array of expanded values. + * @api public + */ + +braces.expand = (input, options = {}) => { + if (typeof input === 'string') { + input = braces.parse(input, options); + } + + let result = expand(input, options); + + // filter out empty strings if specified + if (options.noempty === true) { + result = result.filter(Boolean); + } + + // filter out duplicates if specified + if (options.nodupes === true) { + result = [...new Set(result)]; + } + + return result; +}; + +/** + * Processes a brace pattern and returns either an expanded array + * (if `options.expand` is true), a highly optimized regex-compatible string. + * This method is called by the main [braces](#braces) function. + * + * ```js + * const braces = require('braces'); + * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}')) + * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)' + * ``` + * @param {String} `pattern` Brace pattern + * @param {Object} `options` + * @return {Array} Returns an array of expanded values. + * @api public + */ + +braces.create = (input, options = {}) => { + if (input === '' || input.length < 3) { + return [input]; + } + + return options.expand !== true + ? braces.compile(input, options) + : braces.expand(input, options); +}; + +/** + * Expose "braces" + */ + +module.exports = braces; diff --git a/node_modules/braces/lib/compile.js b/node_modules/braces/lib/compile.js new file mode 100644 index 0000000..dce69be --- /dev/null +++ b/node_modules/braces/lib/compile.js @@ -0,0 +1,60 @@ +'use strict'; + +const fill = require('fill-range'); +const utils = require('./utils'); + +const compile = (ast, options = {}) => { + const walk = (node, parent = {}) => { + const invalidBlock = utils.isInvalidBrace(parent); + const invalidNode = node.invalid === true && options.escapeInvalid === true; + const invalid = invalidBlock === true || invalidNode === true; + const prefix = options.escapeInvalid === true ? '\\' : ''; + let output = ''; + + if (node.isOpen === true) { + return prefix + node.value; + } + + if (node.isClose === true) { + console.log('node.isClose', prefix, node.value); + return prefix + node.value; + } + + if (node.type === 'open') { + return invalid ? prefix + node.value : '('; + } + + if (node.type === 'close') { + return invalid ? prefix + node.value : ')'; + } + + if (node.type === 'comma') { + return node.prev.type === 'comma' ? '' : invalid ? node.value : '|'; + } + + if (node.value) { + return node.value; + } + + if (node.nodes && node.ranges > 0) { + const args = utils.reduce(node.nodes); + const range = fill(...args, { ...options, wrap: false, toRegex: true, strictZeros: true }); + + if (range.length !== 0) { + return args.length > 1 && range.length > 1 ? `(${range})` : range; + } + } + + if (node.nodes) { + for (const child of node.nodes) { + output += walk(child, node); + } + } + + return output; + }; + + return walk(ast); +}; + +module.exports = compile; diff --git a/node_modules/braces/lib/constants.js b/node_modules/braces/lib/constants.js new file mode 100644 index 0000000..2bb3b88 --- /dev/null +++ b/node_modules/braces/lib/constants.js @@ -0,0 +1,57 @@ +'use strict'; + +module.exports = { + MAX_LENGTH: 10000, + + // Digits + CHAR_0: '0', /* 0 */ + CHAR_9: '9', /* 9 */ + + // Alphabet chars. + CHAR_UPPERCASE_A: 'A', /* A */ + CHAR_LOWERCASE_A: 'a', /* a */ + CHAR_UPPERCASE_Z: 'Z', /* Z */ + CHAR_LOWERCASE_Z: 'z', /* z */ + + CHAR_LEFT_PARENTHESES: '(', /* ( */ + CHAR_RIGHT_PARENTHESES: ')', /* ) */ + + CHAR_ASTERISK: '*', /* * */ + + // Non-alphabetic chars. + CHAR_AMPERSAND: '&', /* & */ + CHAR_AT: '@', /* @ */ + CHAR_BACKSLASH: '\\', /* \ */ + CHAR_BACKTICK: '`', /* ` */ + CHAR_CARRIAGE_RETURN: '\r', /* \r */ + CHAR_CIRCUMFLEX_ACCENT: '^', /* ^ */ + CHAR_COLON: ':', /* : */ + CHAR_COMMA: ',', /* , */ + CHAR_DOLLAR: '$', /* . */ + CHAR_DOT: '.', /* . */ + CHAR_DOUBLE_QUOTE: '"', /* " */ + CHAR_EQUAL: '=', /* = */ + CHAR_EXCLAMATION_MARK: '!', /* ! */ + CHAR_FORM_FEED: '\f', /* \f */ + CHAR_FORWARD_SLASH: '/', /* / */ + CHAR_HASH: '#', /* # */ + CHAR_HYPHEN_MINUS: '-', /* - */ + CHAR_LEFT_ANGLE_BRACKET: '<', /* < */ + CHAR_LEFT_CURLY_BRACE: '{', /* { */ + CHAR_LEFT_SQUARE_BRACKET: '[', /* [ */ + CHAR_LINE_FEED: '\n', /* \n */ + CHAR_NO_BREAK_SPACE: '\u00A0', /* \u00A0 */ + CHAR_PERCENT: '%', /* % */ + CHAR_PLUS: '+', /* + */ + CHAR_QUESTION_MARK: '?', /* ? */ + CHAR_RIGHT_ANGLE_BRACKET: '>', /* > */ + CHAR_RIGHT_CURLY_BRACE: '}', /* } */ + CHAR_RIGHT_SQUARE_BRACKET: ']', /* ] */ + CHAR_SEMICOLON: ';', /* ; */ + CHAR_SINGLE_QUOTE: '\'', /* ' */ + CHAR_SPACE: ' ', /* */ + CHAR_TAB: '\t', /* \t */ + CHAR_UNDERSCORE: '_', /* _ */ + CHAR_VERTICAL_LINE: '|', /* | */ + CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */ +}; diff --git a/node_modules/braces/lib/expand.js b/node_modules/braces/lib/expand.js new file mode 100644 index 0000000..35b2c41 --- /dev/null +++ b/node_modules/braces/lib/expand.js @@ -0,0 +1,113 @@ +'use strict'; + +const fill = require('fill-range'); +const stringify = require('./stringify'); +const utils = require('./utils'); + +const append = (queue = '', stash = '', enclose = false) => { + const result = []; + + queue = [].concat(queue); + stash = [].concat(stash); + + if (!stash.length) return queue; + if (!queue.length) { + return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash; + } + + for (const item of queue) { + if (Array.isArray(item)) { + for (const value of item) { + result.push(append(value, stash, enclose)); + } + } else { + for (let ele of stash) { + if (enclose === true && typeof ele === 'string') ele = `{${ele}}`; + result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele); + } + } + } + return utils.flatten(result); +}; + +const expand = (ast, options = {}) => { + const rangeLimit = options.rangeLimit === undefined ? 1000 : options.rangeLimit; + + const walk = (node, parent = {}) => { + node.queue = []; + + let p = parent; + let q = parent.queue; + + while (p.type !== 'brace' && p.type !== 'root' && p.parent) { + p = p.parent; + q = p.queue; + } + + if (node.invalid || node.dollar) { + q.push(append(q.pop(), stringify(node, options))); + return; + } + + if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) { + q.push(append(q.pop(), ['{}'])); + return; + } + + if (node.nodes && node.ranges > 0) { + const args = utils.reduce(node.nodes); + + if (utils.exceedsLimit(...args, options.step, rangeLimit)) { + throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.'); + } + + let range = fill(...args, options); + if (range.length === 0) { + range = stringify(node, options); + } + + q.push(append(q.pop(), range)); + node.nodes = []; + return; + } + + const enclose = utils.encloseBrace(node); + let queue = node.queue; + let block = node; + + while (block.type !== 'brace' && block.type !== 'root' && block.parent) { + block = block.parent; + queue = block.queue; + } + + for (let i = 0; i < node.nodes.length; i++) { + const child = node.nodes[i]; + + if (child.type === 'comma' && node.type === 'brace') { + if (i === 1) queue.push(''); + queue.push(''); + continue; + } + + if (child.type === 'close') { + q.push(append(q.pop(), queue, enclose)); + continue; + } + + if (child.value && child.type !== 'open') { + queue.push(append(queue.pop(), child.value)); + continue; + } + + if (child.nodes) { + walk(child, node); + } + } + + return queue; + }; + + return utils.flatten(walk(ast)); +}; + +module.exports = expand; diff --git a/node_modules/braces/lib/parse.js b/node_modules/braces/lib/parse.js new file mode 100644 index 0000000..3a6988e --- /dev/null +++ b/node_modules/braces/lib/parse.js @@ -0,0 +1,331 @@ +'use strict'; + +const stringify = require('./stringify'); + +/** + * Constants + */ + +const { + MAX_LENGTH, + CHAR_BACKSLASH, /* \ */ + CHAR_BACKTICK, /* ` */ + CHAR_COMMA, /* , */ + CHAR_DOT, /* . */ + CHAR_LEFT_PARENTHESES, /* ( */ + CHAR_RIGHT_PARENTHESES, /* ) */ + CHAR_LEFT_CURLY_BRACE, /* { */ + CHAR_RIGHT_CURLY_BRACE, /* } */ + CHAR_LEFT_SQUARE_BRACKET, /* [ */ + CHAR_RIGHT_SQUARE_BRACKET, /* ] */ + CHAR_DOUBLE_QUOTE, /* " */ + CHAR_SINGLE_QUOTE, /* ' */ + CHAR_NO_BREAK_SPACE, + CHAR_ZERO_WIDTH_NOBREAK_SPACE +} = require('./constants'); + +/** + * parse + */ + +const parse = (input, options = {}) => { + if (typeof input !== 'string') { + throw new TypeError('Expected a string'); + } + + const opts = options || {}; + const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH; + if (input.length > max) { + throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`); + } + + const ast = { type: 'root', input, nodes: [] }; + const stack = [ast]; + let block = ast; + let prev = ast; + let brackets = 0; + const length = input.length; + let index = 0; + let depth = 0; + let value; + + /** + * Helpers + */ + + const advance = () => input[index++]; + const push = node => { + if (node.type === 'text' && prev.type === 'dot') { + prev.type = 'text'; + } + + if (prev && prev.type === 'text' && node.type === 'text') { + prev.value += node.value; + return; + } + + block.nodes.push(node); + node.parent = block; + node.prev = prev; + prev = node; + return node; + }; + + push({ type: 'bos' }); + + while (index < length) { + block = stack[stack.length - 1]; + value = advance(); + + /** + * Invalid chars + */ + + if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) { + continue; + } + + /** + * Escaped chars + */ + + if (value === CHAR_BACKSLASH) { + push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() }); + continue; + } + + /** + * Right square bracket (literal): ']' + */ + + if (value === CHAR_RIGHT_SQUARE_BRACKET) { + push({ type: 'text', value: '\\' + value }); + continue; + } + + /** + * Left square bracket: '[' + */ + + if (value === CHAR_LEFT_SQUARE_BRACKET) { + brackets++; + + let next; + + while (index < length && (next = advance())) { + value += next; + + if (next === CHAR_LEFT_SQUARE_BRACKET) { + brackets++; + continue; + } + + if (next === CHAR_BACKSLASH) { + value += advance(); + continue; + } + + if (next === CHAR_RIGHT_SQUARE_BRACKET) { + brackets--; + + if (brackets === 0) { + break; + } + } + } + + push({ type: 'text', value }); + continue; + } + + /** + * Parentheses + */ + + if (value === CHAR_LEFT_PARENTHESES) { + block = push({ type: 'paren', nodes: [] }); + stack.push(block); + push({ type: 'text', value }); + continue; + } + + if (value === CHAR_RIGHT_PARENTHESES) { + if (block.type !== 'paren') { + push({ type: 'text', value }); + continue; + } + block = stack.pop(); + push({ type: 'text', value }); + block = stack[stack.length - 1]; + continue; + } + + /** + * Quotes: '|"|` + */ + + if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) { + const open = value; + let next; + + if (options.keepQuotes !== true) { + value = ''; + } + + while (index < length && (next = advance())) { + if (next === CHAR_BACKSLASH) { + value += next + advance(); + continue; + } + + if (next === open) { + if (options.keepQuotes === true) value += next; + break; + } + + value += next; + } + + push({ type: 'text', value }); + continue; + } + + /** + * Left curly brace: '{' + */ + + if (value === CHAR_LEFT_CURLY_BRACE) { + depth++; + + const dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true; + const brace = { + type: 'brace', + open: true, + close: false, + dollar, + depth, + commas: 0, + ranges: 0, + nodes: [] + }; + + block = push(brace); + stack.push(block); + push({ type: 'open', value }); + continue; + } + + /** + * Right curly brace: '}' + */ + + if (value === CHAR_RIGHT_CURLY_BRACE) { + if (block.type !== 'brace') { + push({ type: 'text', value }); + continue; + } + + const type = 'close'; + block = stack.pop(); + block.close = true; + + push({ type, value }); + depth--; + + block = stack[stack.length - 1]; + continue; + } + + /** + * Comma: ',' + */ + + if (value === CHAR_COMMA && depth > 0) { + if (block.ranges > 0) { + block.ranges = 0; + const open = block.nodes.shift(); + block.nodes = [open, { type: 'text', value: stringify(block) }]; + } + + push({ type: 'comma', value }); + block.commas++; + continue; + } + + /** + * Dot: '.' + */ + + if (value === CHAR_DOT && depth > 0 && block.commas === 0) { + const siblings = block.nodes; + + if (depth === 0 || siblings.length === 0) { + push({ type: 'text', value }); + continue; + } + + if (prev.type === 'dot') { + block.range = []; + prev.value += value; + prev.type = 'range'; + + if (block.nodes.length !== 3 && block.nodes.length !== 5) { + block.invalid = true; + block.ranges = 0; + prev.type = 'text'; + continue; + } + + block.ranges++; + block.args = []; + continue; + } + + if (prev.type === 'range') { + siblings.pop(); + + const before = siblings[siblings.length - 1]; + before.value += prev.value + value; + prev = before; + block.ranges--; + continue; + } + + push({ type: 'dot', value }); + continue; + } + + /** + * Text + */ + + push({ type: 'text', value }); + } + + // Mark imbalanced braces and brackets as invalid + do { + block = stack.pop(); + + if (block.type !== 'root') { + block.nodes.forEach(node => { + if (!node.nodes) { + if (node.type === 'open') node.isOpen = true; + if (node.type === 'close') node.isClose = true; + if (!node.nodes) node.type = 'text'; + node.invalid = true; + } + }); + + // get the location of the block on parent.nodes (block's siblings) + const parent = stack[stack.length - 1]; + const index = parent.nodes.indexOf(block); + // replace the (invalid) block with it's nodes + parent.nodes.splice(index, 1, ...block.nodes); + } + } while (stack.length > 0); + + push({ type: 'eos' }); + return ast; +}; + +module.exports = parse; diff --git a/node_modules/braces/lib/stringify.js b/node_modules/braces/lib/stringify.js new file mode 100644 index 0000000..8bcf872 --- /dev/null +++ b/node_modules/braces/lib/stringify.js @@ -0,0 +1,32 @@ +'use strict'; + +const utils = require('./utils'); + +module.exports = (ast, options = {}) => { + const stringify = (node, parent = {}) => { + const invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent); + const invalidNode = node.invalid === true && options.escapeInvalid === true; + let output = ''; + + if (node.value) { + if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) { + return '\\' + node.value; + } + return node.value; + } + + if (node.value) { + return node.value; + } + + if (node.nodes) { + for (const child of node.nodes) { + output += stringify(child); + } + } + return output; + }; + + return stringify(ast); +}; + diff --git a/node_modules/braces/lib/utils.js b/node_modules/braces/lib/utils.js new file mode 100644 index 0000000..d19311f --- /dev/null +++ b/node_modules/braces/lib/utils.js @@ -0,0 +1,122 @@ +'use strict'; + +exports.isInteger = num => { + if (typeof num === 'number') { + return Number.isInteger(num); + } + if (typeof num === 'string' && num.trim() !== '') { + return Number.isInteger(Number(num)); + } + return false; +}; + +/** + * Find a node of the given type + */ + +exports.find = (node, type) => node.nodes.find(node => node.type === type); + +/** + * Find a node of the given type + */ + +exports.exceedsLimit = (min, max, step = 1, limit) => { + if (limit === false) return false; + if (!exports.isInteger(min) || !exports.isInteger(max)) return false; + return ((Number(max) - Number(min)) / Number(step)) >= limit; +}; + +/** + * Escape the given node with '\\' before node.value + */ + +exports.escapeNode = (block, n = 0, type) => { + const node = block.nodes[n]; + if (!node) return; + + if ((type && node.type === type) || node.type === 'open' || node.type === 'close') { + if (node.escaped !== true) { + node.value = '\\' + node.value; + node.escaped = true; + } + } +}; + +/** + * Returns true if the given brace node should be enclosed in literal braces + */ + +exports.encloseBrace = node => { + if (node.type !== 'brace') return false; + if ((node.commas >> 0 + node.ranges >> 0) === 0) { + node.invalid = true; + return true; + } + return false; +}; + +/** + * Returns true if a brace node is invalid. + */ + +exports.isInvalidBrace = block => { + if (block.type !== 'brace') return false; + if (block.invalid === true || block.dollar) return true; + if ((block.commas >> 0 + block.ranges >> 0) === 0) { + block.invalid = true; + return true; + } + if (block.open !== true || block.close !== true) { + block.invalid = true; + return true; + } + return false; +}; + +/** + * Returns true if a node is an open or close node + */ + +exports.isOpenOrClose = node => { + if (node.type === 'open' || node.type === 'close') { + return true; + } + return node.open === true || node.close === true; +}; + +/** + * Reduce an array of text nodes. + */ + +exports.reduce = nodes => nodes.reduce((acc, node) => { + if (node.type === 'text') acc.push(node.value); + if (node.type === 'range') node.type = 'text'; + return acc; +}, []); + +/** + * Flatten an array + */ + +exports.flatten = (...args) => { + const result = []; + + const flat = arr => { + for (let i = 0; i < arr.length; i++) { + const ele = arr[i]; + + if (Array.isArray(ele)) { + flat(ele); + continue; + } + + if (ele !== undefined) { + result.push(ele); + } + } + return result; + }; + + flat(args); + return result; +}; diff --git a/node_modules/braces/package.json b/node_modules/braces/package.json new file mode 100644 index 0000000..c3c056e --- /dev/null +++ b/node_modules/braces/package.json @@ -0,0 +1,77 @@ +{ + "name": "braces", + "description": "Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support for the Bash 4.3 braces specification, without sacrificing speed.", + "version": "3.0.3", + "homepage": "https://github.com/micromatch/braces", + "author": "Jon Schlinkert (https://github.com/jonschlinkert)", + "contributors": [ + "Brian Woodward (https://twitter.com/doowb)", + "Elan Shanker (https://github.com/es128)", + "Eugene Sharygin (https://github.com/eush77)", + "hemanth.hm (http://h3manth.com)", + "Jon Schlinkert (http://twitter.com/jonschlinkert)" + ], + "repository": "micromatch/braces", + "bugs": { + "url": "https://github.com/micromatch/braces/issues" + }, + "license": "MIT", + "files": [ + "index.js", + "lib" + ], + "main": "index.js", + "engines": { + "node": ">=8" + }, + "scripts": { + "test": "mocha", + "benchmark": "node benchmark" + }, + "dependencies": { + "fill-range": "^7.1.1" + }, + "devDependencies": { + "ansi-colors": "^3.2.4", + "bash-path": "^2.0.1", + "gulp-format-md": "^2.0.0", + "mocha": "^6.1.1" + }, + "keywords": [ + "alpha", + "alphabetical", + "bash", + "brace", + "braces", + "expand", + "expansion", + "filepath", + "fill", + "fs", + "glob", + "globbing", + "letter", + "match", + "matches", + "matching", + "number", + "numerical", + "path", + "range", + "ranges", + "sh" + ], + "verb": { + "toc": false, + "layout": "default", + "tasks": [ + "readme" + ], + "lint": { + "reflinks": true + }, + "plugins": [ + "gulp-format-md" + ] + } +} diff --git a/node_modules/chokidar/LICENSE b/node_modules/chokidar/LICENSE new file mode 100644 index 0000000..8c27184 --- /dev/null +++ b/node_modules/chokidar/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2012 Paul Miller (https://paulmillr.com), Elan Shanker + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the “Software”), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/chokidar/README.md b/node_modules/chokidar/README.md new file mode 100644 index 0000000..ca3bcbb --- /dev/null +++ b/node_modules/chokidar/README.md @@ -0,0 +1,305 @@ +# Chokidar [![Weekly downloads](https://img.shields.io/npm/dw/chokidar.svg)](https://github.com/paulmillr/chokidar) + +> Minimal and efficient cross-platform file watching library + +## Why? + +There are many reasons to prefer Chokidar to raw fs.watch / fs.watchFile in 2024: + +- Events are properly reported + - macOS events report filenames + - events are not reported twice + - changes are reported as add / change / unlink instead of useless `rename` +- Atomic writes are supported, using `atomic` option + - Some file editors use them +- Chunked writes are supported, using `awaitWriteFinish` option + - Large files are commonly written in chunks +- File / dir filtering is supported +- Symbolic links are supported +- Recursive watching is always supported, instead of partial when using raw events + - Includes a way to limit recursion depth + +Chokidar relies on the Node.js core `fs` module, but when using +`fs.watch` and `fs.watchFile` for watching, it normalizes the events it +receives, often checking for truth by getting file stats and/or dir contents. +The `fs.watch`-based implementation is the default, which +avoids polling and keeps CPU usage down. Be advised that chokidar will initiate +watchers recursively for everything within scope of the paths that have been +specified, so be judicious about not wasting system resources by watching much +more than needed. For some cases, `fs.watchFile`, which utilizes polling and uses more resources, is used. + +Made for [Brunch](https://brunch.io/) in 2012, +it is now used in [~30 million repositories](https://www.npmjs.com/browse/depended/chokidar) and +has proven itself in production environments. + +**Sep 2024 update:** v4 is out! It decreases dependency count from 13 to 1, removes +support for globs, adds support for ESM / Common.js modules, and bumps minimum node.js version from v8 to v14. +Check out [upgrading](#upgrading). + +## Getting started + +Install with npm: + +```sh +npm install chokidar +``` + +Use it in your code: + +```javascript +import chokidar from 'chokidar'; + +// One-liner for current directory +chokidar.watch('.').on('all', (event, path) => { + console.log(event, path); +}); + + +// Extended options +// ---------------- + +// Initialize watcher. +const watcher = chokidar.watch('file, dir, or array', { + ignored: (path, stats) => stats?.isFile() && !path.endsWith('.js'), // only watch js files + persistent: true +}); + +// Something to use when events are received. +const log = console.log.bind(console); +// Add event listeners. +watcher + .on('add', path => log(`File ${path} has been added`)) + .on('change', path => log(`File ${path} has been changed`)) + .on('unlink', path => log(`File ${path} has been removed`)); + +// More possible events. +watcher + .on('addDir', path => log(`Directory ${path} has been added`)) + .on('unlinkDir', path => log(`Directory ${path} has been removed`)) + .on('error', error => log(`Watcher error: ${error}`)) + .on('ready', () => log('Initial scan complete. Ready for changes')) + .on('raw', (event, path, details) => { // internal + log('Raw event info:', event, path, details); + }); + +// 'add', 'addDir' and 'change' events also receive stat() results as second +// argument when available: https://nodejs.org/api/fs.html#fs_class_fs_stats +watcher.on('change', (path, stats) => { + if (stats) console.log(`File ${path} changed size to ${stats.size}`); +}); + +// Watch new files. +watcher.add('new-file'); +watcher.add(['new-file-2', 'new-file-3']); + +// Get list of actual paths being watched on the filesystem +let watchedPaths = watcher.getWatched(); + +// Un-watch some files. +await watcher.unwatch('new-file'); + +// Stop watching. The method is async! +await watcher.close().then(() => console.log('closed')); + +// Full list of options. See below for descriptions. +// Do not use this example! +chokidar.watch('file', { + persistent: true, + + // ignore .txt files + ignored: (file) => file.endsWith('.txt'), + // watch only .txt files + // ignored: (file, _stats) => _stats?.isFile() && !file.endsWith('.txt'), + + awaitWriteFinish: true, // emit single event when chunked writes are completed + atomic: true, // emit proper events when "atomic writes" (mv _tmp file) are used + + // The options also allow specifying custom intervals in ms + // awaitWriteFinish: { + // stabilityThreshold: 2000, + // pollInterval: 100 + // }, + // atomic: 100, + + interval: 100, + binaryInterval: 300, + + cwd: '.', + depth: 99, + + followSymlinks: true, + ignoreInitial: false, + ignorePermissionErrors: false, + usePolling: false, + alwaysStat: false, +}); + +``` + +`chokidar.watch(paths, [options])` + +* `paths` (string or array of strings). Paths to files, dirs to be watched +recursively. +* `options` (object) Options object as defined below: + +#### Persistence + +* `persistent` (default: `true`). Indicates whether the process +should continue to run as long as files are being watched. + +#### Path filtering + +* `ignored` function, regex, or path. Defines files/paths to be ignored. +The whole relative or absolute path is tested, not just filename. If a function with two arguments +is provided, it gets called twice per path - once with a single argument (the path), second +time with two arguments (the path and the +[`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) +object of that path). +* `ignoreInitial` (default: `false`). If set to `false` then `add`/`addDir` events are also emitted for matching paths while +instantiating the watching as chokidar discovers these file paths (before the `ready` event). +* `followSymlinks` (default: `true`). When `false`, only the +symlinks themselves will be watched for changes instead of following +the link references and bubbling events through the link's path. +* `cwd` (no default). The base directory from which watch `paths` are to be +derived. Paths emitted with events will be relative to this. + +#### Performance + +* `usePolling` (default: `false`). +Whether to use fs.watchFile (backed by polling), or fs.watch. If polling +leads to high CPU utilization, consider setting this to `false`. It is +typically necessary to **set this to `true` to successfully watch files over +a network**, and it may be necessary to successfully watch files in other +non-standard situations. Setting to `true` explicitly on MacOS overrides the +`useFsEvents` default. You may also set the CHOKIDAR_USEPOLLING env variable +to true (1) or false (0) in order to override this option. +* _Polling-specific settings_ (effective when `usePolling: true`) + * `interval` (default: `100`). Interval of file system polling, in milliseconds. You may also + set the CHOKIDAR_INTERVAL env variable to override this option. + * `binaryInterval` (default: `300`). Interval of file system + polling for binary files. + ([see list of binary extensions](https://github.com/sindresorhus/binary-extensions/blob/master/binary-extensions.json)) +* `alwaysStat` (default: `false`). If relying upon the +[`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) +object that may get passed with `add`, `addDir`, and `change` events, set +this to `true` to ensure it is provided even in cases where it wasn't +already available from the underlying watch events. +* `depth` (default: `undefined`). If set, limits how many levels of +subdirectories will be traversed. +* `awaitWriteFinish` (default: `false`). +By default, the `add` event will fire when a file first appears on disk, before +the entire file has been written. Furthermore, in some cases some `change` +events will be emitted while the file is being written. In some cases, +especially when watching for large files there will be a need to wait for the +write operation to finish before responding to a file creation or modification. +Setting `awaitWriteFinish` to `true` (or a truthy value) will poll file size, +holding its `add` and `change` events until the size does not change for a +configurable amount of time. The appropriate duration setting is heavily +dependent on the OS and hardware. For accurate detection this parameter should +be relatively high, making file watching much less responsive. +Use with caution. + * *`options.awaitWriteFinish` can be set to an object in order to adjust + timing params:* + * `awaitWriteFinish.stabilityThreshold` (default: 2000). Amount of time in + milliseconds for a file size to remain constant before emitting its event. + * `awaitWriteFinish.pollInterval` (default: 100). File size polling interval, in milliseconds. + +#### Errors + +* `ignorePermissionErrors` (default: `false`). Indicates whether to watch files +that don't have read permissions if possible. If watching fails due to `EPERM` +or `EACCES` with this set to `true`, the errors will be suppressed silently. +* `atomic` (default: `true` if `useFsEvents` and `usePolling` are `false`). +Automatically filters out artifacts that occur when using editors that use +"atomic writes" instead of writing directly to the source file. If a file is +re-added within 100 ms of being deleted, Chokidar emits a `change` event +rather than `unlink` then `add`. If the default of 100 ms does not work well +for you, you can override it by setting `atomic` to a custom value, in +milliseconds. + +### Methods & Events + +`chokidar.watch()` produces an instance of `FSWatcher`. Methods of `FSWatcher`: + +* `.add(path / paths)`: Add files, directories for tracking. +Takes an array of strings or just one string. +* `.on(event, callback)`: Listen for an FS event. +Available events: `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `ready`, +`raw`, `error`. +Additionally `all` is available which gets emitted with the underlying event +name and path for every event other than `ready`, `raw`, and `error`. `raw` is internal, use it carefully. +* `.unwatch(path / paths)`: Stop watching files or directories. +Takes an array of strings or just one string. +* `.close()`: **async** Removes all listeners from watched files. Asynchronous, returns Promise. Use with `await` to ensure bugs don't happen. +* `.getWatched()`: Returns an object representing all the paths on the file +system being watched by this `FSWatcher` instance. The object's keys are all the +directories (using absolute paths unless the `cwd` option was used), and the +values are arrays of the names of the items contained in each directory. + +### CLI + +Check out third party [chokidar-cli](https://github.com/open-cli-tools/chokidar-cli), +which allows to execute a command on each change, or get a stdio stream of change events. + +## Troubleshooting + +Sometimes, Chokidar runs out of file handles, causing `EMFILE` and `ENOSP` errors: + +* `bash: cannot set terminal process group (-1): Inappropriate ioctl for device bash: no job control in this shell` +* `Error: watch /home/ ENOSPC` + +There are two things that can cause it. + +1. Exhausted file handles for generic fs operations + - Can be solved by using [graceful-fs](https://www.npmjs.com/package/graceful-fs), + which can monkey-patch native `fs` module used by chokidar: `let fs = require('fs'); let grfs = require('graceful-fs'); grfs.gracefulify(fs);` + - Can also be solved by tuning OS: `echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p`. +2. Exhausted file handles for `fs.watch` + - Can't seem to be solved by graceful-fs or OS tuning + - It's possible to start using `usePolling: true`, which will switch backend to resource-intensive `fs.watchFile` + +All fsevents-related issues (`WARN optional dep failed`, `fsevents is not a constructor`) are solved by upgrading to v4+. + +## Changelog + +- **v4 (Sep 2024):** remove glob support and bundled fsevents. Decrease dependency count from 13 to 1. Rewrite in typescript. Bumps minimum node.js requirement to v14+ +- **v3 (Apr 2019):** massive CPU & RAM consumption improvements; reduces deps / package size by a factor of 17x and bumps Node.js requirement to v8.16+. +- **v2 (Dec 2017):** globs are now posix-style-only. Tons of bugfixes. +- **v1 (Apr 2015):** glob support, symlink support, tons of bugfixes. Node 0.8+ is supported +- **v0.1 (Apr 2012):** Initial release, extracted from [Brunch](https://github.com/brunch/brunch/blob/9847a065aea300da99bd0753f90354cde9de1261/src/helpers.coffee#L66) + +### Upgrading + +If you've used globs before and want do replicate the functionality with v4: + +```js +// v3 +chok.watch('**/*.js'); +chok.watch("./directory/**/*"); + +// v4 +chok.watch('.', { + ignored: (path, stats) => stats?.isFile() && !path.endsWith('.js'), // only watch js files +}); +chok.watch('./directory'); + +// other way +import { glob } from 'node:fs/promises'; +const watcher = watch(await Array.fromAsync(glob('**/*.js'))); + +// unwatching +// v3 +chok.unwatch('**/*.js'); +// v4 +chok.unwatch(await glob('**/*.js')); +``` + +## Also + +Why was chokidar named this way? What's the meaning behind it? + +>Chowkidar is a transliteration of a Hindi word meaning 'watchman, gatekeeper', चौकीदार. This ultimately comes from Sanskrit _ चतुष्क_ (crossway, quadrangle, consisting-of-four). This word is also used in other languages like Urdu as (چوکیدار) which is widely used in Pakistan and India. + +## License + +MIT (c) Paul Miller (), see [LICENSE](LICENSE) file. diff --git a/node_modules/chokidar/esm/handler.d.ts b/node_modules/chokidar/esm/handler.d.ts new file mode 100644 index 0000000..ea777d0 --- /dev/null +++ b/node_modules/chokidar/esm/handler.d.ts @@ -0,0 +1,90 @@ +import type { WatchEventType, Stats, FSWatcher as NativeFsWatcher } from 'fs'; +import type { FSWatcher, WatchHelper, Throttler } from './index.js'; +import type { EntryInfo } from 'readdirp'; +export type Path = string; +export declare const STR_DATA = "data"; +export declare const STR_END = "end"; +export declare const STR_CLOSE = "close"; +export declare const EMPTY_FN: () => void; +export declare const IDENTITY_FN: (val: unknown) => unknown; +export declare const isWindows: boolean; +export declare const isMacos: boolean; +export declare const isLinux: boolean; +export declare const isFreeBSD: boolean; +export declare const isIBMi: boolean; +export declare const EVENTS: { + readonly ALL: "all"; + readonly READY: "ready"; + readonly ADD: "add"; + readonly CHANGE: "change"; + readonly ADD_DIR: "addDir"; + readonly UNLINK: "unlink"; + readonly UNLINK_DIR: "unlinkDir"; + readonly RAW: "raw"; + readonly ERROR: "error"; +}; +export type EventName = (typeof EVENTS)[keyof typeof EVENTS]; +export type FsWatchContainer = { + listeners: (path: string) => void | Set; + errHandlers: (err: unknown) => void | Set; + rawEmitters: (ev: WatchEventType, path: string, opts: unknown) => void | Set; + watcher: NativeFsWatcher; + watcherUnusable?: boolean; +}; +export interface WatchHandlers { + listener: (path: string) => void; + errHandler: (err: unknown) => void; + rawEmitter: (ev: WatchEventType, path: string, opts: unknown) => void; +} +/** + * @mixin + */ +export declare class NodeFsHandler { + fsw: FSWatcher; + _boundHandleError: (error: unknown) => void; + constructor(fsW: FSWatcher); + /** + * Watch file for changes with fs_watchFile or fs_watch. + * @param path to file or dir + * @param listener on fs change + * @returns closer for the watcher instance + */ + _watchWithNodeFs(path: string, listener: (path: string, newStats?: any) => void | Promise): (() => void) | undefined; + /** + * Watch a file and emit add event if warranted. + * @returns closer for the watcher instance + */ + _handleFile(file: Path, stats: Stats, initialAdd: boolean): (() => void) | undefined; + /** + * Handle symlinks encountered while reading a dir. + * @param entry returned by readdirp + * @param directory path of dir being read + * @param path of this item + * @param item basename of this item + * @returns true if no more processing is needed for this entry. + */ + _handleSymlink(entry: EntryInfo, directory: string, path: Path, item: string): Promise; + _handleRead(directory: string, initialAdd: boolean, wh: WatchHelper, target: Path, dir: Path, depth: number, throttler: Throttler): Promise | undefined; + /** + * Read directory to add / remove files from `@watched` list and re-read it on change. + * @param dir fs path + * @param stats + * @param initialAdd + * @param depth relative to user-supplied path + * @param target child path targeted for watch + * @param wh Common watch helpers for this path + * @param realpath + * @returns closer for the watcher instance. + */ + _handleDir(dir: string, stats: Stats, initialAdd: boolean, depth: number, target: string, wh: WatchHelper, realpath: string): Promise<(() => void) | undefined>; + /** + * Handle added file, directory, or glob pattern. + * Delegates call to _handleFile / _handleDir after checks. + * @param path to file or ir + * @param initialAdd was the file added at watch instantiation? + * @param priorWh depth relative to user-supplied path + * @param depth Child path actually targeted for watch + * @param target Child path actually targeted for watch + */ + _addToNodeFs(path: string, initialAdd: boolean, priorWh: WatchHelper | undefined, depth: number, target?: string): Promise; +} diff --git a/node_modules/chokidar/esm/handler.js b/node_modules/chokidar/esm/handler.js new file mode 100644 index 0000000..bbda010 --- /dev/null +++ b/node_modules/chokidar/esm/handler.js @@ -0,0 +1,629 @@ +import { watchFile, unwatchFile, watch as fs_watch } from 'fs'; +import { open, stat, lstat, realpath as fsrealpath } from 'fs/promises'; +import * as sysPath from 'path'; +import { type as osType } from 'os'; +export const STR_DATA = 'data'; +export const STR_END = 'end'; +export const STR_CLOSE = 'close'; +export const EMPTY_FN = () => { }; +export const IDENTITY_FN = (val) => val; +const pl = process.platform; +export const isWindows = pl === 'win32'; +export const isMacos = pl === 'darwin'; +export const isLinux = pl === 'linux'; +export const isFreeBSD = pl === 'freebsd'; +export const isIBMi = osType() === 'OS400'; +export const EVENTS = { + ALL: 'all', + READY: 'ready', + ADD: 'add', + CHANGE: 'change', + ADD_DIR: 'addDir', + UNLINK: 'unlink', + UNLINK_DIR: 'unlinkDir', + RAW: 'raw', + ERROR: 'error', +}; +const EV = EVENTS; +const THROTTLE_MODE_WATCH = 'watch'; +const statMethods = { lstat, stat }; +const KEY_LISTENERS = 'listeners'; +const KEY_ERR = 'errHandlers'; +const KEY_RAW = 'rawEmitters'; +const HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW]; +// prettier-ignore +const binaryExtensions = new Set([ + '3dm', '3ds', '3g2', '3gp', '7z', 'a', 'aac', 'adp', 'afdesign', 'afphoto', 'afpub', 'ai', + 'aif', 'aiff', 'alz', 'ape', 'apk', 'appimage', 'ar', 'arj', 'asf', 'au', 'avi', + 'bak', 'baml', 'bh', 'bin', 'bk', 'bmp', 'btif', 'bz2', 'bzip2', + 'cab', 'caf', 'cgm', 'class', 'cmx', 'cpio', 'cr2', 'cur', 'dat', 'dcm', 'deb', 'dex', 'djvu', + 'dll', 'dmg', 'dng', 'doc', 'docm', 'docx', 'dot', 'dotm', 'dra', 'DS_Store', 'dsk', 'dts', + 'dtshd', 'dvb', 'dwg', 'dxf', + 'ecelp4800', 'ecelp7470', 'ecelp9600', 'egg', 'eol', 'eot', 'epub', 'exe', + 'f4v', 'fbs', 'fh', 'fla', 'flac', 'flatpak', 'fli', 'flv', 'fpx', 'fst', 'fvt', + 'g3', 'gh', 'gif', 'graffle', 'gz', 'gzip', + 'h261', 'h263', 'h264', 'icns', 'ico', 'ief', 'img', 'ipa', 'iso', + 'jar', 'jpeg', 'jpg', 'jpgv', 'jpm', 'jxr', 'key', 'ktx', + 'lha', 'lib', 'lvp', 'lz', 'lzh', 'lzma', 'lzo', + 'm3u', 'm4a', 'm4v', 'mar', 'mdi', 'mht', 'mid', 'midi', 'mj2', 'mka', 'mkv', 'mmr', 'mng', + 'mobi', 'mov', 'movie', 'mp3', + 'mp4', 'mp4a', 'mpeg', 'mpg', 'mpga', 'mxu', + 'nef', 'npx', 'numbers', 'nupkg', + 'o', 'odp', 'ods', 'odt', 'oga', 'ogg', 'ogv', 'otf', 'ott', + 'pages', 'pbm', 'pcx', 'pdb', 'pdf', 'pea', 'pgm', 'pic', 'png', 'pnm', 'pot', 'potm', + 'potx', 'ppa', 'ppam', + 'ppm', 'pps', 'ppsm', 'ppsx', 'ppt', 'pptm', 'pptx', 'psd', 'pya', 'pyc', 'pyo', 'pyv', + 'qt', + 'rar', 'ras', 'raw', 'resources', 'rgb', 'rip', 'rlc', 'rmf', 'rmvb', 'rpm', 'rtf', 'rz', + 's3m', 's7z', 'scpt', 'sgi', 'shar', 'snap', 'sil', 'sketch', 'slk', 'smv', 'snk', 'so', + 'stl', 'suo', 'sub', 'swf', + 'tar', 'tbz', 'tbz2', 'tga', 'tgz', 'thmx', 'tif', 'tiff', 'tlz', 'ttc', 'ttf', 'txz', + 'udf', 'uvh', 'uvi', 'uvm', 'uvp', 'uvs', 'uvu', + 'viv', 'vob', + 'war', 'wav', 'wax', 'wbmp', 'wdp', 'weba', 'webm', 'webp', 'whl', 'wim', 'wm', 'wma', + 'wmv', 'wmx', 'woff', 'woff2', 'wrm', 'wvx', + 'xbm', 'xif', 'xla', 'xlam', 'xls', 'xlsb', 'xlsm', 'xlsx', 'xlt', 'xltm', 'xltx', 'xm', + 'xmind', 'xpi', 'xpm', 'xwd', 'xz', + 'z', 'zip', 'zipx', +]); +const isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase()); +// TODO: emit errors properly. Example: EMFILE on Macos. +const foreach = (val, fn) => { + if (val instanceof Set) { + val.forEach(fn); + } + else { + fn(val); + } +}; +const addAndConvert = (main, prop, item) => { + let container = main[prop]; + if (!(container instanceof Set)) { + main[prop] = container = new Set([container]); + } + container.add(item); +}; +const clearItem = (cont) => (key) => { + const set = cont[key]; + if (set instanceof Set) { + set.clear(); + } + else { + delete cont[key]; + } +}; +const delFromSet = (main, prop, item) => { + const container = main[prop]; + if (container instanceof Set) { + container.delete(item); + } + else if (container === item) { + delete main[prop]; + } +}; +const isEmptySet = (val) => (val instanceof Set ? val.size === 0 : !val); +const FsWatchInstances = new Map(); +/** + * Instantiates the fs_watch interface + * @param path to be watched + * @param options to be passed to fs_watch + * @param listener main event handler + * @param errHandler emits info about errors + * @param emitRaw emits raw event data + * @returns {NativeFsWatcher} + */ +function createFsWatchInstance(path, options, listener, errHandler, emitRaw) { + const handleEvent = (rawEvent, evPath) => { + listener(path); + emitRaw(rawEvent, evPath, { watchedPath: path }); + // emit based on events occurring for files from a directory's watcher in + // case the file's watcher misses it (and rely on throttling to de-dupe) + if (evPath && path !== evPath) { + fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath)); + } + }; + try { + return fs_watch(path, { + persistent: options.persistent, + }, handleEvent); + } + catch (error) { + errHandler(error); + return undefined; + } +} +/** + * Helper for passing fs_watch event data to a collection of listeners + * @param fullPath absolute path bound to fs_watch instance + */ +const fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => { + const cont = FsWatchInstances.get(fullPath); + if (!cont) + return; + foreach(cont[listenerType], (listener) => { + listener(val1, val2, val3); + }); +}; +/** + * Instantiates the fs_watch interface or binds listeners + * to an existing one covering the same file system entry + * @param path + * @param fullPath absolute path + * @param options to be passed to fs_watch + * @param handlers container for event listener functions + */ +const setFsWatchListener = (path, fullPath, options, handlers) => { + const { listener, errHandler, rawEmitter } = handlers; + let cont = FsWatchInstances.get(fullPath); + let watcher; + if (!options.persistent) { + watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter); + if (!watcher) + return; + return watcher.close.bind(watcher); + } + if (cont) { + addAndConvert(cont, KEY_LISTENERS, listener); + addAndConvert(cont, KEY_ERR, errHandler); + addAndConvert(cont, KEY_RAW, rawEmitter); + } + else { + watcher = createFsWatchInstance(path, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, // no need to use broadcast here + fsWatchBroadcast.bind(null, fullPath, KEY_RAW)); + if (!watcher) + return; + watcher.on(EV.ERROR, async (error) => { + const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR); + if (cont) + cont.watcherUnusable = true; // documented since Node 10.4.1 + // Workaround for https://github.com/joyent/node/issues/4337 + if (isWindows && error.code === 'EPERM') { + try { + const fd = await open(path, 'r'); + await fd.close(); + broadcastErr(error); + } + catch (err) { + // do nothing + } + } + else { + broadcastErr(error); + } + }); + cont = { + listeners: listener, + errHandlers: errHandler, + rawEmitters: rawEmitter, + watcher, + }; + FsWatchInstances.set(fullPath, cont); + } + // const index = cont.listeners.indexOf(listener); + // removes this instance's listeners and closes the underlying fs_watch + // instance if there are no more listeners left + return () => { + delFromSet(cont, KEY_LISTENERS, listener); + delFromSet(cont, KEY_ERR, errHandler); + delFromSet(cont, KEY_RAW, rawEmitter); + if (isEmptySet(cont.listeners)) { + // Check to protect against issue gh-730. + // if (cont.watcherUnusable) { + cont.watcher.close(); + // } + FsWatchInstances.delete(fullPath); + HANDLER_KEYS.forEach(clearItem(cont)); + // @ts-ignore + cont.watcher = undefined; + Object.freeze(cont); + } + }; +}; +// fs_watchFile helpers +// object to hold per-process fs_watchFile instances +// (may be shared across chokidar FSWatcher instances) +const FsWatchFileInstances = new Map(); +/** + * Instantiates the fs_watchFile interface or binds listeners + * to an existing one covering the same file system entry + * @param path to be watched + * @param fullPath absolute path + * @param options options to be passed to fs_watchFile + * @param handlers container for event listener functions + * @returns closer + */ +const setFsWatchFileListener = (path, fullPath, options, handlers) => { + const { listener, rawEmitter } = handlers; + let cont = FsWatchFileInstances.get(fullPath); + // let listeners = new Set(); + // let rawEmitters = new Set(); + const copts = cont && cont.options; + if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) { + // "Upgrade" the watcher to persistence or a quicker interval. + // This creates some unlikely edge case issues if the user mixes + // settings in a very weird way, but solving for those cases + // doesn't seem worthwhile for the added complexity. + // listeners = cont.listeners; + // rawEmitters = cont.rawEmitters; + unwatchFile(fullPath); + cont = undefined; + } + if (cont) { + addAndConvert(cont, KEY_LISTENERS, listener); + addAndConvert(cont, KEY_RAW, rawEmitter); + } + else { + // TODO + // listeners.add(listener); + // rawEmitters.add(rawEmitter); + cont = { + listeners: listener, + rawEmitters: rawEmitter, + options, + watcher: watchFile(fullPath, options, (curr, prev) => { + foreach(cont.rawEmitters, (rawEmitter) => { + rawEmitter(EV.CHANGE, fullPath, { curr, prev }); + }); + const currmtime = curr.mtimeMs; + if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) { + foreach(cont.listeners, (listener) => listener(path, curr)); + } + }), + }; + FsWatchFileInstances.set(fullPath, cont); + } + // const index = cont.listeners.indexOf(listener); + // Removes this instance's listeners and closes the underlying fs_watchFile + // instance if there are no more listeners left. + return () => { + delFromSet(cont, KEY_LISTENERS, listener); + delFromSet(cont, KEY_RAW, rawEmitter); + if (isEmptySet(cont.listeners)) { + FsWatchFileInstances.delete(fullPath); + unwatchFile(fullPath); + cont.options = cont.watcher = undefined; + Object.freeze(cont); + } + }; +}; +/** + * @mixin + */ +export class NodeFsHandler { + constructor(fsW) { + this.fsw = fsW; + this._boundHandleError = (error) => fsW._handleError(error); + } + /** + * Watch file for changes with fs_watchFile or fs_watch. + * @param path to file or dir + * @param listener on fs change + * @returns closer for the watcher instance + */ + _watchWithNodeFs(path, listener) { + const opts = this.fsw.options; + const directory = sysPath.dirname(path); + const basename = sysPath.basename(path); + const parent = this.fsw._getWatchedDir(directory); + parent.add(basename); + const absolutePath = sysPath.resolve(path); + const options = { + persistent: opts.persistent, + }; + if (!listener) + listener = EMPTY_FN; + let closer; + if (opts.usePolling) { + const enableBin = opts.interval !== opts.binaryInterval; + options.interval = enableBin && isBinaryPath(basename) ? opts.binaryInterval : opts.interval; + closer = setFsWatchFileListener(path, absolutePath, options, { + listener, + rawEmitter: this.fsw._emitRaw, + }); + } + else { + closer = setFsWatchListener(path, absolutePath, options, { + listener, + errHandler: this._boundHandleError, + rawEmitter: this.fsw._emitRaw, + }); + } + return closer; + } + /** + * Watch a file and emit add event if warranted. + * @returns closer for the watcher instance + */ + _handleFile(file, stats, initialAdd) { + if (this.fsw.closed) { + return; + } + const dirname = sysPath.dirname(file); + const basename = sysPath.basename(file); + const parent = this.fsw._getWatchedDir(dirname); + // stats is always present + let prevStats = stats; + // if the file is already being watched, do nothing + if (parent.has(basename)) + return; + const listener = async (path, newStats) => { + if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) + return; + if (!newStats || newStats.mtimeMs === 0) { + try { + const newStats = await stat(file); + if (this.fsw.closed) + return; + // Check that change event was not fired because of changed only accessTime. + const at = newStats.atimeMs; + const mt = newStats.mtimeMs; + if (!at || at <= mt || mt !== prevStats.mtimeMs) { + this.fsw._emit(EV.CHANGE, file, newStats); + } + if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats.ino) { + this.fsw._closeFile(path); + prevStats = newStats; + const closer = this._watchWithNodeFs(file, listener); + if (closer) + this.fsw._addPathCloser(path, closer); + } + else { + prevStats = newStats; + } + } + catch (error) { + // Fix issues where mtime is null but file is still present + this.fsw._remove(dirname, basename); + } + // add is about to be emitted if file not already tracked in parent + } + else if (parent.has(basename)) { + // Check that change event was not fired because of changed only accessTime. + const at = newStats.atimeMs; + const mt = newStats.mtimeMs; + if (!at || at <= mt || mt !== prevStats.mtimeMs) { + this.fsw._emit(EV.CHANGE, file, newStats); + } + prevStats = newStats; + } + }; + // kick off the watcher + const closer = this._watchWithNodeFs(file, listener); + // emit an add event if we're supposed to + if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) { + if (!this.fsw._throttle(EV.ADD, file, 0)) + return; + this.fsw._emit(EV.ADD, file, stats); + } + return closer; + } + /** + * Handle symlinks encountered while reading a dir. + * @param entry returned by readdirp + * @param directory path of dir being read + * @param path of this item + * @param item basename of this item + * @returns true if no more processing is needed for this entry. + */ + async _handleSymlink(entry, directory, path, item) { + if (this.fsw.closed) { + return; + } + const full = entry.fullPath; + const dir = this.fsw._getWatchedDir(directory); + if (!this.fsw.options.followSymlinks) { + // watch symlink directly (don't follow) and detect changes + this.fsw._incrReadyCount(); + let linkPath; + try { + linkPath = await fsrealpath(path); + } + catch (e) { + this.fsw._emitReady(); + return true; + } + if (this.fsw.closed) + return; + if (dir.has(item)) { + if (this.fsw._symlinkPaths.get(full) !== linkPath) { + this.fsw._symlinkPaths.set(full, linkPath); + this.fsw._emit(EV.CHANGE, path, entry.stats); + } + } + else { + dir.add(item); + this.fsw._symlinkPaths.set(full, linkPath); + this.fsw._emit(EV.ADD, path, entry.stats); + } + this.fsw._emitReady(); + return true; + } + // don't follow the same symlink more than once + if (this.fsw._symlinkPaths.has(full)) { + return true; + } + this.fsw._symlinkPaths.set(full, true); + } + _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) { + // Normalize the directory name on Windows + directory = sysPath.join(directory, ''); + throttler = this.fsw._throttle('readdir', directory, 1000); + if (!throttler) + return; + const previous = this.fsw._getWatchedDir(wh.path); + const current = new Set(); + let stream = this.fsw._readdirp(directory, { + fileFilter: (entry) => wh.filterPath(entry), + directoryFilter: (entry) => wh.filterDir(entry), + }); + if (!stream) + return; + stream + .on(STR_DATA, async (entry) => { + if (this.fsw.closed) { + stream = undefined; + return; + } + const item = entry.path; + let path = sysPath.join(directory, item); + current.add(item); + if (entry.stats.isSymbolicLink() && + (await this._handleSymlink(entry, directory, path, item))) { + return; + } + if (this.fsw.closed) { + stream = undefined; + return; + } + // Files that present in current directory snapshot + // but absent in previous are added to watch list and + // emit `add` event. + if (item === target || (!target && !previous.has(item))) { + this.fsw._incrReadyCount(); + // ensure relativeness of path is preserved in case of watcher reuse + path = sysPath.join(dir, sysPath.relative(dir, path)); + this._addToNodeFs(path, initialAdd, wh, depth + 1); + } + }) + .on(EV.ERROR, this._boundHandleError); + return new Promise((resolve, reject) => { + if (!stream) + return reject(); + stream.once(STR_END, () => { + if (this.fsw.closed) { + stream = undefined; + return; + } + const wasThrottled = throttler ? throttler.clear() : false; + resolve(undefined); + // Files that absent in current directory snapshot + // but present in previous emit `remove` event + // and are removed from @watched[directory]. + previous + .getChildren() + .filter((item) => { + return item !== directory && !current.has(item); + }) + .forEach((item) => { + this.fsw._remove(directory, item); + }); + stream = undefined; + // one more time for any missed in case changes came in extremely quickly + if (wasThrottled) + this._handleRead(directory, false, wh, target, dir, depth, throttler); + }); + }); + } + /** + * Read directory to add / remove files from `@watched` list and re-read it on change. + * @param dir fs path + * @param stats + * @param initialAdd + * @param depth relative to user-supplied path + * @param target child path targeted for watch + * @param wh Common watch helpers for this path + * @param realpath + * @returns closer for the watcher instance. + */ + async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) { + const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir)); + const tracked = parentDir.has(sysPath.basename(dir)); + if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) { + this.fsw._emit(EV.ADD_DIR, dir, stats); + } + // ensure dir is tracked (harmless if redundant) + parentDir.add(sysPath.basename(dir)); + this.fsw._getWatchedDir(dir); + let throttler; + let closer; + const oDepth = this.fsw.options.depth; + if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) { + if (!target) { + await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler); + if (this.fsw.closed) + return; + } + closer = this._watchWithNodeFs(dir, (dirPath, stats) => { + // if current directory is removed, do nothing + if (stats && stats.mtimeMs === 0) + return; + this._handleRead(dirPath, false, wh, target, dir, depth, throttler); + }); + } + return closer; + } + /** + * Handle added file, directory, or glob pattern. + * Delegates call to _handleFile / _handleDir after checks. + * @param path to file or ir + * @param initialAdd was the file added at watch instantiation? + * @param priorWh depth relative to user-supplied path + * @param depth Child path actually targeted for watch + * @param target Child path actually targeted for watch + */ + async _addToNodeFs(path, initialAdd, priorWh, depth, target) { + const ready = this.fsw._emitReady; + if (this.fsw._isIgnored(path) || this.fsw.closed) { + ready(); + return false; + } + const wh = this.fsw._getWatchHelpers(path); + if (priorWh) { + wh.filterPath = (entry) => priorWh.filterPath(entry); + wh.filterDir = (entry) => priorWh.filterDir(entry); + } + // evaluate what is at the path we're being asked to watch + try { + const stats = await statMethods[wh.statMethod](wh.watchPath); + if (this.fsw.closed) + return; + if (this.fsw._isIgnored(wh.watchPath, stats)) { + ready(); + return false; + } + const follow = this.fsw.options.followSymlinks; + let closer; + if (stats.isDirectory()) { + const absPath = sysPath.resolve(path); + const targetPath = follow ? await fsrealpath(path) : path; + if (this.fsw.closed) + return; + closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath); + if (this.fsw.closed) + return; + // preserve this symlink's target path + if (absPath !== targetPath && targetPath !== undefined) { + this.fsw._symlinkPaths.set(absPath, targetPath); + } + } + else if (stats.isSymbolicLink()) { + const targetPath = follow ? await fsrealpath(path) : path; + if (this.fsw.closed) + return; + const parent = sysPath.dirname(wh.watchPath); + this.fsw._getWatchedDir(parent).add(wh.watchPath); + this.fsw._emit(EV.ADD, wh.watchPath, stats); + closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath); + if (this.fsw.closed) + return; + // preserve this symlink's target path + if (targetPath !== undefined) { + this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath); + } + } + else { + closer = this._handleFile(wh.watchPath, stats, initialAdd); + } + ready(); + if (closer) + this.fsw._addPathCloser(path, closer); + return false; + } + catch (error) { + if (this.fsw._handleError(error)) { + ready(); + return path; + } + } + } +} diff --git a/node_modules/chokidar/esm/index.d.ts b/node_modules/chokidar/esm/index.d.ts new file mode 100644 index 0000000..ffeb1e7 --- /dev/null +++ b/node_modules/chokidar/esm/index.d.ts @@ -0,0 +1,215 @@ +/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */ +import { Stats } from 'fs'; +import { EventEmitter } from 'events'; +import { ReaddirpStream, ReaddirpOptions, EntryInfo } from 'readdirp'; +import { NodeFsHandler, EventName, Path, EVENTS as EV, WatchHandlers } from './handler.js'; +type AWF = { + stabilityThreshold: number; + pollInterval: number; +}; +type BasicOpts = { + persistent: boolean; + ignoreInitial: boolean; + followSymlinks: boolean; + cwd?: string; + usePolling: boolean; + interval: number; + binaryInterval: number; + alwaysStat?: boolean; + depth?: number; + ignorePermissionErrors: boolean; + atomic: boolean | number; +}; +export type Throttler = { + timeoutObject: NodeJS.Timeout; + clear: () => void; + count: number; +}; +export type ChokidarOptions = Partial; +}>; +export type FSWInstanceOptions = BasicOpts & { + ignored: Matcher[]; + awaitWriteFinish: false | AWF; +}; +export type ThrottleType = 'readdir' | 'watch' | 'add' | 'remove' | 'change'; +export type EmitArgs = [path: Path, stats?: Stats]; +export type EmitErrorArgs = [error: Error, stats?: Stats]; +export type EmitArgsWithName = [event: EventName, ...EmitArgs]; +export type MatchFunction = (val: string, stats?: Stats) => boolean; +export interface MatcherObject { + path: string; + recursive?: boolean; +} +export type Matcher = string | RegExp | MatchFunction | MatcherObject; +/** + * Directory entry. + */ +declare class DirEntry { + path: Path; + _removeWatcher: (dir: string, base: string) => void; + items: Set; + constructor(dir: Path, removeWatcher: (dir: string, base: string) => void); + add(item: string): void; + remove(item: string): Promise; + has(item: string): boolean | undefined; + getChildren(): string[]; + dispose(): void; +} +export declare class WatchHelper { + fsw: FSWatcher; + path: string; + watchPath: string; + fullWatchPath: string; + dirParts: string[][]; + followSymlinks: boolean; + statMethod: 'stat' | 'lstat'; + constructor(path: string, follow: boolean, fsw: FSWatcher); + entryPath(entry: EntryInfo): Path; + filterPath(entry: EntryInfo): boolean; + filterDir(entry: EntryInfo): boolean; +} +export interface FSWatcherKnownEventMap { + [EV.READY]: []; + [EV.RAW]: Parameters; + [EV.ERROR]: Parameters; + [EV.ALL]: [event: EventName, ...EmitArgs]; +} +export type FSWatcherEventMap = FSWatcherKnownEventMap & { + [k in Exclude]: EmitArgs; +}; +/** + * Watches files & directories for changes. Emitted events: + * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error` + * + * new FSWatcher() + * .add(directories) + * .on('add', path => log('File', path, 'was added')) + */ +export declare class FSWatcher extends EventEmitter { + closed: boolean; + options: FSWInstanceOptions; + _closers: Map>; + _ignoredPaths: Set; + _throttled: Map>; + _streams: Set; + _symlinkPaths: Map; + _watched: Map; + _pendingWrites: Map; + _pendingUnlinks: Map; + _readyCount: number; + _emitReady: () => void; + _closePromise?: Promise; + _userIgnored?: MatchFunction; + _readyEmitted: boolean; + _emitRaw: WatchHandlers['rawEmitter']; + _boundRemove: (dir: string, item: string) => void; + _nodeFsHandler: NodeFsHandler; + constructor(_opts?: ChokidarOptions); + _addIgnoredPath(matcher: Matcher): void; + _removeIgnoredPath(matcher: Matcher): void; + /** + * Adds paths to be watched on an existing FSWatcher instance. + * @param paths_ file or file list. Other arguments are unused + */ + add(paths_: Path | Path[], _origAdd?: string, _internal?: boolean): FSWatcher; + /** + * Close watchers or start ignoring events from specified paths. + */ + unwatch(paths_: Path | Path[]): FSWatcher; + /** + * Close watchers and remove all listeners from watched paths. + */ + close(): Promise; + /** + * Expose list of watched paths + * @returns for chaining + */ + getWatched(): Record; + emitWithAll(event: EventName, args: EmitArgs): void; + /** + * Normalize and emit events. + * Calling _emit DOES NOT MEAN emit() would be called! + * @param event Type of event + * @param path File or directory path + * @param stats arguments to be passed with event + * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag + */ + _emit(event: EventName, path: Path, stats?: Stats): Promise; + /** + * Common handler for errors + * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag + */ + _handleError(error: Error): Error | boolean; + /** + * Helper utility for throttling + * @param actionType type being throttled + * @param path being acted upon + * @param timeout duration of time to suppress duplicate actions + * @returns tracking object or false if action should be suppressed + */ + _throttle(actionType: ThrottleType, path: Path, timeout: number): Throttler | false; + _incrReadyCount(): number; + /** + * Awaits write operation to finish. + * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback. + * @param path being acted upon + * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished + * @param event + * @param awfEmit Callback to be called when ready for event to be emitted. + */ + _awaitWriteFinish(path: Path, threshold: number, event: EventName, awfEmit: (err?: Error, stat?: Stats) => void): void; + /** + * Determines whether user has asked to ignore this path. + */ + _isIgnored(path: Path, stats?: Stats): boolean; + _isntIgnored(path: Path, stat?: Stats): boolean; + /** + * Provides a set of common helpers and properties relating to symlink handling. + * @param path file or directory pattern being watched + */ + _getWatchHelpers(path: Path): WatchHelper; + /** + * Provides directory tracking objects + * @param directory path of the directory + */ + _getWatchedDir(directory: string): DirEntry; + /** + * Check for read permissions: https://stackoverflow.com/a/11781404/1358405 + */ + _hasReadPermissions(stats: Stats): boolean; + /** + * Handles emitting unlink events for + * files and directories, and via recursion, for + * files and directories within directories that are unlinked + * @param directory within which the following item is located + * @param item base path of item/directory + */ + _remove(directory: string, item: string, isDirectory?: boolean): void; + /** + * Closes all watchers for a path + */ + _closePath(path: Path): void; + /** + * Closes only file-specific watchers + */ + _closeFile(path: Path): void; + _addPathCloser(path: Path, closer: () => void): void; + _readdirp(root: Path, opts?: Partial): ReaddirpStream | undefined; +} +/** + * Instantiates watcher with paths to be tracked. + * @param paths file / directory paths + * @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others + * @returns an instance of FSWatcher for chaining. + * @example + * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); }); + * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') }) + */ +export declare function watch(paths: string | string[], options?: ChokidarOptions): FSWatcher; +declare const _default: { + watch: typeof watch; + FSWatcher: typeof FSWatcher; +}; +export default _default; diff --git a/node_modules/chokidar/esm/index.js b/node_modules/chokidar/esm/index.js new file mode 100644 index 0000000..1c80a40 --- /dev/null +++ b/node_modules/chokidar/esm/index.js @@ -0,0 +1,798 @@ +/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */ +import { stat as statcb } from 'fs'; +import { stat, readdir } from 'fs/promises'; +import { EventEmitter } from 'events'; +import * as sysPath from 'path'; +import { readdirp } from 'readdirp'; +import { NodeFsHandler, EVENTS as EV, isWindows, isIBMi, EMPTY_FN, STR_CLOSE, STR_END, } from './handler.js'; +const SLASH = '/'; +const SLASH_SLASH = '//'; +const ONE_DOT = '.'; +const TWO_DOTS = '..'; +const STRING_TYPE = 'string'; +const BACK_SLASH_RE = /\\/g; +const DOUBLE_SLASH_RE = /\/\//; +const DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/; +const REPLACER_RE = /^\.[/\\]/; +function arrify(item) { + return Array.isArray(item) ? item : [item]; +} +const isMatcherObject = (matcher) => typeof matcher === 'object' && matcher !== null && !(matcher instanceof RegExp); +function createPattern(matcher) { + if (typeof matcher === 'function') + return matcher; + if (typeof matcher === 'string') + return (string) => matcher === string; + if (matcher instanceof RegExp) + return (string) => matcher.test(string); + if (typeof matcher === 'object' && matcher !== null) { + return (string) => { + if (matcher.path === string) + return true; + if (matcher.recursive) { + const relative = sysPath.relative(matcher.path, string); + if (!relative) { + return false; + } + return !relative.startsWith('..') && !sysPath.isAbsolute(relative); + } + return false; + }; + } + return () => false; +} +function normalizePath(path) { + if (typeof path !== 'string') + throw new Error('string expected'); + path = sysPath.normalize(path); + path = path.replace(/\\/g, '/'); + let prepend = false; + if (path.startsWith('//')) + prepend = true; + const DOUBLE_SLASH_RE = /\/\//; + while (path.match(DOUBLE_SLASH_RE)) + path = path.replace(DOUBLE_SLASH_RE, '/'); + if (prepend) + path = '/' + path; + return path; +} +function matchPatterns(patterns, testString, stats) { + const path = normalizePath(testString); + for (let index = 0; index < patterns.length; index++) { + const pattern = patterns[index]; + if (pattern(path, stats)) { + return true; + } + } + return false; +} +function anymatch(matchers, testString) { + if (matchers == null) { + throw new TypeError('anymatch: specify first argument'); + } + // Early cache for matchers. + const matchersArray = arrify(matchers); + const patterns = matchersArray.map((matcher) => createPattern(matcher)); + if (testString == null) { + return (testString, stats) => { + return matchPatterns(patterns, testString, stats); + }; + } + return matchPatterns(patterns, testString); +} +const unifyPaths = (paths_) => { + const paths = arrify(paths_).flat(); + if (!paths.every((p) => typeof p === STRING_TYPE)) { + throw new TypeError(`Non-string provided as watch path: ${paths}`); + } + return paths.map(normalizePathToUnix); +}; +// If SLASH_SLASH occurs at the beginning of path, it is not replaced +// because "//StoragePC/DrivePool/Movies" is a valid network path +const toUnix = (string) => { + let str = string.replace(BACK_SLASH_RE, SLASH); + let prepend = false; + if (str.startsWith(SLASH_SLASH)) { + prepend = true; + } + while (str.match(DOUBLE_SLASH_RE)) { + str = str.replace(DOUBLE_SLASH_RE, SLASH); + } + if (prepend) { + str = SLASH + str; + } + return str; +}; +// Our version of upath.normalize +// TODO: this is not equal to path-normalize module - investigate why +const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path))); +// TODO: refactor +const normalizeIgnored = (cwd = '') => (path) => { + if (typeof path === 'string') { + return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path)); + } + else { + return path; + } +}; +const getAbsolutePath = (path, cwd) => { + if (sysPath.isAbsolute(path)) { + return path; + } + return sysPath.join(cwd, path); +}; +const EMPTY_SET = Object.freeze(new Set()); +/** + * Directory entry. + */ +class DirEntry { + constructor(dir, removeWatcher) { + this.path = dir; + this._removeWatcher = removeWatcher; + this.items = new Set(); + } + add(item) { + const { items } = this; + if (!items) + return; + if (item !== ONE_DOT && item !== TWO_DOTS) + items.add(item); + } + async remove(item) { + const { items } = this; + if (!items) + return; + items.delete(item); + if (items.size > 0) + return; + const dir = this.path; + try { + await readdir(dir); + } + catch (err) { + if (this._removeWatcher) { + this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir)); + } + } + } + has(item) { + const { items } = this; + if (!items) + return; + return items.has(item); + } + getChildren() { + const { items } = this; + if (!items) + return []; + return [...items.values()]; + } + dispose() { + this.items.clear(); + this.path = ''; + this._removeWatcher = EMPTY_FN; + this.items = EMPTY_SET; + Object.freeze(this); + } +} +const STAT_METHOD_F = 'stat'; +const STAT_METHOD_L = 'lstat'; +export class WatchHelper { + constructor(path, follow, fsw) { + this.fsw = fsw; + const watchPath = path; + this.path = path = path.replace(REPLACER_RE, ''); + this.watchPath = watchPath; + this.fullWatchPath = sysPath.resolve(watchPath); + this.dirParts = []; + this.dirParts.forEach((parts) => { + if (parts.length > 1) + parts.pop(); + }); + this.followSymlinks = follow; + this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L; + } + entryPath(entry) { + return sysPath.join(this.watchPath, sysPath.relative(this.watchPath, entry.fullPath)); + } + filterPath(entry) { + const { stats } = entry; + if (stats && stats.isSymbolicLink()) + return this.filterDir(entry); + const resolvedPath = this.entryPath(entry); + // TODO: what if stats is undefined? remove ! + return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats); + } + filterDir(entry) { + return this.fsw._isntIgnored(this.entryPath(entry), entry.stats); + } +} +/** + * Watches files & directories for changes. Emitted events: + * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error` + * + * new FSWatcher() + * .add(directories) + * .on('add', path => log('File', path, 'was added')) + */ +export class FSWatcher extends EventEmitter { + // Not indenting methods for history sake; for now. + constructor(_opts = {}) { + super(); + this.closed = false; + this._closers = new Map(); + this._ignoredPaths = new Set(); + this._throttled = new Map(); + this._streams = new Set(); + this._symlinkPaths = new Map(); + this._watched = new Map(); + this._pendingWrites = new Map(); + this._pendingUnlinks = new Map(); + this._readyCount = 0; + this._readyEmitted = false; + const awf = _opts.awaitWriteFinish; + const DEF_AWF = { stabilityThreshold: 2000, pollInterval: 100 }; + const opts = { + // Defaults + persistent: true, + ignoreInitial: false, + ignorePermissionErrors: false, + interval: 100, + binaryInterval: 300, + followSymlinks: true, + usePolling: false, + // useAsync: false, + atomic: true, // NOTE: overwritten later (depends on usePolling) + ..._opts, + // Change format + ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]), + awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === 'object' ? { ...DEF_AWF, ...awf } : false, + }; + // Always default to polling on IBM i because fs.watch() is not available on IBM i. + if (isIBMi) + opts.usePolling = true; + // Editor atomic write normalization enabled by default with fs.watch + if (opts.atomic === undefined) + opts.atomic = !opts.usePolling; + // opts.atomic = typeof _opts.atomic === 'number' ? _opts.atomic : 100; + // Global override. Useful for developers, who need to force polling for all + // instances of chokidar, regardless of usage / dependency depth + const envPoll = process.env.CHOKIDAR_USEPOLLING; + if (envPoll !== undefined) { + const envLower = envPoll.toLowerCase(); + if (envLower === 'false' || envLower === '0') + opts.usePolling = false; + else if (envLower === 'true' || envLower === '1') + opts.usePolling = true; + else + opts.usePolling = !!envLower; + } + const envInterval = process.env.CHOKIDAR_INTERVAL; + if (envInterval) + opts.interval = Number.parseInt(envInterval, 10); + // This is done to emit ready only once, but each 'add' will increase that? + let readyCalls = 0; + this._emitReady = () => { + readyCalls++; + if (readyCalls >= this._readyCount) { + this._emitReady = EMPTY_FN; + this._readyEmitted = true; + // use process.nextTick to allow time for listener to be bound + process.nextTick(() => this.emit(EV.READY)); + } + }; + this._emitRaw = (...args) => this.emit(EV.RAW, ...args); + this._boundRemove = this._remove.bind(this); + this.options = opts; + this._nodeFsHandler = new NodeFsHandler(this); + // You’re frozen when your heart’s not open. + Object.freeze(opts); + } + _addIgnoredPath(matcher) { + if (isMatcherObject(matcher)) { + // return early if we already have a deeply equal matcher object + for (const ignored of this._ignoredPaths) { + if (isMatcherObject(ignored) && + ignored.path === matcher.path && + ignored.recursive === matcher.recursive) { + return; + } + } + } + this._ignoredPaths.add(matcher); + } + _removeIgnoredPath(matcher) { + this._ignoredPaths.delete(matcher); + // now find any matcher objects with the matcher as path + if (typeof matcher === 'string') { + for (const ignored of this._ignoredPaths) { + // TODO (43081j): make this more efficient. + // probably just make a `this._ignoredDirectories` or some + // such thing. + if (isMatcherObject(ignored) && ignored.path === matcher) { + this._ignoredPaths.delete(ignored); + } + } + } + } + // Public methods + /** + * Adds paths to be watched on an existing FSWatcher instance. + * @param paths_ file or file list. Other arguments are unused + */ + add(paths_, _origAdd, _internal) { + const { cwd } = this.options; + this.closed = false; + this._closePromise = undefined; + let paths = unifyPaths(paths_); + if (cwd) { + paths = paths.map((path) => { + const absPath = getAbsolutePath(path, cwd); + // Check `path` instead of `absPath` because the cwd portion can't be a glob + return absPath; + }); + } + paths.forEach((path) => { + this._removeIgnoredPath(path); + }); + this._userIgnored = undefined; + if (!this._readyCount) + this._readyCount = 0; + this._readyCount += paths.length; + Promise.all(paths.map(async (path) => { + const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, undefined, 0, _origAdd); + if (res) + this._emitReady(); + return res; + })).then((results) => { + if (this.closed) + return; + results.forEach((item) => { + if (item) + this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item)); + }); + }); + return this; + } + /** + * Close watchers or start ignoring events from specified paths. + */ + unwatch(paths_) { + if (this.closed) + return this; + const paths = unifyPaths(paths_); + const { cwd } = this.options; + paths.forEach((path) => { + // convert to absolute path unless relative path already matches + if (!sysPath.isAbsolute(path) && !this._closers.has(path)) { + if (cwd) + path = sysPath.join(cwd, path); + path = sysPath.resolve(path); + } + this._closePath(path); + this._addIgnoredPath(path); + if (this._watched.has(path)) { + this._addIgnoredPath({ + path, + recursive: true, + }); + } + // reset the cached userIgnored anymatch fn + // to make ignoredPaths changes effective + this._userIgnored = undefined; + }); + return this; + } + /** + * Close watchers and remove all listeners from watched paths. + */ + close() { + if (this._closePromise) { + return this._closePromise; + } + this.closed = true; + // Memory management. + this.removeAllListeners(); + const closers = []; + this._closers.forEach((closerList) => closerList.forEach((closer) => { + const promise = closer(); + if (promise instanceof Promise) + closers.push(promise); + })); + this._streams.forEach((stream) => stream.destroy()); + this._userIgnored = undefined; + this._readyCount = 0; + this._readyEmitted = false; + this._watched.forEach((dirent) => dirent.dispose()); + this._closers.clear(); + this._watched.clear(); + this._streams.clear(); + this._symlinkPaths.clear(); + this._throttled.clear(); + this._closePromise = closers.length + ? Promise.all(closers).then(() => undefined) + : Promise.resolve(); + return this._closePromise; + } + /** + * Expose list of watched paths + * @returns for chaining + */ + getWatched() { + const watchList = {}; + this._watched.forEach((entry, dir) => { + const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir; + const index = key || ONE_DOT; + watchList[index] = entry.getChildren().sort(); + }); + return watchList; + } + emitWithAll(event, args) { + this.emit(event, ...args); + if (event !== EV.ERROR) + this.emit(EV.ALL, event, ...args); + } + // Common helpers + // -------------- + /** + * Normalize and emit events. + * Calling _emit DOES NOT MEAN emit() would be called! + * @param event Type of event + * @param path File or directory path + * @param stats arguments to be passed with event + * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag + */ + async _emit(event, path, stats) { + if (this.closed) + return; + const opts = this.options; + if (isWindows) + path = sysPath.normalize(path); + if (opts.cwd) + path = sysPath.relative(opts.cwd, path); + const args = [path]; + if (stats != null) + args.push(stats); + const awf = opts.awaitWriteFinish; + let pw; + if (awf && (pw = this._pendingWrites.get(path))) { + pw.lastChange = new Date(); + return this; + } + if (opts.atomic) { + if (event === EV.UNLINK) { + this._pendingUnlinks.set(path, [event, ...args]); + setTimeout(() => { + this._pendingUnlinks.forEach((entry, path) => { + this.emit(...entry); + this.emit(EV.ALL, ...entry); + this._pendingUnlinks.delete(path); + }); + }, typeof opts.atomic === 'number' ? opts.atomic : 100); + return this; + } + if (event === EV.ADD && this._pendingUnlinks.has(path)) { + event = EV.CHANGE; + this._pendingUnlinks.delete(path); + } + } + if (awf && (event === EV.ADD || event === EV.CHANGE) && this._readyEmitted) { + const awfEmit = (err, stats) => { + if (err) { + event = EV.ERROR; + args[0] = err; + this.emitWithAll(event, args); + } + else if (stats) { + // if stats doesn't exist the file must have been deleted + if (args.length > 1) { + args[1] = stats; + } + else { + args.push(stats); + } + this.emitWithAll(event, args); + } + }; + this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit); + return this; + } + if (event === EV.CHANGE) { + const isThrottled = !this._throttle(EV.CHANGE, path, 50); + if (isThrottled) + return this; + } + if (opts.alwaysStat && + stats === undefined && + (event === EV.ADD || event === EV.ADD_DIR || event === EV.CHANGE)) { + const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path; + let stats; + try { + stats = await stat(fullPath); + } + catch (err) { + // do nothing + } + // Suppress event when fs_stat fails, to avoid sending undefined 'stat' + if (!stats || this.closed) + return; + args.push(stats); + } + this.emitWithAll(event, args); + return this; + } + /** + * Common handler for errors + * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag + */ + _handleError(error) { + const code = error && error.code; + if (error && + code !== 'ENOENT' && + code !== 'ENOTDIR' && + (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))) { + this.emit(EV.ERROR, error); + } + return error || this.closed; + } + /** + * Helper utility for throttling + * @param actionType type being throttled + * @param path being acted upon + * @param timeout duration of time to suppress duplicate actions + * @returns tracking object or false if action should be suppressed + */ + _throttle(actionType, path, timeout) { + if (!this._throttled.has(actionType)) { + this._throttled.set(actionType, new Map()); + } + const action = this._throttled.get(actionType); + if (!action) + throw new Error('invalid throttle'); + const actionPath = action.get(path); + if (actionPath) { + actionPath.count++; + return false; + } + // eslint-disable-next-line prefer-const + let timeoutObject; + const clear = () => { + const item = action.get(path); + const count = item ? item.count : 0; + action.delete(path); + clearTimeout(timeoutObject); + if (item) + clearTimeout(item.timeoutObject); + return count; + }; + timeoutObject = setTimeout(clear, timeout); + const thr = { timeoutObject, clear, count: 0 }; + action.set(path, thr); + return thr; + } + _incrReadyCount() { + return this._readyCount++; + } + /** + * Awaits write operation to finish. + * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback. + * @param path being acted upon + * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished + * @param event + * @param awfEmit Callback to be called when ready for event to be emitted. + */ + _awaitWriteFinish(path, threshold, event, awfEmit) { + const awf = this.options.awaitWriteFinish; + if (typeof awf !== 'object') + return; + const pollInterval = awf.pollInterval; + let timeoutHandler; + let fullPath = path; + if (this.options.cwd && !sysPath.isAbsolute(path)) { + fullPath = sysPath.join(this.options.cwd, path); + } + const now = new Date(); + const writes = this._pendingWrites; + function awaitWriteFinishFn(prevStat) { + statcb(fullPath, (err, curStat) => { + if (err || !writes.has(path)) { + if (err && err.code !== 'ENOENT') + awfEmit(err); + return; + } + const now = Number(new Date()); + if (prevStat && curStat.size !== prevStat.size) { + writes.get(path).lastChange = now; + } + const pw = writes.get(path); + const df = now - pw.lastChange; + if (df >= threshold) { + writes.delete(path); + awfEmit(undefined, curStat); + } + else { + timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat); + } + }); + } + if (!writes.has(path)) { + writes.set(path, { + lastChange: now, + cancelWait: () => { + writes.delete(path); + clearTimeout(timeoutHandler); + return event; + }, + }); + timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval); + } + } + /** + * Determines whether user has asked to ignore this path. + */ + _isIgnored(path, stats) { + if (this.options.atomic && DOT_RE.test(path)) + return true; + if (!this._userIgnored) { + const { cwd } = this.options; + const ign = this.options.ignored; + const ignored = (ign || []).map(normalizeIgnored(cwd)); + const ignoredPaths = [...this._ignoredPaths]; + const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored]; + this._userIgnored = anymatch(list, undefined); + } + return this._userIgnored(path, stats); + } + _isntIgnored(path, stat) { + return !this._isIgnored(path, stat); + } + /** + * Provides a set of common helpers and properties relating to symlink handling. + * @param path file or directory pattern being watched + */ + _getWatchHelpers(path) { + return new WatchHelper(path, this.options.followSymlinks, this); + } + // Directory helpers + // ----------------- + /** + * Provides directory tracking objects + * @param directory path of the directory + */ + _getWatchedDir(directory) { + const dir = sysPath.resolve(directory); + if (!this._watched.has(dir)) + this._watched.set(dir, new DirEntry(dir, this._boundRemove)); + return this._watched.get(dir); + } + // File helpers + // ------------ + /** + * Check for read permissions: https://stackoverflow.com/a/11781404/1358405 + */ + _hasReadPermissions(stats) { + if (this.options.ignorePermissionErrors) + return true; + return Boolean(Number(stats.mode) & 0o400); + } + /** + * Handles emitting unlink events for + * files and directories, and via recursion, for + * files and directories within directories that are unlinked + * @param directory within which the following item is located + * @param item base path of item/directory + */ + _remove(directory, item, isDirectory) { + // if what is being deleted is a directory, get that directory's paths + // for recursive deleting and cleaning of watched object + // if it is not a directory, nestedDirectoryChildren will be empty array + const path = sysPath.join(directory, item); + const fullPath = sysPath.resolve(path); + isDirectory = + isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath); + // prevent duplicate handling in case of arriving here nearly simultaneously + // via multiple paths (such as _handleFile and _handleDir) + if (!this._throttle('remove', path, 100)) + return; + // if the only watched file is removed, watch for its return + if (!isDirectory && this._watched.size === 1) { + this.add(directory, item, true); + } + // This will create a new entry in the watched object in either case + // so we got to do the directory check beforehand + const wp = this._getWatchedDir(path); + const nestedDirectoryChildren = wp.getChildren(); + // Recursively remove children directories / files. + nestedDirectoryChildren.forEach((nested) => this._remove(path, nested)); + // Check if item was on the watched list and remove it + const parent = this._getWatchedDir(directory); + const wasTracked = parent.has(item); + parent.remove(item); + // Fixes issue #1042 -> Relative paths were detected and added as symlinks + // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612), + // but never removed from the map in case the path was deleted. + // This leads to an incorrect state if the path was recreated: + // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553 + if (this._symlinkPaths.has(fullPath)) { + this._symlinkPaths.delete(fullPath); + } + // If we wait for this file to be fully written, cancel the wait. + let relPath = path; + if (this.options.cwd) + relPath = sysPath.relative(this.options.cwd, path); + if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) { + const event = this._pendingWrites.get(relPath).cancelWait(); + if (event === EV.ADD) + return; + } + // The Entry will either be a directory that just got removed + // or a bogus entry to a file, in either case we have to remove it + this._watched.delete(path); + this._watched.delete(fullPath); + const eventName = isDirectory ? EV.UNLINK_DIR : EV.UNLINK; + if (wasTracked && !this._isIgnored(path)) + this._emit(eventName, path); + // Avoid conflicts if we later create another file with the same name + this._closePath(path); + } + /** + * Closes all watchers for a path + */ + _closePath(path) { + this._closeFile(path); + const dir = sysPath.dirname(path); + this._getWatchedDir(dir).remove(sysPath.basename(path)); + } + /** + * Closes only file-specific watchers + */ + _closeFile(path) { + const closers = this._closers.get(path); + if (!closers) + return; + closers.forEach((closer) => closer()); + this._closers.delete(path); + } + _addPathCloser(path, closer) { + if (!closer) + return; + let list = this._closers.get(path); + if (!list) { + list = []; + this._closers.set(path, list); + } + list.push(closer); + } + _readdirp(root, opts) { + if (this.closed) + return; + const options = { type: EV.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 }; + let stream = readdirp(root, options); + this._streams.add(stream); + stream.once(STR_CLOSE, () => { + stream = undefined; + }); + stream.once(STR_END, () => { + if (stream) { + this._streams.delete(stream); + stream = undefined; + } + }); + return stream; + } +} +/** + * Instantiates watcher with paths to be tracked. + * @param paths file / directory paths + * @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others + * @returns an instance of FSWatcher for chaining. + * @example + * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); }); + * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') }) + */ +export function watch(paths, options = {}) { + const watcher = new FSWatcher(options); + watcher.add(paths); + return watcher; +} +export default { watch, FSWatcher }; diff --git a/node_modules/chokidar/esm/package.json b/node_modules/chokidar/esm/package.json new file mode 100644 index 0000000..8769641 --- /dev/null +++ b/node_modules/chokidar/esm/package.json @@ -0,0 +1 @@ +{ "type": "module", "sideEffects": false } diff --git a/node_modules/chokidar/handler.d.ts b/node_modules/chokidar/handler.d.ts new file mode 100644 index 0000000..ea777d0 --- /dev/null +++ b/node_modules/chokidar/handler.d.ts @@ -0,0 +1,90 @@ +import type { WatchEventType, Stats, FSWatcher as NativeFsWatcher } from 'fs'; +import type { FSWatcher, WatchHelper, Throttler } from './index.js'; +import type { EntryInfo } from 'readdirp'; +export type Path = string; +export declare const STR_DATA = "data"; +export declare const STR_END = "end"; +export declare const STR_CLOSE = "close"; +export declare const EMPTY_FN: () => void; +export declare const IDENTITY_FN: (val: unknown) => unknown; +export declare const isWindows: boolean; +export declare const isMacos: boolean; +export declare const isLinux: boolean; +export declare const isFreeBSD: boolean; +export declare const isIBMi: boolean; +export declare const EVENTS: { + readonly ALL: "all"; + readonly READY: "ready"; + readonly ADD: "add"; + readonly CHANGE: "change"; + readonly ADD_DIR: "addDir"; + readonly UNLINK: "unlink"; + readonly UNLINK_DIR: "unlinkDir"; + readonly RAW: "raw"; + readonly ERROR: "error"; +}; +export type EventName = (typeof EVENTS)[keyof typeof EVENTS]; +export type FsWatchContainer = { + listeners: (path: string) => void | Set; + errHandlers: (err: unknown) => void | Set; + rawEmitters: (ev: WatchEventType, path: string, opts: unknown) => void | Set; + watcher: NativeFsWatcher; + watcherUnusable?: boolean; +}; +export interface WatchHandlers { + listener: (path: string) => void; + errHandler: (err: unknown) => void; + rawEmitter: (ev: WatchEventType, path: string, opts: unknown) => void; +} +/** + * @mixin + */ +export declare class NodeFsHandler { + fsw: FSWatcher; + _boundHandleError: (error: unknown) => void; + constructor(fsW: FSWatcher); + /** + * Watch file for changes with fs_watchFile or fs_watch. + * @param path to file or dir + * @param listener on fs change + * @returns closer for the watcher instance + */ + _watchWithNodeFs(path: string, listener: (path: string, newStats?: any) => void | Promise): (() => void) | undefined; + /** + * Watch a file and emit add event if warranted. + * @returns closer for the watcher instance + */ + _handleFile(file: Path, stats: Stats, initialAdd: boolean): (() => void) | undefined; + /** + * Handle symlinks encountered while reading a dir. + * @param entry returned by readdirp + * @param directory path of dir being read + * @param path of this item + * @param item basename of this item + * @returns true if no more processing is needed for this entry. + */ + _handleSymlink(entry: EntryInfo, directory: string, path: Path, item: string): Promise; + _handleRead(directory: string, initialAdd: boolean, wh: WatchHelper, target: Path, dir: Path, depth: number, throttler: Throttler): Promise | undefined; + /** + * Read directory to add / remove files from `@watched` list and re-read it on change. + * @param dir fs path + * @param stats + * @param initialAdd + * @param depth relative to user-supplied path + * @param target child path targeted for watch + * @param wh Common watch helpers for this path + * @param realpath + * @returns closer for the watcher instance. + */ + _handleDir(dir: string, stats: Stats, initialAdd: boolean, depth: number, target: string, wh: WatchHelper, realpath: string): Promise<(() => void) | undefined>; + /** + * Handle added file, directory, or glob pattern. + * Delegates call to _handleFile / _handleDir after checks. + * @param path to file or ir + * @param initialAdd was the file added at watch instantiation? + * @param priorWh depth relative to user-supplied path + * @param depth Child path actually targeted for watch + * @param target Child path actually targeted for watch + */ + _addToNodeFs(path: string, initialAdd: boolean, priorWh: WatchHelper | undefined, depth: number, target?: string): Promise; +} diff --git a/node_modules/chokidar/handler.js b/node_modules/chokidar/handler.js new file mode 100644 index 0000000..9c2ef28 --- /dev/null +++ b/node_modules/chokidar/handler.js @@ -0,0 +1,635 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.NodeFsHandler = exports.EVENTS = exports.isIBMi = exports.isFreeBSD = exports.isLinux = exports.isMacos = exports.isWindows = exports.IDENTITY_FN = exports.EMPTY_FN = exports.STR_CLOSE = exports.STR_END = exports.STR_DATA = void 0; +const fs_1 = require("fs"); +const promises_1 = require("fs/promises"); +const sysPath = require("path"); +const os_1 = require("os"); +exports.STR_DATA = 'data'; +exports.STR_END = 'end'; +exports.STR_CLOSE = 'close'; +const EMPTY_FN = () => { }; +exports.EMPTY_FN = EMPTY_FN; +const IDENTITY_FN = (val) => val; +exports.IDENTITY_FN = IDENTITY_FN; +const pl = process.platform; +exports.isWindows = pl === 'win32'; +exports.isMacos = pl === 'darwin'; +exports.isLinux = pl === 'linux'; +exports.isFreeBSD = pl === 'freebsd'; +exports.isIBMi = (0, os_1.type)() === 'OS400'; +exports.EVENTS = { + ALL: 'all', + READY: 'ready', + ADD: 'add', + CHANGE: 'change', + ADD_DIR: 'addDir', + UNLINK: 'unlink', + UNLINK_DIR: 'unlinkDir', + RAW: 'raw', + ERROR: 'error', +}; +const EV = exports.EVENTS; +const THROTTLE_MODE_WATCH = 'watch'; +const statMethods = { lstat: promises_1.lstat, stat: promises_1.stat }; +const KEY_LISTENERS = 'listeners'; +const KEY_ERR = 'errHandlers'; +const KEY_RAW = 'rawEmitters'; +const HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW]; +// prettier-ignore +const binaryExtensions = new Set([ + '3dm', '3ds', '3g2', '3gp', '7z', 'a', 'aac', 'adp', 'afdesign', 'afphoto', 'afpub', 'ai', + 'aif', 'aiff', 'alz', 'ape', 'apk', 'appimage', 'ar', 'arj', 'asf', 'au', 'avi', + 'bak', 'baml', 'bh', 'bin', 'bk', 'bmp', 'btif', 'bz2', 'bzip2', + 'cab', 'caf', 'cgm', 'class', 'cmx', 'cpio', 'cr2', 'cur', 'dat', 'dcm', 'deb', 'dex', 'djvu', + 'dll', 'dmg', 'dng', 'doc', 'docm', 'docx', 'dot', 'dotm', 'dra', 'DS_Store', 'dsk', 'dts', + 'dtshd', 'dvb', 'dwg', 'dxf', + 'ecelp4800', 'ecelp7470', 'ecelp9600', 'egg', 'eol', 'eot', 'epub', 'exe', + 'f4v', 'fbs', 'fh', 'fla', 'flac', 'flatpak', 'fli', 'flv', 'fpx', 'fst', 'fvt', + 'g3', 'gh', 'gif', 'graffle', 'gz', 'gzip', + 'h261', 'h263', 'h264', 'icns', 'ico', 'ief', 'img', 'ipa', 'iso', + 'jar', 'jpeg', 'jpg', 'jpgv', 'jpm', 'jxr', 'key', 'ktx', + 'lha', 'lib', 'lvp', 'lz', 'lzh', 'lzma', 'lzo', + 'm3u', 'm4a', 'm4v', 'mar', 'mdi', 'mht', 'mid', 'midi', 'mj2', 'mka', 'mkv', 'mmr', 'mng', + 'mobi', 'mov', 'movie', 'mp3', + 'mp4', 'mp4a', 'mpeg', 'mpg', 'mpga', 'mxu', + 'nef', 'npx', 'numbers', 'nupkg', + 'o', 'odp', 'ods', 'odt', 'oga', 'ogg', 'ogv', 'otf', 'ott', + 'pages', 'pbm', 'pcx', 'pdb', 'pdf', 'pea', 'pgm', 'pic', 'png', 'pnm', 'pot', 'potm', + 'potx', 'ppa', 'ppam', + 'ppm', 'pps', 'ppsm', 'ppsx', 'ppt', 'pptm', 'pptx', 'psd', 'pya', 'pyc', 'pyo', 'pyv', + 'qt', + 'rar', 'ras', 'raw', 'resources', 'rgb', 'rip', 'rlc', 'rmf', 'rmvb', 'rpm', 'rtf', 'rz', + 's3m', 's7z', 'scpt', 'sgi', 'shar', 'snap', 'sil', 'sketch', 'slk', 'smv', 'snk', 'so', + 'stl', 'suo', 'sub', 'swf', + 'tar', 'tbz', 'tbz2', 'tga', 'tgz', 'thmx', 'tif', 'tiff', 'tlz', 'ttc', 'ttf', 'txz', + 'udf', 'uvh', 'uvi', 'uvm', 'uvp', 'uvs', 'uvu', + 'viv', 'vob', + 'war', 'wav', 'wax', 'wbmp', 'wdp', 'weba', 'webm', 'webp', 'whl', 'wim', 'wm', 'wma', + 'wmv', 'wmx', 'woff', 'woff2', 'wrm', 'wvx', + 'xbm', 'xif', 'xla', 'xlam', 'xls', 'xlsb', 'xlsm', 'xlsx', 'xlt', 'xltm', 'xltx', 'xm', + 'xmind', 'xpi', 'xpm', 'xwd', 'xz', + 'z', 'zip', 'zipx', +]); +const isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase()); +// TODO: emit errors properly. Example: EMFILE on Macos. +const foreach = (val, fn) => { + if (val instanceof Set) { + val.forEach(fn); + } + else { + fn(val); + } +}; +const addAndConvert = (main, prop, item) => { + let container = main[prop]; + if (!(container instanceof Set)) { + main[prop] = container = new Set([container]); + } + container.add(item); +}; +const clearItem = (cont) => (key) => { + const set = cont[key]; + if (set instanceof Set) { + set.clear(); + } + else { + delete cont[key]; + } +}; +const delFromSet = (main, prop, item) => { + const container = main[prop]; + if (container instanceof Set) { + container.delete(item); + } + else if (container === item) { + delete main[prop]; + } +}; +const isEmptySet = (val) => (val instanceof Set ? val.size === 0 : !val); +const FsWatchInstances = new Map(); +/** + * Instantiates the fs_watch interface + * @param path to be watched + * @param options to be passed to fs_watch + * @param listener main event handler + * @param errHandler emits info about errors + * @param emitRaw emits raw event data + * @returns {NativeFsWatcher} + */ +function createFsWatchInstance(path, options, listener, errHandler, emitRaw) { + const handleEvent = (rawEvent, evPath) => { + listener(path); + emitRaw(rawEvent, evPath, { watchedPath: path }); + // emit based on events occurring for files from a directory's watcher in + // case the file's watcher misses it (and rely on throttling to de-dupe) + if (evPath && path !== evPath) { + fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath)); + } + }; + try { + return (0, fs_1.watch)(path, { + persistent: options.persistent, + }, handleEvent); + } + catch (error) { + errHandler(error); + return undefined; + } +} +/** + * Helper for passing fs_watch event data to a collection of listeners + * @param fullPath absolute path bound to fs_watch instance + */ +const fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => { + const cont = FsWatchInstances.get(fullPath); + if (!cont) + return; + foreach(cont[listenerType], (listener) => { + listener(val1, val2, val3); + }); +}; +/** + * Instantiates the fs_watch interface or binds listeners + * to an existing one covering the same file system entry + * @param path + * @param fullPath absolute path + * @param options to be passed to fs_watch + * @param handlers container for event listener functions + */ +const setFsWatchListener = (path, fullPath, options, handlers) => { + const { listener, errHandler, rawEmitter } = handlers; + let cont = FsWatchInstances.get(fullPath); + let watcher; + if (!options.persistent) { + watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter); + if (!watcher) + return; + return watcher.close.bind(watcher); + } + if (cont) { + addAndConvert(cont, KEY_LISTENERS, listener); + addAndConvert(cont, KEY_ERR, errHandler); + addAndConvert(cont, KEY_RAW, rawEmitter); + } + else { + watcher = createFsWatchInstance(path, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, // no need to use broadcast here + fsWatchBroadcast.bind(null, fullPath, KEY_RAW)); + if (!watcher) + return; + watcher.on(EV.ERROR, async (error) => { + const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR); + if (cont) + cont.watcherUnusable = true; // documented since Node 10.4.1 + // Workaround for https://github.com/joyent/node/issues/4337 + if (exports.isWindows && error.code === 'EPERM') { + try { + const fd = await (0, promises_1.open)(path, 'r'); + await fd.close(); + broadcastErr(error); + } + catch (err) { + // do nothing + } + } + else { + broadcastErr(error); + } + }); + cont = { + listeners: listener, + errHandlers: errHandler, + rawEmitters: rawEmitter, + watcher, + }; + FsWatchInstances.set(fullPath, cont); + } + // const index = cont.listeners.indexOf(listener); + // removes this instance's listeners and closes the underlying fs_watch + // instance if there are no more listeners left + return () => { + delFromSet(cont, KEY_LISTENERS, listener); + delFromSet(cont, KEY_ERR, errHandler); + delFromSet(cont, KEY_RAW, rawEmitter); + if (isEmptySet(cont.listeners)) { + // Check to protect against issue gh-730. + // if (cont.watcherUnusable) { + cont.watcher.close(); + // } + FsWatchInstances.delete(fullPath); + HANDLER_KEYS.forEach(clearItem(cont)); + // @ts-ignore + cont.watcher = undefined; + Object.freeze(cont); + } + }; +}; +// fs_watchFile helpers +// object to hold per-process fs_watchFile instances +// (may be shared across chokidar FSWatcher instances) +const FsWatchFileInstances = new Map(); +/** + * Instantiates the fs_watchFile interface or binds listeners + * to an existing one covering the same file system entry + * @param path to be watched + * @param fullPath absolute path + * @param options options to be passed to fs_watchFile + * @param handlers container for event listener functions + * @returns closer + */ +const setFsWatchFileListener = (path, fullPath, options, handlers) => { + const { listener, rawEmitter } = handlers; + let cont = FsWatchFileInstances.get(fullPath); + // let listeners = new Set(); + // let rawEmitters = new Set(); + const copts = cont && cont.options; + if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) { + // "Upgrade" the watcher to persistence or a quicker interval. + // This creates some unlikely edge case issues if the user mixes + // settings in a very weird way, but solving for those cases + // doesn't seem worthwhile for the added complexity. + // listeners = cont.listeners; + // rawEmitters = cont.rawEmitters; + (0, fs_1.unwatchFile)(fullPath); + cont = undefined; + } + if (cont) { + addAndConvert(cont, KEY_LISTENERS, listener); + addAndConvert(cont, KEY_RAW, rawEmitter); + } + else { + // TODO + // listeners.add(listener); + // rawEmitters.add(rawEmitter); + cont = { + listeners: listener, + rawEmitters: rawEmitter, + options, + watcher: (0, fs_1.watchFile)(fullPath, options, (curr, prev) => { + foreach(cont.rawEmitters, (rawEmitter) => { + rawEmitter(EV.CHANGE, fullPath, { curr, prev }); + }); + const currmtime = curr.mtimeMs; + if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) { + foreach(cont.listeners, (listener) => listener(path, curr)); + } + }), + }; + FsWatchFileInstances.set(fullPath, cont); + } + // const index = cont.listeners.indexOf(listener); + // Removes this instance's listeners and closes the underlying fs_watchFile + // instance if there are no more listeners left. + return () => { + delFromSet(cont, KEY_LISTENERS, listener); + delFromSet(cont, KEY_RAW, rawEmitter); + if (isEmptySet(cont.listeners)) { + FsWatchFileInstances.delete(fullPath); + (0, fs_1.unwatchFile)(fullPath); + cont.options = cont.watcher = undefined; + Object.freeze(cont); + } + }; +}; +/** + * @mixin + */ +class NodeFsHandler { + constructor(fsW) { + this.fsw = fsW; + this._boundHandleError = (error) => fsW._handleError(error); + } + /** + * Watch file for changes with fs_watchFile or fs_watch. + * @param path to file or dir + * @param listener on fs change + * @returns closer for the watcher instance + */ + _watchWithNodeFs(path, listener) { + const opts = this.fsw.options; + const directory = sysPath.dirname(path); + const basename = sysPath.basename(path); + const parent = this.fsw._getWatchedDir(directory); + parent.add(basename); + const absolutePath = sysPath.resolve(path); + const options = { + persistent: opts.persistent, + }; + if (!listener) + listener = exports.EMPTY_FN; + let closer; + if (opts.usePolling) { + const enableBin = opts.interval !== opts.binaryInterval; + options.interval = enableBin && isBinaryPath(basename) ? opts.binaryInterval : opts.interval; + closer = setFsWatchFileListener(path, absolutePath, options, { + listener, + rawEmitter: this.fsw._emitRaw, + }); + } + else { + closer = setFsWatchListener(path, absolutePath, options, { + listener, + errHandler: this._boundHandleError, + rawEmitter: this.fsw._emitRaw, + }); + } + return closer; + } + /** + * Watch a file and emit add event if warranted. + * @returns closer for the watcher instance + */ + _handleFile(file, stats, initialAdd) { + if (this.fsw.closed) { + return; + } + const dirname = sysPath.dirname(file); + const basename = sysPath.basename(file); + const parent = this.fsw._getWatchedDir(dirname); + // stats is always present + let prevStats = stats; + // if the file is already being watched, do nothing + if (parent.has(basename)) + return; + const listener = async (path, newStats) => { + if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) + return; + if (!newStats || newStats.mtimeMs === 0) { + try { + const newStats = await (0, promises_1.stat)(file); + if (this.fsw.closed) + return; + // Check that change event was not fired because of changed only accessTime. + const at = newStats.atimeMs; + const mt = newStats.mtimeMs; + if (!at || at <= mt || mt !== prevStats.mtimeMs) { + this.fsw._emit(EV.CHANGE, file, newStats); + } + if ((exports.isMacos || exports.isLinux || exports.isFreeBSD) && prevStats.ino !== newStats.ino) { + this.fsw._closeFile(path); + prevStats = newStats; + const closer = this._watchWithNodeFs(file, listener); + if (closer) + this.fsw._addPathCloser(path, closer); + } + else { + prevStats = newStats; + } + } + catch (error) { + // Fix issues where mtime is null but file is still present + this.fsw._remove(dirname, basename); + } + // add is about to be emitted if file not already tracked in parent + } + else if (parent.has(basename)) { + // Check that change event was not fired because of changed only accessTime. + const at = newStats.atimeMs; + const mt = newStats.mtimeMs; + if (!at || at <= mt || mt !== prevStats.mtimeMs) { + this.fsw._emit(EV.CHANGE, file, newStats); + } + prevStats = newStats; + } + }; + // kick off the watcher + const closer = this._watchWithNodeFs(file, listener); + // emit an add event if we're supposed to + if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) { + if (!this.fsw._throttle(EV.ADD, file, 0)) + return; + this.fsw._emit(EV.ADD, file, stats); + } + return closer; + } + /** + * Handle symlinks encountered while reading a dir. + * @param entry returned by readdirp + * @param directory path of dir being read + * @param path of this item + * @param item basename of this item + * @returns true if no more processing is needed for this entry. + */ + async _handleSymlink(entry, directory, path, item) { + if (this.fsw.closed) { + return; + } + const full = entry.fullPath; + const dir = this.fsw._getWatchedDir(directory); + if (!this.fsw.options.followSymlinks) { + // watch symlink directly (don't follow) and detect changes + this.fsw._incrReadyCount(); + let linkPath; + try { + linkPath = await (0, promises_1.realpath)(path); + } + catch (e) { + this.fsw._emitReady(); + return true; + } + if (this.fsw.closed) + return; + if (dir.has(item)) { + if (this.fsw._symlinkPaths.get(full) !== linkPath) { + this.fsw._symlinkPaths.set(full, linkPath); + this.fsw._emit(EV.CHANGE, path, entry.stats); + } + } + else { + dir.add(item); + this.fsw._symlinkPaths.set(full, linkPath); + this.fsw._emit(EV.ADD, path, entry.stats); + } + this.fsw._emitReady(); + return true; + } + // don't follow the same symlink more than once + if (this.fsw._symlinkPaths.has(full)) { + return true; + } + this.fsw._symlinkPaths.set(full, true); + } + _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) { + // Normalize the directory name on Windows + directory = sysPath.join(directory, ''); + throttler = this.fsw._throttle('readdir', directory, 1000); + if (!throttler) + return; + const previous = this.fsw._getWatchedDir(wh.path); + const current = new Set(); + let stream = this.fsw._readdirp(directory, { + fileFilter: (entry) => wh.filterPath(entry), + directoryFilter: (entry) => wh.filterDir(entry), + }); + if (!stream) + return; + stream + .on(exports.STR_DATA, async (entry) => { + if (this.fsw.closed) { + stream = undefined; + return; + } + const item = entry.path; + let path = sysPath.join(directory, item); + current.add(item); + if (entry.stats.isSymbolicLink() && + (await this._handleSymlink(entry, directory, path, item))) { + return; + } + if (this.fsw.closed) { + stream = undefined; + return; + } + // Files that present in current directory snapshot + // but absent in previous are added to watch list and + // emit `add` event. + if (item === target || (!target && !previous.has(item))) { + this.fsw._incrReadyCount(); + // ensure relativeness of path is preserved in case of watcher reuse + path = sysPath.join(dir, sysPath.relative(dir, path)); + this._addToNodeFs(path, initialAdd, wh, depth + 1); + } + }) + .on(EV.ERROR, this._boundHandleError); + return new Promise((resolve, reject) => { + if (!stream) + return reject(); + stream.once(exports.STR_END, () => { + if (this.fsw.closed) { + stream = undefined; + return; + } + const wasThrottled = throttler ? throttler.clear() : false; + resolve(undefined); + // Files that absent in current directory snapshot + // but present in previous emit `remove` event + // and are removed from @watched[directory]. + previous + .getChildren() + .filter((item) => { + return item !== directory && !current.has(item); + }) + .forEach((item) => { + this.fsw._remove(directory, item); + }); + stream = undefined; + // one more time for any missed in case changes came in extremely quickly + if (wasThrottled) + this._handleRead(directory, false, wh, target, dir, depth, throttler); + }); + }); + } + /** + * Read directory to add / remove files from `@watched` list and re-read it on change. + * @param dir fs path + * @param stats + * @param initialAdd + * @param depth relative to user-supplied path + * @param target child path targeted for watch + * @param wh Common watch helpers for this path + * @param realpath + * @returns closer for the watcher instance. + */ + async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) { + const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir)); + const tracked = parentDir.has(sysPath.basename(dir)); + if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) { + this.fsw._emit(EV.ADD_DIR, dir, stats); + } + // ensure dir is tracked (harmless if redundant) + parentDir.add(sysPath.basename(dir)); + this.fsw._getWatchedDir(dir); + let throttler; + let closer; + const oDepth = this.fsw.options.depth; + if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) { + if (!target) { + await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler); + if (this.fsw.closed) + return; + } + closer = this._watchWithNodeFs(dir, (dirPath, stats) => { + // if current directory is removed, do nothing + if (stats && stats.mtimeMs === 0) + return; + this._handleRead(dirPath, false, wh, target, dir, depth, throttler); + }); + } + return closer; + } + /** + * Handle added file, directory, or glob pattern. + * Delegates call to _handleFile / _handleDir after checks. + * @param path to file or ir + * @param initialAdd was the file added at watch instantiation? + * @param priorWh depth relative to user-supplied path + * @param depth Child path actually targeted for watch + * @param target Child path actually targeted for watch + */ + async _addToNodeFs(path, initialAdd, priorWh, depth, target) { + const ready = this.fsw._emitReady; + if (this.fsw._isIgnored(path) || this.fsw.closed) { + ready(); + return false; + } + const wh = this.fsw._getWatchHelpers(path); + if (priorWh) { + wh.filterPath = (entry) => priorWh.filterPath(entry); + wh.filterDir = (entry) => priorWh.filterDir(entry); + } + // evaluate what is at the path we're being asked to watch + try { + const stats = await statMethods[wh.statMethod](wh.watchPath); + if (this.fsw.closed) + return; + if (this.fsw._isIgnored(wh.watchPath, stats)) { + ready(); + return false; + } + const follow = this.fsw.options.followSymlinks; + let closer; + if (stats.isDirectory()) { + const absPath = sysPath.resolve(path); + const targetPath = follow ? await (0, promises_1.realpath)(path) : path; + if (this.fsw.closed) + return; + closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath); + if (this.fsw.closed) + return; + // preserve this symlink's target path + if (absPath !== targetPath && targetPath !== undefined) { + this.fsw._symlinkPaths.set(absPath, targetPath); + } + } + else if (stats.isSymbolicLink()) { + const targetPath = follow ? await (0, promises_1.realpath)(path) : path; + if (this.fsw.closed) + return; + const parent = sysPath.dirname(wh.watchPath); + this.fsw._getWatchedDir(parent).add(wh.watchPath); + this.fsw._emit(EV.ADD, wh.watchPath, stats); + closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath); + if (this.fsw.closed) + return; + // preserve this symlink's target path + if (targetPath !== undefined) { + this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath); + } + } + else { + closer = this._handleFile(wh.watchPath, stats, initialAdd); + } + ready(); + if (closer) + this.fsw._addPathCloser(path, closer); + return false; + } + catch (error) { + if (this.fsw._handleError(error)) { + ready(); + return path; + } + } + } +} +exports.NodeFsHandler = NodeFsHandler; diff --git a/node_modules/chokidar/index.d.ts b/node_modules/chokidar/index.d.ts new file mode 100644 index 0000000..ffeb1e7 --- /dev/null +++ b/node_modules/chokidar/index.d.ts @@ -0,0 +1,215 @@ +/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */ +import { Stats } from 'fs'; +import { EventEmitter } from 'events'; +import { ReaddirpStream, ReaddirpOptions, EntryInfo } from 'readdirp'; +import { NodeFsHandler, EventName, Path, EVENTS as EV, WatchHandlers } from './handler.js'; +type AWF = { + stabilityThreshold: number; + pollInterval: number; +}; +type BasicOpts = { + persistent: boolean; + ignoreInitial: boolean; + followSymlinks: boolean; + cwd?: string; + usePolling: boolean; + interval: number; + binaryInterval: number; + alwaysStat?: boolean; + depth?: number; + ignorePermissionErrors: boolean; + atomic: boolean | number; +}; +export type Throttler = { + timeoutObject: NodeJS.Timeout; + clear: () => void; + count: number; +}; +export type ChokidarOptions = Partial; +}>; +export type FSWInstanceOptions = BasicOpts & { + ignored: Matcher[]; + awaitWriteFinish: false | AWF; +}; +export type ThrottleType = 'readdir' | 'watch' | 'add' | 'remove' | 'change'; +export type EmitArgs = [path: Path, stats?: Stats]; +export type EmitErrorArgs = [error: Error, stats?: Stats]; +export type EmitArgsWithName = [event: EventName, ...EmitArgs]; +export type MatchFunction = (val: string, stats?: Stats) => boolean; +export interface MatcherObject { + path: string; + recursive?: boolean; +} +export type Matcher = string | RegExp | MatchFunction | MatcherObject; +/** + * Directory entry. + */ +declare class DirEntry { + path: Path; + _removeWatcher: (dir: string, base: string) => void; + items: Set; + constructor(dir: Path, removeWatcher: (dir: string, base: string) => void); + add(item: string): void; + remove(item: string): Promise; + has(item: string): boolean | undefined; + getChildren(): string[]; + dispose(): void; +} +export declare class WatchHelper { + fsw: FSWatcher; + path: string; + watchPath: string; + fullWatchPath: string; + dirParts: string[][]; + followSymlinks: boolean; + statMethod: 'stat' | 'lstat'; + constructor(path: string, follow: boolean, fsw: FSWatcher); + entryPath(entry: EntryInfo): Path; + filterPath(entry: EntryInfo): boolean; + filterDir(entry: EntryInfo): boolean; +} +export interface FSWatcherKnownEventMap { + [EV.READY]: []; + [EV.RAW]: Parameters; + [EV.ERROR]: Parameters; + [EV.ALL]: [event: EventName, ...EmitArgs]; +} +export type FSWatcherEventMap = FSWatcherKnownEventMap & { + [k in Exclude]: EmitArgs; +}; +/** + * Watches files & directories for changes. Emitted events: + * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error` + * + * new FSWatcher() + * .add(directories) + * .on('add', path => log('File', path, 'was added')) + */ +export declare class FSWatcher extends EventEmitter { + closed: boolean; + options: FSWInstanceOptions; + _closers: Map>; + _ignoredPaths: Set; + _throttled: Map>; + _streams: Set; + _symlinkPaths: Map; + _watched: Map; + _pendingWrites: Map; + _pendingUnlinks: Map; + _readyCount: number; + _emitReady: () => void; + _closePromise?: Promise; + _userIgnored?: MatchFunction; + _readyEmitted: boolean; + _emitRaw: WatchHandlers['rawEmitter']; + _boundRemove: (dir: string, item: string) => void; + _nodeFsHandler: NodeFsHandler; + constructor(_opts?: ChokidarOptions); + _addIgnoredPath(matcher: Matcher): void; + _removeIgnoredPath(matcher: Matcher): void; + /** + * Adds paths to be watched on an existing FSWatcher instance. + * @param paths_ file or file list. Other arguments are unused + */ + add(paths_: Path | Path[], _origAdd?: string, _internal?: boolean): FSWatcher; + /** + * Close watchers or start ignoring events from specified paths. + */ + unwatch(paths_: Path | Path[]): FSWatcher; + /** + * Close watchers and remove all listeners from watched paths. + */ + close(): Promise; + /** + * Expose list of watched paths + * @returns for chaining + */ + getWatched(): Record; + emitWithAll(event: EventName, args: EmitArgs): void; + /** + * Normalize and emit events. + * Calling _emit DOES NOT MEAN emit() would be called! + * @param event Type of event + * @param path File or directory path + * @param stats arguments to be passed with event + * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag + */ + _emit(event: EventName, path: Path, stats?: Stats): Promise; + /** + * Common handler for errors + * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag + */ + _handleError(error: Error): Error | boolean; + /** + * Helper utility for throttling + * @param actionType type being throttled + * @param path being acted upon + * @param timeout duration of time to suppress duplicate actions + * @returns tracking object or false if action should be suppressed + */ + _throttle(actionType: ThrottleType, path: Path, timeout: number): Throttler | false; + _incrReadyCount(): number; + /** + * Awaits write operation to finish. + * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback. + * @param path being acted upon + * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished + * @param event + * @param awfEmit Callback to be called when ready for event to be emitted. + */ + _awaitWriteFinish(path: Path, threshold: number, event: EventName, awfEmit: (err?: Error, stat?: Stats) => void): void; + /** + * Determines whether user has asked to ignore this path. + */ + _isIgnored(path: Path, stats?: Stats): boolean; + _isntIgnored(path: Path, stat?: Stats): boolean; + /** + * Provides a set of common helpers and properties relating to symlink handling. + * @param path file or directory pattern being watched + */ + _getWatchHelpers(path: Path): WatchHelper; + /** + * Provides directory tracking objects + * @param directory path of the directory + */ + _getWatchedDir(directory: string): DirEntry; + /** + * Check for read permissions: https://stackoverflow.com/a/11781404/1358405 + */ + _hasReadPermissions(stats: Stats): boolean; + /** + * Handles emitting unlink events for + * files and directories, and via recursion, for + * files and directories within directories that are unlinked + * @param directory within which the following item is located + * @param item base path of item/directory + */ + _remove(directory: string, item: string, isDirectory?: boolean): void; + /** + * Closes all watchers for a path + */ + _closePath(path: Path): void; + /** + * Closes only file-specific watchers + */ + _closeFile(path: Path): void; + _addPathCloser(path: Path, closer: () => void): void; + _readdirp(root: Path, opts?: Partial): ReaddirpStream | undefined; +} +/** + * Instantiates watcher with paths to be tracked. + * @param paths file / directory paths + * @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others + * @returns an instance of FSWatcher for chaining. + * @example + * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); }); + * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') }) + */ +export declare function watch(paths: string | string[], options?: ChokidarOptions): FSWatcher; +declare const _default: { + watch: typeof watch; + FSWatcher: typeof FSWatcher; +}; +export default _default; diff --git a/node_modules/chokidar/index.js b/node_modules/chokidar/index.js new file mode 100644 index 0000000..79370ee --- /dev/null +++ b/node_modules/chokidar/index.js @@ -0,0 +1,804 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.FSWatcher = exports.WatchHelper = void 0; +exports.watch = watch; +/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */ +const fs_1 = require("fs"); +const promises_1 = require("fs/promises"); +const events_1 = require("events"); +const sysPath = require("path"); +const readdirp_1 = require("readdirp"); +const handler_js_1 = require("./handler.js"); +const SLASH = '/'; +const SLASH_SLASH = '//'; +const ONE_DOT = '.'; +const TWO_DOTS = '..'; +const STRING_TYPE = 'string'; +const BACK_SLASH_RE = /\\/g; +const DOUBLE_SLASH_RE = /\/\//; +const DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/; +const REPLACER_RE = /^\.[/\\]/; +function arrify(item) { + return Array.isArray(item) ? item : [item]; +} +const isMatcherObject = (matcher) => typeof matcher === 'object' && matcher !== null && !(matcher instanceof RegExp); +function createPattern(matcher) { + if (typeof matcher === 'function') + return matcher; + if (typeof matcher === 'string') + return (string) => matcher === string; + if (matcher instanceof RegExp) + return (string) => matcher.test(string); + if (typeof matcher === 'object' && matcher !== null) { + return (string) => { + if (matcher.path === string) + return true; + if (matcher.recursive) { + const relative = sysPath.relative(matcher.path, string); + if (!relative) { + return false; + } + return !relative.startsWith('..') && !sysPath.isAbsolute(relative); + } + return false; + }; + } + return () => false; +} +function normalizePath(path) { + if (typeof path !== 'string') + throw new Error('string expected'); + path = sysPath.normalize(path); + path = path.replace(/\\/g, '/'); + let prepend = false; + if (path.startsWith('//')) + prepend = true; + const DOUBLE_SLASH_RE = /\/\//; + while (path.match(DOUBLE_SLASH_RE)) + path = path.replace(DOUBLE_SLASH_RE, '/'); + if (prepend) + path = '/' + path; + return path; +} +function matchPatterns(patterns, testString, stats) { + const path = normalizePath(testString); + for (let index = 0; index < patterns.length; index++) { + const pattern = patterns[index]; + if (pattern(path, stats)) { + return true; + } + } + return false; +} +function anymatch(matchers, testString) { + if (matchers == null) { + throw new TypeError('anymatch: specify first argument'); + } + // Early cache for matchers. + const matchersArray = arrify(matchers); + const patterns = matchersArray.map((matcher) => createPattern(matcher)); + if (testString == null) { + return (testString, stats) => { + return matchPatterns(patterns, testString, stats); + }; + } + return matchPatterns(patterns, testString); +} +const unifyPaths = (paths_) => { + const paths = arrify(paths_).flat(); + if (!paths.every((p) => typeof p === STRING_TYPE)) { + throw new TypeError(`Non-string provided as watch path: ${paths}`); + } + return paths.map(normalizePathToUnix); +}; +// If SLASH_SLASH occurs at the beginning of path, it is not replaced +// because "//StoragePC/DrivePool/Movies" is a valid network path +const toUnix = (string) => { + let str = string.replace(BACK_SLASH_RE, SLASH); + let prepend = false; + if (str.startsWith(SLASH_SLASH)) { + prepend = true; + } + while (str.match(DOUBLE_SLASH_RE)) { + str = str.replace(DOUBLE_SLASH_RE, SLASH); + } + if (prepend) { + str = SLASH + str; + } + return str; +}; +// Our version of upath.normalize +// TODO: this is not equal to path-normalize module - investigate why +const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path))); +// TODO: refactor +const normalizeIgnored = (cwd = '') => (path) => { + if (typeof path === 'string') { + return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path)); + } + else { + return path; + } +}; +const getAbsolutePath = (path, cwd) => { + if (sysPath.isAbsolute(path)) { + return path; + } + return sysPath.join(cwd, path); +}; +const EMPTY_SET = Object.freeze(new Set()); +/** + * Directory entry. + */ +class DirEntry { + constructor(dir, removeWatcher) { + this.path = dir; + this._removeWatcher = removeWatcher; + this.items = new Set(); + } + add(item) { + const { items } = this; + if (!items) + return; + if (item !== ONE_DOT && item !== TWO_DOTS) + items.add(item); + } + async remove(item) { + const { items } = this; + if (!items) + return; + items.delete(item); + if (items.size > 0) + return; + const dir = this.path; + try { + await (0, promises_1.readdir)(dir); + } + catch (err) { + if (this._removeWatcher) { + this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir)); + } + } + } + has(item) { + const { items } = this; + if (!items) + return; + return items.has(item); + } + getChildren() { + const { items } = this; + if (!items) + return []; + return [...items.values()]; + } + dispose() { + this.items.clear(); + this.path = ''; + this._removeWatcher = handler_js_1.EMPTY_FN; + this.items = EMPTY_SET; + Object.freeze(this); + } +} +const STAT_METHOD_F = 'stat'; +const STAT_METHOD_L = 'lstat'; +class WatchHelper { + constructor(path, follow, fsw) { + this.fsw = fsw; + const watchPath = path; + this.path = path = path.replace(REPLACER_RE, ''); + this.watchPath = watchPath; + this.fullWatchPath = sysPath.resolve(watchPath); + this.dirParts = []; + this.dirParts.forEach((parts) => { + if (parts.length > 1) + parts.pop(); + }); + this.followSymlinks = follow; + this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L; + } + entryPath(entry) { + return sysPath.join(this.watchPath, sysPath.relative(this.watchPath, entry.fullPath)); + } + filterPath(entry) { + const { stats } = entry; + if (stats && stats.isSymbolicLink()) + return this.filterDir(entry); + const resolvedPath = this.entryPath(entry); + // TODO: what if stats is undefined? remove ! + return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats); + } + filterDir(entry) { + return this.fsw._isntIgnored(this.entryPath(entry), entry.stats); + } +} +exports.WatchHelper = WatchHelper; +/** + * Watches files & directories for changes. Emitted events: + * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error` + * + * new FSWatcher() + * .add(directories) + * .on('add', path => log('File', path, 'was added')) + */ +class FSWatcher extends events_1.EventEmitter { + // Not indenting methods for history sake; for now. + constructor(_opts = {}) { + super(); + this.closed = false; + this._closers = new Map(); + this._ignoredPaths = new Set(); + this._throttled = new Map(); + this._streams = new Set(); + this._symlinkPaths = new Map(); + this._watched = new Map(); + this._pendingWrites = new Map(); + this._pendingUnlinks = new Map(); + this._readyCount = 0; + this._readyEmitted = false; + const awf = _opts.awaitWriteFinish; + const DEF_AWF = { stabilityThreshold: 2000, pollInterval: 100 }; + const opts = { + // Defaults + persistent: true, + ignoreInitial: false, + ignorePermissionErrors: false, + interval: 100, + binaryInterval: 300, + followSymlinks: true, + usePolling: false, + // useAsync: false, + atomic: true, // NOTE: overwritten later (depends on usePolling) + ..._opts, + // Change format + ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]), + awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === 'object' ? { ...DEF_AWF, ...awf } : false, + }; + // Always default to polling on IBM i because fs.watch() is not available on IBM i. + if (handler_js_1.isIBMi) + opts.usePolling = true; + // Editor atomic write normalization enabled by default with fs.watch + if (opts.atomic === undefined) + opts.atomic = !opts.usePolling; + // opts.atomic = typeof _opts.atomic === 'number' ? _opts.atomic : 100; + // Global override. Useful for developers, who need to force polling for all + // instances of chokidar, regardless of usage / dependency depth + const envPoll = process.env.CHOKIDAR_USEPOLLING; + if (envPoll !== undefined) { + const envLower = envPoll.toLowerCase(); + if (envLower === 'false' || envLower === '0') + opts.usePolling = false; + else if (envLower === 'true' || envLower === '1') + opts.usePolling = true; + else + opts.usePolling = !!envLower; + } + const envInterval = process.env.CHOKIDAR_INTERVAL; + if (envInterval) + opts.interval = Number.parseInt(envInterval, 10); + // This is done to emit ready only once, but each 'add' will increase that? + let readyCalls = 0; + this._emitReady = () => { + readyCalls++; + if (readyCalls >= this._readyCount) { + this._emitReady = handler_js_1.EMPTY_FN; + this._readyEmitted = true; + // use process.nextTick to allow time for listener to be bound + process.nextTick(() => this.emit(handler_js_1.EVENTS.READY)); + } + }; + this._emitRaw = (...args) => this.emit(handler_js_1.EVENTS.RAW, ...args); + this._boundRemove = this._remove.bind(this); + this.options = opts; + this._nodeFsHandler = new handler_js_1.NodeFsHandler(this); + // You’re frozen when your heart’s not open. + Object.freeze(opts); + } + _addIgnoredPath(matcher) { + if (isMatcherObject(matcher)) { + // return early if we already have a deeply equal matcher object + for (const ignored of this._ignoredPaths) { + if (isMatcherObject(ignored) && + ignored.path === matcher.path && + ignored.recursive === matcher.recursive) { + return; + } + } + } + this._ignoredPaths.add(matcher); + } + _removeIgnoredPath(matcher) { + this._ignoredPaths.delete(matcher); + // now find any matcher objects with the matcher as path + if (typeof matcher === 'string') { + for (const ignored of this._ignoredPaths) { + // TODO (43081j): make this more efficient. + // probably just make a `this._ignoredDirectories` or some + // such thing. + if (isMatcherObject(ignored) && ignored.path === matcher) { + this._ignoredPaths.delete(ignored); + } + } + } + } + // Public methods + /** + * Adds paths to be watched on an existing FSWatcher instance. + * @param paths_ file or file list. Other arguments are unused + */ + add(paths_, _origAdd, _internal) { + const { cwd } = this.options; + this.closed = false; + this._closePromise = undefined; + let paths = unifyPaths(paths_); + if (cwd) { + paths = paths.map((path) => { + const absPath = getAbsolutePath(path, cwd); + // Check `path` instead of `absPath` because the cwd portion can't be a glob + return absPath; + }); + } + paths.forEach((path) => { + this._removeIgnoredPath(path); + }); + this._userIgnored = undefined; + if (!this._readyCount) + this._readyCount = 0; + this._readyCount += paths.length; + Promise.all(paths.map(async (path) => { + const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, undefined, 0, _origAdd); + if (res) + this._emitReady(); + return res; + })).then((results) => { + if (this.closed) + return; + results.forEach((item) => { + if (item) + this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item)); + }); + }); + return this; + } + /** + * Close watchers or start ignoring events from specified paths. + */ + unwatch(paths_) { + if (this.closed) + return this; + const paths = unifyPaths(paths_); + const { cwd } = this.options; + paths.forEach((path) => { + // convert to absolute path unless relative path already matches + if (!sysPath.isAbsolute(path) && !this._closers.has(path)) { + if (cwd) + path = sysPath.join(cwd, path); + path = sysPath.resolve(path); + } + this._closePath(path); + this._addIgnoredPath(path); + if (this._watched.has(path)) { + this._addIgnoredPath({ + path, + recursive: true, + }); + } + // reset the cached userIgnored anymatch fn + // to make ignoredPaths changes effective + this._userIgnored = undefined; + }); + return this; + } + /** + * Close watchers and remove all listeners from watched paths. + */ + close() { + if (this._closePromise) { + return this._closePromise; + } + this.closed = true; + // Memory management. + this.removeAllListeners(); + const closers = []; + this._closers.forEach((closerList) => closerList.forEach((closer) => { + const promise = closer(); + if (promise instanceof Promise) + closers.push(promise); + })); + this._streams.forEach((stream) => stream.destroy()); + this._userIgnored = undefined; + this._readyCount = 0; + this._readyEmitted = false; + this._watched.forEach((dirent) => dirent.dispose()); + this._closers.clear(); + this._watched.clear(); + this._streams.clear(); + this._symlinkPaths.clear(); + this._throttled.clear(); + this._closePromise = closers.length + ? Promise.all(closers).then(() => undefined) + : Promise.resolve(); + return this._closePromise; + } + /** + * Expose list of watched paths + * @returns for chaining + */ + getWatched() { + const watchList = {}; + this._watched.forEach((entry, dir) => { + const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir; + const index = key || ONE_DOT; + watchList[index] = entry.getChildren().sort(); + }); + return watchList; + } + emitWithAll(event, args) { + this.emit(event, ...args); + if (event !== handler_js_1.EVENTS.ERROR) + this.emit(handler_js_1.EVENTS.ALL, event, ...args); + } + // Common helpers + // -------------- + /** + * Normalize and emit events. + * Calling _emit DOES NOT MEAN emit() would be called! + * @param event Type of event + * @param path File or directory path + * @param stats arguments to be passed with event + * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag + */ + async _emit(event, path, stats) { + if (this.closed) + return; + const opts = this.options; + if (handler_js_1.isWindows) + path = sysPath.normalize(path); + if (opts.cwd) + path = sysPath.relative(opts.cwd, path); + const args = [path]; + if (stats != null) + args.push(stats); + const awf = opts.awaitWriteFinish; + let pw; + if (awf && (pw = this._pendingWrites.get(path))) { + pw.lastChange = new Date(); + return this; + } + if (opts.atomic) { + if (event === handler_js_1.EVENTS.UNLINK) { + this._pendingUnlinks.set(path, [event, ...args]); + setTimeout(() => { + this._pendingUnlinks.forEach((entry, path) => { + this.emit(...entry); + this.emit(handler_js_1.EVENTS.ALL, ...entry); + this._pendingUnlinks.delete(path); + }); + }, typeof opts.atomic === 'number' ? opts.atomic : 100); + return this; + } + if (event === handler_js_1.EVENTS.ADD && this._pendingUnlinks.has(path)) { + event = handler_js_1.EVENTS.CHANGE; + this._pendingUnlinks.delete(path); + } + } + if (awf && (event === handler_js_1.EVENTS.ADD || event === handler_js_1.EVENTS.CHANGE) && this._readyEmitted) { + const awfEmit = (err, stats) => { + if (err) { + event = handler_js_1.EVENTS.ERROR; + args[0] = err; + this.emitWithAll(event, args); + } + else if (stats) { + // if stats doesn't exist the file must have been deleted + if (args.length > 1) { + args[1] = stats; + } + else { + args.push(stats); + } + this.emitWithAll(event, args); + } + }; + this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit); + return this; + } + if (event === handler_js_1.EVENTS.CHANGE) { + const isThrottled = !this._throttle(handler_js_1.EVENTS.CHANGE, path, 50); + if (isThrottled) + return this; + } + if (opts.alwaysStat && + stats === undefined && + (event === handler_js_1.EVENTS.ADD || event === handler_js_1.EVENTS.ADD_DIR || event === handler_js_1.EVENTS.CHANGE)) { + const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path; + let stats; + try { + stats = await (0, promises_1.stat)(fullPath); + } + catch (err) { + // do nothing + } + // Suppress event when fs_stat fails, to avoid sending undefined 'stat' + if (!stats || this.closed) + return; + args.push(stats); + } + this.emitWithAll(event, args); + return this; + } + /** + * Common handler for errors + * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag + */ + _handleError(error) { + const code = error && error.code; + if (error && + code !== 'ENOENT' && + code !== 'ENOTDIR' && + (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))) { + this.emit(handler_js_1.EVENTS.ERROR, error); + } + return error || this.closed; + } + /** + * Helper utility for throttling + * @param actionType type being throttled + * @param path being acted upon + * @param timeout duration of time to suppress duplicate actions + * @returns tracking object or false if action should be suppressed + */ + _throttle(actionType, path, timeout) { + if (!this._throttled.has(actionType)) { + this._throttled.set(actionType, new Map()); + } + const action = this._throttled.get(actionType); + if (!action) + throw new Error('invalid throttle'); + const actionPath = action.get(path); + if (actionPath) { + actionPath.count++; + return false; + } + // eslint-disable-next-line prefer-const + let timeoutObject; + const clear = () => { + const item = action.get(path); + const count = item ? item.count : 0; + action.delete(path); + clearTimeout(timeoutObject); + if (item) + clearTimeout(item.timeoutObject); + return count; + }; + timeoutObject = setTimeout(clear, timeout); + const thr = { timeoutObject, clear, count: 0 }; + action.set(path, thr); + return thr; + } + _incrReadyCount() { + return this._readyCount++; + } + /** + * Awaits write operation to finish. + * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback. + * @param path being acted upon + * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished + * @param event + * @param awfEmit Callback to be called when ready for event to be emitted. + */ + _awaitWriteFinish(path, threshold, event, awfEmit) { + const awf = this.options.awaitWriteFinish; + if (typeof awf !== 'object') + return; + const pollInterval = awf.pollInterval; + let timeoutHandler; + let fullPath = path; + if (this.options.cwd && !sysPath.isAbsolute(path)) { + fullPath = sysPath.join(this.options.cwd, path); + } + const now = new Date(); + const writes = this._pendingWrites; + function awaitWriteFinishFn(prevStat) { + (0, fs_1.stat)(fullPath, (err, curStat) => { + if (err || !writes.has(path)) { + if (err && err.code !== 'ENOENT') + awfEmit(err); + return; + } + const now = Number(new Date()); + if (prevStat && curStat.size !== prevStat.size) { + writes.get(path).lastChange = now; + } + const pw = writes.get(path); + const df = now - pw.lastChange; + if (df >= threshold) { + writes.delete(path); + awfEmit(undefined, curStat); + } + else { + timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat); + } + }); + } + if (!writes.has(path)) { + writes.set(path, { + lastChange: now, + cancelWait: () => { + writes.delete(path); + clearTimeout(timeoutHandler); + return event; + }, + }); + timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval); + } + } + /** + * Determines whether user has asked to ignore this path. + */ + _isIgnored(path, stats) { + if (this.options.atomic && DOT_RE.test(path)) + return true; + if (!this._userIgnored) { + const { cwd } = this.options; + const ign = this.options.ignored; + const ignored = (ign || []).map(normalizeIgnored(cwd)); + const ignoredPaths = [...this._ignoredPaths]; + const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored]; + this._userIgnored = anymatch(list, undefined); + } + return this._userIgnored(path, stats); + } + _isntIgnored(path, stat) { + return !this._isIgnored(path, stat); + } + /** + * Provides a set of common helpers and properties relating to symlink handling. + * @param path file or directory pattern being watched + */ + _getWatchHelpers(path) { + return new WatchHelper(path, this.options.followSymlinks, this); + } + // Directory helpers + // ----------------- + /** + * Provides directory tracking objects + * @param directory path of the directory + */ + _getWatchedDir(directory) { + const dir = sysPath.resolve(directory); + if (!this._watched.has(dir)) + this._watched.set(dir, new DirEntry(dir, this._boundRemove)); + return this._watched.get(dir); + } + // File helpers + // ------------ + /** + * Check for read permissions: https://stackoverflow.com/a/11781404/1358405 + */ + _hasReadPermissions(stats) { + if (this.options.ignorePermissionErrors) + return true; + return Boolean(Number(stats.mode) & 0o400); + } + /** + * Handles emitting unlink events for + * files and directories, and via recursion, for + * files and directories within directories that are unlinked + * @param directory within which the following item is located + * @param item base path of item/directory + */ + _remove(directory, item, isDirectory) { + // if what is being deleted is a directory, get that directory's paths + // for recursive deleting and cleaning of watched object + // if it is not a directory, nestedDirectoryChildren will be empty array + const path = sysPath.join(directory, item); + const fullPath = sysPath.resolve(path); + isDirectory = + isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath); + // prevent duplicate handling in case of arriving here nearly simultaneously + // via multiple paths (such as _handleFile and _handleDir) + if (!this._throttle('remove', path, 100)) + return; + // if the only watched file is removed, watch for its return + if (!isDirectory && this._watched.size === 1) { + this.add(directory, item, true); + } + // This will create a new entry in the watched object in either case + // so we got to do the directory check beforehand + const wp = this._getWatchedDir(path); + const nestedDirectoryChildren = wp.getChildren(); + // Recursively remove children directories / files. + nestedDirectoryChildren.forEach((nested) => this._remove(path, nested)); + // Check if item was on the watched list and remove it + const parent = this._getWatchedDir(directory); + const wasTracked = parent.has(item); + parent.remove(item); + // Fixes issue #1042 -> Relative paths were detected and added as symlinks + // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612), + // but never removed from the map in case the path was deleted. + // This leads to an incorrect state if the path was recreated: + // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553 + if (this._symlinkPaths.has(fullPath)) { + this._symlinkPaths.delete(fullPath); + } + // If we wait for this file to be fully written, cancel the wait. + let relPath = path; + if (this.options.cwd) + relPath = sysPath.relative(this.options.cwd, path); + if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) { + const event = this._pendingWrites.get(relPath).cancelWait(); + if (event === handler_js_1.EVENTS.ADD) + return; + } + // The Entry will either be a directory that just got removed + // or a bogus entry to a file, in either case we have to remove it + this._watched.delete(path); + this._watched.delete(fullPath); + const eventName = isDirectory ? handler_js_1.EVENTS.UNLINK_DIR : handler_js_1.EVENTS.UNLINK; + if (wasTracked && !this._isIgnored(path)) + this._emit(eventName, path); + // Avoid conflicts if we later create another file with the same name + this._closePath(path); + } + /** + * Closes all watchers for a path + */ + _closePath(path) { + this._closeFile(path); + const dir = sysPath.dirname(path); + this._getWatchedDir(dir).remove(sysPath.basename(path)); + } + /** + * Closes only file-specific watchers + */ + _closeFile(path) { + const closers = this._closers.get(path); + if (!closers) + return; + closers.forEach((closer) => closer()); + this._closers.delete(path); + } + _addPathCloser(path, closer) { + if (!closer) + return; + let list = this._closers.get(path); + if (!list) { + list = []; + this._closers.set(path, list); + } + list.push(closer); + } + _readdirp(root, opts) { + if (this.closed) + return; + const options = { type: handler_js_1.EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 }; + let stream = (0, readdirp_1.readdirp)(root, options); + this._streams.add(stream); + stream.once(handler_js_1.STR_CLOSE, () => { + stream = undefined; + }); + stream.once(handler_js_1.STR_END, () => { + if (stream) { + this._streams.delete(stream); + stream = undefined; + } + }); + return stream; + } +} +exports.FSWatcher = FSWatcher; +/** + * Instantiates watcher with paths to be tracked. + * @param paths file / directory paths + * @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others + * @returns an instance of FSWatcher for chaining. + * @example + * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); }); + * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') }) + */ +function watch(paths, options = {}) { + const watcher = new FSWatcher(options); + watcher.add(paths); + return watcher; +} +exports.default = { watch, FSWatcher }; diff --git a/node_modules/chokidar/package.json b/node_modules/chokidar/package.json new file mode 100644 index 0000000..db79241 --- /dev/null +++ b/node_modules/chokidar/package.json @@ -0,0 +1,69 @@ +{ + "name": "chokidar", + "description": "Minimal and efficient cross-platform file watching library", + "version": "4.0.3", + "homepage": "https://github.com/paulmillr/chokidar", + "author": "Paul Miller (https://paulmillr.com)", + "files": [ + "index.js", + "index.d.ts", + "handler.js", + "handler.d.ts", + "esm" + ], + "main": "./index.js", + "module": "./esm/index.js", + "types": "./index.d.ts", + "exports": { + ".": { + "import": "./esm/index.js", + "require": "./index.js" + }, + "./handler.js": { + "import": "./esm/handler.js", + "require": "./handler.js" + } + }, + "dependencies": { + "readdirp": "^4.0.1" + }, + "devDependencies": { + "@paulmillr/jsbt": "0.2.1", + "@types/node": "20.14.8", + "chai": "4.3.4", + "prettier": "3.1.1", + "rimraf": "5.0.5", + "sinon": "12.0.1", + "sinon-chai": "3.7.0", + "typescript": "5.5.2", + "upath": "2.0.1" + }, + "sideEffects": false, + "engines": { + "node": ">= 14.16.0" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/paulmillr/chokidar.git" + }, + "bugs": { + "url": "https://github.com/paulmillr/chokidar/issues" + }, + "license": "MIT", + "scripts": { + "build": "tsc && tsc -p tsconfig.esm.json", + "lint": "prettier --check src", + "format": "prettier --write src", + "test": "node --test" + }, + "keywords": [ + "fs", + "watch", + "watchFile", + "watcher", + "watching", + "file", + "fsevents" + ], + "funding": "https://paulmillr.com/funding/" +} diff --git a/node_modules/crypto-js/CONTRIBUTING.md b/node_modules/crypto-js/CONTRIBUTING.md new file mode 100644 index 0000000..09bf774 --- /dev/null +++ b/node_modules/crypto-js/CONTRIBUTING.md @@ -0,0 +1,28 @@ +# Contribution + +# Git Flow + +The crypto-js project uses [git flow](https://github.com/nvie/gitflow) to manage branches. +Do your changes on the `develop` or even better on a `feature/*` branch. Don't do any changes on the `master` branch. + +# Pull request + +Target your pull request on `develop` branch. Other pull request won't be accepted. + +# How to build + +1. Clone + +2. Run + + ```sh + npm install + ``` + +3. Run + + ```sh + npm run build + ``` + +4. Check `build` folder \ No newline at end of file diff --git a/node_modules/crypto-js/LICENSE b/node_modules/crypto-js/LICENSE new file mode 100644 index 0000000..b0828e5 --- /dev/null +++ b/node_modules/crypto-js/LICENSE @@ -0,0 +1,24 @@ +# License + +[The MIT License (MIT)](http://opensource.org/licenses/MIT) + +Copyright (c) 2009-2013 Jeff Mott +Copyright (c) 2013-2016 Evan Vosberg + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/crypto-js/README.md b/node_modules/crypto-js/README.md new file mode 100644 index 0000000..6a9bcdf --- /dev/null +++ b/node_modules/crypto-js/README.md @@ -0,0 +1,275 @@ +# crypto-js + +JavaScript library of crypto standards. + +## Discontinued + +Active development of CryptoJS has been discontinued. This library is no longer maintained. + +Nowadays, NodeJS and modern browsers have a native `Crypto` module. The latest version of CryptoJS already uses the native Crypto module for random number generation, since `Math.random()` is not crypto-safe. Further development of CryptoJS would result in it only being a wrapper of native Crypto. Therefore, development and maintenance has been discontinued, it is time to go for the native `crypto` module. + +## Node.js (Install) + +Requirements: + +- Node.js +- npm (Node.js package manager) + +```bash +npm install crypto-js +``` + +### Usage + +ES6 import for typical API call signing use case: + +```javascript +import sha256 from 'crypto-js/sha256'; +import hmacSHA512 from 'crypto-js/hmac-sha512'; +import Base64 from 'crypto-js/enc-base64'; + +const message, nonce, path, privateKey; // ... +const hashDigest = sha256(nonce + message); +const hmacDigest = Base64.stringify(hmacSHA512(path + hashDigest, privateKey)); +``` + +Modular include: + +```javascript +var AES = require("crypto-js/aes"); +var SHA256 = require("crypto-js/sha256"); +... +console.log(SHA256("Message")); +``` + +Including all libraries, for access to extra methods: + +```javascript +var CryptoJS = require("crypto-js"); +console.log(CryptoJS.HmacSHA1("Message", "Key")); +``` + +## Client (browser) + +Requirements: + +- Node.js +- Bower (package manager for frontend) + +```bash +bower install crypto-js +``` + +### Usage + +Modular include: + +```javascript +require.config({ + packages: [ + { + name: 'crypto-js', + location: 'path-to/bower_components/crypto-js', + main: 'index' + } + ] +}); + +require(["crypto-js/aes", "crypto-js/sha256"], function (AES, SHA256) { + console.log(SHA256("Message")); +}); +``` + +Including all libraries, for access to extra methods: + +```javascript +// Above-mentioned will work or use this simple form +require.config({ + paths: { + 'crypto-js': 'path-to/bower_components/crypto-js/crypto-js' + } +}); + +require(["crypto-js"], function (CryptoJS) { + console.log(CryptoJS.HmacSHA1("Message", "Key")); +}); +``` + +### Usage without RequireJS + +```html + + +``` + +## API + +See: https://cryptojs.gitbook.io/docs/ + +### AES Encryption + +#### Plain text encryption + +```javascript +var CryptoJS = require("crypto-js"); + +// Encrypt +var ciphertext = CryptoJS.AES.encrypt('my message', 'secret key 123').toString(); + +// Decrypt +var bytes = CryptoJS.AES.decrypt(ciphertext, 'secret key 123'); +var originalText = bytes.toString(CryptoJS.enc.Utf8); + +console.log(originalText); // 'my message' +``` + +#### Object encryption + +```javascript +var CryptoJS = require("crypto-js"); + +var data = [{id: 1}, {id: 2}] + +// Encrypt +var ciphertext = CryptoJS.AES.encrypt(JSON.stringify(data), 'secret key 123').toString(); + +// Decrypt +var bytes = CryptoJS.AES.decrypt(ciphertext, 'secret key 123'); +var decryptedData = JSON.parse(bytes.toString(CryptoJS.enc.Utf8)); + +console.log(decryptedData); // [{id: 1}, {id: 2}] +``` + +### List of modules + + +- ```crypto-js/core``` +- ```crypto-js/x64-core``` +- ```crypto-js/lib-typedarrays``` + +--- + +- ```crypto-js/md5``` +- ```crypto-js/sha1``` +- ```crypto-js/sha256``` +- ```crypto-js/sha224``` +- ```crypto-js/sha512``` +- ```crypto-js/sha384``` +- ```crypto-js/sha3``` +- ```crypto-js/ripemd160``` + +--- + +- ```crypto-js/hmac-md5``` +- ```crypto-js/hmac-sha1``` +- ```crypto-js/hmac-sha256``` +- ```crypto-js/hmac-sha224``` +- ```crypto-js/hmac-sha512``` +- ```crypto-js/hmac-sha384``` +- ```crypto-js/hmac-sha3``` +- ```crypto-js/hmac-ripemd160``` + +--- + +- ```crypto-js/pbkdf2``` + +--- + +- ```crypto-js/aes``` +- ```crypto-js/tripledes``` +- ```crypto-js/rc4``` +- ```crypto-js/rabbit``` +- ```crypto-js/rabbit-legacy``` +- ```crypto-js/evpkdf``` + +--- + +- ```crypto-js/format-openssl``` +- ```crypto-js/format-hex``` + +--- + +- ```crypto-js/enc-latin1``` +- ```crypto-js/enc-utf8``` +- ```crypto-js/enc-hex``` +- ```crypto-js/enc-utf16``` +- ```crypto-js/enc-base64``` + +--- + +- ```crypto-js/mode-cfb``` +- ```crypto-js/mode-ctr``` +- ```crypto-js/mode-ctr-gladman``` +- ```crypto-js/mode-ofb``` +- ```crypto-js/mode-ecb``` + +--- + +- ```crypto-js/pad-pkcs7``` +- ```crypto-js/pad-ansix923``` +- ```crypto-js/pad-iso10126``` +- ```crypto-js/pad-iso97971``` +- ```crypto-js/pad-zeropadding``` +- ```crypto-js/pad-nopadding``` + + +## Release notes + +### 4.2.0 + +Change default hash algorithm and iteration's for PBKDF2 to prevent weak security by using the default configuration. + +Custom KDF Hasher + +Blowfish support + +### 4.1.1 + +Fix module order in bundled release. + +Include the browser field in the released package.json. + +### 4.1.0 + +Added url safe variant of base64 encoding. [357](https://github.com/brix/crypto-js/pull/357) + +Avoid webpack to add crypto-browser package. [364](https://github.com/brix/crypto-js/pull/364) + +### 4.0.0 + +This is an update including breaking changes for some environments. + +In this version `Math.random()` has been replaced by the random methods of the native crypto module. + +For this reason CryptoJS might not run in some JavaScript environments without native crypto module. Such as IE 10 or before or React Native. + +### 3.3.0 + +Rollback, `3.3.0` is the same as `3.1.9-1`. + +The move of using native secure crypto module will be shifted to a new `4.x.x` version. As it is a breaking change the impact is too big for a minor release. + +### 3.2.1 + +The usage of the native crypto module has been fixed. The import and access of the native crypto module has been improved. + +### 3.2.0 + +In this version `Math.random()` has been replaced by the random methods of the native crypto module. + +For this reason CryptoJS might does not run in some JavaScript environments without native crypto module. Such as IE 10 or before. + +If it's absolute required to run CryptoJS in such an environment, stay with `3.1.x` version. Encrypting and decrypting stays compatible. But keep in mind `3.1.x` versions still use `Math.random()` which is cryptographically not secure, as it's not random enough. + +This version came along with `CRITICAL` `BUG`. + +DO NOT USE THIS VERSION! Please, go for a newer version! + +### 3.1.x + +The `3.1.x` are based on the original CryptoJS, wrapped in CommonJS modules. + + diff --git a/node_modules/crypto-js/aes.js b/node_modules/crypto-js/aes.js new file mode 100644 index 0000000..166e3ea --- /dev/null +++ b/node_modules/crypto-js/aes.js @@ -0,0 +1,234 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var BlockCipher = C_lib.BlockCipher; + var C_algo = C.algo; + + // Lookup tables + var SBOX = []; + var INV_SBOX = []; + var SUB_MIX_0 = []; + var SUB_MIX_1 = []; + var SUB_MIX_2 = []; + var SUB_MIX_3 = []; + var INV_SUB_MIX_0 = []; + var INV_SUB_MIX_1 = []; + var INV_SUB_MIX_2 = []; + var INV_SUB_MIX_3 = []; + + // Compute lookup tables + (function () { + // Compute double table + var d = []; + for (var i = 0; i < 256; i++) { + if (i < 128) { + d[i] = i << 1; + } else { + d[i] = (i << 1) ^ 0x11b; + } + } + + // Walk GF(2^8) + var x = 0; + var xi = 0; + for (var i = 0; i < 256; i++) { + // Compute sbox + var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4); + sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63; + SBOX[x] = sx; + INV_SBOX[sx] = x; + + // Compute multiplication + var x2 = d[x]; + var x4 = d[x2]; + var x8 = d[x4]; + + // Compute sub bytes, mix columns tables + var t = (d[sx] * 0x101) ^ (sx * 0x1010100); + SUB_MIX_0[x] = (t << 24) | (t >>> 8); + SUB_MIX_1[x] = (t << 16) | (t >>> 16); + SUB_MIX_2[x] = (t << 8) | (t >>> 24); + SUB_MIX_3[x] = t; + + // Compute inv sub bytes, inv mix columns tables + var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100); + INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8); + INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16); + INV_SUB_MIX_2[sx] = (t << 8) | (t >>> 24); + INV_SUB_MIX_3[sx] = t; + + // Compute next counter + if (!x) { + x = xi = 1; + } else { + x = x2 ^ d[d[d[x8 ^ x2]]]; + xi ^= d[d[xi]]; + } + } + }()); + + // Precomputed Rcon lookup + var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]; + + /** + * AES block cipher algorithm. + */ + var AES = C_algo.AES = BlockCipher.extend({ + _doReset: function () { + var t; + + // Skip reset of nRounds has been set before and key did not change + if (this._nRounds && this._keyPriorReset === this._key) { + return; + } + + // Shortcuts + var key = this._keyPriorReset = this._key; + var keyWords = key.words; + var keySize = key.sigBytes / 4; + + // Compute number of rounds + var nRounds = this._nRounds = keySize + 6; + + // Compute number of key schedule rows + var ksRows = (nRounds + 1) * 4; + + // Compute key schedule + var keySchedule = this._keySchedule = []; + for (var ksRow = 0; ksRow < ksRows; ksRow++) { + if (ksRow < keySize) { + keySchedule[ksRow] = keyWords[ksRow]; + } else { + t = keySchedule[ksRow - 1]; + + if (!(ksRow % keySize)) { + // Rot word + t = (t << 8) | (t >>> 24); + + // Sub word + t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff]; + + // Mix Rcon + t ^= RCON[(ksRow / keySize) | 0] << 24; + } else if (keySize > 6 && ksRow % keySize == 4) { + // Sub word + t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff]; + } + + keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t; + } + } + + // Compute inv key schedule + var invKeySchedule = this._invKeySchedule = []; + for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) { + var ksRow = ksRows - invKsRow; + + if (invKsRow % 4) { + var t = keySchedule[ksRow]; + } else { + var t = keySchedule[ksRow - 4]; + } + + if (invKsRow < 4 || ksRow <= 4) { + invKeySchedule[invKsRow] = t; + } else { + invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^ + INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]]; + } + } + }, + + encryptBlock: function (M, offset) { + this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX); + }, + + decryptBlock: function (M, offset) { + // Swap 2nd and 4th rows + var t = M[offset + 1]; + M[offset + 1] = M[offset + 3]; + M[offset + 3] = t; + + this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX); + + // Inv swap 2nd and 4th rows + var t = M[offset + 1]; + M[offset + 1] = M[offset + 3]; + M[offset + 3] = t; + }, + + _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) { + // Shortcut + var nRounds = this._nRounds; + + // Get input, add round key + var s0 = M[offset] ^ keySchedule[0]; + var s1 = M[offset + 1] ^ keySchedule[1]; + var s2 = M[offset + 2] ^ keySchedule[2]; + var s3 = M[offset + 3] ^ keySchedule[3]; + + // Key schedule row counter + var ksRow = 4; + + // Rounds + for (var round = 1; round < nRounds; round++) { + // Shift rows, sub bytes, mix columns, add round key + var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++]; + var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++]; + var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++]; + var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++]; + + // Update state + s0 = t0; + s1 = t1; + s2 = t2; + s3 = t3; + } + + // Shift rows, sub bytes, add round key + var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++]; + var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++]; + var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++]; + var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++]; + + // Set output + M[offset] = t0; + M[offset + 1] = t1; + M[offset + 2] = t2; + M[offset + 3] = t3; + }, + + keySize: 256/32 + }); + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.AES.encrypt(message, key, cfg); + * var plaintext = CryptoJS.AES.decrypt(ciphertext, key, cfg); + */ + C.AES = BlockCipher._createHelper(AES); + }()); + + + return CryptoJS.AES; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/blowfish.js b/node_modules/crypto-js/blowfish.js new file mode 100644 index 0000000..149812f --- /dev/null +++ b/node_modules/crypto-js/blowfish.js @@ -0,0 +1,471 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var BlockCipher = C_lib.BlockCipher; + var C_algo = C.algo; + + const N = 16; + + //Origin pbox and sbox, derived from PI + const ORIG_P = [ + 0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344, + 0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89, + 0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C, + 0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917, + 0x9216D5D9, 0x8979FB1B + ]; + + const ORIG_S = [ + [ 0xD1310BA6, 0x98DFB5AC, 0x2FFD72DB, 0xD01ADFB7, + 0xB8E1AFED, 0x6A267E96, 0xBA7C9045, 0xF12C7F99, + 0x24A19947, 0xB3916CF7, 0x0801F2E2, 0x858EFC16, + 0x636920D8, 0x71574E69, 0xA458FEA3, 0xF4933D7E, + 0x0D95748F, 0x728EB658, 0x718BCD58, 0x82154AEE, + 0x7B54A41D, 0xC25A59B5, 0x9C30D539, 0x2AF26013, + 0xC5D1B023, 0x286085F0, 0xCA417918, 0xB8DB38EF, + 0x8E79DCB0, 0x603A180E, 0x6C9E0E8B, 0xB01E8A3E, + 0xD71577C1, 0xBD314B27, 0x78AF2FDA, 0x55605C60, + 0xE65525F3, 0xAA55AB94, 0x57489862, 0x63E81440, + 0x55CA396A, 0x2AAB10B6, 0xB4CC5C34, 0x1141E8CE, + 0xA15486AF, 0x7C72E993, 0xB3EE1411, 0x636FBC2A, + 0x2BA9C55D, 0x741831F6, 0xCE5C3E16, 0x9B87931E, + 0xAFD6BA33, 0x6C24CF5C, 0x7A325381, 0x28958677, + 0x3B8F4898, 0x6B4BB9AF, 0xC4BFE81B, 0x66282193, + 0x61D809CC, 0xFB21A991, 0x487CAC60, 0x5DEC8032, + 0xEF845D5D, 0xE98575B1, 0xDC262302, 0xEB651B88, + 0x23893E81, 0xD396ACC5, 0x0F6D6FF3, 0x83F44239, + 0x2E0B4482, 0xA4842004, 0x69C8F04A, 0x9E1F9B5E, + 0x21C66842, 0xF6E96C9A, 0x670C9C61, 0xABD388F0, + 0x6A51A0D2, 0xD8542F68, 0x960FA728, 0xAB5133A3, + 0x6EEF0B6C, 0x137A3BE4, 0xBA3BF050, 0x7EFB2A98, + 0xA1F1651D, 0x39AF0176, 0x66CA593E, 0x82430E88, + 0x8CEE8619, 0x456F9FB4, 0x7D84A5C3, 0x3B8B5EBE, + 0xE06F75D8, 0x85C12073, 0x401A449F, 0x56C16AA6, + 0x4ED3AA62, 0x363F7706, 0x1BFEDF72, 0x429B023D, + 0x37D0D724, 0xD00A1248, 0xDB0FEAD3, 0x49F1C09B, + 0x075372C9, 0x80991B7B, 0x25D479D8, 0xF6E8DEF7, + 0xE3FE501A, 0xB6794C3B, 0x976CE0BD, 0x04C006BA, + 0xC1A94FB6, 0x409F60C4, 0x5E5C9EC2, 0x196A2463, + 0x68FB6FAF, 0x3E6C53B5, 0x1339B2EB, 0x3B52EC6F, + 0x6DFC511F, 0x9B30952C, 0xCC814544, 0xAF5EBD09, + 0xBEE3D004, 0xDE334AFD, 0x660F2807, 0x192E4BB3, + 0xC0CBA857, 0x45C8740F, 0xD20B5F39, 0xB9D3FBDB, + 0x5579C0BD, 0x1A60320A, 0xD6A100C6, 0x402C7279, + 0x679F25FE, 0xFB1FA3CC, 0x8EA5E9F8, 0xDB3222F8, + 0x3C7516DF, 0xFD616B15, 0x2F501EC8, 0xAD0552AB, + 0x323DB5FA, 0xFD238760, 0x53317B48, 0x3E00DF82, + 0x9E5C57BB, 0xCA6F8CA0, 0x1A87562E, 0xDF1769DB, + 0xD542A8F6, 0x287EFFC3, 0xAC6732C6, 0x8C4F5573, + 0x695B27B0, 0xBBCA58C8, 0xE1FFA35D, 0xB8F011A0, + 0x10FA3D98, 0xFD2183B8, 0x4AFCB56C, 0x2DD1D35B, + 0x9A53E479, 0xB6F84565, 0xD28E49BC, 0x4BFB9790, + 0xE1DDF2DA, 0xA4CB7E33, 0x62FB1341, 0xCEE4C6E8, + 0xEF20CADA, 0x36774C01, 0xD07E9EFE, 0x2BF11FB4, + 0x95DBDA4D, 0xAE909198, 0xEAAD8E71, 0x6B93D5A0, + 0xD08ED1D0, 0xAFC725E0, 0x8E3C5B2F, 0x8E7594B7, + 0x8FF6E2FB, 0xF2122B64, 0x8888B812, 0x900DF01C, + 0x4FAD5EA0, 0x688FC31C, 0xD1CFF191, 0xB3A8C1AD, + 0x2F2F2218, 0xBE0E1777, 0xEA752DFE, 0x8B021FA1, + 0xE5A0CC0F, 0xB56F74E8, 0x18ACF3D6, 0xCE89E299, + 0xB4A84FE0, 0xFD13E0B7, 0x7CC43B81, 0xD2ADA8D9, + 0x165FA266, 0x80957705, 0x93CC7314, 0x211A1477, + 0xE6AD2065, 0x77B5FA86, 0xC75442F5, 0xFB9D35CF, + 0xEBCDAF0C, 0x7B3E89A0, 0xD6411BD3, 0xAE1E7E49, + 0x00250E2D, 0x2071B35E, 0x226800BB, 0x57B8E0AF, + 0x2464369B, 0xF009B91E, 0x5563911D, 0x59DFA6AA, + 0x78C14389, 0xD95A537F, 0x207D5BA2, 0x02E5B9C5, + 0x83260376, 0x6295CFA9, 0x11C81968, 0x4E734A41, + 0xB3472DCA, 0x7B14A94A, 0x1B510052, 0x9A532915, + 0xD60F573F, 0xBC9BC6E4, 0x2B60A476, 0x81E67400, + 0x08BA6FB5, 0x571BE91F, 0xF296EC6B, 0x2A0DD915, + 0xB6636521, 0xE7B9F9B6, 0xFF34052E, 0xC5855664, + 0x53B02D5D, 0xA99F8FA1, 0x08BA4799, 0x6E85076A ], + [ 0x4B7A70E9, 0xB5B32944, 0xDB75092E, 0xC4192623, + 0xAD6EA6B0, 0x49A7DF7D, 0x9CEE60B8, 0x8FEDB266, + 0xECAA8C71, 0x699A17FF, 0x5664526C, 0xC2B19EE1, + 0x193602A5, 0x75094C29, 0xA0591340, 0xE4183A3E, + 0x3F54989A, 0x5B429D65, 0x6B8FE4D6, 0x99F73FD6, + 0xA1D29C07, 0xEFE830F5, 0x4D2D38E6, 0xF0255DC1, + 0x4CDD2086, 0x8470EB26, 0x6382E9C6, 0x021ECC5E, + 0x09686B3F, 0x3EBAEFC9, 0x3C971814, 0x6B6A70A1, + 0x687F3584, 0x52A0E286, 0xB79C5305, 0xAA500737, + 0x3E07841C, 0x7FDEAE5C, 0x8E7D44EC, 0x5716F2B8, + 0xB03ADA37, 0xF0500C0D, 0xF01C1F04, 0x0200B3FF, + 0xAE0CF51A, 0x3CB574B2, 0x25837A58, 0xDC0921BD, + 0xD19113F9, 0x7CA92FF6, 0x94324773, 0x22F54701, + 0x3AE5E581, 0x37C2DADC, 0xC8B57634, 0x9AF3DDA7, + 0xA9446146, 0x0FD0030E, 0xECC8C73E, 0xA4751E41, + 0xE238CD99, 0x3BEA0E2F, 0x3280BBA1, 0x183EB331, + 0x4E548B38, 0x4F6DB908, 0x6F420D03, 0xF60A04BF, + 0x2CB81290, 0x24977C79, 0x5679B072, 0xBCAF89AF, + 0xDE9A771F, 0xD9930810, 0xB38BAE12, 0xDCCF3F2E, + 0x5512721F, 0x2E6B7124, 0x501ADDE6, 0x9F84CD87, + 0x7A584718, 0x7408DA17, 0xBC9F9ABC, 0xE94B7D8C, + 0xEC7AEC3A, 0xDB851DFA, 0x63094366, 0xC464C3D2, + 0xEF1C1847, 0x3215D908, 0xDD433B37, 0x24C2BA16, + 0x12A14D43, 0x2A65C451, 0x50940002, 0x133AE4DD, + 0x71DFF89E, 0x10314E55, 0x81AC77D6, 0x5F11199B, + 0x043556F1, 0xD7A3C76B, 0x3C11183B, 0x5924A509, + 0xF28FE6ED, 0x97F1FBFA, 0x9EBABF2C, 0x1E153C6E, + 0x86E34570, 0xEAE96FB1, 0x860E5E0A, 0x5A3E2AB3, + 0x771FE71C, 0x4E3D06FA, 0x2965DCB9, 0x99E71D0F, + 0x803E89D6, 0x5266C825, 0x2E4CC978, 0x9C10B36A, + 0xC6150EBA, 0x94E2EA78, 0xA5FC3C53, 0x1E0A2DF4, + 0xF2F74EA7, 0x361D2B3D, 0x1939260F, 0x19C27960, + 0x5223A708, 0xF71312B6, 0xEBADFE6E, 0xEAC31F66, + 0xE3BC4595, 0xA67BC883, 0xB17F37D1, 0x018CFF28, + 0xC332DDEF, 0xBE6C5AA5, 0x65582185, 0x68AB9802, + 0xEECEA50F, 0xDB2F953B, 0x2AEF7DAD, 0x5B6E2F84, + 0x1521B628, 0x29076170, 0xECDD4775, 0x619F1510, + 0x13CCA830, 0xEB61BD96, 0x0334FE1E, 0xAA0363CF, + 0xB5735C90, 0x4C70A239, 0xD59E9E0B, 0xCBAADE14, + 0xEECC86BC, 0x60622CA7, 0x9CAB5CAB, 0xB2F3846E, + 0x648B1EAF, 0x19BDF0CA, 0xA02369B9, 0x655ABB50, + 0x40685A32, 0x3C2AB4B3, 0x319EE9D5, 0xC021B8F7, + 0x9B540B19, 0x875FA099, 0x95F7997E, 0x623D7DA8, + 0xF837889A, 0x97E32D77, 0x11ED935F, 0x16681281, + 0x0E358829, 0xC7E61FD6, 0x96DEDFA1, 0x7858BA99, + 0x57F584A5, 0x1B227263, 0x9B83C3FF, 0x1AC24696, + 0xCDB30AEB, 0x532E3054, 0x8FD948E4, 0x6DBC3128, + 0x58EBF2EF, 0x34C6FFEA, 0xFE28ED61, 0xEE7C3C73, + 0x5D4A14D9, 0xE864B7E3, 0x42105D14, 0x203E13E0, + 0x45EEE2B6, 0xA3AAABEA, 0xDB6C4F15, 0xFACB4FD0, + 0xC742F442, 0xEF6ABBB5, 0x654F3B1D, 0x41CD2105, + 0xD81E799E, 0x86854DC7, 0xE44B476A, 0x3D816250, + 0xCF62A1F2, 0x5B8D2646, 0xFC8883A0, 0xC1C7B6A3, + 0x7F1524C3, 0x69CB7492, 0x47848A0B, 0x5692B285, + 0x095BBF00, 0xAD19489D, 0x1462B174, 0x23820E00, + 0x58428D2A, 0x0C55F5EA, 0x1DADF43E, 0x233F7061, + 0x3372F092, 0x8D937E41, 0xD65FECF1, 0x6C223BDB, + 0x7CDE3759, 0xCBEE7460, 0x4085F2A7, 0xCE77326E, + 0xA6078084, 0x19F8509E, 0xE8EFD855, 0x61D99735, + 0xA969A7AA, 0xC50C06C2, 0x5A04ABFC, 0x800BCADC, + 0x9E447A2E, 0xC3453484, 0xFDD56705, 0x0E1E9EC9, + 0xDB73DBD3, 0x105588CD, 0x675FDA79, 0xE3674340, + 0xC5C43465, 0x713E38D8, 0x3D28F89E, 0xF16DFF20, + 0x153E21E7, 0x8FB03D4A, 0xE6E39F2B, 0xDB83ADF7 ], + [ 0xE93D5A68, 0x948140F7, 0xF64C261C, 0x94692934, + 0x411520F7, 0x7602D4F7, 0xBCF46B2E, 0xD4A20068, + 0xD4082471, 0x3320F46A, 0x43B7D4B7, 0x500061AF, + 0x1E39F62E, 0x97244546, 0x14214F74, 0xBF8B8840, + 0x4D95FC1D, 0x96B591AF, 0x70F4DDD3, 0x66A02F45, + 0xBFBC09EC, 0x03BD9785, 0x7FAC6DD0, 0x31CB8504, + 0x96EB27B3, 0x55FD3941, 0xDA2547E6, 0xABCA0A9A, + 0x28507825, 0x530429F4, 0x0A2C86DA, 0xE9B66DFB, + 0x68DC1462, 0xD7486900, 0x680EC0A4, 0x27A18DEE, + 0x4F3FFEA2, 0xE887AD8C, 0xB58CE006, 0x7AF4D6B6, + 0xAACE1E7C, 0xD3375FEC, 0xCE78A399, 0x406B2A42, + 0x20FE9E35, 0xD9F385B9, 0xEE39D7AB, 0x3B124E8B, + 0x1DC9FAF7, 0x4B6D1856, 0x26A36631, 0xEAE397B2, + 0x3A6EFA74, 0xDD5B4332, 0x6841E7F7, 0xCA7820FB, + 0xFB0AF54E, 0xD8FEB397, 0x454056AC, 0xBA489527, + 0x55533A3A, 0x20838D87, 0xFE6BA9B7, 0xD096954B, + 0x55A867BC, 0xA1159A58, 0xCCA92963, 0x99E1DB33, + 0xA62A4A56, 0x3F3125F9, 0x5EF47E1C, 0x9029317C, + 0xFDF8E802, 0x04272F70, 0x80BB155C, 0x05282CE3, + 0x95C11548, 0xE4C66D22, 0x48C1133F, 0xC70F86DC, + 0x07F9C9EE, 0x41041F0F, 0x404779A4, 0x5D886E17, + 0x325F51EB, 0xD59BC0D1, 0xF2BCC18F, 0x41113564, + 0x257B7834, 0x602A9C60, 0xDFF8E8A3, 0x1F636C1B, + 0x0E12B4C2, 0x02E1329E, 0xAF664FD1, 0xCAD18115, + 0x6B2395E0, 0x333E92E1, 0x3B240B62, 0xEEBEB922, + 0x85B2A20E, 0xE6BA0D99, 0xDE720C8C, 0x2DA2F728, + 0xD0127845, 0x95B794FD, 0x647D0862, 0xE7CCF5F0, + 0x5449A36F, 0x877D48FA, 0xC39DFD27, 0xF33E8D1E, + 0x0A476341, 0x992EFF74, 0x3A6F6EAB, 0xF4F8FD37, + 0xA812DC60, 0xA1EBDDF8, 0x991BE14C, 0xDB6E6B0D, + 0xC67B5510, 0x6D672C37, 0x2765D43B, 0xDCD0E804, + 0xF1290DC7, 0xCC00FFA3, 0xB5390F92, 0x690FED0B, + 0x667B9FFB, 0xCEDB7D9C, 0xA091CF0B, 0xD9155EA3, + 0xBB132F88, 0x515BAD24, 0x7B9479BF, 0x763BD6EB, + 0x37392EB3, 0xCC115979, 0x8026E297, 0xF42E312D, + 0x6842ADA7, 0xC66A2B3B, 0x12754CCC, 0x782EF11C, + 0x6A124237, 0xB79251E7, 0x06A1BBE6, 0x4BFB6350, + 0x1A6B1018, 0x11CAEDFA, 0x3D25BDD8, 0xE2E1C3C9, + 0x44421659, 0x0A121386, 0xD90CEC6E, 0xD5ABEA2A, + 0x64AF674E, 0xDA86A85F, 0xBEBFE988, 0x64E4C3FE, + 0x9DBC8057, 0xF0F7C086, 0x60787BF8, 0x6003604D, + 0xD1FD8346, 0xF6381FB0, 0x7745AE04, 0xD736FCCC, + 0x83426B33, 0xF01EAB71, 0xB0804187, 0x3C005E5F, + 0x77A057BE, 0xBDE8AE24, 0x55464299, 0xBF582E61, + 0x4E58F48F, 0xF2DDFDA2, 0xF474EF38, 0x8789BDC2, + 0x5366F9C3, 0xC8B38E74, 0xB475F255, 0x46FCD9B9, + 0x7AEB2661, 0x8B1DDF84, 0x846A0E79, 0x915F95E2, + 0x466E598E, 0x20B45770, 0x8CD55591, 0xC902DE4C, + 0xB90BACE1, 0xBB8205D0, 0x11A86248, 0x7574A99E, + 0xB77F19B6, 0xE0A9DC09, 0x662D09A1, 0xC4324633, + 0xE85A1F02, 0x09F0BE8C, 0x4A99A025, 0x1D6EFE10, + 0x1AB93D1D, 0x0BA5A4DF, 0xA186F20F, 0x2868F169, + 0xDCB7DA83, 0x573906FE, 0xA1E2CE9B, 0x4FCD7F52, + 0x50115E01, 0xA70683FA, 0xA002B5C4, 0x0DE6D027, + 0x9AF88C27, 0x773F8641, 0xC3604C06, 0x61A806B5, + 0xF0177A28, 0xC0F586E0, 0x006058AA, 0x30DC7D62, + 0x11E69ED7, 0x2338EA63, 0x53C2DD94, 0xC2C21634, + 0xBBCBEE56, 0x90BCB6DE, 0xEBFC7DA1, 0xCE591D76, + 0x6F05E409, 0x4B7C0188, 0x39720A3D, 0x7C927C24, + 0x86E3725F, 0x724D9DB9, 0x1AC15BB4, 0xD39EB8FC, + 0xED545578, 0x08FCA5B5, 0xD83D7CD3, 0x4DAD0FC4, + 0x1E50EF5E, 0xB161E6F8, 0xA28514D9, 0x6C51133C, + 0x6FD5C7E7, 0x56E14EC4, 0x362ABFCE, 0xDDC6C837, + 0xD79A3234, 0x92638212, 0x670EFA8E, 0x406000E0 ], + [ 0x3A39CE37, 0xD3FAF5CF, 0xABC27737, 0x5AC52D1B, + 0x5CB0679E, 0x4FA33742, 0xD3822740, 0x99BC9BBE, + 0xD5118E9D, 0xBF0F7315, 0xD62D1C7E, 0xC700C47B, + 0xB78C1B6B, 0x21A19045, 0xB26EB1BE, 0x6A366EB4, + 0x5748AB2F, 0xBC946E79, 0xC6A376D2, 0x6549C2C8, + 0x530FF8EE, 0x468DDE7D, 0xD5730A1D, 0x4CD04DC6, + 0x2939BBDB, 0xA9BA4650, 0xAC9526E8, 0xBE5EE304, + 0xA1FAD5F0, 0x6A2D519A, 0x63EF8CE2, 0x9A86EE22, + 0xC089C2B8, 0x43242EF6, 0xA51E03AA, 0x9CF2D0A4, + 0x83C061BA, 0x9BE96A4D, 0x8FE51550, 0xBA645BD6, + 0x2826A2F9, 0xA73A3AE1, 0x4BA99586, 0xEF5562E9, + 0xC72FEFD3, 0xF752F7DA, 0x3F046F69, 0x77FA0A59, + 0x80E4A915, 0x87B08601, 0x9B09E6AD, 0x3B3EE593, + 0xE990FD5A, 0x9E34D797, 0x2CF0B7D9, 0x022B8B51, + 0x96D5AC3A, 0x017DA67D, 0xD1CF3ED6, 0x7C7D2D28, + 0x1F9F25CF, 0xADF2B89B, 0x5AD6B472, 0x5A88F54C, + 0xE029AC71, 0xE019A5E6, 0x47B0ACFD, 0xED93FA9B, + 0xE8D3C48D, 0x283B57CC, 0xF8D56629, 0x79132E28, + 0x785F0191, 0xED756055, 0xF7960E44, 0xE3D35E8C, + 0x15056DD4, 0x88F46DBA, 0x03A16125, 0x0564F0BD, + 0xC3EB9E15, 0x3C9057A2, 0x97271AEC, 0xA93A072A, + 0x1B3F6D9B, 0x1E6321F5, 0xF59C66FB, 0x26DCF319, + 0x7533D928, 0xB155FDF5, 0x03563482, 0x8ABA3CBB, + 0x28517711, 0xC20AD9F8, 0xABCC5167, 0xCCAD925F, + 0x4DE81751, 0x3830DC8E, 0x379D5862, 0x9320F991, + 0xEA7A90C2, 0xFB3E7BCE, 0x5121CE64, 0x774FBE32, + 0xA8B6E37E, 0xC3293D46, 0x48DE5369, 0x6413E680, + 0xA2AE0810, 0xDD6DB224, 0x69852DFD, 0x09072166, + 0xB39A460A, 0x6445C0DD, 0x586CDECF, 0x1C20C8AE, + 0x5BBEF7DD, 0x1B588D40, 0xCCD2017F, 0x6BB4E3BB, + 0xDDA26A7E, 0x3A59FF45, 0x3E350A44, 0xBCB4CDD5, + 0x72EACEA8, 0xFA6484BB, 0x8D6612AE, 0xBF3C6F47, + 0xD29BE463, 0x542F5D9E, 0xAEC2771B, 0xF64E6370, + 0x740E0D8D, 0xE75B1357, 0xF8721671, 0xAF537D5D, + 0x4040CB08, 0x4EB4E2CC, 0x34D2466A, 0x0115AF84, + 0xE1B00428, 0x95983A1D, 0x06B89FB4, 0xCE6EA048, + 0x6F3F3B82, 0x3520AB82, 0x011A1D4B, 0x277227F8, + 0x611560B1, 0xE7933FDC, 0xBB3A792B, 0x344525BD, + 0xA08839E1, 0x51CE794B, 0x2F32C9B7, 0xA01FBAC9, + 0xE01CC87E, 0xBCC7D1F6, 0xCF0111C3, 0xA1E8AAC7, + 0x1A908749, 0xD44FBD9A, 0xD0DADECB, 0xD50ADA38, + 0x0339C32A, 0xC6913667, 0x8DF9317C, 0xE0B12B4F, + 0xF79E59B7, 0x43F5BB3A, 0xF2D519FF, 0x27D9459C, + 0xBF97222C, 0x15E6FC2A, 0x0F91FC71, 0x9B941525, + 0xFAE59361, 0xCEB69CEB, 0xC2A86459, 0x12BAA8D1, + 0xB6C1075E, 0xE3056A0C, 0x10D25065, 0xCB03A442, + 0xE0EC6E0E, 0x1698DB3B, 0x4C98A0BE, 0x3278E964, + 0x9F1F9532, 0xE0D392DF, 0xD3A0342B, 0x8971F21E, + 0x1B0A7441, 0x4BA3348C, 0xC5BE7120, 0xC37632D8, + 0xDF359F8D, 0x9B992F2E, 0xE60B6F47, 0x0FE3F11D, + 0xE54CDA54, 0x1EDAD891, 0xCE6279CF, 0xCD3E7E6F, + 0x1618B166, 0xFD2C1D05, 0x848FD2C5, 0xF6FB2299, + 0xF523F357, 0xA6327623, 0x93A83531, 0x56CCCD02, + 0xACF08162, 0x5A75EBB5, 0x6E163697, 0x88D273CC, + 0xDE966292, 0x81B949D0, 0x4C50901B, 0x71C65614, + 0xE6C6C7BD, 0x327A140A, 0x45E1D006, 0xC3F27B9A, + 0xC9AA53FD, 0x62A80F00, 0xBB25BFE2, 0x35BDD2F6, + 0x71126905, 0xB2040222, 0xB6CBCF7C, 0xCD769C2B, + 0x53113EC0, 0x1640E3D3, 0x38ABBD60, 0x2547ADF0, + 0xBA38209C, 0xF746CE76, 0x77AFA1C5, 0x20756060, + 0x85CBFE4E, 0x8AE88DD8, 0x7AAAF9B0, 0x4CF9AA7E, + 0x1948C25C, 0x02FB8A8C, 0x01C36AE4, 0xD6EBE1F9, + 0x90D4F869, 0xA65CDEA0, 0x3F09252D, 0xC208E69F, + 0xB74E6132, 0xCE77E25B, 0x578FDFE3, 0x3AC372E6 ] + ]; + + var BLOWFISH_CTX = { + pbox: [], + sbox: [] + } + + function F(ctx, x){ + let a = (x >> 24) & 0xFF; + let b = (x >> 16) & 0xFF; + let c = (x >> 8) & 0xFF; + let d = x & 0xFF; + + let y = ctx.sbox[0][a] + ctx.sbox[1][b]; + y = y ^ ctx.sbox[2][c]; + y = y + ctx.sbox[3][d]; + + return y; + } + + function BlowFish_Encrypt(ctx, left, right){ + let Xl = left; + let Xr = right; + let temp; + + for(let i = 0; i < N; ++i){ + Xl = Xl ^ ctx.pbox[i]; + Xr = F(ctx, Xl) ^ Xr; + + temp = Xl; + Xl = Xr; + Xr = temp; + } + + temp = Xl; + Xl = Xr; + Xr = temp; + + Xr = Xr ^ ctx.pbox[N]; + Xl = Xl ^ ctx.pbox[N + 1]; + + return {left: Xl, right: Xr}; + } + + function BlowFish_Decrypt(ctx, left, right){ + let Xl = left; + let Xr = right; + let temp; + + for(let i = N + 1; i > 1; --i){ + Xl = Xl ^ ctx.pbox[i]; + Xr = F(ctx, Xl) ^ Xr; + + temp = Xl; + Xl = Xr; + Xr = temp; + } + + temp = Xl; + Xl = Xr; + Xr = temp; + + Xr = Xr ^ ctx.pbox[1]; + Xl = Xl ^ ctx.pbox[0]; + + return {left: Xl, right: Xr}; + } + + /** + * Initialization ctx's pbox and sbox. + * + * @param {Object} ctx The object has pbox and sbox. + * @param {Array} key An array of 32-bit words. + * @param {int} keysize The length of the key. + * + * @example + * + * BlowFishInit(BLOWFISH_CTX, key, 128/32); + */ + function BlowFishInit(ctx, key, keysize) + { + for(let Row = 0; Row < 4; Row++) + { + ctx.sbox[Row] = []; + for(let Col = 0; Col < 256; Col++) + { + ctx.sbox[Row][Col] = ORIG_S[Row][Col]; + } + } + + let keyIndex = 0; + for(let index = 0; index < N + 2; index++) + { + ctx.pbox[index] = ORIG_P[index] ^ key[keyIndex]; + keyIndex++; + if(keyIndex >= keysize) + { + keyIndex = 0; + } + } + + let Data1 = 0; + let Data2 = 0; + let res = 0; + for(let i = 0; i < N + 2; i += 2) + { + res = BlowFish_Encrypt(ctx, Data1, Data2); + Data1 = res.left; + Data2 = res.right; + ctx.pbox[i] = Data1; + ctx.pbox[i + 1] = Data2; + } + + for(let i = 0; i < 4; i++) + { + for(let j = 0; j < 256; j += 2) + { + res = BlowFish_Encrypt(ctx, Data1, Data2); + Data1 = res.left; + Data2 = res.right; + ctx.sbox[i][j] = Data1; + ctx.sbox[i][j + 1] = Data2; + } + } + + return true; + } + + /** + * Blowfish block cipher algorithm. + */ + var Blowfish = C_algo.Blowfish = BlockCipher.extend({ + _doReset: function () { + // Skip reset of nRounds has been set before and key did not change + if (this._keyPriorReset === this._key) { + return; + } + + // Shortcuts + var key = this._keyPriorReset = this._key; + var keyWords = key.words; + var keySize = key.sigBytes / 4; + + //Initialization pbox and sbox + BlowFishInit(BLOWFISH_CTX, keyWords, keySize); + }, + + encryptBlock: function (M, offset) { + var res = BlowFish_Encrypt(BLOWFISH_CTX, M[offset], M[offset + 1]); + M[offset] = res.left; + M[offset + 1] = res.right; + }, + + decryptBlock: function (M, offset) { + var res = BlowFish_Decrypt(BLOWFISH_CTX, M[offset], M[offset + 1]); + M[offset] = res.left; + M[offset + 1] = res.right; + }, + + blockSize: 64/32, + + keySize: 128/32, + + ivSize: 64/32 + }); + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.Blowfish.encrypt(message, key, cfg); + * var plaintext = CryptoJS.Blowfish.decrypt(ciphertext, key, cfg); + */ + C.Blowfish = BlockCipher._createHelper(Blowfish); + }()); + + + return CryptoJS.Blowfish; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/bower.json b/node_modules/crypto-js/bower.json new file mode 100644 index 0000000..4dee617 --- /dev/null +++ b/node_modules/crypto-js/bower.json @@ -0,0 +1,39 @@ +{ + "name": "crypto-js", + "version": "4.2.0", + "description": "JavaScript library of crypto standards.", + "license": "MIT", + "homepage": "http://github.com/brix/crypto-js", + "repository": { + "type": "git", + "url": "http://github.com/brix/crypto-js.git" + }, + "keywords": [ + "security", + "crypto", + "Hash", + "MD5", + "SHA1", + "SHA-1", + "SHA256", + "SHA-256", + "RC4", + "Rabbit", + "AES", + "DES", + "PBKDF2", + "HMAC", + "OFB", + "CFB", + "CTR", + "CBC", + "Base64", + "Base64url" + ], + "main": "index.js", + "dependencies": {}, + "browser": { + "crypto": false + }, + "ignore": [] +} diff --git a/node_modules/crypto-js/cipher-core.js b/node_modules/crypto-js/cipher-core.js new file mode 100644 index 0000000..903f462 --- /dev/null +++ b/node_modules/crypto-js/cipher-core.js @@ -0,0 +1,895 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./evpkdf")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./evpkdf"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + /** + * Cipher core components. + */ + CryptoJS.lib.Cipher || (function (undefined) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var Base = C_lib.Base; + var WordArray = C_lib.WordArray; + var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm; + var C_enc = C.enc; + var Utf8 = C_enc.Utf8; + var Base64 = C_enc.Base64; + var C_algo = C.algo; + var EvpKDF = C_algo.EvpKDF; + + /** + * Abstract base cipher template. + * + * @property {number} keySize This cipher's key size. Default: 4 (128 bits) + * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits) + * @property {number} _ENC_XFORM_MODE A constant representing encryption mode. + * @property {number} _DEC_XFORM_MODE A constant representing decryption mode. + */ + var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({ + /** + * Configuration options. + * + * @property {WordArray} iv The IV to use for this operation. + */ + cfg: Base.extend(), + + /** + * Creates this cipher in encryption mode. + * + * @param {WordArray} key The key. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {Cipher} A cipher instance. + * + * @static + * + * @example + * + * var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray }); + */ + createEncryptor: function (key, cfg) { + return this.create(this._ENC_XFORM_MODE, key, cfg); + }, + + /** + * Creates this cipher in decryption mode. + * + * @param {WordArray} key The key. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {Cipher} A cipher instance. + * + * @static + * + * @example + * + * var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray }); + */ + createDecryptor: function (key, cfg) { + return this.create(this._DEC_XFORM_MODE, key, cfg); + }, + + /** + * Initializes a newly created cipher. + * + * @param {number} xformMode Either the encryption or decryption transormation mode constant. + * @param {WordArray} key The key. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @example + * + * var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray }); + */ + init: function (xformMode, key, cfg) { + // Apply config defaults + this.cfg = this.cfg.extend(cfg); + + // Store transform mode and key + this._xformMode = xformMode; + this._key = key; + + // Set initial values + this.reset(); + }, + + /** + * Resets this cipher to its initial state. + * + * @example + * + * cipher.reset(); + */ + reset: function () { + // Reset data buffer + BufferedBlockAlgorithm.reset.call(this); + + // Perform concrete-cipher logic + this._doReset(); + }, + + /** + * Adds data to be encrypted or decrypted. + * + * @param {WordArray|string} dataUpdate The data to encrypt or decrypt. + * + * @return {WordArray} The data after processing. + * + * @example + * + * var encrypted = cipher.process('data'); + * var encrypted = cipher.process(wordArray); + */ + process: function (dataUpdate) { + // Append + this._append(dataUpdate); + + // Process available blocks + return this._process(); + }, + + /** + * Finalizes the encryption or decryption process. + * Note that the finalize operation is effectively a destructive, read-once operation. + * + * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt. + * + * @return {WordArray} The data after final processing. + * + * @example + * + * var encrypted = cipher.finalize(); + * var encrypted = cipher.finalize('data'); + * var encrypted = cipher.finalize(wordArray); + */ + finalize: function (dataUpdate) { + // Final data update + if (dataUpdate) { + this._append(dataUpdate); + } + + // Perform concrete-cipher logic + var finalProcessedData = this._doFinalize(); + + return finalProcessedData; + }, + + keySize: 128/32, + + ivSize: 128/32, + + _ENC_XFORM_MODE: 1, + + _DEC_XFORM_MODE: 2, + + /** + * Creates shortcut functions to a cipher's object interface. + * + * @param {Cipher} cipher The cipher to create a helper for. + * + * @return {Object} An object with encrypt and decrypt shortcut functions. + * + * @static + * + * @example + * + * var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES); + */ + _createHelper: (function () { + function selectCipherStrategy(key) { + if (typeof key == 'string') { + return PasswordBasedCipher; + } else { + return SerializableCipher; + } + } + + return function (cipher) { + return { + encrypt: function (message, key, cfg) { + return selectCipherStrategy(key).encrypt(cipher, message, key, cfg); + }, + + decrypt: function (ciphertext, key, cfg) { + return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg); + } + }; + }; + }()) + }); + + /** + * Abstract base stream cipher template. + * + * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits) + */ + var StreamCipher = C_lib.StreamCipher = Cipher.extend({ + _doFinalize: function () { + // Process partial blocks + var finalProcessedBlocks = this._process(!!'flush'); + + return finalProcessedBlocks; + }, + + blockSize: 1 + }); + + /** + * Mode namespace. + */ + var C_mode = C.mode = {}; + + /** + * Abstract base block cipher mode template. + */ + var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({ + /** + * Creates this mode for encryption. + * + * @param {Cipher} cipher A block cipher instance. + * @param {Array} iv The IV words. + * + * @static + * + * @example + * + * var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words); + */ + createEncryptor: function (cipher, iv) { + return this.Encryptor.create(cipher, iv); + }, + + /** + * Creates this mode for decryption. + * + * @param {Cipher} cipher A block cipher instance. + * @param {Array} iv The IV words. + * + * @static + * + * @example + * + * var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words); + */ + createDecryptor: function (cipher, iv) { + return this.Decryptor.create(cipher, iv); + }, + + /** + * Initializes a newly created mode. + * + * @param {Cipher} cipher A block cipher instance. + * @param {Array} iv The IV words. + * + * @example + * + * var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words); + */ + init: function (cipher, iv) { + this._cipher = cipher; + this._iv = iv; + } + }); + + /** + * Cipher Block Chaining mode. + */ + var CBC = C_mode.CBC = (function () { + /** + * Abstract base CBC mode. + */ + var CBC = BlockCipherMode.extend(); + + /** + * CBC encryptor. + */ + CBC.Encryptor = CBC.extend({ + /** + * Processes the data block at offset. + * + * @param {Array} words The data words to operate on. + * @param {number} offset The offset where the block starts. + * + * @example + * + * mode.processBlock(data.words, offset); + */ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher; + var blockSize = cipher.blockSize; + + // XOR and encrypt + xorBlock.call(this, words, offset, blockSize); + cipher.encryptBlock(words, offset); + + // Remember this block to use with next block + this._prevBlock = words.slice(offset, offset + blockSize); + } + }); + + /** + * CBC decryptor. + */ + CBC.Decryptor = CBC.extend({ + /** + * Processes the data block at offset. + * + * @param {Array} words The data words to operate on. + * @param {number} offset The offset where the block starts. + * + * @example + * + * mode.processBlock(data.words, offset); + */ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher; + var blockSize = cipher.blockSize; + + // Remember this block to use with next block + var thisBlock = words.slice(offset, offset + blockSize); + + // Decrypt and XOR + cipher.decryptBlock(words, offset); + xorBlock.call(this, words, offset, blockSize); + + // This block becomes the previous block + this._prevBlock = thisBlock; + } + }); + + function xorBlock(words, offset, blockSize) { + var block; + + // Shortcut + var iv = this._iv; + + // Choose mixing block + if (iv) { + block = iv; + + // Remove IV for subsequent blocks + this._iv = undefined; + } else { + block = this._prevBlock; + } + + // XOR blocks + for (var i = 0; i < blockSize; i++) { + words[offset + i] ^= block[i]; + } + } + + return CBC; + }()); + + /** + * Padding namespace. + */ + var C_pad = C.pad = {}; + + /** + * PKCS #5/7 padding strategy. + */ + var Pkcs7 = C_pad.Pkcs7 = { + /** + * Pads data using the algorithm defined in PKCS #5/7. + * + * @param {WordArray} data The data to pad. + * @param {number} blockSize The multiple that the data should be padded to. + * + * @static + * + * @example + * + * CryptoJS.pad.Pkcs7.pad(wordArray, 4); + */ + pad: function (data, blockSize) { + // Shortcut + var blockSizeBytes = blockSize * 4; + + // Count padding bytes + var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes; + + // Create padding word + var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes; + + // Create padding + var paddingWords = []; + for (var i = 0; i < nPaddingBytes; i += 4) { + paddingWords.push(paddingWord); + } + var padding = WordArray.create(paddingWords, nPaddingBytes); + + // Add padding + data.concat(padding); + }, + + /** + * Unpads data that had been padded using the algorithm defined in PKCS #5/7. + * + * @param {WordArray} data The data to unpad. + * + * @static + * + * @example + * + * CryptoJS.pad.Pkcs7.unpad(wordArray); + */ + unpad: function (data) { + // Get number of padding bytes from last byte + var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff; + + // Remove padding + data.sigBytes -= nPaddingBytes; + } + }; + + /** + * Abstract base block cipher template. + * + * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits) + */ + var BlockCipher = C_lib.BlockCipher = Cipher.extend({ + /** + * Configuration options. + * + * @property {Mode} mode The block mode to use. Default: CBC + * @property {Padding} padding The padding strategy to use. Default: Pkcs7 + */ + cfg: Cipher.cfg.extend({ + mode: CBC, + padding: Pkcs7 + }), + + reset: function () { + var modeCreator; + + // Reset cipher + Cipher.reset.call(this); + + // Shortcuts + var cfg = this.cfg; + var iv = cfg.iv; + var mode = cfg.mode; + + // Reset block mode + if (this._xformMode == this._ENC_XFORM_MODE) { + modeCreator = mode.createEncryptor; + } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ { + modeCreator = mode.createDecryptor; + // Keep at least one block in the buffer for unpadding + this._minBufferSize = 1; + } + + if (this._mode && this._mode.__creator == modeCreator) { + this._mode.init(this, iv && iv.words); + } else { + this._mode = modeCreator.call(mode, this, iv && iv.words); + this._mode.__creator = modeCreator; + } + }, + + _doProcessBlock: function (words, offset) { + this._mode.processBlock(words, offset); + }, + + _doFinalize: function () { + var finalProcessedBlocks; + + // Shortcut + var padding = this.cfg.padding; + + // Finalize + if (this._xformMode == this._ENC_XFORM_MODE) { + // Pad data + padding.pad(this._data, this.blockSize); + + // Process final blocks + finalProcessedBlocks = this._process(!!'flush'); + } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ { + // Process final blocks + finalProcessedBlocks = this._process(!!'flush'); + + // Unpad data + padding.unpad(finalProcessedBlocks); + } + + return finalProcessedBlocks; + }, + + blockSize: 128/32 + }); + + /** + * A collection of cipher parameters. + * + * @property {WordArray} ciphertext The raw ciphertext. + * @property {WordArray} key The key to this ciphertext. + * @property {WordArray} iv The IV used in the ciphering operation. + * @property {WordArray} salt The salt used with a key derivation function. + * @property {Cipher} algorithm The cipher algorithm. + * @property {Mode} mode The block mode used in the ciphering operation. + * @property {Padding} padding The padding scheme used in the ciphering operation. + * @property {number} blockSize The block size of the cipher. + * @property {Format} formatter The default formatting strategy to convert this cipher params object to a string. + */ + var CipherParams = C_lib.CipherParams = Base.extend({ + /** + * Initializes a newly created cipher params object. + * + * @param {Object} cipherParams An object with any of the possible cipher parameters. + * + * @example + * + * var cipherParams = CryptoJS.lib.CipherParams.create({ + * ciphertext: ciphertextWordArray, + * key: keyWordArray, + * iv: ivWordArray, + * salt: saltWordArray, + * algorithm: CryptoJS.algo.AES, + * mode: CryptoJS.mode.CBC, + * padding: CryptoJS.pad.PKCS7, + * blockSize: 4, + * formatter: CryptoJS.format.OpenSSL + * }); + */ + init: function (cipherParams) { + this.mixIn(cipherParams); + }, + + /** + * Converts this cipher params object to a string. + * + * @param {Format} formatter (Optional) The formatting strategy to use. + * + * @return {string} The stringified cipher params. + * + * @throws Error If neither the formatter nor the default formatter is set. + * + * @example + * + * var string = cipherParams + ''; + * var string = cipherParams.toString(); + * var string = cipherParams.toString(CryptoJS.format.OpenSSL); + */ + toString: function (formatter) { + return (formatter || this.formatter).stringify(this); + } + }); + + /** + * Format namespace. + */ + var C_format = C.format = {}; + + /** + * OpenSSL formatting strategy. + */ + var OpenSSLFormatter = C_format.OpenSSL = { + /** + * Converts a cipher params object to an OpenSSL-compatible string. + * + * @param {CipherParams} cipherParams The cipher params object. + * + * @return {string} The OpenSSL-compatible string. + * + * @static + * + * @example + * + * var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams); + */ + stringify: function (cipherParams) { + var wordArray; + + // Shortcuts + var ciphertext = cipherParams.ciphertext; + var salt = cipherParams.salt; + + // Format + if (salt) { + wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext); + } else { + wordArray = ciphertext; + } + + return wordArray.toString(Base64); + }, + + /** + * Converts an OpenSSL-compatible string to a cipher params object. + * + * @param {string} openSSLStr The OpenSSL-compatible string. + * + * @return {CipherParams} The cipher params object. + * + * @static + * + * @example + * + * var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString); + */ + parse: function (openSSLStr) { + var salt; + + // Parse base64 + var ciphertext = Base64.parse(openSSLStr); + + // Shortcut + var ciphertextWords = ciphertext.words; + + // Test for salt + if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) { + // Extract salt + salt = WordArray.create(ciphertextWords.slice(2, 4)); + + // Remove salt from ciphertext + ciphertextWords.splice(0, 4); + ciphertext.sigBytes -= 16; + } + + return CipherParams.create({ ciphertext: ciphertext, salt: salt }); + } + }; + + /** + * A cipher wrapper that returns ciphertext as a serializable cipher params object. + */ + var SerializableCipher = C_lib.SerializableCipher = Base.extend({ + /** + * Configuration options. + * + * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL + */ + cfg: Base.extend({ + format: OpenSSLFormatter + }), + + /** + * Encrypts a message. + * + * @param {Cipher} cipher The cipher algorithm to use. + * @param {WordArray|string} message The message to encrypt. + * @param {WordArray} key The key. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {CipherParams} A cipher params object. + * + * @static + * + * @example + * + * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key); + * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv }); + * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL }); + */ + encrypt: function (cipher, message, key, cfg) { + // Apply config defaults + cfg = this.cfg.extend(cfg); + + // Encrypt + var encryptor = cipher.createEncryptor(key, cfg); + var ciphertext = encryptor.finalize(message); + + // Shortcut + var cipherCfg = encryptor.cfg; + + // Create and return serializable cipher params + return CipherParams.create({ + ciphertext: ciphertext, + key: key, + iv: cipherCfg.iv, + algorithm: cipher, + mode: cipherCfg.mode, + padding: cipherCfg.padding, + blockSize: cipher.blockSize, + formatter: cfg.format + }); + }, + + /** + * Decrypts serialized ciphertext. + * + * @param {Cipher} cipher The cipher algorithm to use. + * @param {CipherParams|string} ciphertext The ciphertext to decrypt. + * @param {WordArray} key The key. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {WordArray} The plaintext. + * + * @static + * + * @example + * + * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL }); + * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL }); + */ + decrypt: function (cipher, ciphertext, key, cfg) { + // Apply config defaults + cfg = this.cfg.extend(cfg); + + // Convert string to CipherParams + ciphertext = this._parse(ciphertext, cfg.format); + + // Decrypt + var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext); + + return plaintext; + }, + + /** + * Converts serialized ciphertext to CipherParams, + * else assumed CipherParams already and returns ciphertext unchanged. + * + * @param {CipherParams|string} ciphertext The ciphertext. + * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext. + * + * @return {CipherParams} The unserialized ciphertext. + * + * @static + * + * @example + * + * var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format); + */ + _parse: function (ciphertext, format) { + if (typeof ciphertext == 'string') { + return format.parse(ciphertext, this); + } else { + return ciphertext; + } + } + }); + + /** + * Key derivation function namespace. + */ + var C_kdf = C.kdf = {}; + + /** + * OpenSSL key derivation function. + */ + var OpenSSLKdf = C_kdf.OpenSSL = { + /** + * Derives a key and IV from a password. + * + * @param {string} password The password to derive from. + * @param {number} keySize The size in words of the key to generate. + * @param {number} ivSize The size in words of the IV to generate. + * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly. + * + * @return {CipherParams} A cipher params object with the key, IV, and salt. + * + * @static + * + * @example + * + * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32); + * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt'); + */ + execute: function (password, keySize, ivSize, salt, hasher) { + // Generate random salt + if (!salt) { + salt = WordArray.random(64/8); + } + + // Derive key and IV + if (!hasher) { + var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt); + } else { + var key = EvpKDF.create({ keySize: keySize + ivSize, hasher: hasher }).compute(password, salt); + } + + + // Separate key and IV + var iv = WordArray.create(key.words.slice(keySize), ivSize * 4); + key.sigBytes = keySize * 4; + + // Return params + return CipherParams.create({ key: key, iv: iv, salt: salt }); + } + }; + + /** + * A serializable cipher wrapper that derives the key from a password, + * and returns ciphertext as a serializable cipher params object. + */ + var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({ + /** + * Configuration options. + * + * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL + */ + cfg: SerializableCipher.cfg.extend({ + kdf: OpenSSLKdf + }), + + /** + * Encrypts a message using a password. + * + * @param {Cipher} cipher The cipher algorithm to use. + * @param {WordArray|string} message The message to encrypt. + * @param {string} password The password. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {CipherParams} A cipher params object. + * + * @static + * + * @example + * + * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password'); + * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL }); + */ + encrypt: function (cipher, message, password, cfg) { + // Apply config defaults + cfg = this.cfg.extend(cfg); + + // Derive key and other params + var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, cfg.salt, cfg.hasher); + + // Add IV to config + cfg.iv = derivedParams.iv; + + // Encrypt + var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg); + + // Mix in derived params + ciphertext.mixIn(derivedParams); + + return ciphertext; + }, + + /** + * Decrypts serialized ciphertext using a password. + * + * @param {Cipher} cipher The cipher algorithm to use. + * @param {CipherParams|string} ciphertext The ciphertext to decrypt. + * @param {string} password The password. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {WordArray} The plaintext. + * + * @static + * + * @example + * + * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL }); + * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL }); + */ + decrypt: function (cipher, ciphertext, password, cfg) { + // Apply config defaults + cfg = this.cfg.extend(cfg); + + // Convert string to CipherParams + ciphertext = this._parse(ciphertext, cfg.format); + + // Derive key and other params + var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt, cfg.hasher); + + // Add IV to config + cfg.iv = derivedParams.iv; + + // Decrypt + var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg); + + return plaintext; + } + }); + }()); + + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/core.js b/node_modules/crypto-js/core.js new file mode 100644 index 0000000..e3a498b --- /dev/null +++ b/node_modules/crypto-js/core.js @@ -0,0 +1,807 @@ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(); + } + else if (typeof define === "function" && define.amd) { + // AMD + define([], factory); + } + else { + // Global (browser) + root.CryptoJS = factory(); + } +}(this, function () { + + /*globals window, global, require*/ + + /** + * CryptoJS core components. + */ + var CryptoJS = CryptoJS || (function (Math, undefined) { + + var crypto; + + // Native crypto from window (Browser) + if (typeof window !== 'undefined' && window.crypto) { + crypto = window.crypto; + } + + // Native crypto in web worker (Browser) + if (typeof self !== 'undefined' && self.crypto) { + crypto = self.crypto; + } + + // Native crypto from worker + if (typeof globalThis !== 'undefined' && globalThis.crypto) { + crypto = globalThis.crypto; + } + + // Native (experimental IE 11) crypto from window (Browser) + if (!crypto && typeof window !== 'undefined' && window.msCrypto) { + crypto = window.msCrypto; + } + + // Native crypto from global (NodeJS) + if (!crypto && typeof global !== 'undefined' && global.crypto) { + crypto = global.crypto; + } + + // Native crypto import via require (NodeJS) + if (!crypto && typeof require === 'function') { + try { + crypto = require('crypto'); + } catch (err) {} + } + + /* + * Cryptographically secure pseudorandom number generator + * + * As Math.random() is cryptographically not safe to use + */ + var cryptoSecureRandomInt = function () { + if (crypto) { + // Use getRandomValues method (Browser) + if (typeof crypto.getRandomValues === 'function') { + try { + return crypto.getRandomValues(new Uint32Array(1))[0]; + } catch (err) {} + } + + // Use randomBytes method (NodeJS) + if (typeof crypto.randomBytes === 'function') { + try { + return crypto.randomBytes(4).readInt32LE(); + } catch (err) {} + } + } + + throw new Error('Native crypto module could not be used to get secure random number.'); + }; + + /* + * Local polyfill of Object.create + + */ + var create = Object.create || (function () { + function F() {} + + return function (obj) { + var subtype; + + F.prototype = obj; + + subtype = new F(); + + F.prototype = null; + + return subtype; + }; + }()); + + /** + * CryptoJS namespace. + */ + var C = {}; + + /** + * Library namespace. + */ + var C_lib = C.lib = {}; + + /** + * Base object for prototypal inheritance. + */ + var Base = C_lib.Base = (function () { + + + return { + /** + * Creates a new object that inherits from this object. + * + * @param {Object} overrides Properties to copy into the new object. + * + * @return {Object} The new object. + * + * @static + * + * @example + * + * var MyType = CryptoJS.lib.Base.extend({ + * field: 'value', + * + * method: function () { + * } + * }); + */ + extend: function (overrides) { + // Spawn + var subtype = create(this); + + // Augment + if (overrides) { + subtype.mixIn(overrides); + } + + // Create default initializer + if (!subtype.hasOwnProperty('init') || this.init === subtype.init) { + subtype.init = function () { + subtype.$super.init.apply(this, arguments); + }; + } + + // Initializer's prototype is the subtype object + subtype.init.prototype = subtype; + + // Reference supertype + subtype.$super = this; + + return subtype; + }, + + /** + * Extends this object and runs the init method. + * Arguments to create() will be passed to init(). + * + * @return {Object} The new object. + * + * @static + * + * @example + * + * var instance = MyType.create(); + */ + create: function () { + var instance = this.extend(); + instance.init.apply(instance, arguments); + + return instance; + }, + + /** + * Initializes a newly created object. + * Override this method to add some logic when your objects are created. + * + * @example + * + * var MyType = CryptoJS.lib.Base.extend({ + * init: function () { + * // ... + * } + * }); + */ + init: function () { + }, + + /** + * Copies properties into this object. + * + * @param {Object} properties The properties to mix in. + * + * @example + * + * MyType.mixIn({ + * field: 'value' + * }); + */ + mixIn: function (properties) { + for (var propertyName in properties) { + if (properties.hasOwnProperty(propertyName)) { + this[propertyName] = properties[propertyName]; + } + } + + // IE won't copy toString using the loop above + if (properties.hasOwnProperty('toString')) { + this.toString = properties.toString; + } + }, + + /** + * Creates a copy of this object. + * + * @return {Object} The clone. + * + * @example + * + * var clone = instance.clone(); + */ + clone: function () { + return this.init.prototype.extend(this); + } + }; + }()); + + /** + * An array of 32-bit words. + * + * @property {Array} words The array of 32-bit words. + * @property {number} sigBytes The number of significant bytes in this word array. + */ + var WordArray = C_lib.WordArray = Base.extend({ + /** + * Initializes a newly created word array. + * + * @param {Array} words (Optional) An array of 32-bit words. + * @param {number} sigBytes (Optional) The number of significant bytes in the words. + * + * @example + * + * var wordArray = CryptoJS.lib.WordArray.create(); + * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]); + * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6); + */ + init: function (words, sigBytes) { + words = this.words = words || []; + + if (sigBytes != undefined) { + this.sigBytes = sigBytes; + } else { + this.sigBytes = words.length * 4; + } + }, + + /** + * Converts this word array to a string. + * + * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex + * + * @return {string} The stringified word array. + * + * @example + * + * var string = wordArray + ''; + * var string = wordArray.toString(); + * var string = wordArray.toString(CryptoJS.enc.Utf8); + */ + toString: function (encoder) { + return (encoder || Hex).stringify(this); + }, + + /** + * Concatenates a word array to this word array. + * + * @param {WordArray} wordArray The word array to append. + * + * @return {WordArray} This word array. + * + * @example + * + * wordArray1.concat(wordArray2); + */ + concat: function (wordArray) { + // Shortcuts + var thisWords = this.words; + var thatWords = wordArray.words; + var thisSigBytes = this.sigBytes; + var thatSigBytes = wordArray.sigBytes; + + // Clamp excess bits + this.clamp(); + + // Concat + if (thisSigBytes % 4) { + // Copy one byte at a time + for (var i = 0; i < thatSigBytes; i++) { + var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8); + } + } else { + // Copy one word at a time + for (var j = 0; j < thatSigBytes; j += 4) { + thisWords[(thisSigBytes + j) >>> 2] = thatWords[j >>> 2]; + } + } + this.sigBytes += thatSigBytes; + + // Chainable + return this; + }, + + /** + * Removes insignificant bits. + * + * @example + * + * wordArray.clamp(); + */ + clamp: function () { + // Shortcuts + var words = this.words; + var sigBytes = this.sigBytes; + + // Clamp + words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8); + words.length = Math.ceil(sigBytes / 4); + }, + + /** + * Creates a copy of this word array. + * + * @return {WordArray} The clone. + * + * @example + * + * var clone = wordArray.clone(); + */ + clone: function () { + var clone = Base.clone.call(this); + clone.words = this.words.slice(0); + + return clone; + }, + + /** + * Creates a word array filled with random bytes. + * + * @param {number} nBytes The number of random bytes to generate. + * + * @return {WordArray} The random word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.lib.WordArray.random(16); + */ + random: function (nBytes) { + var words = []; + + for (var i = 0; i < nBytes; i += 4) { + words.push(cryptoSecureRandomInt()); + } + + return new WordArray.init(words, nBytes); + } + }); + + /** + * Encoder namespace. + */ + var C_enc = C.enc = {}; + + /** + * Hex encoding strategy. + */ + var Hex = C_enc.Hex = { + /** + * Converts a word array to a hex string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The hex string. + * + * @static + * + * @example + * + * var hexString = CryptoJS.enc.Hex.stringify(wordArray); + */ + stringify: function (wordArray) { + // Shortcuts + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + + // Convert + var hexChars = []; + for (var i = 0; i < sigBytes; i++) { + var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + hexChars.push((bite >>> 4).toString(16)); + hexChars.push((bite & 0x0f).toString(16)); + } + + return hexChars.join(''); + }, + + /** + * Converts a hex string to a word array. + * + * @param {string} hexStr The hex string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Hex.parse(hexString); + */ + parse: function (hexStr) { + // Shortcut + var hexStrLength = hexStr.length; + + // Convert + var words = []; + for (var i = 0; i < hexStrLength; i += 2) { + words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4); + } + + return new WordArray.init(words, hexStrLength / 2); + } + }; + + /** + * Latin1 encoding strategy. + */ + var Latin1 = C_enc.Latin1 = { + /** + * Converts a word array to a Latin1 string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The Latin1 string. + * + * @static + * + * @example + * + * var latin1String = CryptoJS.enc.Latin1.stringify(wordArray); + */ + stringify: function (wordArray) { + // Shortcuts + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + + // Convert + var latin1Chars = []; + for (var i = 0; i < sigBytes; i++) { + var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + latin1Chars.push(String.fromCharCode(bite)); + } + + return latin1Chars.join(''); + }, + + /** + * Converts a Latin1 string to a word array. + * + * @param {string} latin1Str The Latin1 string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Latin1.parse(latin1String); + */ + parse: function (latin1Str) { + // Shortcut + var latin1StrLength = latin1Str.length; + + // Convert + var words = []; + for (var i = 0; i < latin1StrLength; i++) { + words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8); + } + + return new WordArray.init(words, latin1StrLength); + } + }; + + /** + * UTF-8 encoding strategy. + */ + var Utf8 = C_enc.Utf8 = { + /** + * Converts a word array to a UTF-8 string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The UTF-8 string. + * + * @static + * + * @example + * + * var utf8String = CryptoJS.enc.Utf8.stringify(wordArray); + */ + stringify: function (wordArray) { + try { + return decodeURIComponent(escape(Latin1.stringify(wordArray))); + } catch (e) { + throw new Error('Malformed UTF-8 data'); + } + }, + + /** + * Converts a UTF-8 string to a word array. + * + * @param {string} utf8Str The UTF-8 string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Utf8.parse(utf8String); + */ + parse: function (utf8Str) { + return Latin1.parse(unescape(encodeURIComponent(utf8Str))); + } + }; + + /** + * Abstract buffered block algorithm template. + * + * The property blockSize must be implemented in a concrete subtype. + * + * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0 + */ + var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({ + /** + * Resets this block algorithm's data buffer to its initial state. + * + * @example + * + * bufferedBlockAlgorithm.reset(); + */ + reset: function () { + // Initial values + this._data = new WordArray.init(); + this._nDataBytes = 0; + }, + + /** + * Adds new data to this block algorithm's buffer. + * + * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8. + * + * @example + * + * bufferedBlockAlgorithm._append('data'); + * bufferedBlockAlgorithm._append(wordArray); + */ + _append: function (data) { + // Convert string to WordArray, else assume WordArray already + if (typeof data == 'string') { + data = Utf8.parse(data); + } + + // Append + this._data.concat(data); + this._nDataBytes += data.sigBytes; + }, + + /** + * Processes available data blocks. + * + * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype. + * + * @param {boolean} doFlush Whether all blocks and partial blocks should be processed. + * + * @return {WordArray} The processed data. + * + * @example + * + * var processedData = bufferedBlockAlgorithm._process(); + * var processedData = bufferedBlockAlgorithm._process(!!'flush'); + */ + _process: function (doFlush) { + var processedWords; + + // Shortcuts + var data = this._data; + var dataWords = data.words; + var dataSigBytes = data.sigBytes; + var blockSize = this.blockSize; + var blockSizeBytes = blockSize * 4; + + // Count blocks ready + var nBlocksReady = dataSigBytes / blockSizeBytes; + if (doFlush) { + // Round up to include partial blocks + nBlocksReady = Math.ceil(nBlocksReady); + } else { + // Round down to include only full blocks, + // less the number of blocks that must remain in the buffer + nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0); + } + + // Count words ready + var nWordsReady = nBlocksReady * blockSize; + + // Count bytes ready + var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes); + + // Process blocks + if (nWordsReady) { + for (var offset = 0; offset < nWordsReady; offset += blockSize) { + // Perform concrete-algorithm logic + this._doProcessBlock(dataWords, offset); + } + + // Remove processed words + processedWords = dataWords.splice(0, nWordsReady); + data.sigBytes -= nBytesReady; + } + + // Return processed words + return new WordArray.init(processedWords, nBytesReady); + }, + + /** + * Creates a copy of this object. + * + * @return {Object} The clone. + * + * @example + * + * var clone = bufferedBlockAlgorithm.clone(); + */ + clone: function () { + var clone = Base.clone.call(this); + clone._data = this._data.clone(); + + return clone; + }, + + _minBufferSize: 0 + }); + + /** + * Abstract hasher template. + * + * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits) + */ + var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({ + /** + * Configuration options. + */ + cfg: Base.extend(), + + /** + * Initializes a newly created hasher. + * + * @param {Object} cfg (Optional) The configuration options to use for this hash computation. + * + * @example + * + * var hasher = CryptoJS.algo.SHA256.create(); + */ + init: function (cfg) { + // Apply config defaults + this.cfg = this.cfg.extend(cfg); + + // Set initial values + this.reset(); + }, + + /** + * Resets this hasher to its initial state. + * + * @example + * + * hasher.reset(); + */ + reset: function () { + // Reset data buffer + BufferedBlockAlgorithm.reset.call(this); + + // Perform concrete-hasher logic + this._doReset(); + }, + + /** + * Updates this hasher with a message. + * + * @param {WordArray|string} messageUpdate The message to append. + * + * @return {Hasher} This hasher. + * + * @example + * + * hasher.update('message'); + * hasher.update(wordArray); + */ + update: function (messageUpdate) { + // Append + this._append(messageUpdate); + + // Update the hash + this._process(); + + // Chainable + return this; + }, + + /** + * Finalizes the hash computation. + * Note that the finalize operation is effectively a destructive, read-once operation. + * + * @param {WordArray|string} messageUpdate (Optional) A final message update. + * + * @return {WordArray} The hash. + * + * @example + * + * var hash = hasher.finalize(); + * var hash = hasher.finalize('message'); + * var hash = hasher.finalize(wordArray); + */ + finalize: function (messageUpdate) { + // Final message update + if (messageUpdate) { + this._append(messageUpdate); + } + + // Perform concrete-hasher logic + var hash = this._doFinalize(); + + return hash; + }, + + blockSize: 512/32, + + /** + * Creates a shortcut function to a hasher's object interface. + * + * @param {Hasher} hasher The hasher to create a helper for. + * + * @return {Function} The shortcut function. + * + * @static + * + * @example + * + * var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256); + */ + _createHelper: function (hasher) { + return function (message, cfg) { + return new hasher.init(cfg).finalize(message); + }; + }, + + /** + * Creates a shortcut function to the HMAC's object interface. + * + * @param {Hasher} hasher The hasher to use in this HMAC helper. + * + * @return {Function} The shortcut function. + * + * @static + * + * @example + * + * var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256); + */ + _createHmacHelper: function (hasher) { + return function (message, key) { + return new C_algo.HMAC.init(hasher, key).finalize(message); + }; + } + }); + + /** + * Algorithm namespace. + */ + var C_algo = C.algo = {}; + + return C; + }(Math)); + + + return CryptoJS; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/crypto-js.js b/node_modules/crypto-js/crypto-js.js new file mode 100644 index 0000000..958ee53 --- /dev/null +++ b/node_modules/crypto-js/crypto-js.js @@ -0,0 +1,6657 @@ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(); + } + else if (typeof define === "function" && define.amd) { + // AMD + define([], factory); + } + else { + // Global (browser) + root.CryptoJS = factory(); + } +}(this, function () { + + /*globals window, global, require*/ + + /** + * CryptoJS core components. + */ + var CryptoJS = CryptoJS || (function (Math, undefined) { + + var crypto; + + // Native crypto from window (Browser) + if (typeof window !== 'undefined' && window.crypto) { + crypto = window.crypto; + } + + // Native crypto in web worker (Browser) + if (typeof self !== 'undefined' && self.crypto) { + crypto = self.crypto; + } + + // Native crypto from worker + if (typeof globalThis !== 'undefined' && globalThis.crypto) { + crypto = globalThis.crypto; + } + + // Native (experimental IE 11) crypto from window (Browser) + if (!crypto && typeof window !== 'undefined' && window.msCrypto) { + crypto = window.msCrypto; + } + + // Native crypto from global (NodeJS) + if (!crypto && typeof global !== 'undefined' && global.crypto) { + crypto = global.crypto; + } + + // Native crypto import via require (NodeJS) + if (!crypto && typeof require === 'function') { + try { + crypto = require('crypto'); + } catch (err) {} + } + + /* + * Cryptographically secure pseudorandom number generator + * + * As Math.random() is cryptographically not safe to use + */ + var cryptoSecureRandomInt = function () { + if (crypto) { + // Use getRandomValues method (Browser) + if (typeof crypto.getRandomValues === 'function') { + try { + return crypto.getRandomValues(new Uint32Array(1))[0]; + } catch (err) {} + } + + // Use randomBytes method (NodeJS) + if (typeof crypto.randomBytes === 'function') { + try { + return crypto.randomBytes(4).readInt32LE(); + } catch (err) {} + } + } + + throw new Error('Native crypto module could not be used to get secure random number.'); + }; + + /* + * Local polyfill of Object.create + + */ + var create = Object.create || (function () { + function F() {} + + return function (obj) { + var subtype; + + F.prototype = obj; + + subtype = new F(); + + F.prototype = null; + + return subtype; + }; + }()); + + /** + * CryptoJS namespace. + */ + var C = {}; + + /** + * Library namespace. + */ + var C_lib = C.lib = {}; + + /** + * Base object for prototypal inheritance. + */ + var Base = C_lib.Base = (function () { + + + return { + /** + * Creates a new object that inherits from this object. + * + * @param {Object} overrides Properties to copy into the new object. + * + * @return {Object} The new object. + * + * @static + * + * @example + * + * var MyType = CryptoJS.lib.Base.extend({ + * field: 'value', + * + * method: function () { + * } + * }); + */ + extend: function (overrides) { + // Spawn + var subtype = create(this); + + // Augment + if (overrides) { + subtype.mixIn(overrides); + } + + // Create default initializer + if (!subtype.hasOwnProperty('init') || this.init === subtype.init) { + subtype.init = function () { + subtype.$super.init.apply(this, arguments); + }; + } + + // Initializer's prototype is the subtype object + subtype.init.prototype = subtype; + + // Reference supertype + subtype.$super = this; + + return subtype; + }, + + /** + * Extends this object and runs the init method. + * Arguments to create() will be passed to init(). + * + * @return {Object} The new object. + * + * @static + * + * @example + * + * var instance = MyType.create(); + */ + create: function () { + var instance = this.extend(); + instance.init.apply(instance, arguments); + + return instance; + }, + + /** + * Initializes a newly created object. + * Override this method to add some logic when your objects are created. + * + * @example + * + * var MyType = CryptoJS.lib.Base.extend({ + * init: function () { + * // ... + * } + * }); + */ + init: function () { + }, + + /** + * Copies properties into this object. + * + * @param {Object} properties The properties to mix in. + * + * @example + * + * MyType.mixIn({ + * field: 'value' + * }); + */ + mixIn: function (properties) { + for (var propertyName in properties) { + if (properties.hasOwnProperty(propertyName)) { + this[propertyName] = properties[propertyName]; + } + } + + // IE won't copy toString using the loop above + if (properties.hasOwnProperty('toString')) { + this.toString = properties.toString; + } + }, + + /** + * Creates a copy of this object. + * + * @return {Object} The clone. + * + * @example + * + * var clone = instance.clone(); + */ + clone: function () { + return this.init.prototype.extend(this); + } + }; + }()); + + /** + * An array of 32-bit words. + * + * @property {Array} words The array of 32-bit words. + * @property {number} sigBytes The number of significant bytes in this word array. + */ + var WordArray = C_lib.WordArray = Base.extend({ + /** + * Initializes a newly created word array. + * + * @param {Array} words (Optional) An array of 32-bit words. + * @param {number} sigBytes (Optional) The number of significant bytes in the words. + * + * @example + * + * var wordArray = CryptoJS.lib.WordArray.create(); + * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]); + * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6); + */ + init: function (words, sigBytes) { + words = this.words = words || []; + + if (sigBytes != undefined) { + this.sigBytes = sigBytes; + } else { + this.sigBytes = words.length * 4; + } + }, + + /** + * Converts this word array to a string. + * + * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex + * + * @return {string} The stringified word array. + * + * @example + * + * var string = wordArray + ''; + * var string = wordArray.toString(); + * var string = wordArray.toString(CryptoJS.enc.Utf8); + */ + toString: function (encoder) { + return (encoder || Hex).stringify(this); + }, + + /** + * Concatenates a word array to this word array. + * + * @param {WordArray} wordArray The word array to append. + * + * @return {WordArray} This word array. + * + * @example + * + * wordArray1.concat(wordArray2); + */ + concat: function (wordArray) { + // Shortcuts + var thisWords = this.words; + var thatWords = wordArray.words; + var thisSigBytes = this.sigBytes; + var thatSigBytes = wordArray.sigBytes; + + // Clamp excess bits + this.clamp(); + + // Concat + if (thisSigBytes % 4) { + // Copy one byte at a time + for (var i = 0; i < thatSigBytes; i++) { + var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8); + } + } else { + // Copy one word at a time + for (var j = 0; j < thatSigBytes; j += 4) { + thisWords[(thisSigBytes + j) >>> 2] = thatWords[j >>> 2]; + } + } + this.sigBytes += thatSigBytes; + + // Chainable + return this; + }, + + /** + * Removes insignificant bits. + * + * @example + * + * wordArray.clamp(); + */ + clamp: function () { + // Shortcuts + var words = this.words; + var sigBytes = this.sigBytes; + + // Clamp + words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8); + words.length = Math.ceil(sigBytes / 4); + }, + + /** + * Creates a copy of this word array. + * + * @return {WordArray} The clone. + * + * @example + * + * var clone = wordArray.clone(); + */ + clone: function () { + var clone = Base.clone.call(this); + clone.words = this.words.slice(0); + + return clone; + }, + + /** + * Creates a word array filled with random bytes. + * + * @param {number} nBytes The number of random bytes to generate. + * + * @return {WordArray} The random word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.lib.WordArray.random(16); + */ + random: function (nBytes) { + var words = []; + + for (var i = 0; i < nBytes; i += 4) { + words.push(cryptoSecureRandomInt()); + } + + return new WordArray.init(words, nBytes); + } + }); + + /** + * Encoder namespace. + */ + var C_enc = C.enc = {}; + + /** + * Hex encoding strategy. + */ + var Hex = C_enc.Hex = { + /** + * Converts a word array to a hex string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The hex string. + * + * @static + * + * @example + * + * var hexString = CryptoJS.enc.Hex.stringify(wordArray); + */ + stringify: function (wordArray) { + // Shortcuts + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + + // Convert + var hexChars = []; + for (var i = 0; i < sigBytes; i++) { + var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + hexChars.push((bite >>> 4).toString(16)); + hexChars.push((bite & 0x0f).toString(16)); + } + + return hexChars.join(''); + }, + + /** + * Converts a hex string to a word array. + * + * @param {string} hexStr The hex string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Hex.parse(hexString); + */ + parse: function (hexStr) { + // Shortcut + var hexStrLength = hexStr.length; + + // Convert + var words = []; + for (var i = 0; i < hexStrLength; i += 2) { + words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4); + } + + return new WordArray.init(words, hexStrLength / 2); + } + }; + + /** + * Latin1 encoding strategy. + */ + var Latin1 = C_enc.Latin1 = { + /** + * Converts a word array to a Latin1 string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The Latin1 string. + * + * @static + * + * @example + * + * var latin1String = CryptoJS.enc.Latin1.stringify(wordArray); + */ + stringify: function (wordArray) { + // Shortcuts + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + + // Convert + var latin1Chars = []; + for (var i = 0; i < sigBytes; i++) { + var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + latin1Chars.push(String.fromCharCode(bite)); + } + + return latin1Chars.join(''); + }, + + /** + * Converts a Latin1 string to a word array. + * + * @param {string} latin1Str The Latin1 string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Latin1.parse(latin1String); + */ + parse: function (latin1Str) { + // Shortcut + var latin1StrLength = latin1Str.length; + + // Convert + var words = []; + for (var i = 0; i < latin1StrLength; i++) { + words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8); + } + + return new WordArray.init(words, latin1StrLength); + } + }; + + /** + * UTF-8 encoding strategy. + */ + var Utf8 = C_enc.Utf8 = { + /** + * Converts a word array to a UTF-8 string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The UTF-8 string. + * + * @static + * + * @example + * + * var utf8String = CryptoJS.enc.Utf8.stringify(wordArray); + */ + stringify: function (wordArray) { + try { + return decodeURIComponent(escape(Latin1.stringify(wordArray))); + } catch (e) { + throw new Error('Malformed UTF-8 data'); + } + }, + + /** + * Converts a UTF-8 string to a word array. + * + * @param {string} utf8Str The UTF-8 string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Utf8.parse(utf8String); + */ + parse: function (utf8Str) { + return Latin1.parse(unescape(encodeURIComponent(utf8Str))); + } + }; + + /** + * Abstract buffered block algorithm template. + * + * The property blockSize must be implemented in a concrete subtype. + * + * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0 + */ + var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({ + /** + * Resets this block algorithm's data buffer to its initial state. + * + * @example + * + * bufferedBlockAlgorithm.reset(); + */ + reset: function () { + // Initial values + this._data = new WordArray.init(); + this._nDataBytes = 0; + }, + + /** + * Adds new data to this block algorithm's buffer. + * + * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8. + * + * @example + * + * bufferedBlockAlgorithm._append('data'); + * bufferedBlockAlgorithm._append(wordArray); + */ + _append: function (data) { + // Convert string to WordArray, else assume WordArray already + if (typeof data == 'string') { + data = Utf8.parse(data); + } + + // Append + this._data.concat(data); + this._nDataBytes += data.sigBytes; + }, + + /** + * Processes available data blocks. + * + * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype. + * + * @param {boolean} doFlush Whether all blocks and partial blocks should be processed. + * + * @return {WordArray} The processed data. + * + * @example + * + * var processedData = bufferedBlockAlgorithm._process(); + * var processedData = bufferedBlockAlgorithm._process(!!'flush'); + */ + _process: function (doFlush) { + var processedWords; + + // Shortcuts + var data = this._data; + var dataWords = data.words; + var dataSigBytes = data.sigBytes; + var blockSize = this.blockSize; + var blockSizeBytes = blockSize * 4; + + // Count blocks ready + var nBlocksReady = dataSigBytes / blockSizeBytes; + if (doFlush) { + // Round up to include partial blocks + nBlocksReady = Math.ceil(nBlocksReady); + } else { + // Round down to include only full blocks, + // less the number of blocks that must remain in the buffer + nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0); + } + + // Count words ready + var nWordsReady = nBlocksReady * blockSize; + + // Count bytes ready + var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes); + + // Process blocks + if (nWordsReady) { + for (var offset = 0; offset < nWordsReady; offset += blockSize) { + // Perform concrete-algorithm logic + this._doProcessBlock(dataWords, offset); + } + + // Remove processed words + processedWords = dataWords.splice(0, nWordsReady); + data.sigBytes -= nBytesReady; + } + + // Return processed words + return new WordArray.init(processedWords, nBytesReady); + }, + + /** + * Creates a copy of this object. + * + * @return {Object} The clone. + * + * @example + * + * var clone = bufferedBlockAlgorithm.clone(); + */ + clone: function () { + var clone = Base.clone.call(this); + clone._data = this._data.clone(); + + return clone; + }, + + _minBufferSize: 0 + }); + + /** + * Abstract hasher template. + * + * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits) + */ + var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({ + /** + * Configuration options. + */ + cfg: Base.extend(), + + /** + * Initializes a newly created hasher. + * + * @param {Object} cfg (Optional) The configuration options to use for this hash computation. + * + * @example + * + * var hasher = CryptoJS.algo.SHA256.create(); + */ + init: function (cfg) { + // Apply config defaults + this.cfg = this.cfg.extend(cfg); + + // Set initial values + this.reset(); + }, + + /** + * Resets this hasher to its initial state. + * + * @example + * + * hasher.reset(); + */ + reset: function () { + // Reset data buffer + BufferedBlockAlgorithm.reset.call(this); + + // Perform concrete-hasher logic + this._doReset(); + }, + + /** + * Updates this hasher with a message. + * + * @param {WordArray|string} messageUpdate The message to append. + * + * @return {Hasher} This hasher. + * + * @example + * + * hasher.update('message'); + * hasher.update(wordArray); + */ + update: function (messageUpdate) { + // Append + this._append(messageUpdate); + + // Update the hash + this._process(); + + // Chainable + return this; + }, + + /** + * Finalizes the hash computation. + * Note that the finalize operation is effectively a destructive, read-once operation. + * + * @param {WordArray|string} messageUpdate (Optional) A final message update. + * + * @return {WordArray} The hash. + * + * @example + * + * var hash = hasher.finalize(); + * var hash = hasher.finalize('message'); + * var hash = hasher.finalize(wordArray); + */ + finalize: function (messageUpdate) { + // Final message update + if (messageUpdate) { + this._append(messageUpdate); + } + + // Perform concrete-hasher logic + var hash = this._doFinalize(); + + return hash; + }, + + blockSize: 512/32, + + /** + * Creates a shortcut function to a hasher's object interface. + * + * @param {Hasher} hasher The hasher to create a helper for. + * + * @return {Function} The shortcut function. + * + * @static + * + * @example + * + * var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256); + */ + _createHelper: function (hasher) { + return function (message, cfg) { + return new hasher.init(cfg).finalize(message); + }; + }, + + /** + * Creates a shortcut function to the HMAC's object interface. + * + * @param {Hasher} hasher The hasher to use in this HMAC helper. + * + * @return {Function} The shortcut function. + * + * @static + * + * @example + * + * var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256); + */ + _createHmacHelper: function (hasher) { + return function (message, key) { + return new C_algo.HMAC.init(hasher, key).finalize(message); + }; + } + }); + + /** + * Algorithm namespace. + */ + var C_algo = C.algo = {}; + + return C; + }(Math)); + + + (function (undefined) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var Base = C_lib.Base; + var X32WordArray = C_lib.WordArray; + + /** + * x64 namespace. + */ + var C_x64 = C.x64 = {}; + + /** + * A 64-bit word. + */ + var X64Word = C_x64.Word = Base.extend({ + /** + * Initializes a newly created 64-bit word. + * + * @param {number} high The high 32 bits. + * @param {number} low The low 32 bits. + * + * @example + * + * var x64Word = CryptoJS.x64.Word.create(0x00010203, 0x04050607); + */ + init: function (high, low) { + this.high = high; + this.low = low; + } + + /** + * Bitwise NOTs this word. + * + * @return {X64Word} A new x64-Word object after negating. + * + * @example + * + * var negated = x64Word.not(); + */ + // not: function () { + // var high = ~this.high; + // var low = ~this.low; + + // return X64Word.create(high, low); + // }, + + /** + * Bitwise ANDs this word with the passed word. + * + * @param {X64Word} word The x64-Word to AND with this word. + * + * @return {X64Word} A new x64-Word object after ANDing. + * + * @example + * + * var anded = x64Word.and(anotherX64Word); + */ + // and: function (word) { + // var high = this.high & word.high; + // var low = this.low & word.low; + + // return X64Word.create(high, low); + // }, + + /** + * Bitwise ORs this word with the passed word. + * + * @param {X64Word} word The x64-Word to OR with this word. + * + * @return {X64Word} A new x64-Word object after ORing. + * + * @example + * + * var ored = x64Word.or(anotherX64Word); + */ + // or: function (word) { + // var high = this.high | word.high; + // var low = this.low | word.low; + + // return X64Word.create(high, low); + // }, + + /** + * Bitwise XORs this word with the passed word. + * + * @param {X64Word} word The x64-Word to XOR with this word. + * + * @return {X64Word} A new x64-Word object after XORing. + * + * @example + * + * var xored = x64Word.xor(anotherX64Word); + */ + // xor: function (word) { + // var high = this.high ^ word.high; + // var low = this.low ^ word.low; + + // return X64Word.create(high, low); + // }, + + /** + * Shifts this word n bits to the left. + * + * @param {number} n The number of bits to shift. + * + * @return {X64Word} A new x64-Word object after shifting. + * + * @example + * + * var shifted = x64Word.shiftL(25); + */ + // shiftL: function (n) { + // if (n < 32) { + // var high = (this.high << n) | (this.low >>> (32 - n)); + // var low = this.low << n; + // } else { + // var high = this.low << (n - 32); + // var low = 0; + // } + + // return X64Word.create(high, low); + // }, + + /** + * Shifts this word n bits to the right. + * + * @param {number} n The number of bits to shift. + * + * @return {X64Word} A new x64-Word object after shifting. + * + * @example + * + * var shifted = x64Word.shiftR(7); + */ + // shiftR: function (n) { + // if (n < 32) { + // var low = (this.low >>> n) | (this.high << (32 - n)); + // var high = this.high >>> n; + // } else { + // var low = this.high >>> (n - 32); + // var high = 0; + // } + + // return X64Word.create(high, low); + // }, + + /** + * Rotates this word n bits to the left. + * + * @param {number} n The number of bits to rotate. + * + * @return {X64Word} A new x64-Word object after rotating. + * + * @example + * + * var rotated = x64Word.rotL(25); + */ + // rotL: function (n) { + // return this.shiftL(n).or(this.shiftR(64 - n)); + // }, + + /** + * Rotates this word n bits to the right. + * + * @param {number} n The number of bits to rotate. + * + * @return {X64Word} A new x64-Word object after rotating. + * + * @example + * + * var rotated = x64Word.rotR(7); + */ + // rotR: function (n) { + // return this.shiftR(n).or(this.shiftL(64 - n)); + // }, + + /** + * Adds this word with the passed word. + * + * @param {X64Word} word The x64-Word to add with this word. + * + * @return {X64Word} A new x64-Word object after adding. + * + * @example + * + * var added = x64Word.add(anotherX64Word); + */ + // add: function (word) { + // var low = (this.low + word.low) | 0; + // var carry = (low >>> 0) < (this.low >>> 0) ? 1 : 0; + // var high = (this.high + word.high + carry) | 0; + + // return X64Word.create(high, low); + // } + }); + + /** + * An array of 64-bit words. + * + * @property {Array} words The array of CryptoJS.x64.Word objects. + * @property {number} sigBytes The number of significant bytes in this word array. + */ + var X64WordArray = C_x64.WordArray = Base.extend({ + /** + * Initializes a newly created word array. + * + * @param {Array} words (Optional) An array of CryptoJS.x64.Word objects. + * @param {number} sigBytes (Optional) The number of significant bytes in the words. + * + * @example + * + * var wordArray = CryptoJS.x64.WordArray.create(); + * + * var wordArray = CryptoJS.x64.WordArray.create([ + * CryptoJS.x64.Word.create(0x00010203, 0x04050607), + * CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f) + * ]); + * + * var wordArray = CryptoJS.x64.WordArray.create([ + * CryptoJS.x64.Word.create(0x00010203, 0x04050607), + * CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f) + * ], 10); + */ + init: function (words, sigBytes) { + words = this.words = words || []; + + if (sigBytes != undefined) { + this.sigBytes = sigBytes; + } else { + this.sigBytes = words.length * 8; + } + }, + + /** + * Converts this 64-bit word array to a 32-bit word array. + * + * @return {CryptoJS.lib.WordArray} This word array's data as a 32-bit word array. + * + * @example + * + * var x32WordArray = x64WordArray.toX32(); + */ + toX32: function () { + // Shortcuts + var x64Words = this.words; + var x64WordsLength = x64Words.length; + + // Convert + var x32Words = []; + for (var i = 0; i < x64WordsLength; i++) { + var x64Word = x64Words[i]; + x32Words.push(x64Word.high); + x32Words.push(x64Word.low); + } + + return X32WordArray.create(x32Words, this.sigBytes); + }, + + /** + * Creates a copy of this word array. + * + * @return {X64WordArray} The clone. + * + * @example + * + * var clone = x64WordArray.clone(); + */ + clone: function () { + var clone = Base.clone.call(this); + + // Clone "words" array + var words = clone.words = this.words.slice(0); + + // Clone each X64Word object + var wordsLength = words.length; + for (var i = 0; i < wordsLength; i++) { + words[i] = words[i].clone(); + } + + return clone; + } + }); + }()); + + + (function () { + // Check if typed arrays are supported + if (typeof ArrayBuffer != 'function') { + return; + } + + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + + // Reference original init + var superInit = WordArray.init; + + // Augment WordArray.init to handle typed arrays + var subInit = WordArray.init = function (typedArray) { + // Convert buffers to uint8 + if (typedArray instanceof ArrayBuffer) { + typedArray = new Uint8Array(typedArray); + } + + // Convert other array views to uint8 + if ( + typedArray instanceof Int8Array || + (typeof Uint8ClampedArray !== "undefined" && typedArray instanceof Uint8ClampedArray) || + typedArray instanceof Int16Array || + typedArray instanceof Uint16Array || + typedArray instanceof Int32Array || + typedArray instanceof Uint32Array || + typedArray instanceof Float32Array || + typedArray instanceof Float64Array + ) { + typedArray = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength); + } + + // Handle Uint8Array + if (typedArray instanceof Uint8Array) { + // Shortcut + var typedArrayByteLength = typedArray.byteLength; + + // Extract bytes + var words = []; + for (var i = 0; i < typedArrayByteLength; i++) { + words[i >>> 2] |= typedArray[i] << (24 - (i % 4) * 8); + } + + // Initialize this word array + superInit.call(this, words, typedArrayByteLength); + } else { + // Else call normal init + superInit.apply(this, arguments); + } + }; + + subInit.prototype = WordArray; + }()); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var C_enc = C.enc; + + /** + * UTF-16 BE encoding strategy. + */ + var Utf16BE = C_enc.Utf16 = C_enc.Utf16BE = { + /** + * Converts a word array to a UTF-16 BE string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The UTF-16 BE string. + * + * @static + * + * @example + * + * var utf16String = CryptoJS.enc.Utf16.stringify(wordArray); + */ + stringify: function (wordArray) { + // Shortcuts + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + + // Convert + var utf16Chars = []; + for (var i = 0; i < sigBytes; i += 2) { + var codePoint = (words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff; + utf16Chars.push(String.fromCharCode(codePoint)); + } + + return utf16Chars.join(''); + }, + + /** + * Converts a UTF-16 BE string to a word array. + * + * @param {string} utf16Str The UTF-16 BE string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Utf16.parse(utf16String); + */ + parse: function (utf16Str) { + // Shortcut + var utf16StrLength = utf16Str.length; + + // Convert + var words = []; + for (var i = 0; i < utf16StrLength; i++) { + words[i >>> 1] |= utf16Str.charCodeAt(i) << (16 - (i % 2) * 16); + } + + return WordArray.create(words, utf16StrLength * 2); + } + }; + + /** + * UTF-16 LE encoding strategy. + */ + C_enc.Utf16LE = { + /** + * Converts a word array to a UTF-16 LE string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The UTF-16 LE string. + * + * @static + * + * @example + * + * var utf16Str = CryptoJS.enc.Utf16LE.stringify(wordArray); + */ + stringify: function (wordArray) { + // Shortcuts + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + + // Convert + var utf16Chars = []; + for (var i = 0; i < sigBytes; i += 2) { + var codePoint = swapEndian((words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff); + utf16Chars.push(String.fromCharCode(codePoint)); + } + + return utf16Chars.join(''); + }, + + /** + * Converts a UTF-16 LE string to a word array. + * + * @param {string} utf16Str The UTF-16 LE string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Utf16LE.parse(utf16Str); + */ + parse: function (utf16Str) { + // Shortcut + var utf16StrLength = utf16Str.length; + + // Convert + var words = []; + for (var i = 0; i < utf16StrLength; i++) { + words[i >>> 1] |= swapEndian(utf16Str.charCodeAt(i) << (16 - (i % 2) * 16)); + } + + return WordArray.create(words, utf16StrLength * 2); + } + }; + + function swapEndian(word) { + return ((word << 8) & 0xff00ff00) | ((word >>> 8) & 0x00ff00ff); + } + }()); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var C_enc = C.enc; + + /** + * Base64 encoding strategy. + */ + var Base64 = C_enc.Base64 = { + /** + * Converts a word array to a Base64 string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The Base64 string. + * + * @static + * + * @example + * + * var base64String = CryptoJS.enc.Base64.stringify(wordArray); + */ + stringify: function (wordArray) { + // Shortcuts + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + var map = this._map; + + // Clamp excess bits + wordArray.clamp(); + + // Convert + var base64Chars = []; + for (var i = 0; i < sigBytes; i += 3) { + var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff; + var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff; + + var triplet = (byte1 << 16) | (byte2 << 8) | byte3; + + for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) { + base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f)); + } + } + + // Add padding + var paddingChar = map.charAt(64); + if (paddingChar) { + while (base64Chars.length % 4) { + base64Chars.push(paddingChar); + } + } + + return base64Chars.join(''); + }, + + /** + * Converts a Base64 string to a word array. + * + * @param {string} base64Str The Base64 string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Base64.parse(base64String); + */ + parse: function (base64Str) { + // Shortcuts + var base64StrLength = base64Str.length; + var map = this._map; + var reverseMap = this._reverseMap; + + if (!reverseMap) { + reverseMap = this._reverseMap = []; + for (var j = 0; j < map.length; j++) { + reverseMap[map.charCodeAt(j)] = j; + } + } + + // Ignore padding + var paddingChar = map.charAt(64); + if (paddingChar) { + var paddingIndex = base64Str.indexOf(paddingChar); + if (paddingIndex !== -1) { + base64StrLength = paddingIndex; + } + } + + // Convert + return parseLoop(base64Str, base64StrLength, reverseMap); + + }, + + _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=' + }; + + function parseLoop(base64Str, base64StrLength, reverseMap) { + var words = []; + var nBytes = 0; + for (var i = 0; i < base64StrLength; i++) { + if (i % 4) { + var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2); + var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2); + var bitsCombined = bits1 | bits2; + words[nBytes >>> 2] |= bitsCombined << (24 - (nBytes % 4) * 8); + nBytes++; + } + } + return WordArray.create(words, nBytes); + } + }()); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var C_enc = C.enc; + + /** + * Base64url encoding strategy. + */ + var Base64url = C_enc.Base64url = { + /** + * Converts a word array to a Base64url string. + * + * @param {WordArray} wordArray The word array. + * + * @param {boolean} urlSafe Whether to use url safe + * + * @return {string} The Base64url string. + * + * @static + * + * @example + * + * var base64String = CryptoJS.enc.Base64url.stringify(wordArray); + */ + stringify: function (wordArray, urlSafe) { + if (urlSafe === undefined) { + urlSafe = true + } + // Shortcuts + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + var map = urlSafe ? this._safe_map : this._map; + + // Clamp excess bits + wordArray.clamp(); + + // Convert + var base64Chars = []; + for (var i = 0; i < sigBytes; i += 3) { + var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff; + var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff; + + var triplet = (byte1 << 16) | (byte2 << 8) | byte3; + + for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) { + base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f)); + } + } + + // Add padding + var paddingChar = map.charAt(64); + if (paddingChar) { + while (base64Chars.length % 4) { + base64Chars.push(paddingChar); + } + } + + return base64Chars.join(''); + }, + + /** + * Converts a Base64url string to a word array. + * + * @param {string} base64Str The Base64url string. + * + * @param {boolean} urlSafe Whether to use url safe + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Base64url.parse(base64String); + */ + parse: function (base64Str, urlSafe) { + if (urlSafe === undefined) { + urlSafe = true + } + + // Shortcuts + var base64StrLength = base64Str.length; + var map = urlSafe ? this._safe_map : this._map; + var reverseMap = this._reverseMap; + + if (!reverseMap) { + reverseMap = this._reverseMap = []; + for (var j = 0; j < map.length; j++) { + reverseMap[map.charCodeAt(j)] = j; + } + } + + // Ignore padding + var paddingChar = map.charAt(64); + if (paddingChar) { + var paddingIndex = base64Str.indexOf(paddingChar); + if (paddingIndex !== -1) { + base64StrLength = paddingIndex; + } + } + + // Convert + return parseLoop(base64Str, base64StrLength, reverseMap); + + }, + + _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=', + _safe_map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_', + }; + + function parseLoop(base64Str, base64StrLength, reverseMap) { + var words = []; + var nBytes = 0; + for (var i = 0; i < base64StrLength; i++) { + if (i % 4) { + var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2); + var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2); + var bitsCombined = bits1 | bits2; + words[nBytes >>> 2] |= bitsCombined << (24 - (nBytes % 4) * 8); + nBytes++; + } + } + return WordArray.create(words, nBytes); + } + }()); + + + (function (Math) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var Hasher = C_lib.Hasher; + var C_algo = C.algo; + + // Constants table + var T = []; + + // Compute constants + (function () { + for (var i = 0; i < 64; i++) { + T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0; + } + }()); + + /** + * MD5 hash algorithm. + */ + var MD5 = C_algo.MD5 = Hasher.extend({ + _doReset: function () { + this._hash = new WordArray.init([ + 0x67452301, 0xefcdab89, + 0x98badcfe, 0x10325476 + ]); + }, + + _doProcessBlock: function (M, offset) { + // Swap endian + for (var i = 0; i < 16; i++) { + // Shortcuts + var offset_i = offset + i; + var M_offset_i = M[offset_i]; + + M[offset_i] = ( + (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) | + (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00) + ); + } + + // Shortcuts + var H = this._hash.words; + + var M_offset_0 = M[offset + 0]; + var M_offset_1 = M[offset + 1]; + var M_offset_2 = M[offset + 2]; + var M_offset_3 = M[offset + 3]; + var M_offset_4 = M[offset + 4]; + var M_offset_5 = M[offset + 5]; + var M_offset_6 = M[offset + 6]; + var M_offset_7 = M[offset + 7]; + var M_offset_8 = M[offset + 8]; + var M_offset_9 = M[offset + 9]; + var M_offset_10 = M[offset + 10]; + var M_offset_11 = M[offset + 11]; + var M_offset_12 = M[offset + 12]; + var M_offset_13 = M[offset + 13]; + var M_offset_14 = M[offset + 14]; + var M_offset_15 = M[offset + 15]; + + // Working variables + var a = H[0]; + var b = H[1]; + var c = H[2]; + var d = H[3]; + + // Computation + a = FF(a, b, c, d, M_offset_0, 7, T[0]); + d = FF(d, a, b, c, M_offset_1, 12, T[1]); + c = FF(c, d, a, b, M_offset_2, 17, T[2]); + b = FF(b, c, d, a, M_offset_3, 22, T[3]); + a = FF(a, b, c, d, M_offset_4, 7, T[4]); + d = FF(d, a, b, c, M_offset_5, 12, T[5]); + c = FF(c, d, a, b, M_offset_6, 17, T[6]); + b = FF(b, c, d, a, M_offset_7, 22, T[7]); + a = FF(a, b, c, d, M_offset_8, 7, T[8]); + d = FF(d, a, b, c, M_offset_9, 12, T[9]); + c = FF(c, d, a, b, M_offset_10, 17, T[10]); + b = FF(b, c, d, a, M_offset_11, 22, T[11]); + a = FF(a, b, c, d, M_offset_12, 7, T[12]); + d = FF(d, a, b, c, M_offset_13, 12, T[13]); + c = FF(c, d, a, b, M_offset_14, 17, T[14]); + b = FF(b, c, d, a, M_offset_15, 22, T[15]); + + a = GG(a, b, c, d, M_offset_1, 5, T[16]); + d = GG(d, a, b, c, M_offset_6, 9, T[17]); + c = GG(c, d, a, b, M_offset_11, 14, T[18]); + b = GG(b, c, d, a, M_offset_0, 20, T[19]); + a = GG(a, b, c, d, M_offset_5, 5, T[20]); + d = GG(d, a, b, c, M_offset_10, 9, T[21]); + c = GG(c, d, a, b, M_offset_15, 14, T[22]); + b = GG(b, c, d, a, M_offset_4, 20, T[23]); + a = GG(a, b, c, d, M_offset_9, 5, T[24]); + d = GG(d, a, b, c, M_offset_14, 9, T[25]); + c = GG(c, d, a, b, M_offset_3, 14, T[26]); + b = GG(b, c, d, a, M_offset_8, 20, T[27]); + a = GG(a, b, c, d, M_offset_13, 5, T[28]); + d = GG(d, a, b, c, M_offset_2, 9, T[29]); + c = GG(c, d, a, b, M_offset_7, 14, T[30]); + b = GG(b, c, d, a, M_offset_12, 20, T[31]); + + a = HH(a, b, c, d, M_offset_5, 4, T[32]); + d = HH(d, a, b, c, M_offset_8, 11, T[33]); + c = HH(c, d, a, b, M_offset_11, 16, T[34]); + b = HH(b, c, d, a, M_offset_14, 23, T[35]); + a = HH(a, b, c, d, M_offset_1, 4, T[36]); + d = HH(d, a, b, c, M_offset_4, 11, T[37]); + c = HH(c, d, a, b, M_offset_7, 16, T[38]); + b = HH(b, c, d, a, M_offset_10, 23, T[39]); + a = HH(a, b, c, d, M_offset_13, 4, T[40]); + d = HH(d, a, b, c, M_offset_0, 11, T[41]); + c = HH(c, d, a, b, M_offset_3, 16, T[42]); + b = HH(b, c, d, a, M_offset_6, 23, T[43]); + a = HH(a, b, c, d, M_offset_9, 4, T[44]); + d = HH(d, a, b, c, M_offset_12, 11, T[45]); + c = HH(c, d, a, b, M_offset_15, 16, T[46]); + b = HH(b, c, d, a, M_offset_2, 23, T[47]); + + a = II(a, b, c, d, M_offset_0, 6, T[48]); + d = II(d, a, b, c, M_offset_7, 10, T[49]); + c = II(c, d, a, b, M_offset_14, 15, T[50]); + b = II(b, c, d, a, M_offset_5, 21, T[51]); + a = II(a, b, c, d, M_offset_12, 6, T[52]); + d = II(d, a, b, c, M_offset_3, 10, T[53]); + c = II(c, d, a, b, M_offset_10, 15, T[54]); + b = II(b, c, d, a, M_offset_1, 21, T[55]); + a = II(a, b, c, d, M_offset_8, 6, T[56]); + d = II(d, a, b, c, M_offset_15, 10, T[57]); + c = II(c, d, a, b, M_offset_6, 15, T[58]); + b = II(b, c, d, a, M_offset_13, 21, T[59]); + a = II(a, b, c, d, M_offset_4, 6, T[60]); + d = II(d, a, b, c, M_offset_11, 10, T[61]); + c = II(c, d, a, b, M_offset_2, 15, T[62]); + b = II(b, c, d, a, M_offset_9, 21, T[63]); + + // Intermediate hash value + H[0] = (H[0] + a) | 0; + H[1] = (H[1] + b) | 0; + H[2] = (H[2] + c) | 0; + H[3] = (H[3] + d) | 0; + }, + + _doFinalize: function () { + // Shortcuts + var data = this._data; + var dataWords = data.words; + + var nBitsTotal = this._nDataBytes * 8; + var nBitsLeft = data.sigBytes * 8; + + // Add padding + dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); + + var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000); + var nBitsTotalL = nBitsTotal; + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = ( + (((nBitsTotalH << 8) | (nBitsTotalH >>> 24)) & 0x00ff00ff) | + (((nBitsTotalH << 24) | (nBitsTotalH >>> 8)) & 0xff00ff00) + ); + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = ( + (((nBitsTotalL << 8) | (nBitsTotalL >>> 24)) & 0x00ff00ff) | + (((nBitsTotalL << 24) | (nBitsTotalL >>> 8)) & 0xff00ff00) + ); + + data.sigBytes = (dataWords.length + 1) * 4; + + // Hash final blocks + this._process(); + + // Shortcuts + var hash = this._hash; + var H = hash.words; + + // Swap endian + for (var i = 0; i < 4; i++) { + // Shortcut + var H_i = H[i]; + + H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) | + (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00); + } + + // Return final computed hash + return hash; + }, + + clone: function () { + var clone = Hasher.clone.call(this); + clone._hash = this._hash.clone(); + + return clone; + } + }); + + function FF(a, b, c, d, x, s, t) { + var n = a + ((b & c) | (~b & d)) + x + t; + return ((n << s) | (n >>> (32 - s))) + b; + } + + function GG(a, b, c, d, x, s, t) { + var n = a + ((b & d) | (c & ~d)) + x + t; + return ((n << s) | (n >>> (32 - s))) + b; + } + + function HH(a, b, c, d, x, s, t) { + var n = a + (b ^ c ^ d) + x + t; + return ((n << s) | (n >>> (32 - s))) + b; + } + + function II(a, b, c, d, x, s, t) { + var n = a + (c ^ (b | ~d)) + x + t; + return ((n << s) | (n >>> (32 - s))) + b; + } + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.MD5('message'); + * var hash = CryptoJS.MD5(wordArray); + */ + C.MD5 = Hasher._createHelper(MD5); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacMD5(message, key); + */ + C.HmacMD5 = Hasher._createHmacHelper(MD5); + }(Math)); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var Hasher = C_lib.Hasher; + var C_algo = C.algo; + + // Reusable object + var W = []; + + /** + * SHA-1 hash algorithm. + */ + var SHA1 = C_algo.SHA1 = Hasher.extend({ + _doReset: function () { + this._hash = new WordArray.init([ + 0x67452301, 0xefcdab89, + 0x98badcfe, 0x10325476, + 0xc3d2e1f0 + ]); + }, + + _doProcessBlock: function (M, offset) { + // Shortcut + var H = this._hash.words; + + // Working variables + var a = H[0]; + var b = H[1]; + var c = H[2]; + var d = H[3]; + var e = H[4]; + + // Computation + for (var i = 0; i < 80; i++) { + if (i < 16) { + W[i] = M[offset + i] | 0; + } else { + var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]; + W[i] = (n << 1) | (n >>> 31); + } + + var t = ((a << 5) | (a >>> 27)) + e + W[i]; + if (i < 20) { + t += ((b & c) | (~b & d)) + 0x5a827999; + } else if (i < 40) { + t += (b ^ c ^ d) + 0x6ed9eba1; + } else if (i < 60) { + t += ((b & c) | (b & d) | (c & d)) - 0x70e44324; + } else /* if (i < 80) */ { + t += (b ^ c ^ d) - 0x359d3e2a; + } + + e = d; + d = c; + c = (b << 30) | (b >>> 2); + b = a; + a = t; + } + + // Intermediate hash value + H[0] = (H[0] + a) | 0; + H[1] = (H[1] + b) | 0; + H[2] = (H[2] + c) | 0; + H[3] = (H[3] + d) | 0; + H[4] = (H[4] + e) | 0; + }, + + _doFinalize: function () { + // Shortcuts + var data = this._data; + var dataWords = data.words; + + var nBitsTotal = this._nDataBytes * 8; + var nBitsLeft = data.sigBytes * 8; + + // Add padding + dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000); + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal; + data.sigBytes = dataWords.length * 4; + + // Hash final blocks + this._process(); + + // Return final computed hash + return this._hash; + }, + + clone: function () { + var clone = Hasher.clone.call(this); + clone._hash = this._hash.clone(); + + return clone; + } + }); + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.SHA1('message'); + * var hash = CryptoJS.SHA1(wordArray); + */ + C.SHA1 = Hasher._createHelper(SHA1); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacSHA1(message, key); + */ + C.HmacSHA1 = Hasher._createHmacHelper(SHA1); + }()); + + + (function (Math) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var Hasher = C_lib.Hasher; + var C_algo = C.algo; + + // Initialization and round constants tables + var H = []; + var K = []; + + // Compute constants + (function () { + function isPrime(n) { + var sqrtN = Math.sqrt(n); + for (var factor = 2; factor <= sqrtN; factor++) { + if (!(n % factor)) { + return false; + } + } + + return true; + } + + function getFractionalBits(n) { + return ((n - (n | 0)) * 0x100000000) | 0; + } + + var n = 2; + var nPrime = 0; + while (nPrime < 64) { + if (isPrime(n)) { + if (nPrime < 8) { + H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2)); + } + K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3)); + + nPrime++; + } + + n++; + } + }()); + + // Reusable object + var W = []; + + /** + * SHA-256 hash algorithm. + */ + var SHA256 = C_algo.SHA256 = Hasher.extend({ + _doReset: function () { + this._hash = new WordArray.init(H.slice(0)); + }, + + _doProcessBlock: function (M, offset) { + // Shortcut + var H = this._hash.words; + + // Working variables + var a = H[0]; + var b = H[1]; + var c = H[2]; + var d = H[3]; + var e = H[4]; + var f = H[5]; + var g = H[6]; + var h = H[7]; + + // Computation + for (var i = 0; i < 64; i++) { + if (i < 16) { + W[i] = M[offset + i] | 0; + } else { + var gamma0x = W[i - 15]; + var gamma0 = ((gamma0x << 25) | (gamma0x >>> 7)) ^ + ((gamma0x << 14) | (gamma0x >>> 18)) ^ + (gamma0x >>> 3); + + var gamma1x = W[i - 2]; + var gamma1 = ((gamma1x << 15) | (gamma1x >>> 17)) ^ + ((gamma1x << 13) | (gamma1x >>> 19)) ^ + (gamma1x >>> 10); + + W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]; + } + + var ch = (e & f) ^ (~e & g); + var maj = (a & b) ^ (a & c) ^ (b & c); + + var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22)); + var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7) | (e >>> 25)); + + var t1 = h + sigma1 + ch + K[i] + W[i]; + var t2 = sigma0 + maj; + + h = g; + g = f; + f = e; + e = (d + t1) | 0; + d = c; + c = b; + b = a; + a = (t1 + t2) | 0; + } + + // Intermediate hash value + H[0] = (H[0] + a) | 0; + H[1] = (H[1] + b) | 0; + H[2] = (H[2] + c) | 0; + H[3] = (H[3] + d) | 0; + H[4] = (H[4] + e) | 0; + H[5] = (H[5] + f) | 0; + H[6] = (H[6] + g) | 0; + H[7] = (H[7] + h) | 0; + }, + + _doFinalize: function () { + // Shortcuts + var data = this._data; + var dataWords = data.words; + + var nBitsTotal = this._nDataBytes * 8; + var nBitsLeft = data.sigBytes * 8; + + // Add padding + dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000); + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal; + data.sigBytes = dataWords.length * 4; + + // Hash final blocks + this._process(); + + // Return final computed hash + return this._hash; + }, + + clone: function () { + var clone = Hasher.clone.call(this); + clone._hash = this._hash.clone(); + + return clone; + } + }); + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.SHA256('message'); + * var hash = CryptoJS.SHA256(wordArray); + */ + C.SHA256 = Hasher._createHelper(SHA256); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacSHA256(message, key); + */ + C.HmacSHA256 = Hasher._createHmacHelper(SHA256); + }(Math)); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var C_algo = C.algo; + var SHA256 = C_algo.SHA256; + + /** + * SHA-224 hash algorithm. + */ + var SHA224 = C_algo.SHA224 = SHA256.extend({ + _doReset: function () { + this._hash = new WordArray.init([ + 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, + 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4 + ]); + }, + + _doFinalize: function () { + var hash = SHA256._doFinalize.call(this); + + hash.sigBytes -= 4; + + return hash; + } + }); + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.SHA224('message'); + * var hash = CryptoJS.SHA224(wordArray); + */ + C.SHA224 = SHA256._createHelper(SHA224); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacSHA224(message, key); + */ + C.HmacSHA224 = SHA256._createHmacHelper(SHA224); + }()); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var Hasher = C_lib.Hasher; + var C_x64 = C.x64; + var X64Word = C_x64.Word; + var X64WordArray = C_x64.WordArray; + var C_algo = C.algo; + + function X64Word_create() { + return X64Word.create.apply(X64Word, arguments); + } + + // Constants + var K = [ + X64Word_create(0x428a2f98, 0xd728ae22), X64Word_create(0x71374491, 0x23ef65cd), + X64Word_create(0xb5c0fbcf, 0xec4d3b2f), X64Word_create(0xe9b5dba5, 0x8189dbbc), + X64Word_create(0x3956c25b, 0xf348b538), X64Word_create(0x59f111f1, 0xb605d019), + X64Word_create(0x923f82a4, 0xaf194f9b), X64Word_create(0xab1c5ed5, 0xda6d8118), + X64Word_create(0xd807aa98, 0xa3030242), X64Word_create(0x12835b01, 0x45706fbe), + X64Word_create(0x243185be, 0x4ee4b28c), X64Word_create(0x550c7dc3, 0xd5ffb4e2), + X64Word_create(0x72be5d74, 0xf27b896f), X64Word_create(0x80deb1fe, 0x3b1696b1), + X64Word_create(0x9bdc06a7, 0x25c71235), X64Word_create(0xc19bf174, 0xcf692694), + X64Word_create(0xe49b69c1, 0x9ef14ad2), X64Word_create(0xefbe4786, 0x384f25e3), + X64Word_create(0x0fc19dc6, 0x8b8cd5b5), X64Word_create(0x240ca1cc, 0x77ac9c65), + X64Word_create(0x2de92c6f, 0x592b0275), X64Word_create(0x4a7484aa, 0x6ea6e483), + X64Word_create(0x5cb0a9dc, 0xbd41fbd4), X64Word_create(0x76f988da, 0x831153b5), + X64Word_create(0x983e5152, 0xee66dfab), X64Word_create(0xa831c66d, 0x2db43210), + X64Word_create(0xb00327c8, 0x98fb213f), X64Word_create(0xbf597fc7, 0xbeef0ee4), + X64Word_create(0xc6e00bf3, 0x3da88fc2), X64Word_create(0xd5a79147, 0x930aa725), + X64Word_create(0x06ca6351, 0xe003826f), X64Word_create(0x14292967, 0x0a0e6e70), + X64Word_create(0x27b70a85, 0x46d22ffc), X64Word_create(0x2e1b2138, 0x5c26c926), + X64Word_create(0x4d2c6dfc, 0x5ac42aed), X64Word_create(0x53380d13, 0x9d95b3df), + X64Word_create(0x650a7354, 0x8baf63de), X64Word_create(0x766a0abb, 0x3c77b2a8), + X64Word_create(0x81c2c92e, 0x47edaee6), X64Word_create(0x92722c85, 0x1482353b), + X64Word_create(0xa2bfe8a1, 0x4cf10364), X64Word_create(0xa81a664b, 0xbc423001), + X64Word_create(0xc24b8b70, 0xd0f89791), X64Word_create(0xc76c51a3, 0x0654be30), + X64Word_create(0xd192e819, 0xd6ef5218), X64Word_create(0xd6990624, 0x5565a910), + X64Word_create(0xf40e3585, 0x5771202a), X64Word_create(0x106aa070, 0x32bbd1b8), + X64Word_create(0x19a4c116, 0xb8d2d0c8), X64Word_create(0x1e376c08, 0x5141ab53), + X64Word_create(0x2748774c, 0xdf8eeb99), X64Word_create(0x34b0bcb5, 0xe19b48a8), + X64Word_create(0x391c0cb3, 0xc5c95a63), X64Word_create(0x4ed8aa4a, 0xe3418acb), + X64Word_create(0x5b9cca4f, 0x7763e373), X64Word_create(0x682e6ff3, 0xd6b2b8a3), + X64Word_create(0x748f82ee, 0x5defb2fc), X64Word_create(0x78a5636f, 0x43172f60), + X64Word_create(0x84c87814, 0xa1f0ab72), X64Word_create(0x8cc70208, 0x1a6439ec), + X64Word_create(0x90befffa, 0x23631e28), X64Word_create(0xa4506ceb, 0xde82bde9), + X64Word_create(0xbef9a3f7, 0xb2c67915), X64Word_create(0xc67178f2, 0xe372532b), + X64Word_create(0xca273ece, 0xea26619c), X64Word_create(0xd186b8c7, 0x21c0c207), + X64Word_create(0xeada7dd6, 0xcde0eb1e), X64Word_create(0xf57d4f7f, 0xee6ed178), + X64Word_create(0x06f067aa, 0x72176fba), X64Word_create(0x0a637dc5, 0xa2c898a6), + X64Word_create(0x113f9804, 0xbef90dae), X64Word_create(0x1b710b35, 0x131c471b), + X64Word_create(0x28db77f5, 0x23047d84), X64Word_create(0x32caab7b, 0x40c72493), + X64Word_create(0x3c9ebe0a, 0x15c9bebc), X64Word_create(0x431d67c4, 0x9c100d4c), + X64Word_create(0x4cc5d4be, 0xcb3e42b6), X64Word_create(0x597f299c, 0xfc657e2a), + X64Word_create(0x5fcb6fab, 0x3ad6faec), X64Word_create(0x6c44198c, 0x4a475817) + ]; + + // Reusable objects + var W = []; + (function () { + for (var i = 0; i < 80; i++) { + W[i] = X64Word_create(); + } + }()); + + /** + * SHA-512 hash algorithm. + */ + var SHA512 = C_algo.SHA512 = Hasher.extend({ + _doReset: function () { + this._hash = new X64WordArray.init([ + new X64Word.init(0x6a09e667, 0xf3bcc908), new X64Word.init(0xbb67ae85, 0x84caa73b), + new X64Word.init(0x3c6ef372, 0xfe94f82b), new X64Word.init(0xa54ff53a, 0x5f1d36f1), + new X64Word.init(0x510e527f, 0xade682d1), new X64Word.init(0x9b05688c, 0x2b3e6c1f), + new X64Word.init(0x1f83d9ab, 0xfb41bd6b), new X64Word.init(0x5be0cd19, 0x137e2179) + ]); + }, + + _doProcessBlock: function (M, offset) { + // Shortcuts + var H = this._hash.words; + + var H0 = H[0]; + var H1 = H[1]; + var H2 = H[2]; + var H3 = H[3]; + var H4 = H[4]; + var H5 = H[5]; + var H6 = H[6]; + var H7 = H[7]; + + var H0h = H0.high; + var H0l = H0.low; + var H1h = H1.high; + var H1l = H1.low; + var H2h = H2.high; + var H2l = H2.low; + var H3h = H3.high; + var H3l = H3.low; + var H4h = H4.high; + var H4l = H4.low; + var H5h = H5.high; + var H5l = H5.low; + var H6h = H6.high; + var H6l = H6.low; + var H7h = H7.high; + var H7l = H7.low; + + // Working variables + var ah = H0h; + var al = H0l; + var bh = H1h; + var bl = H1l; + var ch = H2h; + var cl = H2l; + var dh = H3h; + var dl = H3l; + var eh = H4h; + var el = H4l; + var fh = H5h; + var fl = H5l; + var gh = H6h; + var gl = H6l; + var hh = H7h; + var hl = H7l; + + // Rounds + for (var i = 0; i < 80; i++) { + var Wil; + var Wih; + + // Shortcut + var Wi = W[i]; + + // Extend message + if (i < 16) { + Wih = Wi.high = M[offset + i * 2] | 0; + Wil = Wi.low = M[offset + i * 2 + 1] | 0; + } else { + // Gamma0 + var gamma0x = W[i - 15]; + var gamma0xh = gamma0x.high; + var gamma0xl = gamma0x.low; + var gamma0h = ((gamma0xh >>> 1) | (gamma0xl << 31)) ^ ((gamma0xh >>> 8) | (gamma0xl << 24)) ^ (gamma0xh >>> 7); + var gamma0l = ((gamma0xl >>> 1) | (gamma0xh << 31)) ^ ((gamma0xl >>> 8) | (gamma0xh << 24)) ^ ((gamma0xl >>> 7) | (gamma0xh << 25)); + + // Gamma1 + var gamma1x = W[i - 2]; + var gamma1xh = gamma1x.high; + var gamma1xl = gamma1x.low; + var gamma1h = ((gamma1xh >>> 19) | (gamma1xl << 13)) ^ ((gamma1xh << 3) | (gamma1xl >>> 29)) ^ (gamma1xh >>> 6); + var gamma1l = ((gamma1xl >>> 19) | (gamma1xh << 13)) ^ ((gamma1xl << 3) | (gamma1xh >>> 29)) ^ ((gamma1xl >>> 6) | (gamma1xh << 26)); + + // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16] + var Wi7 = W[i - 7]; + var Wi7h = Wi7.high; + var Wi7l = Wi7.low; + + var Wi16 = W[i - 16]; + var Wi16h = Wi16.high; + var Wi16l = Wi16.low; + + Wil = gamma0l + Wi7l; + Wih = gamma0h + Wi7h + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0); + Wil = Wil + gamma1l; + Wih = Wih + gamma1h + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0); + Wil = Wil + Wi16l; + Wih = Wih + Wi16h + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0); + + Wi.high = Wih; + Wi.low = Wil; + } + + var chh = (eh & fh) ^ (~eh & gh); + var chl = (el & fl) ^ (~el & gl); + var majh = (ah & bh) ^ (ah & ch) ^ (bh & ch); + var majl = (al & bl) ^ (al & cl) ^ (bl & cl); + + var sigma0h = ((ah >>> 28) | (al << 4)) ^ ((ah << 30) | (al >>> 2)) ^ ((ah << 25) | (al >>> 7)); + var sigma0l = ((al >>> 28) | (ah << 4)) ^ ((al << 30) | (ah >>> 2)) ^ ((al << 25) | (ah >>> 7)); + var sigma1h = ((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9)); + var sigma1l = ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)); + + // t1 = h + sigma1 + ch + K[i] + W[i] + var Ki = K[i]; + var Kih = Ki.high; + var Kil = Ki.low; + + var t1l = hl + sigma1l; + var t1h = hh + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0); + var t1l = t1l + chl; + var t1h = t1h + chh + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0); + var t1l = t1l + Kil; + var t1h = t1h + Kih + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0); + var t1l = t1l + Wil; + var t1h = t1h + Wih + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0); + + // t2 = sigma0 + maj + var t2l = sigma0l + majl; + var t2h = sigma0h + majh + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0); + + // Update working variables + hh = gh; + hl = gl; + gh = fh; + gl = fl; + fh = eh; + fl = el; + el = (dl + t1l) | 0; + eh = (dh + t1h + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0; + dh = ch; + dl = cl; + ch = bh; + cl = bl; + bh = ah; + bl = al; + al = (t1l + t2l) | 0; + ah = (t1h + t2h + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0; + } + + // Intermediate hash value + H0l = H0.low = (H0l + al); + H0.high = (H0h + ah + ((H0l >>> 0) < (al >>> 0) ? 1 : 0)); + H1l = H1.low = (H1l + bl); + H1.high = (H1h + bh + ((H1l >>> 0) < (bl >>> 0) ? 1 : 0)); + H2l = H2.low = (H2l + cl); + H2.high = (H2h + ch + ((H2l >>> 0) < (cl >>> 0) ? 1 : 0)); + H3l = H3.low = (H3l + dl); + H3.high = (H3h + dh + ((H3l >>> 0) < (dl >>> 0) ? 1 : 0)); + H4l = H4.low = (H4l + el); + H4.high = (H4h + eh + ((H4l >>> 0) < (el >>> 0) ? 1 : 0)); + H5l = H5.low = (H5l + fl); + H5.high = (H5h + fh + ((H5l >>> 0) < (fl >>> 0) ? 1 : 0)); + H6l = H6.low = (H6l + gl); + H6.high = (H6h + gh + ((H6l >>> 0) < (gl >>> 0) ? 1 : 0)); + H7l = H7.low = (H7l + hl); + H7.high = (H7h + hh + ((H7l >>> 0) < (hl >>> 0) ? 1 : 0)); + }, + + _doFinalize: function () { + // Shortcuts + var data = this._data; + var dataWords = data.words; + + var nBitsTotal = this._nDataBytes * 8; + var nBitsLeft = data.sigBytes * 8; + + // Add padding + dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); + dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 30] = Math.floor(nBitsTotal / 0x100000000); + dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 31] = nBitsTotal; + data.sigBytes = dataWords.length * 4; + + // Hash final blocks + this._process(); + + // Convert hash to 32-bit word array before returning + var hash = this._hash.toX32(); + + // Return final computed hash + return hash; + }, + + clone: function () { + var clone = Hasher.clone.call(this); + clone._hash = this._hash.clone(); + + return clone; + }, + + blockSize: 1024/32 + }); + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.SHA512('message'); + * var hash = CryptoJS.SHA512(wordArray); + */ + C.SHA512 = Hasher._createHelper(SHA512); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacSHA512(message, key); + */ + C.HmacSHA512 = Hasher._createHmacHelper(SHA512); + }()); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_x64 = C.x64; + var X64Word = C_x64.Word; + var X64WordArray = C_x64.WordArray; + var C_algo = C.algo; + var SHA512 = C_algo.SHA512; + + /** + * SHA-384 hash algorithm. + */ + var SHA384 = C_algo.SHA384 = SHA512.extend({ + _doReset: function () { + this._hash = new X64WordArray.init([ + new X64Word.init(0xcbbb9d5d, 0xc1059ed8), new X64Word.init(0x629a292a, 0x367cd507), + new X64Word.init(0x9159015a, 0x3070dd17), new X64Word.init(0x152fecd8, 0xf70e5939), + new X64Word.init(0x67332667, 0xffc00b31), new X64Word.init(0x8eb44a87, 0x68581511), + new X64Word.init(0xdb0c2e0d, 0x64f98fa7), new X64Word.init(0x47b5481d, 0xbefa4fa4) + ]); + }, + + _doFinalize: function () { + var hash = SHA512._doFinalize.call(this); + + hash.sigBytes -= 16; + + return hash; + } + }); + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.SHA384('message'); + * var hash = CryptoJS.SHA384(wordArray); + */ + C.SHA384 = SHA512._createHelper(SHA384); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacSHA384(message, key); + */ + C.HmacSHA384 = SHA512._createHmacHelper(SHA384); + }()); + + + (function (Math) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var Hasher = C_lib.Hasher; + var C_x64 = C.x64; + var X64Word = C_x64.Word; + var C_algo = C.algo; + + // Constants tables + var RHO_OFFSETS = []; + var PI_INDEXES = []; + var ROUND_CONSTANTS = []; + + // Compute Constants + (function () { + // Compute rho offset constants + var x = 1, y = 0; + for (var t = 0; t < 24; t++) { + RHO_OFFSETS[x + 5 * y] = ((t + 1) * (t + 2) / 2) % 64; + + var newX = y % 5; + var newY = (2 * x + 3 * y) % 5; + x = newX; + y = newY; + } + + // Compute pi index constants + for (var x = 0; x < 5; x++) { + for (var y = 0; y < 5; y++) { + PI_INDEXES[x + 5 * y] = y + ((2 * x + 3 * y) % 5) * 5; + } + } + + // Compute round constants + var LFSR = 0x01; + for (var i = 0; i < 24; i++) { + var roundConstantMsw = 0; + var roundConstantLsw = 0; + + for (var j = 0; j < 7; j++) { + if (LFSR & 0x01) { + var bitPosition = (1 << j) - 1; + if (bitPosition < 32) { + roundConstantLsw ^= 1 << bitPosition; + } else /* if (bitPosition >= 32) */ { + roundConstantMsw ^= 1 << (bitPosition - 32); + } + } + + // Compute next LFSR + if (LFSR & 0x80) { + // Primitive polynomial over GF(2): x^8 + x^6 + x^5 + x^4 + 1 + LFSR = (LFSR << 1) ^ 0x71; + } else { + LFSR <<= 1; + } + } + + ROUND_CONSTANTS[i] = X64Word.create(roundConstantMsw, roundConstantLsw); + } + }()); + + // Reusable objects for temporary values + var T = []; + (function () { + for (var i = 0; i < 25; i++) { + T[i] = X64Word.create(); + } + }()); + + /** + * SHA-3 hash algorithm. + */ + var SHA3 = C_algo.SHA3 = Hasher.extend({ + /** + * Configuration options. + * + * @property {number} outputLength + * The desired number of bits in the output hash. + * Only values permitted are: 224, 256, 384, 512. + * Default: 512 + */ + cfg: Hasher.cfg.extend({ + outputLength: 512 + }), + + _doReset: function () { + var state = this._state = [] + for (var i = 0; i < 25; i++) { + state[i] = new X64Word.init(); + } + + this.blockSize = (1600 - 2 * this.cfg.outputLength) / 32; + }, + + _doProcessBlock: function (M, offset) { + // Shortcuts + var state = this._state; + var nBlockSizeLanes = this.blockSize / 2; + + // Absorb + for (var i = 0; i < nBlockSizeLanes; i++) { + // Shortcuts + var M2i = M[offset + 2 * i]; + var M2i1 = M[offset + 2 * i + 1]; + + // Swap endian + M2i = ( + (((M2i << 8) | (M2i >>> 24)) & 0x00ff00ff) | + (((M2i << 24) | (M2i >>> 8)) & 0xff00ff00) + ); + M2i1 = ( + (((M2i1 << 8) | (M2i1 >>> 24)) & 0x00ff00ff) | + (((M2i1 << 24) | (M2i1 >>> 8)) & 0xff00ff00) + ); + + // Absorb message into state + var lane = state[i]; + lane.high ^= M2i1; + lane.low ^= M2i; + } + + // Rounds + for (var round = 0; round < 24; round++) { + // Theta + for (var x = 0; x < 5; x++) { + // Mix column lanes + var tMsw = 0, tLsw = 0; + for (var y = 0; y < 5; y++) { + var lane = state[x + 5 * y]; + tMsw ^= lane.high; + tLsw ^= lane.low; + } + + // Temporary values + var Tx = T[x]; + Tx.high = tMsw; + Tx.low = tLsw; + } + for (var x = 0; x < 5; x++) { + // Shortcuts + var Tx4 = T[(x + 4) % 5]; + var Tx1 = T[(x + 1) % 5]; + var Tx1Msw = Tx1.high; + var Tx1Lsw = Tx1.low; + + // Mix surrounding columns + var tMsw = Tx4.high ^ ((Tx1Msw << 1) | (Tx1Lsw >>> 31)); + var tLsw = Tx4.low ^ ((Tx1Lsw << 1) | (Tx1Msw >>> 31)); + for (var y = 0; y < 5; y++) { + var lane = state[x + 5 * y]; + lane.high ^= tMsw; + lane.low ^= tLsw; + } + } + + // Rho Pi + for (var laneIndex = 1; laneIndex < 25; laneIndex++) { + var tMsw; + var tLsw; + + // Shortcuts + var lane = state[laneIndex]; + var laneMsw = lane.high; + var laneLsw = lane.low; + var rhoOffset = RHO_OFFSETS[laneIndex]; + + // Rotate lanes + if (rhoOffset < 32) { + tMsw = (laneMsw << rhoOffset) | (laneLsw >>> (32 - rhoOffset)); + tLsw = (laneLsw << rhoOffset) | (laneMsw >>> (32 - rhoOffset)); + } else /* if (rhoOffset >= 32) */ { + tMsw = (laneLsw << (rhoOffset - 32)) | (laneMsw >>> (64 - rhoOffset)); + tLsw = (laneMsw << (rhoOffset - 32)) | (laneLsw >>> (64 - rhoOffset)); + } + + // Transpose lanes + var TPiLane = T[PI_INDEXES[laneIndex]]; + TPiLane.high = tMsw; + TPiLane.low = tLsw; + } + + // Rho pi at x = y = 0 + var T0 = T[0]; + var state0 = state[0]; + T0.high = state0.high; + T0.low = state0.low; + + // Chi + for (var x = 0; x < 5; x++) { + for (var y = 0; y < 5; y++) { + // Shortcuts + var laneIndex = x + 5 * y; + var lane = state[laneIndex]; + var TLane = T[laneIndex]; + var Tx1Lane = T[((x + 1) % 5) + 5 * y]; + var Tx2Lane = T[((x + 2) % 5) + 5 * y]; + + // Mix rows + lane.high = TLane.high ^ (~Tx1Lane.high & Tx2Lane.high); + lane.low = TLane.low ^ (~Tx1Lane.low & Tx2Lane.low); + } + } + + // Iota + var lane = state[0]; + var roundConstant = ROUND_CONSTANTS[round]; + lane.high ^= roundConstant.high; + lane.low ^= roundConstant.low; + } + }, + + _doFinalize: function () { + // Shortcuts + var data = this._data; + var dataWords = data.words; + var nBitsTotal = this._nDataBytes * 8; + var nBitsLeft = data.sigBytes * 8; + var blockSizeBits = this.blockSize * 32; + + // Add padding + dataWords[nBitsLeft >>> 5] |= 0x1 << (24 - nBitsLeft % 32); + dataWords[((Math.ceil((nBitsLeft + 1) / blockSizeBits) * blockSizeBits) >>> 5) - 1] |= 0x80; + data.sigBytes = dataWords.length * 4; + + // Hash final blocks + this._process(); + + // Shortcuts + var state = this._state; + var outputLengthBytes = this.cfg.outputLength / 8; + var outputLengthLanes = outputLengthBytes / 8; + + // Squeeze + var hashWords = []; + for (var i = 0; i < outputLengthLanes; i++) { + // Shortcuts + var lane = state[i]; + var laneMsw = lane.high; + var laneLsw = lane.low; + + // Swap endian + laneMsw = ( + (((laneMsw << 8) | (laneMsw >>> 24)) & 0x00ff00ff) | + (((laneMsw << 24) | (laneMsw >>> 8)) & 0xff00ff00) + ); + laneLsw = ( + (((laneLsw << 8) | (laneLsw >>> 24)) & 0x00ff00ff) | + (((laneLsw << 24) | (laneLsw >>> 8)) & 0xff00ff00) + ); + + // Squeeze state to retrieve hash + hashWords.push(laneLsw); + hashWords.push(laneMsw); + } + + // Return final computed hash + return new WordArray.init(hashWords, outputLengthBytes); + }, + + clone: function () { + var clone = Hasher.clone.call(this); + + var state = clone._state = this._state.slice(0); + for (var i = 0; i < 25; i++) { + state[i] = state[i].clone(); + } + + return clone; + } + }); + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.SHA3('message'); + * var hash = CryptoJS.SHA3(wordArray); + */ + C.SHA3 = Hasher._createHelper(SHA3); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacSHA3(message, key); + */ + C.HmacSHA3 = Hasher._createHmacHelper(SHA3); + }(Math)); + + + /** @preserve + (c) 2012 by Cédric Mesnil. All rights reserved. + + Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + + - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + (function (Math) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var Hasher = C_lib.Hasher; + var C_algo = C.algo; + + // Constants table + var _zl = WordArray.create([ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, + 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, + 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, + 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13]); + var _zr = WordArray.create([ + 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, + 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, + 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, + 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, + 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11]); + var _sl = WordArray.create([ + 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, + 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, + 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, + 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, + 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 ]); + var _sr = WordArray.create([ + 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, + 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, + 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, + 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, + 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 ]); + + var _hl = WordArray.create([ 0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E]); + var _hr = WordArray.create([ 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000]); + + /** + * RIPEMD160 hash algorithm. + */ + var RIPEMD160 = C_algo.RIPEMD160 = Hasher.extend({ + _doReset: function () { + this._hash = WordArray.create([0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]); + }, + + _doProcessBlock: function (M, offset) { + + // Swap endian + for (var i = 0; i < 16; i++) { + // Shortcuts + var offset_i = offset + i; + var M_offset_i = M[offset_i]; + + // Swap + M[offset_i] = ( + (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) | + (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00) + ); + } + // Shortcut + var H = this._hash.words; + var hl = _hl.words; + var hr = _hr.words; + var zl = _zl.words; + var zr = _zr.words; + var sl = _sl.words; + var sr = _sr.words; + + // Working variables + var al, bl, cl, dl, el; + var ar, br, cr, dr, er; + + ar = al = H[0]; + br = bl = H[1]; + cr = cl = H[2]; + dr = dl = H[3]; + er = el = H[4]; + // Computation + var t; + for (var i = 0; i < 80; i += 1) { + t = (al + M[offset+zl[i]])|0; + if (i<16){ + t += f1(bl,cl,dl) + hl[0]; + } else if (i<32) { + t += f2(bl,cl,dl) + hl[1]; + } else if (i<48) { + t += f3(bl,cl,dl) + hl[2]; + } else if (i<64) { + t += f4(bl,cl,dl) + hl[3]; + } else {// if (i<80) { + t += f5(bl,cl,dl) + hl[4]; + } + t = t|0; + t = rotl(t,sl[i]); + t = (t+el)|0; + al = el; + el = dl; + dl = rotl(cl, 10); + cl = bl; + bl = t; + + t = (ar + M[offset+zr[i]])|0; + if (i<16){ + t += f5(br,cr,dr) + hr[0]; + } else if (i<32) { + t += f4(br,cr,dr) + hr[1]; + } else if (i<48) { + t += f3(br,cr,dr) + hr[2]; + } else if (i<64) { + t += f2(br,cr,dr) + hr[3]; + } else {// if (i<80) { + t += f1(br,cr,dr) + hr[4]; + } + t = t|0; + t = rotl(t,sr[i]) ; + t = (t+er)|0; + ar = er; + er = dr; + dr = rotl(cr, 10); + cr = br; + br = t; + } + // Intermediate hash value + t = (H[1] + cl + dr)|0; + H[1] = (H[2] + dl + er)|0; + H[2] = (H[3] + el + ar)|0; + H[3] = (H[4] + al + br)|0; + H[4] = (H[0] + bl + cr)|0; + H[0] = t; + }, + + _doFinalize: function () { + // Shortcuts + var data = this._data; + var dataWords = data.words; + + var nBitsTotal = this._nDataBytes * 8; + var nBitsLeft = data.sigBytes * 8; + + // Add padding + dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = ( + (((nBitsTotal << 8) | (nBitsTotal >>> 24)) & 0x00ff00ff) | + (((nBitsTotal << 24) | (nBitsTotal >>> 8)) & 0xff00ff00) + ); + data.sigBytes = (dataWords.length + 1) * 4; + + // Hash final blocks + this._process(); + + // Shortcuts + var hash = this._hash; + var H = hash.words; + + // Swap endian + for (var i = 0; i < 5; i++) { + // Shortcut + var H_i = H[i]; + + // Swap + H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) | + (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00); + } + + // Return final computed hash + return hash; + }, + + clone: function () { + var clone = Hasher.clone.call(this); + clone._hash = this._hash.clone(); + + return clone; + } + }); + + + function f1(x, y, z) { + return ((x) ^ (y) ^ (z)); + + } + + function f2(x, y, z) { + return (((x)&(y)) | ((~x)&(z))); + } + + function f3(x, y, z) { + return (((x) | (~(y))) ^ (z)); + } + + function f4(x, y, z) { + return (((x) & (z)) | ((y)&(~(z)))); + } + + function f5(x, y, z) { + return ((x) ^ ((y) |(~(z)))); + + } + + function rotl(x,n) { + return (x<>>(32-n)); + } + + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.RIPEMD160('message'); + * var hash = CryptoJS.RIPEMD160(wordArray); + */ + C.RIPEMD160 = Hasher._createHelper(RIPEMD160); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacRIPEMD160(message, key); + */ + C.HmacRIPEMD160 = Hasher._createHmacHelper(RIPEMD160); + }(Math)); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var Base = C_lib.Base; + var C_enc = C.enc; + var Utf8 = C_enc.Utf8; + var C_algo = C.algo; + + /** + * HMAC algorithm. + */ + var HMAC = C_algo.HMAC = Base.extend({ + /** + * Initializes a newly created HMAC. + * + * @param {Hasher} hasher The hash algorithm to use. + * @param {WordArray|string} key The secret key. + * + * @example + * + * var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key); + */ + init: function (hasher, key) { + // Init hasher + hasher = this._hasher = new hasher.init(); + + // Convert string to WordArray, else assume WordArray already + if (typeof key == 'string') { + key = Utf8.parse(key); + } + + // Shortcuts + var hasherBlockSize = hasher.blockSize; + var hasherBlockSizeBytes = hasherBlockSize * 4; + + // Allow arbitrary length keys + if (key.sigBytes > hasherBlockSizeBytes) { + key = hasher.finalize(key); + } + + // Clamp excess bits + key.clamp(); + + // Clone key for inner and outer pads + var oKey = this._oKey = key.clone(); + var iKey = this._iKey = key.clone(); + + // Shortcuts + var oKeyWords = oKey.words; + var iKeyWords = iKey.words; + + // XOR keys with pad constants + for (var i = 0; i < hasherBlockSize; i++) { + oKeyWords[i] ^= 0x5c5c5c5c; + iKeyWords[i] ^= 0x36363636; + } + oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes; + + // Set initial values + this.reset(); + }, + + /** + * Resets this HMAC to its initial state. + * + * @example + * + * hmacHasher.reset(); + */ + reset: function () { + // Shortcut + var hasher = this._hasher; + + // Reset + hasher.reset(); + hasher.update(this._iKey); + }, + + /** + * Updates this HMAC with a message. + * + * @param {WordArray|string} messageUpdate The message to append. + * + * @return {HMAC} This HMAC instance. + * + * @example + * + * hmacHasher.update('message'); + * hmacHasher.update(wordArray); + */ + update: function (messageUpdate) { + this._hasher.update(messageUpdate); + + // Chainable + return this; + }, + + /** + * Finalizes the HMAC computation. + * Note that the finalize operation is effectively a destructive, read-once operation. + * + * @param {WordArray|string} messageUpdate (Optional) A final message update. + * + * @return {WordArray} The HMAC. + * + * @example + * + * var hmac = hmacHasher.finalize(); + * var hmac = hmacHasher.finalize('message'); + * var hmac = hmacHasher.finalize(wordArray); + */ + finalize: function (messageUpdate) { + // Shortcut + var hasher = this._hasher; + + // Compute HMAC + var innerHash = hasher.finalize(messageUpdate); + hasher.reset(); + var hmac = hasher.finalize(this._oKey.clone().concat(innerHash)); + + return hmac; + } + }); + }()); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var Base = C_lib.Base; + var WordArray = C_lib.WordArray; + var C_algo = C.algo; + var SHA256 = C_algo.SHA256; + var HMAC = C_algo.HMAC; + + /** + * Password-Based Key Derivation Function 2 algorithm. + */ + var PBKDF2 = C_algo.PBKDF2 = Base.extend({ + /** + * Configuration options. + * + * @property {number} keySize The key size in words to generate. Default: 4 (128 bits) + * @property {Hasher} hasher The hasher to use. Default: SHA256 + * @property {number} iterations The number of iterations to perform. Default: 250000 + */ + cfg: Base.extend({ + keySize: 128/32, + hasher: SHA256, + iterations: 250000 + }), + + /** + * Initializes a newly created key derivation function. + * + * @param {Object} cfg (Optional) The configuration options to use for the derivation. + * + * @example + * + * var kdf = CryptoJS.algo.PBKDF2.create(); + * var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8 }); + * var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8, iterations: 1000 }); + */ + init: function (cfg) { + this.cfg = this.cfg.extend(cfg); + }, + + /** + * Computes the Password-Based Key Derivation Function 2. + * + * @param {WordArray|string} password The password. + * @param {WordArray|string} salt A salt. + * + * @return {WordArray} The derived key. + * + * @example + * + * var key = kdf.compute(password, salt); + */ + compute: function (password, salt) { + // Shortcut + var cfg = this.cfg; + + // Init HMAC + var hmac = HMAC.create(cfg.hasher, password); + + // Initial values + var derivedKey = WordArray.create(); + var blockIndex = WordArray.create([0x00000001]); + + // Shortcuts + var derivedKeyWords = derivedKey.words; + var blockIndexWords = blockIndex.words; + var keySize = cfg.keySize; + var iterations = cfg.iterations; + + // Generate key + while (derivedKeyWords.length < keySize) { + var block = hmac.update(salt).finalize(blockIndex); + hmac.reset(); + + // Shortcuts + var blockWords = block.words; + var blockWordsLength = blockWords.length; + + // Iterations + var intermediate = block; + for (var i = 1; i < iterations; i++) { + intermediate = hmac.finalize(intermediate); + hmac.reset(); + + // Shortcut + var intermediateWords = intermediate.words; + + // XOR intermediate with block + for (var j = 0; j < blockWordsLength; j++) { + blockWords[j] ^= intermediateWords[j]; + } + } + + derivedKey.concat(block); + blockIndexWords[0]++; + } + derivedKey.sigBytes = keySize * 4; + + return derivedKey; + } + }); + + /** + * Computes the Password-Based Key Derivation Function 2. + * + * @param {WordArray|string} password The password. + * @param {WordArray|string} salt A salt. + * @param {Object} cfg (Optional) The configuration options to use for this computation. + * + * @return {WordArray} The derived key. + * + * @static + * + * @example + * + * var key = CryptoJS.PBKDF2(password, salt); + * var key = CryptoJS.PBKDF2(password, salt, { keySize: 8 }); + * var key = CryptoJS.PBKDF2(password, salt, { keySize: 8, iterations: 1000 }); + */ + C.PBKDF2 = function (password, salt, cfg) { + return PBKDF2.create(cfg).compute(password, salt); + }; + }()); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var Base = C_lib.Base; + var WordArray = C_lib.WordArray; + var C_algo = C.algo; + var MD5 = C_algo.MD5; + + /** + * This key derivation function is meant to conform with EVP_BytesToKey. + * www.openssl.org/docs/crypto/EVP_BytesToKey.html + */ + var EvpKDF = C_algo.EvpKDF = Base.extend({ + /** + * Configuration options. + * + * @property {number} keySize The key size in words to generate. Default: 4 (128 bits) + * @property {Hasher} hasher The hash algorithm to use. Default: MD5 + * @property {number} iterations The number of iterations to perform. Default: 1 + */ + cfg: Base.extend({ + keySize: 128/32, + hasher: MD5, + iterations: 1 + }), + + /** + * Initializes a newly created key derivation function. + * + * @param {Object} cfg (Optional) The configuration options to use for the derivation. + * + * @example + * + * var kdf = CryptoJS.algo.EvpKDF.create(); + * var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 }); + * var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 }); + */ + init: function (cfg) { + this.cfg = this.cfg.extend(cfg); + }, + + /** + * Derives a key from a password. + * + * @param {WordArray|string} password The password. + * @param {WordArray|string} salt A salt. + * + * @return {WordArray} The derived key. + * + * @example + * + * var key = kdf.compute(password, salt); + */ + compute: function (password, salt) { + var block; + + // Shortcut + var cfg = this.cfg; + + // Init hasher + var hasher = cfg.hasher.create(); + + // Initial values + var derivedKey = WordArray.create(); + + // Shortcuts + var derivedKeyWords = derivedKey.words; + var keySize = cfg.keySize; + var iterations = cfg.iterations; + + // Generate key + while (derivedKeyWords.length < keySize) { + if (block) { + hasher.update(block); + } + block = hasher.update(password).finalize(salt); + hasher.reset(); + + // Iterations + for (var i = 1; i < iterations; i++) { + block = hasher.finalize(block); + hasher.reset(); + } + + derivedKey.concat(block); + } + derivedKey.sigBytes = keySize * 4; + + return derivedKey; + } + }); + + /** + * Derives a key from a password. + * + * @param {WordArray|string} password The password. + * @param {WordArray|string} salt A salt. + * @param {Object} cfg (Optional) The configuration options to use for this computation. + * + * @return {WordArray} The derived key. + * + * @static + * + * @example + * + * var key = CryptoJS.EvpKDF(password, salt); + * var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 }); + * var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 }); + */ + C.EvpKDF = function (password, salt, cfg) { + return EvpKDF.create(cfg).compute(password, salt); + }; + }()); + + + /** + * Cipher core components. + */ + CryptoJS.lib.Cipher || (function (undefined) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var Base = C_lib.Base; + var WordArray = C_lib.WordArray; + var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm; + var C_enc = C.enc; + var Utf8 = C_enc.Utf8; + var Base64 = C_enc.Base64; + var C_algo = C.algo; + var EvpKDF = C_algo.EvpKDF; + + /** + * Abstract base cipher template. + * + * @property {number} keySize This cipher's key size. Default: 4 (128 bits) + * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits) + * @property {number} _ENC_XFORM_MODE A constant representing encryption mode. + * @property {number} _DEC_XFORM_MODE A constant representing decryption mode. + */ + var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({ + /** + * Configuration options. + * + * @property {WordArray} iv The IV to use for this operation. + */ + cfg: Base.extend(), + + /** + * Creates this cipher in encryption mode. + * + * @param {WordArray} key The key. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {Cipher} A cipher instance. + * + * @static + * + * @example + * + * var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray }); + */ + createEncryptor: function (key, cfg) { + return this.create(this._ENC_XFORM_MODE, key, cfg); + }, + + /** + * Creates this cipher in decryption mode. + * + * @param {WordArray} key The key. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {Cipher} A cipher instance. + * + * @static + * + * @example + * + * var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray }); + */ + createDecryptor: function (key, cfg) { + return this.create(this._DEC_XFORM_MODE, key, cfg); + }, + + /** + * Initializes a newly created cipher. + * + * @param {number} xformMode Either the encryption or decryption transormation mode constant. + * @param {WordArray} key The key. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @example + * + * var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray }); + */ + init: function (xformMode, key, cfg) { + // Apply config defaults + this.cfg = this.cfg.extend(cfg); + + // Store transform mode and key + this._xformMode = xformMode; + this._key = key; + + // Set initial values + this.reset(); + }, + + /** + * Resets this cipher to its initial state. + * + * @example + * + * cipher.reset(); + */ + reset: function () { + // Reset data buffer + BufferedBlockAlgorithm.reset.call(this); + + // Perform concrete-cipher logic + this._doReset(); + }, + + /** + * Adds data to be encrypted or decrypted. + * + * @param {WordArray|string} dataUpdate The data to encrypt or decrypt. + * + * @return {WordArray} The data after processing. + * + * @example + * + * var encrypted = cipher.process('data'); + * var encrypted = cipher.process(wordArray); + */ + process: function (dataUpdate) { + // Append + this._append(dataUpdate); + + // Process available blocks + return this._process(); + }, + + /** + * Finalizes the encryption or decryption process. + * Note that the finalize operation is effectively a destructive, read-once operation. + * + * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt. + * + * @return {WordArray} The data after final processing. + * + * @example + * + * var encrypted = cipher.finalize(); + * var encrypted = cipher.finalize('data'); + * var encrypted = cipher.finalize(wordArray); + */ + finalize: function (dataUpdate) { + // Final data update + if (dataUpdate) { + this._append(dataUpdate); + } + + // Perform concrete-cipher logic + var finalProcessedData = this._doFinalize(); + + return finalProcessedData; + }, + + keySize: 128/32, + + ivSize: 128/32, + + _ENC_XFORM_MODE: 1, + + _DEC_XFORM_MODE: 2, + + /** + * Creates shortcut functions to a cipher's object interface. + * + * @param {Cipher} cipher The cipher to create a helper for. + * + * @return {Object} An object with encrypt and decrypt shortcut functions. + * + * @static + * + * @example + * + * var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES); + */ + _createHelper: (function () { + function selectCipherStrategy(key) { + if (typeof key == 'string') { + return PasswordBasedCipher; + } else { + return SerializableCipher; + } + } + + return function (cipher) { + return { + encrypt: function (message, key, cfg) { + return selectCipherStrategy(key).encrypt(cipher, message, key, cfg); + }, + + decrypt: function (ciphertext, key, cfg) { + return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg); + } + }; + }; + }()) + }); + + /** + * Abstract base stream cipher template. + * + * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits) + */ + var StreamCipher = C_lib.StreamCipher = Cipher.extend({ + _doFinalize: function () { + // Process partial blocks + var finalProcessedBlocks = this._process(!!'flush'); + + return finalProcessedBlocks; + }, + + blockSize: 1 + }); + + /** + * Mode namespace. + */ + var C_mode = C.mode = {}; + + /** + * Abstract base block cipher mode template. + */ + var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({ + /** + * Creates this mode for encryption. + * + * @param {Cipher} cipher A block cipher instance. + * @param {Array} iv The IV words. + * + * @static + * + * @example + * + * var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words); + */ + createEncryptor: function (cipher, iv) { + return this.Encryptor.create(cipher, iv); + }, + + /** + * Creates this mode for decryption. + * + * @param {Cipher} cipher A block cipher instance. + * @param {Array} iv The IV words. + * + * @static + * + * @example + * + * var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words); + */ + createDecryptor: function (cipher, iv) { + return this.Decryptor.create(cipher, iv); + }, + + /** + * Initializes a newly created mode. + * + * @param {Cipher} cipher A block cipher instance. + * @param {Array} iv The IV words. + * + * @example + * + * var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words); + */ + init: function (cipher, iv) { + this._cipher = cipher; + this._iv = iv; + } + }); + + /** + * Cipher Block Chaining mode. + */ + var CBC = C_mode.CBC = (function () { + /** + * Abstract base CBC mode. + */ + var CBC = BlockCipherMode.extend(); + + /** + * CBC encryptor. + */ + CBC.Encryptor = CBC.extend({ + /** + * Processes the data block at offset. + * + * @param {Array} words The data words to operate on. + * @param {number} offset The offset where the block starts. + * + * @example + * + * mode.processBlock(data.words, offset); + */ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher; + var blockSize = cipher.blockSize; + + // XOR and encrypt + xorBlock.call(this, words, offset, blockSize); + cipher.encryptBlock(words, offset); + + // Remember this block to use with next block + this._prevBlock = words.slice(offset, offset + blockSize); + } + }); + + /** + * CBC decryptor. + */ + CBC.Decryptor = CBC.extend({ + /** + * Processes the data block at offset. + * + * @param {Array} words The data words to operate on. + * @param {number} offset The offset where the block starts. + * + * @example + * + * mode.processBlock(data.words, offset); + */ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher; + var blockSize = cipher.blockSize; + + // Remember this block to use with next block + var thisBlock = words.slice(offset, offset + blockSize); + + // Decrypt and XOR + cipher.decryptBlock(words, offset); + xorBlock.call(this, words, offset, blockSize); + + // This block becomes the previous block + this._prevBlock = thisBlock; + } + }); + + function xorBlock(words, offset, blockSize) { + var block; + + // Shortcut + var iv = this._iv; + + // Choose mixing block + if (iv) { + block = iv; + + // Remove IV for subsequent blocks + this._iv = undefined; + } else { + block = this._prevBlock; + } + + // XOR blocks + for (var i = 0; i < blockSize; i++) { + words[offset + i] ^= block[i]; + } + } + + return CBC; + }()); + + /** + * Padding namespace. + */ + var C_pad = C.pad = {}; + + /** + * PKCS #5/7 padding strategy. + */ + var Pkcs7 = C_pad.Pkcs7 = { + /** + * Pads data using the algorithm defined in PKCS #5/7. + * + * @param {WordArray} data The data to pad. + * @param {number} blockSize The multiple that the data should be padded to. + * + * @static + * + * @example + * + * CryptoJS.pad.Pkcs7.pad(wordArray, 4); + */ + pad: function (data, blockSize) { + // Shortcut + var blockSizeBytes = blockSize * 4; + + // Count padding bytes + var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes; + + // Create padding word + var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes; + + // Create padding + var paddingWords = []; + for (var i = 0; i < nPaddingBytes; i += 4) { + paddingWords.push(paddingWord); + } + var padding = WordArray.create(paddingWords, nPaddingBytes); + + // Add padding + data.concat(padding); + }, + + /** + * Unpads data that had been padded using the algorithm defined in PKCS #5/7. + * + * @param {WordArray} data The data to unpad. + * + * @static + * + * @example + * + * CryptoJS.pad.Pkcs7.unpad(wordArray); + */ + unpad: function (data) { + // Get number of padding bytes from last byte + var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff; + + // Remove padding + data.sigBytes -= nPaddingBytes; + } + }; + + /** + * Abstract base block cipher template. + * + * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits) + */ + var BlockCipher = C_lib.BlockCipher = Cipher.extend({ + /** + * Configuration options. + * + * @property {Mode} mode The block mode to use. Default: CBC + * @property {Padding} padding The padding strategy to use. Default: Pkcs7 + */ + cfg: Cipher.cfg.extend({ + mode: CBC, + padding: Pkcs7 + }), + + reset: function () { + var modeCreator; + + // Reset cipher + Cipher.reset.call(this); + + // Shortcuts + var cfg = this.cfg; + var iv = cfg.iv; + var mode = cfg.mode; + + // Reset block mode + if (this._xformMode == this._ENC_XFORM_MODE) { + modeCreator = mode.createEncryptor; + } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ { + modeCreator = mode.createDecryptor; + // Keep at least one block in the buffer for unpadding + this._minBufferSize = 1; + } + + if (this._mode && this._mode.__creator == modeCreator) { + this._mode.init(this, iv && iv.words); + } else { + this._mode = modeCreator.call(mode, this, iv && iv.words); + this._mode.__creator = modeCreator; + } + }, + + _doProcessBlock: function (words, offset) { + this._mode.processBlock(words, offset); + }, + + _doFinalize: function () { + var finalProcessedBlocks; + + // Shortcut + var padding = this.cfg.padding; + + // Finalize + if (this._xformMode == this._ENC_XFORM_MODE) { + // Pad data + padding.pad(this._data, this.blockSize); + + // Process final blocks + finalProcessedBlocks = this._process(!!'flush'); + } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ { + // Process final blocks + finalProcessedBlocks = this._process(!!'flush'); + + // Unpad data + padding.unpad(finalProcessedBlocks); + } + + return finalProcessedBlocks; + }, + + blockSize: 128/32 + }); + + /** + * A collection of cipher parameters. + * + * @property {WordArray} ciphertext The raw ciphertext. + * @property {WordArray} key The key to this ciphertext. + * @property {WordArray} iv The IV used in the ciphering operation. + * @property {WordArray} salt The salt used with a key derivation function. + * @property {Cipher} algorithm The cipher algorithm. + * @property {Mode} mode The block mode used in the ciphering operation. + * @property {Padding} padding The padding scheme used in the ciphering operation. + * @property {number} blockSize The block size of the cipher. + * @property {Format} formatter The default formatting strategy to convert this cipher params object to a string. + */ + var CipherParams = C_lib.CipherParams = Base.extend({ + /** + * Initializes a newly created cipher params object. + * + * @param {Object} cipherParams An object with any of the possible cipher parameters. + * + * @example + * + * var cipherParams = CryptoJS.lib.CipherParams.create({ + * ciphertext: ciphertextWordArray, + * key: keyWordArray, + * iv: ivWordArray, + * salt: saltWordArray, + * algorithm: CryptoJS.algo.AES, + * mode: CryptoJS.mode.CBC, + * padding: CryptoJS.pad.PKCS7, + * blockSize: 4, + * formatter: CryptoJS.format.OpenSSL + * }); + */ + init: function (cipherParams) { + this.mixIn(cipherParams); + }, + + /** + * Converts this cipher params object to a string. + * + * @param {Format} formatter (Optional) The formatting strategy to use. + * + * @return {string} The stringified cipher params. + * + * @throws Error If neither the formatter nor the default formatter is set. + * + * @example + * + * var string = cipherParams + ''; + * var string = cipherParams.toString(); + * var string = cipherParams.toString(CryptoJS.format.OpenSSL); + */ + toString: function (formatter) { + return (formatter || this.formatter).stringify(this); + } + }); + + /** + * Format namespace. + */ + var C_format = C.format = {}; + + /** + * OpenSSL formatting strategy. + */ + var OpenSSLFormatter = C_format.OpenSSL = { + /** + * Converts a cipher params object to an OpenSSL-compatible string. + * + * @param {CipherParams} cipherParams The cipher params object. + * + * @return {string} The OpenSSL-compatible string. + * + * @static + * + * @example + * + * var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams); + */ + stringify: function (cipherParams) { + var wordArray; + + // Shortcuts + var ciphertext = cipherParams.ciphertext; + var salt = cipherParams.salt; + + // Format + if (salt) { + wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext); + } else { + wordArray = ciphertext; + } + + return wordArray.toString(Base64); + }, + + /** + * Converts an OpenSSL-compatible string to a cipher params object. + * + * @param {string} openSSLStr The OpenSSL-compatible string. + * + * @return {CipherParams} The cipher params object. + * + * @static + * + * @example + * + * var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString); + */ + parse: function (openSSLStr) { + var salt; + + // Parse base64 + var ciphertext = Base64.parse(openSSLStr); + + // Shortcut + var ciphertextWords = ciphertext.words; + + // Test for salt + if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) { + // Extract salt + salt = WordArray.create(ciphertextWords.slice(2, 4)); + + // Remove salt from ciphertext + ciphertextWords.splice(0, 4); + ciphertext.sigBytes -= 16; + } + + return CipherParams.create({ ciphertext: ciphertext, salt: salt }); + } + }; + + /** + * A cipher wrapper that returns ciphertext as a serializable cipher params object. + */ + var SerializableCipher = C_lib.SerializableCipher = Base.extend({ + /** + * Configuration options. + * + * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL + */ + cfg: Base.extend({ + format: OpenSSLFormatter + }), + + /** + * Encrypts a message. + * + * @param {Cipher} cipher The cipher algorithm to use. + * @param {WordArray|string} message The message to encrypt. + * @param {WordArray} key The key. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {CipherParams} A cipher params object. + * + * @static + * + * @example + * + * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key); + * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv }); + * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL }); + */ + encrypt: function (cipher, message, key, cfg) { + // Apply config defaults + cfg = this.cfg.extend(cfg); + + // Encrypt + var encryptor = cipher.createEncryptor(key, cfg); + var ciphertext = encryptor.finalize(message); + + // Shortcut + var cipherCfg = encryptor.cfg; + + // Create and return serializable cipher params + return CipherParams.create({ + ciphertext: ciphertext, + key: key, + iv: cipherCfg.iv, + algorithm: cipher, + mode: cipherCfg.mode, + padding: cipherCfg.padding, + blockSize: cipher.blockSize, + formatter: cfg.format + }); + }, + + /** + * Decrypts serialized ciphertext. + * + * @param {Cipher} cipher The cipher algorithm to use. + * @param {CipherParams|string} ciphertext The ciphertext to decrypt. + * @param {WordArray} key The key. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {WordArray} The plaintext. + * + * @static + * + * @example + * + * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL }); + * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL }); + */ + decrypt: function (cipher, ciphertext, key, cfg) { + // Apply config defaults + cfg = this.cfg.extend(cfg); + + // Convert string to CipherParams + ciphertext = this._parse(ciphertext, cfg.format); + + // Decrypt + var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext); + + return plaintext; + }, + + /** + * Converts serialized ciphertext to CipherParams, + * else assumed CipherParams already and returns ciphertext unchanged. + * + * @param {CipherParams|string} ciphertext The ciphertext. + * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext. + * + * @return {CipherParams} The unserialized ciphertext. + * + * @static + * + * @example + * + * var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format); + */ + _parse: function (ciphertext, format) { + if (typeof ciphertext == 'string') { + return format.parse(ciphertext, this); + } else { + return ciphertext; + } + } + }); + + /** + * Key derivation function namespace. + */ + var C_kdf = C.kdf = {}; + + /** + * OpenSSL key derivation function. + */ + var OpenSSLKdf = C_kdf.OpenSSL = { + /** + * Derives a key and IV from a password. + * + * @param {string} password The password to derive from. + * @param {number} keySize The size in words of the key to generate. + * @param {number} ivSize The size in words of the IV to generate. + * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly. + * + * @return {CipherParams} A cipher params object with the key, IV, and salt. + * + * @static + * + * @example + * + * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32); + * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt'); + */ + execute: function (password, keySize, ivSize, salt, hasher) { + // Generate random salt + if (!salt) { + salt = WordArray.random(64/8); + } + + // Derive key and IV + if (!hasher) { + var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt); + } else { + var key = EvpKDF.create({ keySize: keySize + ivSize, hasher: hasher }).compute(password, salt); + } + + + // Separate key and IV + var iv = WordArray.create(key.words.slice(keySize), ivSize * 4); + key.sigBytes = keySize * 4; + + // Return params + return CipherParams.create({ key: key, iv: iv, salt: salt }); + } + }; + + /** + * A serializable cipher wrapper that derives the key from a password, + * and returns ciphertext as a serializable cipher params object. + */ + var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({ + /** + * Configuration options. + * + * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL + */ + cfg: SerializableCipher.cfg.extend({ + kdf: OpenSSLKdf + }), + + /** + * Encrypts a message using a password. + * + * @param {Cipher} cipher The cipher algorithm to use. + * @param {WordArray|string} message The message to encrypt. + * @param {string} password The password. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {CipherParams} A cipher params object. + * + * @static + * + * @example + * + * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password'); + * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL }); + */ + encrypt: function (cipher, message, password, cfg) { + // Apply config defaults + cfg = this.cfg.extend(cfg); + + // Derive key and other params + var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, cfg.salt, cfg.hasher); + + // Add IV to config + cfg.iv = derivedParams.iv; + + // Encrypt + var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg); + + // Mix in derived params + ciphertext.mixIn(derivedParams); + + return ciphertext; + }, + + /** + * Decrypts serialized ciphertext using a password. + * + * @param {Cipher} cipher The cipher algorithm to use. + * @param {CipherParams|string} ciphertext The ciphertext to decrypt. + * @param {string} password The password. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {WordArray} The plaintext. + * + * @static + * + * @example + * + * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL }); + * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL }); + */ + decrypt: function (cipher, ciphertext, password, cfg) { + // Apply config defaults + cfg = this.cfg.extend(cfg); + + // Convert string to CipherParams + ciphertext = this._parse(ciphertext, cfg.format); + + // Derive key and other params + var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt, cfg.hasher); + + // Add IV to config + cfg.iv = derivedParams.iv; + + // Decrypt + var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg); + + return plaintext; + } + }); + }()); + + + /** + * Cipher Feedback block mode. + */ + CryptoJS.mode.CFB = (function () { + var CFB = CryptoJS.lib.BlockCipherMode.extend(); + + CFB.Encryptor = CFB.extend({ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher; + var blockSize = cipher.blockSize; + + generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher); + + // Remember this block to use with next block + this._prevBlock = words.slice(offset, offset + blockSize); + } + }); + + CFB.Decryptor = CFB.extend({ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher; + var blockSize = cipher.blockSize; + + // Remember this block to use with next block + var thisBlock = words.slice(offset, offset + blockSize); + + generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher); + + // This block becomes the previous block + this._prevBlock = thisBlock; + } + }); + + function generateKeystreamAndEncrypt(words, offset, blockSize, cipher) { + var keystream; + + // Shortcut + var iv = this._iv; + + // Generate keystream + if (iv) { + keystream = iv.slice(0); + + // Remove IV for subsequent blocks + this._iv = undefined; + } else { + keystream = this._prevBlock; + } + cipher.encryptBlock(keystream, 0); + + // Encrypt + for (var i = 0; i < blockSize; i++) { + words[offset + i] ^= keystream[i]; + } + } + + return CFB; + }()); + + + /** + * Counter block mode. + */ + CryptoJS.mode.CTR = (function () { + var CTR = CryptoJS.lib.BlockCipherMode.extend(); + + var Encryptor = CTR.Encryptor = CTR.extend({ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher + var blockSize = cipher.blockSize; + var iv = this._iv; + var counter = this._counter; + + // Generate keystream + if (iv) { + counter = this._counter = iv.slice(0); + + // Remove IV for subsequent blocks + this._iv = undefined; + } + var keystream = counter.slice(0); + cipher.encryptBlock(keystream, 0); + + // Increment counter + counter[blockSize - 1] = (counter[blockSize - 1] + 1) | 0 + + // Encrypt + for (var i = 0; i < blockSize; i++) { + words[offset + i] ^= keystream[i]; + } + } + }); + + CTR.Decryptor = Encryptor; + + return CTR; + }()); + + + /** @preserve + * Counter block mode compatible with Dr Brian Gladman fileenc.c + * derived from CryptoJS.mode.CTR + * Jan Hruby jhruby.web@gmail.com + */ + CryptoJS.mode.CTRGladman = (function () { + var CTRGladman = CryptoJS.lib.BlockCipherMode.extend(); + + function incWord(word) + { + if (((word >> 24) & 0xff) === 0xff) { //overflow + var b1 = (word >> 16)&0xff; + var b2 = (word >> 8)&0xff; + var b3 = word & 0xff; + + if (b1 === 0xff) // overflow b1 + { + b1 = 0; + if (b2 === 0xff) + { + b2 = 0; + if (b3 === 0xff) + { + b3 = 0; + } + else + { + ++b3; + } + } + else + { + ++b2; + } + } + else + { + ++b1; + } + + word = 0; + word += (b1 << 16); + word += (b2 << 8); + word += b3; + } + else + { + word += (0x01 << 24); + } + return word; + } + + function incCounter(counter) + { + if ((counter[0] = incWord(counter[0])) === 0) + { + // encr_data in fileenc.c from Dr Brian Gladman's counts only with DWORD j < 8 + counter[1] = incWord(counter[1]); + } + return counter; + } + + var Encryptor = CTRGladman.Encryptor = CTRGladman.extend({ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher + var blockSize = cipher.blockSize; + var iv = this._iv; + var counter = this._counter; + + // Generate keystream + if (iv) { + counter = this._counter = iv.slice(0); + + // Remove IV for subsequent blocks + this._iv = undefined; + } + + incCounter(counter); + + var keystream = counter.slice(0); + cipher.encryptBlock(keystream, 0); + + // Encrypt + for (var i = 0; i < blockSize; i++) { + words[offset + i] ^= keystream[i]; + } + } + }); + + CTRGladman.Decryptor = Encryptor; + + return CTRGladman; + }()); + + + + + /** + * Output Feedback block mode. + */ + CryptoJS.mode.OFB = (function () { + var OFB = CryptoJS.lib.BlockCipherMode.extend(); + + var Encryptor = OFB.Encryptor = OFB.extend({ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher + var blockSize = cipher.blockSize; + var iv = this._iv; + var keystream = this._keystream; + + // Generate keystream + if (iv) { + keystream = this._keystream = iv.slice(0); + + // Remove IV for subsequent blocks + this._iv = undefined; + } + cipher.encryptBlock(keystream, 0); + + // Encrypt + for (var i = 0; i < blockSize; i++) { + words[offset + i] ^= keystream[i]; + } + } + }); + + OFB.Decryptor = Encryptor; + + return OFB; + }()); + + + /** + * Electronic Codebook block mode. + */ + CryptoJS.mode.ECB = (function () { + var ECB = CryptoJS.lib.BlockCipherMode.extend(); + + ECB.Encryptor = ECB.extend({ + processBlock: function (words, offset) { + this._cipher.encryptBlock(words, offset); + } + }); + + ECB.Decryptor = ECB.extend({ + processBlock: function (words, offset) { + this._cipher.decryptBlock(words, offset); + } + }); + + return ECB; + }()); + + + /** + * ANSI X.923 padding strategy. + */ + CryptoJS.pad.AnsiX923 = { + pad: function (data, blockSize) { + // Shortcuts + var dataSigBytes = data.sigBytes; + var blockSizeBytes = blockSize * 4; + + // Count padding bytes + var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes; + + // Compute last byte position + var lastBytePos = dataSigBytes + nPaddingBytes - 1; + + // Pad + data.clamp(); + data.words[lastBytePos >>> 2] |= nPaddingBytes << (24 - (lastBytePos % 4) * 8); + data.sigBytes += nPaddingBytes; + }, + + unpad: function (data) { + // Get number of padding bytes from last byte + var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff; + + // Remove padding + data.sigBytes -= nPaddingBytes; + } + }; + + + /** + * ISO 10126 padding strategy. + */ + CryptoJS.pad.Iso10126 = { + pad: function (data, blockSize) { + // Shortcut + var blockSizeBytes = blockSize * 4; + + // Count padding bytes + var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes; + + // Pad + data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes - 1)). + concat(CryptoJS.lib.WordArray.create([nPaddingBytes << 24], 1)); + }, + + unpad: function (data) { + // Get number of padding bytes from last byte + var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff; + + // Remove padding + data.sigBytes -= nPaddingBytes; + } + }; + + + /** + * ISO/IEC 9797-1 Padding Method 2. + */ + CryptoJS.pad.Iso97971 = { + pad: function (data, blockSize) { + // Add 0x80 byte + data.concat(CryptoJS.lib.WordArray.create([0x80000000], 1)); + + // Zero pad the rest + CryptoJS.pad.ZeroPadding.pad(data, blockSize); + }, + + unpad: function (data) { + // Remove zero padding + CryptoJS.pad.ZeroPadding.unpad(data); + + // Remove one more byte -- the 0x80 byte + data.sigBytes--; + } + }; + + + /** + * Zero padding strategy. + */ + CryptoJS.pad.ZeroPadding = { + pad: function (data, blockSize) { + // Shortcut + var blockSizeBytes = blockSize * 4; + + // Pad + data.clamp(); + data.sigBytes += blockSizeBytes - ((data.sigBytes % blockSizeBytes) || blockSizeBytes); + }, + + unpad: function (data) { + // Shortcut + var dataWords = data.words; + + // Unpad + var i = data.sigBytes - 1; + for (var i = data.sigBytes - 1; i >= 0; i--) { + if (((dataWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff)) { + data.sigBytes = i + 1; + break; + } + } + } + }; + + + /** + * A noop padding strategy. + */ + CryptoJS.pad.NoPadding = { + pad: function () { + }, + + unpad: function () { + } + }; + + + (function (undefined) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var CipherParams = C_lib.CipherParams; + var C_enc = C.enc; + var Hex = C_enc.Hex; + var C_format = C.format; + + var HexFormatter = C_format.Hex = { + /** + * Converts the ciphertext of a cipher params object to a hexadecimally encoded string. + * + * @param {CipherParams} cipherParams The cipher params object. + * + * @return {string} The hexadecimally encoded string. + * + * @static + * + * @example + * + * var hexString = CryptoJS.format.Hex.stringify(cipherParams); + */ + stringify: function (cipherParams) { + return cipherParams.ciphertext.toString(Hex); + }, + + /** + * Converts a hexadecimally encoded ciphertext string to a cipher params object. + * + * @param {string} input The hexadecimally encoded string. + * + * @return {CipherParams} The cipher params object. + * + * @static + * + * @example + * + * var cipherParams = CryptoJS.format.Hex.parse(hexString); + */ + parse: function (input) { + var ciphertext = Hex.parse(input); + return CipherParams.create({ ciphertext: ciphertext }); + } + }; + }()); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var BlockCipher = C_lib.BlockCipher; + var C_algo = C.algo; + + // Lookup tables + var SBOX = []; + var INV_SBOX = []; + var SUB_MIX_0 = []; + var SUB_MIX_1 = []; + var SUB_MIX_2 = []; + var SUB_MIX_3 = []; + var INV_SUB_MIX_0 = []; + var INV_SUB_MIX_1 = []; + var INV_SUB_MIX_2 = []; + var INV_SUB_MIX_3 = []; + + // Compute lookup tables + (function () { + // Compute double table + var d = []; + for (var i = 0; i < 256; i++) { + if (i < 128) { + d[i] = i << 1; + } else { + d[i] = (i << 1) ^ 0x11b; + } + } + + // Walk GF(2^8) + var x = 0; + var xi = 0; + for (var i = 0; i < 256; i++) { + // Compute sbox + var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4); + sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63; + SBOX[x] = sx; + INV_SBOX[sx] = x; + + // Compute multiplication + var x2 = d[x]; + var x4 = d[x2]; + var x8 = d[x4]; + + // Compute sub bytes, mix columns tables + var t = (d[sx] * 0x101) ^ (sx * 0x1010100); + SUB_MIX_0[x] = (t << 24) | (t >>> 8); + SUB_MIX_1[x] = (t << 16) | (t >>> 16); + SUB_MIX_2[x] = (t << 8) | (t >>> 24); + SUB_MIX_3[x] = t; + + // Compute inv sub bytes, inv mix columns tables + var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100); + INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8); + INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16); + INV_SUB_MIX_2[sx] = (t << 8) | (t >>> 24); + INV_SUB_MIX_3[sx] = t; + + // Compute next counter + if (!x) { + x = xi = 1; + } else { + x = x2 ^ d[d[d[x8 ^ x2]]]; + xi ^= d[d[xi]]; + } + } + }()); + + // Precomputed Rcon lookup + var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]; + + /** + * AES block cipher algorithm. + */ + var AES = C_algo.AES = BlockCipher.extend({ + _doReset: function () { + var t; + + // Skip reset of nRounds has been set before and key did not change + if (this._nRounds && this._keyPriorReset === this._key) { + return; + } + + // Shortcuts + var key = this._keyPriorReset = this._key; + var keyWords = key.words; + var keySize = key.sigBytes / 4; + + // Compute number of rounds + var nRounds = this._nRounds = keySize + 6; + + // Compute number of key schedule rows + var ksRows = (nRounds + 1) * 4; + + // Compute key schedule + var keySchedule = this._keySchedule = []; + for (var ksRow = 0; ksRow < ksRows; ksRow++) { + if (ksRow < keySize) { + keySchedule[ksRow] = keyWords[ksRow]; + } else { + t = keySchedule[ksRow - 1]; + + if (!(ksRow % keySize)) { + // Rot word + t = (t << 8) | (t >>> 24); + + // Sub word + t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff]; + + // Mix Rcon + t ^= RCON[(ksRow / keySize) | 0] << 24; + } else if (keySize > 6 && ksRow % keySize == 4) { + // Sub word + t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff]; + } + + keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t; + } + } + + // Compute inv key schedule + var invKeySchedule = this._invKeySchedule = []; + for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) { + var ksRow = ksRows - invKsRow; + + if (invKsRow % 4) { + var t = keySchedule[ksRow]; + } else { + var t = keySchedule[ksRow - 4]; + } + + if (invKsRow < 4 || ksRow <= 4) { + invKeySchedule[invKsRow] = t; + } else { + invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^ + INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]]; + } + } + }, + + encryptBlock: function (M, offset) { + this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX); + }, + + decryptBlock: function (M, offset) { + // Swap 2nd and 4th rows + var t = M[offset + 1]; + M[offset + 1] = M[offset + 3]; + M[offset + 3] = t; + + this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX); + + // Inv swap 2nd and 4th rows + var t = M[offset + 1]; + M[offset + 1] = M[offset + 3]; + M[offset + 3] = t; + }, + + _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) { + // Shortcut + var nRounds = this._nRounds; + + // Get input, add round key + var s0 = M[offset] ^ keySchedule[0]; + var s1 = M[offset + 1] ^ keySchedule[1]; + var s2 = M[offset + 2] ^ keySchedule[2]; + var s3 = M[offset + 3] ^ keySchedule[3]; + + // Key schedule row counter + var ksRow = 4; + + // Rounds + for (var round = 1; round < nRounds; round++) { + // Shift rows, sub bytes, mix columns, add round key + var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++]; + var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++]; + var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++]; + var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++]; + + // Update state + s0 = t0; + s1 = t1; + s2 = t2; + s3 = t3; + } + + // Shift rows, sub bytes, add round key + var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++]; + var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++]; + var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++]; + var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++]; + + // Set output + M[offset] = t0; + M[offset + 1] = t1; + M[offset + 2] = t2; + M[offset + 3] = t3; + }, + + keySize: 256/32 + }); + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.AES.encrypt(message, key, cfg); + * var plaintext = CryptoJS.AES.decrypt(ciphertext, key, cfg); + */ + C.AES = BlockCipher._createHelper(AES); + }()); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var BlockCipher = C_lib.BlockCipher; + var C_algo = C.algo; + + // Permuted Choice 1 constants + var PC1 = [ + 57, 49, 41, 33, 25, 17, 9, 1, + 58, 50, 42, 34, 26, 18, 10, 2, + 59, 51, 43, 35, 27, 19, 11, 3, + 60, 52, 44, 36, 63, 55, 47, 39, + 31, 23, 15, 7, 62, 54, 46, 38, + 30, 22, 14, 6, 61, 53, 45, 37, + 29, 21, 13, 5, 28, 20, 12, 4 + ]; + + // Permuted Choice 2 constants + var PC2 = [ + 14, 17, 11, 24, 1, 5, + 3, 28, 15, 6, 21, 10, + 23, 19, 12, 4, 26, 8, + 16, 7, 27, 20, 13, 2, + 41, 52, 31, 37, 47, 55, + 30, 40, 51, 45, 33, 48, + 44, 49, 39, 56, 34, 53, + 46, 42, 50, 36, 29, 32 + ]; + + // Cumulative bit shift constants + var BIT_SHIFTS = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28]; + + // SBOXes and round permutation constants + var SBOX_P = [ + { + 0x0: 0x808200, + 0x10000000: 0x8000, + 0x20000000: 0x808002, + 0x30000000: 0x2, + 0x40000000: 0x200, + 0x50000000: 0x808202, + 0x60000000: 0x800202, + 0x70000000: 0x800000, + 0x80000000: 0x202, + 0x90000000: 0x800200, + 0xa0000000: 0x8200, + 0xb0000000: 0x808000, + 0xc0000000: 0x8002, + 0xd0000000: 0x800002, + 0xe0000000: 0x0, + 0xf0000000: 0x8202, + 0x8000000: 0x0, + 0x18000000: 0x808202, + 0x28000000: 0x8202, + 0x38000000: 0x8000, + 0x48000000: 0x808200, + 0x58000000: 0x200, + 0x68000000: 0x808002, + 0x78000000: 0x2, + 0x88000000: 0x800200, + 0x98000000: 0x8200, + 0xa8000000: 0x808000, + 0xb8000000: 0x800202, + 0xc8000000: 0x800002, + 0xd8000000: 0x8002, + 0xe8000000: 0x202, + 0xf8000000: 0x800000, + 0x1: 0x8000, + 0x10000001: 0x2, + 0x20000001: 0x808200, + 0x30000001: 0x800000, + 0x40000001: 0x808002, + 0x50000001: 0x8200, + 0x60000001: 0x200, + 0x70000001: 0x800202, + 0x80000001: 0x808202, + 0x90000001: 0x808000, + 0xa0000001: 0x800002, + 0xb0000001: 0x8202, + 0xc0000001: 0x202, + 0xd0000001: 0x800200, + 0xe0000001: 0x8002, + 0xf0000001: 0x0, + 0x8000001: 0x808202, + 0x18000001: 0x808000, + 0x28000001: 0x800000, + 0x38000001: 0x200, + 0x48000001: 0x8000, + 0x58000001: 0x800002, + 0x68000001: 0x2, + 0x78000001: 0x8202, + 0x88000001: 0x8002, + 0x98000001: 0x800202, + 0xa8000001: 0x202, + 0xb8000001: 0x808200, + 0xc8000001: 0x800200, + 0xd8000001: 0x0, + 0xe8000001: 0x8200, + 0xf8000001: 0x808002 + }, + { + 0x0: 0x40084010, + 0x1000000: 0x4000, + 0x2000000: 0x80000, + 0x3000000: 0x40080010, + 0x4000000: 0x40000010, + 0x5000000: 0x40084000, + 0x6000000: 0x40004000, + 0x7000000: 0x10, + 0x8000000: 0x84000, + 0x9000000: 0x40004010, + 0xa000000: 0x40000000, + 0xb000000: 0x84010, + 0xc000000: 0x80010, + 0xd000000: 0x0, + 0xe000000: 0x4010, + 0xf000000: 0x40080000, + 0x800000: 0x40004000, + 0x1800000: 0x84010, + 0x2800000: 0x10, + 0x3800000: 0x40004010, + 0x4800000: 0x40084010, + 0x5800000: 0x40000000, + 0x6800000: 0x80000, + 0x7800000: 0x40080010, + 0x8800000: 0x80010, + 0x9800000: 0x0, + 0xa800000: 0x4000, + 0xb800000: 0x40080000, + 0xc800000: 0x40000010, + 0xd800000: 0x84000, + 0xe800000: 0x40084000, + 0xf800000: 0x4010, + 0x10000000: 0x0, + 0x11000000: 0x40080010, + 0x12000000: 0x40004010, + 0x13000000: 0x40084000, + 0x14000000: 0x40080000, + 0x15000000: 0x10, + 0x16000000: 0x84010, + 0x17000000: 0x4000, + 0x18000000: 0x4010, + 0x19000000: 0x80000, + 0x1a000000: 0x80010, + 0x1b000000: 0x40000010, + 0x1c000000: 0x84000, + 0x1d000000: 0x40004000, + 0x1e000000: 0x40000000, + 0x1f000000: 0x40084010, + 0x10800000: 0x84010, + 0x11800000: 0x80000, + 0x12800000: 0x40080000, + 0x13800000: 0x4000, + 0x14800000: 0x40004000, + 0x15800000: 0x40084010, + 0x16800000: 0x10, + 0x17800000: 0x40000000, + 0x18800000: 0x40084000, + 0x19800000: 0x40000010, + 0x1a800000: 0x40004010, + 0x1b800000: 0x80010, + 0x1c800000: 0x0, + 0x1d800000: 0x4010, + 0x1e800000: 0x40080010, + 0x1f800000: 0x84000 + }, + { + 0x0: 0x104, + 0x100000: 0x0, + 0x200000: 0x4000100, + 0x300000: 0x10104, + 0x400000: 0x10004, + 0x500000: 0x4000004, + 0x600000: 0x4010104, + 0x700000: 0x4010000, + 0x800000: 0x4000000, + 0x900000: 0x4010100, + 0xa00000: 0x10100, + 0xb00000: 0x4010004, + 0xc00000: 0x4000104, + 0xd00000: 0x10000, + 0xe00000: 0x4, + 0xf00000: 0x100, + 0x80000: 0x4010100, + 0x180000: 0x4010004, + 0x280000: 0x0, + 0x380000: 0x4000100, + 0x480000: 0x4000004, + 0x580000: 0x10000, + 0x680000: 0x10004, + 0x780000: 0x104, + 0x880000: 0x4, + 0x980000: 0x100, + 0xa80000: 0x4010000, + 0xb80000: 0x10104, + 0xc80000: 0x10100, + 0xd80000: 0x4000104, + 0xe80000: 0x4010104, + 0xf80000: 0x4000000, + 0x1000000: 0x4010100, + 0x1100000: 0x10004, + 0x1200000: 0x10000, + 0x1300000: 0x4000100, + 0x1400000: 0x100, + 0x1500000: 0x4010104, + 0x1600000: 0x4000004, + 0x1700000: 0x0, + 0x1800000: 0x4000104, + 0x1900000: 0x4000000, + 0x1a00000: 0x4, + 0x1b00000: 0x10100, + 0x1c00000: 0x4010000, + 0x1d00000: 0x104, + 0x1e00000: 0x10104, + 0x1f00000: 0x4010004, + 0x1080000: 0x4000000, + 0x1180000: 0x104, + 0x1280000: 0x4010100, + 0x1380000: 0x0, + 0x1480000: 0x10004, + 0x1580000: 0x4000100, + 0x1680000: 0x100, + 0x1780000: 0x4010004, + 0x1880000: 0x10000, + 0x1980000: 0x4010104, + 0x1a80000: 0x10104, + 0x1b80000: 0x4000004, + 0x1c80000: 0x4000104, + 0x1d80000: 0x4010000, + 0x1e80000: 0x4, + 0x1f80000: 0x10100 + }, + { + 0x0: 0x80401000, + 0x10000: 0x80001040, + 0x20000: 0x401040, + 0x30000: 0x80400000, + 0x40000: 0x0, + 0x50000: 0x401000, + 0x60000: 0x80000040, + 0x70000: 0x400040, + 0x80000: 0x80000000, + 0x90000: 0x400000, + 0xa0000: 0x40, + 0xb0000: 0x80001000, + 0xc0000: 0x80400040, + 0xd0000: 0x1040, + 0xe0000: 0x1000, + 0xf0000: 0x80401040, + 0x8000: 0x80001040, + 0x18000: 0x40, + 0x28000: 0x80400040, + 0x38000: 0x80001000, + 0x48000: 0x401000, + 0x58000: 0x80401040, + 0x68000: 0x0, + 0x78000: 0x80400000, + 0x88000: 0x1000, + 0x98000: 0x80401000, + 0xa8000: 0x400000, + 0xb8000: 0x1040, + 0xc8000: 0x80000000, + 0xd8000: 0x400040, + 0xe8000: 0x401040, + 0xf8000: 0x80000040, + 0x100000: 0x400040, + 0x110000: 0x401000, + 0x120000: 0x80000040, + 0x130000: 0x0, + 0x140000: 0x1040, + 0x150000: 0x80400040, + 0x160000: 0x80401000, + 0x170000: 0x80001040, + 0x180000: 0x80401040, + 0x190000: 0x80000000, + 0x1a0000: 0x80400000, + 0x1b0000: 0x401040, + 0x1c0000: 0x80001000, + 0x1d0000: 0x400000, + 0x1e0000: 0x40, + 0x1f0000: 0x1000, + 0x108000: 0x80400000, + 0x118000: 0x80401040, + 0x128000: 0x0, + 0x138000: 0x401000, + 0x148000: 0x400040, + 0x158000: 0x80000000, + 0x168000: 0x80001040, + 0x178000: 0x40, + 0x188000: 0x80000040, + 0x198000: 0x1000, + 0x1a8000: 0x80001000, + 0x1b8000: 0x80400040, + 0x1c8000: 0x1040, + 0x1d8000: 0x80401000, + 0x1e8000: 0x400000, + 0x1f8000: 0x401040 + }, + { + 0x0: 0x80, + 0x1000: 0x1040000, + 0x2000: 0x40000, + 0x3000: 0x20000000, + 0x4000: 0x20040080, + 0x5000: 0x1000080, + 0x6000: 0x21000080, + 0x7000: 0x40080, + 0x8000: 0x1000000, + 0x9000: 0x20040000, + 0xa000: 0x20000080, + 0xb000: 0x21040080, + 0xc000: 0x21040000, + 0xd000: 0x0, + 0xe000: 0x1040080, + 0xf000: 0x21000000, + 0x800: 0x1040080, + 0x1800: 0x21000080, + 0x2800: 0x80, + 0x3800: 0x1040000, + 0x4800: 0x40000, + 0x5800: 0x20040080, + 0x6800: 0x21040000, + 0x7800: 0x20000000, + 0x8800: 0x20040000, + 0x9800: 0x0, + 0xa800: 0x21040080, + 0xb800: 0x1000080, + 0xc800: 0x20000080, + 0xd800: 0x21000000, + 0xe800: 0x1000000, + 0xf800: 0x40080, + 0x10000: 0x40000, + 0x11000: 0x80, + 0x12000: 0x20000000, + 0x13000: 0x21000080, + 0x14000: 0x1000080, + 0x15000: 0x21040000, + 0x16000: 0x20040080, + 0x17000: 0x1000000, + 0x18000: 0x21040080, + 0x19000: 0x21000000, + 0x1a000: 0x1040000, + 0x1b000: 0x20040000, + 0x1c000: 0x40080, + 0x1d000: 0x20000080, + 0x1e000: 0x0, + 0x1f000: 0x1040080, + 0x10800: 0x21000080, + 0x11800: 0x1000000, + 0x12800: 0x1040000, + 0x13800: 0x20040080, + 0x14800: 0x20000000, + 0x15800: 0x1040080, + 0x16800: 0x80, + 0x17800: 0x21040000, + 0x18800: 0x40080, + 0x19800: 0x21040080, + 0x1a800: 0x0, + 0x1b800: 0x21000000, + 0x1c800: 0x1000080, + 0x1d800: 0x40000, + 0x1e800: 0x20040000, + 0x1f800: 0x20000080 + }, + { + 0x0: 0x10000008, + 0x100: 0x2000, + 0x200: 0x10200000, + 0x300: 0x10202008, + 0x400: 0x10002000, + 0x500: 0x200000, + 0x600: 0x200008, + 0x700: 0x10000000, + 0x800: 0x0, + 0x900: 0x10002008, + 0xa00: 0x202000, + 0xb00: 0x8, + 0xc00: 0x10200008, + 0xd00: 0x202008, + 0xe00: 0x2008, + 0xf00: 0x10202000, + 0x80: 0x10200000, + 0x180: 0x10202008, + 0x280: 0x8, + 0x380: 0x200000, + 0x480: 0x202008, + 0x580: 0x10000008, + 0x680: 0x10002000, + 0x780: 0x2008, + 0x880: 0x200008, + 0x980: 0x2000, + 0xa80: 0x10002008, + 0xb80: 0x10200008, + 0xc80: 0x0, + 0xd80: 0x10202000, + 0xe80: 0x202000, + 0xf80: 0x10000000, + 0x1000: 0x10002000, + 0x1100: 0x10200008, + 0x1200: 0x10202008, + 0x1300: 0x2008, + 0x1400: 0x200000, + 0x1500: 0x10000000, + 0x1600: 0x10000008, + 0x1700: 0x202000, + 0x1800: 0x202008, + 0x1900: 0x0, + 0x1a00: 0x8, + 0x1b00: 0x10200000, + 0x1c00: 0x2000, + 0x1d00: 0x10002008, + 0x1e00: 0x10202000, + 0x1f00: 0x200008, + 0x1080: 0x8, + 0x1180: 0x202000, + 0x1280: 0x200000, + 0x1380: 0x10000008, + 0x1480: 0x10002000, + 0x1580: 0x2008, + 0x1680: 0x10202008, + 0x1780: 0x10200000, + 0x1880: 0x10202000, + 0x1980: 0x10200008, + 0x1a80: 0x2000, + 0x1b80: 0x202008, + 0x1c80: 0x200008, + 0x1d80: 0x0, + 0x1e80: 0x10000000, + 0x1f80: 0x10002008 + }, + { + 0x0: 0x100000, + 0x10: 0x2000401, + 0x20: 0x400, + 0x30: 0x100401, + 0x40: 0x2100401, + 0x50: 0x0, + 0x60: 0x1, + 0x70: 0x2100001, + 0x80: 0x2000400, + 0x90: 0x100001, + 0xa0: 0x2000001, + 0xb0: 0x2100400, + 0xc0: 0x2100000, + 0xd0: 0x401, + 0xe0: 0x100400, + 0xf0: 0x2000000, + 0x8: 0x2100001, + 0x18: 0x0, + 0x28: 0x2000401, + 0x38: 0x2100400, + 0x48: 0x100000, + 0x58: 0x2000001, + 0x68: 0x2000000, + 0x78: 0x401, + 0x88: 0x100401, + 0x98: 0x2000400, + 0xa8: 0x2100000, + 0xb8: 0x100001, + 0xc8: 0x400, + 0xd8: 0x2100401, + 0xe8: 0x1, + 0xf8: 0x100400, + 0x100: 0x2000000, + 0x110: 0x100000, + 0x120: 0x2000401, + 0x130: 0x2100001, + 0x140: 0x100001, + 0x150: 0x2000400, + 0x160: 0x2100400, + 0x170: 0x100401, + 0x180: 0x401, + 0x190: 0x2100401, + 0x1a0: 0x100400, + 0x1b0: 0x1, + 0x1c0: 0x0, + 0x1d0: 0x2100000, + 0x1e0: 0x2000001, + 0x1f0: 0x400, + 0x108: 0x100400, + 0x118: 0x2000401, + 0x128: 0x2100001, + 0x138: 0x1, + 0x148: 0x2000000, + 0x158: 0x100000, + 0x168: 0x401, + 0x178: 0x2100400, + 0x188: 0x2000001, + 0x198: 0x2100000, + 0x1a8: 0x0, + 0x1b8: 0x2100401, + 0x1c8: 0x100401, + 0x1d8: 0x400, + 0x1e8: 0x2000400, + 0x1f8: 0x100001 + }, + { + 0x0: 0x8000820, + 0x1: 0x20000, + 0x2: 0x8000000, + 0x3: 0x20, + 0x4: 0x20020, + 0x5: 0x8020820, + 0x6: 0x8020800, + 0x7: 0x800, + 0x8: 0x8020000, + 0x9: 0x8000800, + 0xa: 0x20800, + 0xb: 0x8020020, + 0xc: 0x820, + 0xd: 0x0, + 0xe: 0x8000020, + 0xf: 0x20820, + 0x80000000: 0x800, + 0x80000001: 0x8020820, + 0x80000002: 0x8000820, + 0x80000003: 0x8000000, + 0x80000004: 0x8020000, + 0x80000005: 0x20800, + 0x80000006: 0x20820, + 0x80000007: 0x20, + 0x80000008: 0x8000020, + 0x80000009: 0x820, + 0x8000000a: 0x20020, + 0x8000000b: 0x8020800, + 0x8000000c: 0x0, + 0x8000000d: 0x8020020, + 0x8000000e: 0x8000800, + 0x8000000f: 0x20000, + 0x10: 0x20820, + 0x11: 0x8020800, + 0x12: 0x20, + 0x13: 0x800, + 0x14: 0x8000800, + 0x15: 0x8000020, + 0x16: 0x8020020, + 0x17: 0x20000, + 0x18: 0x0, + 0x19: 0x20020, + 0x1a: 0x8020000, + 0x1b: 0x8000820, + 0x1c: 0x8020820, + 0x1d: 0x20800, + 0x1e: 0x820, + 0x1f: 0x8000000, + 0x80000010: 0x20000, + 0x80000011: 0x800, + 0x80000012: 0x8020020, + 0x80000013: 0x20820, + 0x80000014: 0x20, + 0x80000015: 0x8020000, + 0x80000016: 0x8000000, + 0x80000017: 0x8000820, + 0x80000018: 0x8020820, + 0x80000019: 0x8000020, + 0x8000001a: 0x8000800, + 0x8000001b: 0x0, + 0x8000001c: 0x20800, + 0x8000001d: 0x820, + 0x8000001e: 0x20020, + 0x8000001f: 0x8020800 + } + ]; + + // Masks that select the SBOX input + var SBOX_MASK = [ + 0xf8000001, 0x1f800000, 0x01f80000, 0x001f8000, + 0x0001f800, 0x00001f80, 0x000001f8, 0x8000001f + ]; + + /** + * DES block cipher algorithm. + */ + var DES = C_algo.DES = BlockCipher.extend({ + _doReset: function () { + // Shortcuts + var key = this._key; + var keyWords = key.words; + + // Select 56 bits according to PC1 + var keyBits = []; + for (var i = 0; i < 56; i++) { + var keyBitPos = PC1[i] - 1; + keyBits[i] = (keyWords[keyBitPos >>> 5] >>> (31 - keyBitPos % 32)) & 1; + } + + // Assemble 16 subkeys + var subKeys = this._subKeys = []; + for (var nSubKey = 0; nSubKey < 16; nSubKey++) { + // Create subkey + var subKey = subKeys[nSubKey] = []; + + // Shortcut + var bitShift = BIT_SHIFTS[nSubKey]; + + // Select 48 bits according to PC2 + for (var i = 0; i < 24; i++) { + // Select from the left 28 key bits + subKey[(i / 6) | 0] |= keyBits[((PC2[i] - 1) + bitShift) % 28] << (31 - i % 6); + + // Select from the right 28 key bits + subKey[4 + ((i / 6) | 0)] |= keyBits[28 + (((PC2[i + 24] - 1) + bitShift) % 28)] << (31 - i % 6); + } + + // Since each subkey is applied to an expanded 32-bit input, + // the subkey can be broken into 8 values scaled to 32-bits, + // which allows the key to be used without expansion + subKey[0] = (subKey[0] << 1) | (subKey[0] >>> 31); + for (var i = 1; i < 7; i++) { + subKey[i] = subKey[i] >>> ((i - 1) * 4 + 3); + } + subKey[7] = (subKey[7] << 5) | (subKey[7] >>> 27); + } + + // Compute inverse subkeys + var invSubKeys = this._invSubKeys = []; + for (var i = 0; i < 16; i++) { + invSubKeys[i] = subKeys[15 - i]; + } + }, + + encryptBlock: function (M, offset) { + this._doCryptBlock(M, offset, this._subKeys); + }, + + decryptBlock: function (M, offset) { + this._doCryptBlock(M, offset, this._invSubKeys); + }, + + _doCryptBlock: function (M, offset, subKeys) { + // Get input + this._lBlock = M[offset]; + this._rBlock = M[offset + 1]; + + // Initial permutation + exchangeLR.call(this, 4, 0x0f0f0f0f); + exchangeLR.call(this, 16, 0x0000ffff); + exchangeRL.call(this, 2, 0x33333333); + exchangeRL.call(this, 8, 0x00ff00ff); + exchangeLR.call(this, 1, 0x55555555); + + // Rounds + for (var round = 0; round < 16; round++) { + // Shortcuts + var subKey = subKeys[round]; + var lBlock = this._lBlock; + var rBlock = this._rBlock; + + // Feistel function + var f = 0; + for (var i = 0; i < 8; i++) { + f |= SBOX_P[i][((rBlock ^ subKey[i]) & SBOX_MASK[i]) >>> 0]; + } + this._lBlock = rBlock; + this._rBlock = lBlock ^ f; + } + + // Undo swap from last round + var t = this._lBlock; + this._lBlock = this._rBlock; + this._rBlock = t; + + // Final permutation + exchangeLR.call(this, 1, 0x55555555); + exchangeRL.call(this, 8, 0x00ff00ff); + exchangeRL.call(this, 2, 0x33333333); + exchangeLR.call(this, 16, 0x0000ffff); + exchangeLR.call(this, 4, 0x0f0f0f0f); + + // Set output + M[offset] = this._lBlock; + M[offset + 1] = this._rBlock; + }, + + keySize: 64/32, + + ivSize: 64/32, + + blockSize: 64/32 + }); + + // Swap bits across the left and right words + function exchangeLR(offset, mask) { + var t = ((this._lBlock >>> offset) ^ this._rBlock) & mask; + this._rBlock ^= t; + this._lBlock ^= t << offset; + } + + function exchangeRL(offset, mask) { + var t = ((this._rBlock >>> offset) ^ this._lBlock) & mask; + this._lBlock ^= t; + this._rBlock ^= t << offset; + } + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.DES.encrypt(message, key, cfg); + * var plaintext = CryptoJS.DES.decrypt(ciphertext, key, cfg); + */ + C.DES = BlockCipher._createHelper(DES); + + /** + * Triple-DES block cipher algorithm. + */ + var TripleDES = C_algo.TripleDES = BlockCipher.extend({ + _doReset: function () { + // Shortcuts + var key = this._key; + var keyWords = key.words; + // Make sure the key length is valid (64, 128 or >= 192 bit) + if (keyWords.length !== 2 && keyWords.length !== 4 && keyWords.length < 6) { + throw new Error('Invalid key length - 3DES requires the key length to be 64, 128, 192 or >192.'); + } + + // Extend the key according to the keying options defined in 3DES standard + var key1 = keyWords.slice(0, 2); + var key2 = keyWords.length < 4 ? keyWords.slice(0, 2) : keyWords.slice(2, 4); + var key3 = keyWords.length < 6 ? keyWords.slice(0, 2) : keyWords.slice(4, 6); + + // Create DES instances + this._des1 = DES.createEncryptor(WordArray.create(key1)); + this._des2 = DES.createEncryptor(WordArray.create(key2)); + this._des3 = DES.createEncryptor(WordArray.create(key3)); + }, + + encryptBlock: function (M, offset) { + this._des1.encryptBlock(M, offset); + this._des2.decryptBlock(M, offset); + this._des3.encryptBlock(M, offset); + }, + + decryptBlock: function (M, offset) { + this._des3.decryptBlock(M, offset); + this._des2.encryptBlock(M, offset); + this._des1.decryptBlock(M, offset); + }, + + keySize: 192/32, + + ivSize: 64/32, + + blockSize: 64/32 + }); + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.TripleDES.encrypt(message, key, cfg); + * var plaintext = CryptoJS.TripleDES.decrypt(ciphertext, key, cfg); + */ + C.TripleDES = BlockCipher._createHelper(TripleDES); + }()); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var StreamCipher = C_lib.StreamCipher; + var C_algo = C.algo; + + /** + * RC4 stream cipher algorithm. + */ + var RC4 = C_algo.RC4 = StreamCipher.extend({ + _doReset: function () { + // Shortcuts + var key = this._key; + var keyWords = key.words; + var keySigBytes = key.sigBytes; + + // Init sbox + var S = this._S = []; + for (var i = 0; i < 256; i++) { + S[i] = i; + } + + // Key setup + for (var i = 0, j = 0; i < 256; i++) { + var keyByteIndex = i % keySigBytes; + var keyByte = (keyWords[keyByteIndex >>> 2] >>> (24 - (keyByteIndex % 4) * 8)) & 0xff; + + j = (j + S[i] + keyByte) % 256; + + // Swap + var t = S[i]; + S[i] = S[j]; + S[j] = t; + } + + // Counters + this._i = this._j = 0; + }, + + _doProcessBlock: function (M, offset) { + M[offset] ^= generateKeystreamWord.call(this); + }, + + keySize: 256/32, + + ivSize: 0 + }); + + function generateKeystreamWord() { + // Shortcuts + var S = this._S; + var i = this._i; + var j = this._j; + + // Generate keystream word + var keystreamWord = 0; + for (var n = 0; n < 4; n++) { + i = (i + 1) % 256; + j = (j + S[i]) % 256; + + // Swap + var t = S[i]; + S[i] = S[j]; + S[j] = t; + + keystreamWord |= S[(S[i] + S[j]) % 256] << (24 - n * 8); + } + + // Update counters + this._i = i; + this._j = j; + + return keystreamWord; + } + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.RC4.encrypt(message, key, cfg); + * var plaintext = CryptoJS.RC4.decrypt(ciphertext, key, cfg); + */ + C.RC4 = StreamCipher._createHelper(RC4); + + /** + * Modified RC4 stream cipher algorithm. + */ + var RC4Drop = C_algo.RC4Drop = RC4.extend({ + /** + * Configuration options. + * + * @property {number} drop The number of keystream words to drop. Default 192 + */ + cfg: RC4.cfg.extend({ + drop: 192 + }), + + _doReset: function () { + RC4._doReset.call(this); + + // Drop + for (var i = this.cfg.drop; i > 0; i--) { + generateKeystreamWord.call(this); + } + } + }); + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.RC4Drop.encrypt(message, key, cfg); + * var plaintext = CryptoJS.RC4Drop.decrypt(ciphertext, key, cfg); + */ + C.RC4Drop = StreamCipher._createHelper(RC4Drop); + }()); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var StreamCipher = C_lib.StreamCipher; + var C_algo = C.algo; + + // Reusable objects + var S = []; + var C_ = []; + var G = []; + + /** + * Rabbit stream cipher algorithm + */ + var Rabbit = C_algo.Rabbit = StreamCipher.extend({ + _doReset: function () { + // Shortcuts + var K = this._key.words; + var iv = this.cfg.iv; + + // Swap endian + for (var i = 0; i < 4; i++) { + K[i] = (((K[i] << 8) | (K[i] >>> 24)) & 0x00ff00ff) | + (((K[i] << 24) | (K[i] >>> 8)) & 0xff00ff00); + } + + // Generate initial state values + var X = this._X = [ + K[0], (K[3] << 16) | (K[2] >>> 16), + K[1], (K[0] << 16) | (K[3] >>> 16), + K[2], (K[1] << 16) | (K[0] >>> 16), + K[3], (K[2] << 16) | (K[1] >>> 16) + ]; + + // Generate initial counter values + var C = this._C = [ + (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff), + (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff), + (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff), + (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff) + ]; + + // Carry bit + this._b = 0; + + // Iterate the system four times + for (var i = 0; i < 4; i++) { + nextState.call(this); + } + + // Modify the counters + for (var i = 0; i < 8; i++) { + C[i] ^= X[(i + 4) & 7]; + } + + // IV setup + if (iv) { + // Shortcuts + var IV = iv.words; + var IV_0 = IV[0]; + var IV_1 = IV[1]; + + // Generate four subvectors + var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00); + var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00); + var i1 = (i0 >>> 16) | (i2 & 0xffff0000); + var i3 = (i2 << 16) | (i0 & 0x0000ffff); + + // Modify counter values + C[0] ^= i0; + C[1] ^= i1; + C[2] ^= i2; + C[3] ^= i3; + C[4] ^= i0; + C[5] ^= i1; + C[6] ^= i2; + C[7] ^= i3; + + // Iterate the system four times + for (var i = 0; i < 4; i++) { + nextState.call(this); + } + } + }, + + _doProcessBlock: function (M, offset) { + // Shortcut + var X = this._X; + + // Iterate the system + nextState.call(this); + + // Generate four keystream words + S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16); + S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16); + S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16); + S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16); + + for (var i = 0; i < 4; i++) { + // Swap endian + S[i] = (((S[i] << 8) | (S[i] >>> 24)) & 0x00ff00ff) | + (((S[i] << 24) | (S[i] >>> 8)) & 0xff00ff00); + + // Encrypt + M[offset + i] ^= S[i]; + } + }, + + blockSize: 128/32, + + ivSize: 64/32 + }); + + function nextState() { + // Shortcuts + var X = this._X; + var C = this._C; + + // Save old counter values + for (var i = 0; i < 8; i++) { + C_[i] = C[i]; + } + + // Calculate new counter values + C[0] = (C[0] + 0x4d34d34d + this._b) | 0; + C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0; + C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0; + C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0; + C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0; + C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0; + C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0; + C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0; + this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0; + + // Calculate the g-values + for (var i = 0; i < 8; i++) { + var gx = X[i] + C[i]; + + // Construct high and low argument for squaring + var ga = gx & 0xffff; + var gb = gx >>> 16; + + // Calculate high and low result of squaring + var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb; + var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0); + + // High XOR low + G[i] = gh ^ gl; + } + + // Calculate new state values + X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0; + X[1] = (G[1] + ((G[0] << 8) | (G[0] >>> 24)) + G[7]) | 0; + X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0; + X[3] = (G[3] + ((G[2] << 8) | (G[2] >>> 24)) + G[1]) | 0; + X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0; + X[5] = (G[5] + ((G[4] << 8) | (G[4] >>> 24)) + G[3]) | 0; + X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0; + X[7] = (G[7] + ((G[6] << 8) | (G[6] >>> 24)) + G[5]) | 0; + } + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.Rabbit.encrypt(message, key, cfg); + * var plaintext = CryptoJS.Rabbit.decrypt(ciphertext, key, cfg); + */ + C.Rabbit = StreamCipher._createHelper(Rabbit); + }()); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var StreamCipher = C_lib.StreamCipher; + var C_algo = C.algo; + + // Reusable objects + var S = []; + var C_ = []; + var G = []; + + /** + * Rabbit stream cipher algorithm. + * + * This is a legacy version that neglected to convert the key to little-endian. + * This error doesn't affect the cipher's security, + * but it does affect its compatibility with other implementations. + */ + var RabbitLegacy = C_algo.RabbitLegacy = StreamCipher.extend({ + _doReset: function () { + // Shortcuts + var K = this._key.words; + var iv = this.cfg.iv; + + // Generate initial state values + var X = this._X = [ + K[0], (K[3] << 16) | (K[2] >>> 16), + K[1], (K[0] << 16) | (K[3] >>> 16), + K[2], (K[1] << 16) | (K[0] >>> 16), + K[3], (K[2] << 16) | (K[1] >>> 16) + ]; + + // Generate initial counter values + var C = this._C = [ + (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff), + (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff), + (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff), + (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff) + ]; + + // Carry bit + this._b = 0; + + // Iterate the system four times + for (var i = 0; i < 4; i++) { + nextState.call(this); + } + + // Modify the counters + for (var i = 0; i < 8; i++) { + C[i] ^= X[(i + 4) & 7]; + } + + // IV setup + if (iv) { + // Shortcuts + var IV = iv.words; + var IV_0 = IV[0]; + var IV_1 = IV[1]; + + // Generate four subvectors + var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00); + var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00); + var i1 = (i0 >>> 16) | (i2 & 0xffff0000); + var i3 = (i2 << 16) | (i0 & 0x0000ffff); + + // Modify counter values + C[0] ^= i0; + C[1] ^= i1; + C[2] ^= i2; + C[3] ^= i3; + C[4] ^= i0; + C[5] ^= i1; + C[6] ^= i2; + C[7] ^= i3; + + // Iterate the system four times + for (var i = 0; i < 4; i++) { + nextState.call(this); + } + } + }, + + _doProcessBlock: function (M, offset) { + // Shortcut + var X = this._X; + + // Iterate the system + nextState.call(this); + + // Generate four keystream words + S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16); + S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16); + S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16); + S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16); + + for (var i = 0; i < 4; i++) { + // Swap endian + S[i] = (((S[i] << 8) | (S[i] >>> 24)) & 0x00ff00ff) | + (((S[i] << 24) | (S[i] >>> 8)) & 0xff00ff00); + + // Encrypt + M[offset + i] ^= S[i]; + } + }, + + blockSize: 128/32, + + ivSize: 64/32 + }); + + function nextState() { + // Shortcuts + var X = this._X; + var C = this._C; + + // Save old counter values + for (var i = 0; i < 8; i++) { + C_[i] = C[i]; + } + + // Calculate new counter values + C[0] = (C[0] + 0x4d34d34d + this._b) | 0; + C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0; + C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0; + C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0; + C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0; + C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0; + C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0; + C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0; + this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0; + + // Calculate the g-values + for (var i = 0; i < 8; i++) { + var gx = X[i] + C[i]; + + // Construct high and low argument for squaring + var ga = gx & 0xffff; + var gb = gx >>> 16; + + // Calculate high and low result of squaring + var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb; + var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0); + + // High XOR low + G[i] = gh ^ gl; + } + + // Calculate new state values + X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0; + X[1] = (G[1] + ((G[0] << 8) | (G[0] >>> 24)) + G[7]) | 0; + X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0; + X[3] = (G[3] + ((G[2] << 8) | (G[2] >>> 24)) + G[1]) | 0; + X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0; + X[5] = (G[5] + ((G[4] << 8) | (G[4] >>> 24)) + G[3]) | 0; + X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0; + X[7] = (G[7] + ((G[6] << 8) | (G[6] >>> 24)) + G[5]) | 0; + } + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.RabbitLegacy.encrypt(message, key, cfg); + * var plaintext = CryptoJS.RabbitLegacy.decrypt(ciphertext, key, cfg); + */ + C.RabbitLegacy = StreamCipher._createHelper(RabbitLegacy); + }()); + + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var BlockCipher = C_lib.BlockCipher; + var C_algo = C.algo; + + const N = 16; + + //Origin pbox and sbox, derived from PI + const ORIG_P = [ + 0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344, + 0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89, + 0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C, + 0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917, + 0x9216D5D9, 0x8979FB1B + ]; + + const ORIG_S = [ + [ 0xD1310BA6, 0x98DFB5AC, 0x2FFD72DB, 0xD01ADFB7, + 0xB8E1AFED, 0x6A267E96, 0xBA7C9045, 0xF12C7F99, + 0x24A19947, 0xB3916CF7, 0x0801F2E2, 0x858EFC16, + 0x636920D8, 0x71574E69, 0xA458FEA3, 0xF4933D7E, + 0x0D95748F, 0x728EB658, 0x718BCD58, 0x82154AEE, + 0x7B54A41D, 0xC25A59B5, 0x9C30D539, 0x2AF26013, + 0xC5D1B023, 0x286085F0, 0xCA417918, 0xB8DB38EF, + 0x8E79DCB0, 0x603A180E, 0x6C9E0E8B, 0xB01E8A3E, + 0xD71577C1, 0xBD314B27, 0x78AF2FDA, 0x55605C60, + 0xE65525F3, 0xAA55AB94, 0x57489862, 0x63E81440, + 0x55CA396A, 0x2AAB10B6, 0xB4CC5C34, 0x1141E8CE, + 0xA15486AF, 0x7C72E993, 0xB3EE1411, 0x636FBC2A, + 0x2BA9C55D, 0x741831F6, 0xCE5C3E16, 0x9B87931E, + 0xAFD6BA33, 0x6C24CF5C, 0x7A325381, 0x28958677, + 0x3B8F4898, 0x6B4BB9AF, 0xC4BFE81B, 0x66282193, + 0x61D809CC, 0xFB21A991, 0x487CAC60, 0x5DEC8032, + 0xEF845D5D, 0xE98575B1, 0xDC262302, 0xEB651B88, + 0x23893E81, 0xD396ACC5, 0x0F6D6FF3, 0x83F44239, + 0x2E0B4482, 0xA4842004, 0x69C8F04A, 0x9E1F9B5E, + 0x21C66842, 0xF6E96C9A, 0x670C9C61, 0xABD388F0, + 0x6A51A0D2, 0xD8542F68, 0x960FA728, 0xAB5133A3, + 0x6EEF0B6C, 0x137A3BE4, 0xBA3BF050, 0x7EFB2A98, + 0xA1F1651D, 0x39AF0176, 0x66CA593E, 0x82430E88, + 0x8CEE8619, 0x456F9FB4, 0x7D84A5C3, 0x3B8B5EBE, + 0xE06F75D8, 0x85C12073, 0x401A449F, 0x56C16AA6, + 0x4ED3AA62, 0x363F7706, 0x1BFEDF72, 0x429B023D, + 0x37D0D724, 0xD00A1248, 0xDB0FEAD3, 0x49F1C09B, + 0x075372C9, 0x80991B7B, 0x25D479D8, 0xF6E8DEF7, + 0xE3FE501A, 0xB6794C3B, 0x976CE0BD, 0x04C006BA, + 0xC1A94FB6, 0x409F60C4, 0x5E5C9EC2, 0x196A2463, + 0x68FB6FAF, 0x3E6C53B5, 0x1339B2EB, 0x3B52EC6F, + 0x6DFC511F, 0x9B30952C, 0xCC814544, 0xAF5EBD09, + 0xBEE3D004, 0xDE334AFD, 0x660F2807, 0x192E4BB3, + 0xC0CBA857, 0x45C8740F, 0xD20B5F39, 0xB9D3FBDB, + 0x5579C0BD, 0x1A60320A, 0xD6A100C6, 0x402C7279, + 0x679F25FE, 0xFB1FA3CC, 0x8EA5E9F8, 0xDB3222F8, + 0x3C7516DF, 0xFD616B15, 0x2F501EC8, 0xAD0552AB, + 0x323DB5FA, 0xFD238760, 0x53317B48, 0x3E00DF82, + 0x9E5C57BB, 0xCA6F8CA0, 0x1A87562E, 0xDF1769DB, + 0xD542A8F6, 0x287EFFC3, 0xAC6732C6, 0x8C4F5573, + 0x695B27B0, 0xBBCA58C8, 0xE1FFA35D, 0xB8F011A0, + 0x10FA3D98, 0xFD2183B8, 0x4AFCB56C, 0x2DD1D35B, + 0x9A53E479, 0xB6F84565, 0xD28E49BC, 0x4BFB9790, + 0xE1DDF2DA, 0xA4CB7E33, 0x62FB1341, 0xCEE4C6E8, + 0xEF20CADA, 0x36774C01, 0xD07E9EFE, 0x2BF11FB4, + 0x95DBDA4D, 0xAE909198, 0xEAAD8E71, 0x6B93D5A0, + 0xD08ED1D0, 0xAFC725E0, 0x8E3C5B2F, 0x8E7594B7, + 0x8FF6E2FB, 0xF2122B64, 0x8888B812, 0x900DF01C, + 0x4FAD5EA0, 0x688FC31C, 0xD1CFF191, 0xB3A8C1AD, + 0x2F2F2218, 0xBE0E1777, 0xEA752DFE, 0x8B021FA1, + 0xE5A0CC0F, 0xB56F74E8, 0x18ACF3D6, 0xCE89E299, + 0xB4A84FE0, 0xFD13E0B7, 0x7CC43B81, 0xD2ADA8D9, + 0x165FA266, 0x80957705, 0x93CC7314, 0x211A1477, + 0xE6AD2065, 0x77B5FA86, 0xC75442F5, 0xFB9D35CF, + 0xEBCDAF0C, 0x7B3E89A0, 0xD6411BD3, 0xAE1E7E49, + 0x00250E2D, 0x2071B35E, 0x226800BB, 0x57B8E0AF, + 0x2464369B, 0xF009B91E, 0x5563911D, 0x59DFA6AA, + 0x78C14389, 0xD95A537F, 0x207D5BA2, 0x02E5B9C5, + 0x83260376, 0x6295CFA9, 0x11C81968, 0x4E734A41, + 0xB3472DCA, 0x7B14A94A, 0x1B510052, 0x9A532915, + 0xD60F573F, 0xBC9BC6E4, 0x2B60A476, 0x81E67400, + 0x08BA6FB5, 0x571BE91F, 0xF296EC6B, 0x2A0DD915, + 0xB6636521, 0xE7B9F9B6, 0xFF34052E, 0xC5855664, + 0x53B02D5D, 0xA99F8FA1, 0x08BA4799, 0x6E85076A ], + [ 0x4B7A70E9, 0xB5B32944, 0xDB75092E, 0xC4192623, + 0xAD6EA6B0, 0x49A7DF7D, 0x9CEE60B8, 0x8FEDB266, + 0xECAA8C71, 0x699A17FF, 0x5664526C, 0xC2B19EE1, + 0x193602A5, 0x75094C29, 0xA0591340, 0xE4183A3E, + 0x3F54989A, 0x5B429D65, 0x6B8FE4D6, 0x99F73FD6, + 0xA1D29C07, 0xEFE830F5, 0x4D2D38E6, 0xF0255DC1, + 0x4CDD2086, 0x8470EB26, 0x6382E9C6, 0x021ECC5E, + 0x09686B3F, 0x3EBAEFC9, 0x3C971814, 0x6B6A70A1, + 0x687F3584, 0x52A0E286, 0xB79C5305, 0xAA500737, + 0x3E07841C, 0x7FDEAE5C, 0x8E7D44EC, 0x5716F2B8, + 0xB03ADA37, 0xF0500C0D, 0xF01C1F04, 0x0200B3FF, + 0xAE0CF51A, 0x3CB574B2, 0x25837A58, 0xDC0921BD, + 0xD19113F9, 0x7CA92FF6, 0x94324773, 0x22F54701, + 0x3AE5E581, 0x37C2DADC, 0xC8B57634, 0x9AF3DDA7, + 0xA9446146, 0x0FD0030E, 0xECC8C73E, 0xA4751E41, + 0xE238CD99, 0x3BEA0E2F, 0x3280BBA1, 0x183EB331, + 0x4E548B38, 0x4F6DB908, 0x6F420D03, 0xF60A04BF, + 0x2CB81290, 0x24977C79, 0x5679B072, 0xBCAF89AF, + 0xDE9A771F, 0xD9930810, 0xB38BAE12, 0xDCCF3F2E, + 0x5512721F, 0x2E6B7124, 0x501ADDE6, 0x9F84CD87, + 0x7A584718, 0x7408DA17, 0xBC9F9ABC, 0xE94B7D8C, + 0xEC7AEC3A, 0xDB851DFA, 0x63094366, 0xC464C3D2, + 0xEF1C1847, 0x3215D908, 0xDD433B37, 0x24C2BA16, + 0x12A14D43, 0x2A65C451, 0x50940002, 0x133AE4DD, + 0x71DFF89E, 0x10314E55, 0x81AC77D6, 0x5F11199B, + 0x043556F1, 0xD7A3C76B, 0x3C11183B, 0x5924A509, + 0xF28FE6ED, 0x97F1FBFA, 0x9EBABF2C, 0x1E153C6E, + 0x86E34570, 0xEAE96FB1, 0x860E5E0A, 0x5A3E2AB3, + 0x771FE71C, 0x4E3D06FA, 0x2965DCB9, 0x99E71D0F, + 0x803E89D6, 0x5266C825, 0x2E4CC978, 0x9C10B36A, + 0xC6150EBA, 0x94E2EA78, 0xA5FC3C53, 0x1E0A2DF4, + 0xF2F74EA7, 0x361D2B3D, 0x1939260F, 0x19C27960, + 0x5223A708, 0xF71312B6, 0xEBADFE6E, 0xEAC31F66, + 0xE3BC4595, 0xA67BC883, 0xB17F37D1, 0x018CFF28, + 0xC332DDEF, 0xBE6C5AA5, 0x65582185, 0x68AB9802, + 0xEECEA50F, 0xDB2F953B, 0x2AEF7DAD, 0x5B6E2F84, + 0x1521B628, 0x29076170, 0xECDD4775, 0x619F1510, + 0x13CCA830, 0xEB61BD96, 0x0334FE1E, 0xAA0363CF, + 0xB5735C90, 0x4C70A239, 0xD59E9E0B, 0xCBAADE14, + 0xEECC86BC, 0x60622CA7, 0x9CAB5CAB, 0xB2F3846E, + 0x648B1EAF, 0x19BDF0CA, 0xA02369B9, 0x655ABB50, + 0x40685A32, 0x3C2AB4B3, 0x319EE9D5, 0xC021B8F7, + 0x9B540B19, 0x875FA099, 0x95F7997E, 0x623D7DA8, + 0xF837889A, 0x97E32D77, 0x11ED935F, 0x16681281, + 0x0E358829, 0xC7E61FD6, 0x96DEDFA1, 0x7858BA99, + 0x57F584A5, 0x1B227263, 0x9B83C3FF, 0x1AC24696, + 0xCDB30AEB, 0x532E3054, 0x8FD948E4, 0x6DBC3128, + 0x58EBF2EF, 0x34C6FFEA, 0xFE28ED61, 0xEE7C3C73, + 0x5D4A14D9, 0xE864B7E3, 0x42105D14, 0x203E13E0, + 0x45EEE2B6, 0xA3AAABEA, 0xDB6C4F15, 0xFACB4FD0, + 0xC742F442, 0xEF6ABBB5, 0x654F3B1D, 0x41CD2105, + 0xD81E799E, 0x86854DC7, 0xE44B476A, 0x3D816250, + 0xCF62A1F2, 0x5B8D2646, 0xFC8883A0, 0xC1C7B6A3, + 0x7F1524C3, 0x69CB7492, 0x47848A0B, 0x5692B285, + 0x095BBF00, 0xAD19489D, 0x1462B174, 0x23820E00, + 0x58428D2A, 0x0C55F5EA, 0x1DADF43E, 0x233F7061, + 0x3372F092, 0x8D937E41, 0xD65FECF1, 0x6C223BDB, + 0x7CDE3759, 0xCBEE7460, 0x4085F2A7, 0xCE77326E, + 0xA6078084, 0x19F8509E, 0xE8EFD855, 0x61D99735, + 0xA969A7AA, 0xC50C06C2, 0x5A04ABFC, 0x800BCADC, + 0x9E447A2E, 0xC3453484, 0xFDD56705, 0x0E1E9EC9, + 0xDB73DBD3, 0x105588CD, 0x675FDA79, 0xE3674340, + 0xC5C43465, 0x713E38D8, 0x3D28F89E, 0xF16DFF20, + 0x153E21E7, 0x8FB03D4A, 0xE6E39F2B, 0xDB83ADF7 ], + [ 0xE93D5A68, 0x948140F7, 0xF64C261C, 0x94692934, + 0x411520F7, 0x7602D4F7, 0xBCF46B2E, 0xD4A20068, + 0xD4082471, 0x3320F46A, 0x43B7D4B7, 0x500061AF, + 0x1E39F62E, 0x97244546, 0x14214F74, 0xBF8B8840, + 0x4D95FC1D, 0x96B591AF, 0x70F4DDD3, 0x66A02F45, + 0xBFBC09EC, 0x03BD9785, 0x7FAC6DD0, 0x31CB8504, + 0x96EB27B3, 0x55FD3941, 0xDA2547E6, 0xABCA0A9A, + 0x28507825, 0x530429F4, 0x0A2C86DA, 0xE9B66DFB, + 0x68DC1462, 0xD7486900, 0x680EC0A4, 0x27A18DEE, + 0x4F3FFEA2, 0xE887AD8C, 0xB58CE006, 0x7AF4D6B6, + 0xAACE1E7C, 0xD3375FEC, 0xCE78A399, 0x406B2A42, + 0x20FE9E35, 0xD9F385B9, 0xEE39D7AB, 0x3B124E8B, + 0x1DC9FAF7, 0x4B6D1856, 0x26A36631, 0xEAE397B2, + 0x3A6EFA74, 0xDD5B4332, 0x6841E7F7, 0xCA7820FB, + 0xFB0AF54E, 0xD8FEB397, 0x454056AC, 0xBA489527, + 0x55533A3A, 0x20838D87, 0xFE6BA9B7, 0xD096954B, + 0x55A867BC, 0xA1159A58, 0xCCA92963, 0x99E1DB33, + 0xA62A4A56, 0x3F3125F9, 0x5EF47E1C, 0x9029317C, + 0xFDF8E802, 0x04272F70, 0x80BB155C, 0x05282CE3, + 0x95C11548, 0xE4C66D22, 0x48C1133F, 0xC70F86DC, + 0x07F9C9EE, 0x41041F0F, 0x404779A4, 0x5D886E17, + 0x325F51EB, 0xD59BC0D1, 0xF2BCC18F, 0x41113564, + 0x257B7834, 0x602A9C60, 0xDFF8E8A3, 0x1F636C1B, + 0x0E12B4C2, 0x02E1329E, 0xAF664FD1, 0xCAD18115, + 0x6B2395E0, 0x333E92E1, 0x3B240B62, 0xEEBEB922, + 0x85B2A20E, 0xE6BA0D99, 0xDE720C8C, 0x2DA2F728, + 0xD0127845, 0x95B794FD, 0x647D0862, 0xE7CCF5F0, + 0x5449A36F, 0x877D48FA, 0xC39DFD27, 0xF33E8D1E, + 0x0A476341, 0x992EFF74, 0x3A6F6EAB, 0xF4F8FD37, + 0xA812DC60, 0xA1EBDDF8, 0x991BE14C, 0xDB6E6B0D, + 0xC67B5510, 0x6D672C37, 0x2765D43B, 0xDCD0E804, + 0xF1290DC7, 0xCC00FFA3, 0xB5390F92, 0x690FED0B, + 0x667B9FFB, 0xCEDB7D9C, 0xA091CF0B, 0xD9155EA3, + 0xBB132F88, 0x515BAD24, 0x7B9479BF, 0x763BD6EB, + 0x37392EB3, 0xCC115979, 0x8026E297, 0xF42E312D, + 0x6842ADA7, 0xC66A2B3B, 0x12754CCC, 0x782EF11C, + 0x6A124237, 0xB79251E7, 0x06A1BBE6, 0x4BFB6350, + 0x1A6B1018, 0x11CAEDFA, 0x3D25BDD8, 0xE2E1C3C9, + 0x44421659, 0x0A121386, 0xD90CEC6E, 0xD5ABEA2A, + 0x64AF674E, 0xDA86A85F, 0xBEBFE988, 0x64E4C3FE, + 0x9DBC8057, 0xF0F7C086, 0x60787BF8, 0x6003604D, + 0xD1FD8346, 0xF6381FB0, 0x7745AE04, 0xD736FCCC, + 0x83426B33, 0xF01EAB71, 0xB0804187, 0x3C005E5F, + 0x77A057BE, 0xBDE8AE24, 0x55464299, 0xBF582E61, + 0x4E58F48F, 0xF2DDFDA2, 0xF474EF38, 0x8789BDC2, + 0x5366F9C3, 0xC8B38E74, 0xB475F255, 0x46FCD9B9, + 0x7AEB2661, 0x8B1DDF84, 0x846A0E79, 0x915F95E2, + 0x466E598E, 0x20B45770, 0x8CD55591, 0xC902DE4C, + 0xB90BACE1, 0xBB8205D0, 0x11A86248, 0x7574A99E, + 0xB77F19B6, 0xE0A9DC09, 0x662D09A1, 0xC4324633, + 0xE85A1F02, 0x09F0BE8C, 0x4A99A025, 0x1D6EFE10, + 0x1AB93D1D, 0x0BA5A4DF, 0xA186F20F, 0x2868F169, + 0xDCB7DA83, 0x573906FE, 0xA1E2CE9B, 0x4FCD7F52, + 0x50115E01, 0xA70683FA, 0xA002B5C4, 0x0DE6D027, + 0x9AF88C27, 0x773F8641, 0xC3604C06, 0x61A806B5, + 0xF0177A28, 0xC0F586E0, 0x006058AA, 0x30DC7D62, + 0x11E69ED7, 0x2338EA63, 0x53C2DD94, 0xC2C21634, + 0xBBCBEE56, 0x90BCB6DE, 0xEBFC7DA1, 0xCE591D76, + 0x6F05E409, 0x4B7C0188, 0x39720A3D, 0x7C927C24, + 0x86E3725F, 0x724D9DB9, 0x1AC15BB4, 0xD39EB8FC, + 0xED545578, 0x08FCA5B5, 0xD83D7CD3, 0x4DAD0FC4, + 0x1E50EF5E, 0xB161E6F8, 0xA28514D9, 0x6C51133C, + 0x6FD5C7E7, 0x56E14EC4, 0x362ABFCE, 0xDDC6C837, + 0xD79A3234, 0x92638212, 0x670EFA8E, 0x406000E0 ], + [ 0x3A39CE37, 0xD3FAF5CF, 0xABC27737, 0x5AC52D1B, + 0x5CB0679E, 0x4FA33742, 0xD3822740, 0x99BC9BBE, + 0xD5118E9D, 0xBF0F7315, 0xD62D1C7E, 0xC700C47B, + 0xB78C1B6B, 0x21A19045, 0xB26EB1BE, 0x6A366EB4, + 0x5748AB2F, 0xBC946E79, 0xC6A376D2, 0x6549C2C8, + 0x530FF8EE, 0x468DDE7D, 0xD5730A1D, 0x4CD04DC6, + 0x2939BBDB, 0xA9BA4650, 0xAC9526E8, 0xBE5EE304, + 0xA1FAD5F0, 0x6A2D519A, 0x63EF8CE2, 0x9A86EE22, + 0xC089C2B8, 0x43242EF6, 0xA51E03AA, 0x9CF2D0A4, + 0x83C061BA, 0x9BE96A4D, 0x8FE51550, 0xBA645BD6, + 0x2826A2F9, 0xA73A3AE1, 0x4BA99586, 0xEF5562E9, + 0xC72FEFD3, 0xF752F7DA, 0x3F046F69, 0x77FA0A59, + 0x80E4A915, 0x87B08601, 0x9B09E6AD, 0x3B3EE593, + 0xE990FD5A, 0x9E34D797, 0x2CF0B7D9, 0x022B8B51, + 0x96D5AC3A, 0x017DA67D, 0xD1CF3ED6, 0x7C7D2D28, + 0x1F9F25CF, 0xADF2B89B, 0x5AD6B472, 0x5A88F54C, + 0xE029AC71, 0xE019A5E6, 0x47B0ACFD, 0xED93FA9B, + 0xE8D3C48D, 0x283B57CC, 0xF8D56629, 0x79132E28, + 0x785F0191, 0xED756055, 0xF7960E44, 0xE3D35E8C, + 0x15056DD4, 0x88F46DBA, 0x03A16125, 0x0564F0BD, + 0xC3EB9E15, 0x3C9057A2, 0x97271AEC, 0xA93A072A, + 0x1B3F6D9B, 0x1E6321F5, 0xF59C66FB, 0x26DCF319, + 0x7533D928, 0xB155FDF5, 0x03563482, 0x8ABA3CBB, + 0x28517711, 0xC20AD9F8, 0xABCC5167, 0xCCAD925F, + 0x4DE81751, 0x3830DC8E, 0x379D5862, 0x9320F991, + 0xEA7A90C2, 0xFB3E7BCE, 0x5121CE64, 0x774FBE32, + 0xA8B6E37E, 0xC3293D46, 0x48DE5369, 0x6413E680, + 0xA2AE0810, 0xDD6DB224, 0x69852DFD, 0x09072166, + 0xB39A460A, 0x6445C0DD, 0x586CDECF, 0x1C20C8AE, + 0x5BBEF7DD, 0x1B588D40, 0xCCD2017F, 0x6BB4E3BB, + 0xDDA26A7E, 0x3A59FF45, 0x3E350A44, 0xBCB4CDD5, + 0x72EACEA8, 0xFA6484BB, 0x8D6612AE, 0xBF3C6F47, + 0xD29BE463, 0x542F5D9E, 0xAEC2771B, 0xF64E6370, + 0x740E0D8D, 0xE75B1357, 0xF8721671, 0xAF537D5D, + 0x4040CB08, 0x4EB4E2CC, 0x34D2466A, 0x0115AF84, + 0xE1B00428, 0x95983A1D, 0x06B89FB4, 0xCE6EA048, + 0x6F3F3B82, 0x3520AB82, 0x011A1D4B, 0x277227F8, + 0x611560B1, 0xE7933FDC, 0xBB3A792B, 0x344525BD, + 0xA08839E1, 0x51CE794B, 0x2F32C9B7, 0xA01FBAC9, + 0xE01CC87E, 0xBCC7D1F6, 0xCF0111C3, 0xA1E8AAC7, + 0x1A908749, 0xD44FBD9A, 0xD0DADECB, 0xD50ADA38, + 0x0339C32A, 0xC6913667, 0x8DF9317C, 0xE0B12B4F, + 0xF79E59B7, 0x43F5BB3A, 0xF2D519FF, 0x27D9459C, + 0xBF97222C, 0x15E6FC2A, 0x0F91FC71, 0x9B941525, + 0xFAE59361, 0xCEB69CEB, 0xC2A86459, 0x12BAA8D1, + 0xB6C1075E, 0xE3056A0C, 0x10D25065, 0xCB03A442, + 0xE0EC6E0E, 0x1698DB3B, 0x4C98A0BE, 0x3278E964, + 0x9F1F9532, 0xE0D392DF, 0xD3A0342B, 0x8971F21E, + 0x1B0A7441, 0x4BA3348C, 0xC5BE7120, 0xC37632D8, + 0xDF359F8D, 0x9B992F2E, 0xE60B6F47, 0x0FE3F11D, + 0xE54CDA54, 0x1EDAD891, 0xCE6279CF, 0xCD3E7E6F, + 0x1618B166, 0xFD2C1D05, 0x848FD2C5, 0xF6FB2299, + 0xF523F357, 0xA6327623, 0x93A83531, 0x56CCCD02, + 0xACF08162, 0x5A75EBB5, 0x6E163697, 0x88D273CC, + 0xDE966292, 0x81B949D0, 0x4C50901B, 0x71C65614, + 0xE6C6C7BD, 0x327A140A, 0x45E1D006, 0xC3F27B9A, + 0xC9AA53FD, 0x62A80F00, 0xBB25BFE2, 0x35BDD2F6, + 0x71126905, 0xB2040222, 0xB6CBCF7C, 0xCD769C2B, + 0x53113EC0, 0x1640E3D3, 0x38ABBD60, 0x2547ADF0, + 0xBA38209C, 0xF746CE76, 0x77AFA1C5, 0x20756060, + 0x85CBFE4E, 0x8AE88DD8, 0x7AAAF9B0, 0x4CF9AA7E, + 0x1948C25C, 0x02FB8A8C, 0x01C36AE4, 0xD6EBE1F9, + 0x90D4F869, 0xA65CDEA0, 0x3F09252D, 0xC208E69F, + 0xB74E6132, 0xCE77E25B, 0x578FDFE3, 0x3AC372E6 ] + ]; + + var BLOWFISH_CTX = { + pbox: [], + sbox: [] + } + + function F(ctx, x){ + let a = (x >> 24) & 0xFF; + let b = (x >> 16) & 0xFF; + let c = (x >> 8) & 0xFF; + let d = x & 0xFF; + + let y = ctx.sbox[0][a] + ctx.sbox[1][b]; + y = y ^ ctx.sbox[2][c]; + y = y + ctx.sbox[3][d]; + + return y; + } + + function BlowFish_Encrypt(ctx, left, right){ + let Xl = left; + let Xr = right; + let temp; + + for(let i = 0; i < N; ++i){ + Xl = Xl ^ ctx.pbox[i]; + Xr = F(ctx, Xl) ^ Xr; + + temp = Xl; + Xl = Xr; + Xr = temp; + } + + temp = Xl; + Xl = Xr; + Xr = temp; + + Xr = Xr ^ ctx.pbox[N]; + Xl = Xl ^ ctx.pbox[N + 1]; + + return {left: Xl, right: Xr}; + } + + function BlowFish_Decrypt(ctx, left, right){ + let Xl = left; + let Xr = right; + let temp; + + for(let i = N + 1; i > 1; --i){ + Xl = Xl ^ ctx.pbox[i]; + Xr = F(ctx, Xl) ^ Xr; + + temp = Xl; + Xl = Xr; + Xr = temp; + } + + temp = Xl; + Xl = Xr; + Xr = temp; + + Xr = Xr ^ ctx.pbox[1]; + Xl = Xl ^ ctx.pbox[0]; + + return {left: Xl, right: Xr}; + } + + /** + * Initialization ctx's pbox and sbox. + * + * @param {Object} ctx The object has pbox and sbox. + * @param {Array} key An array of 32-bit words. + * @param {int} keysize The length of the key. + * + * @example + * + * BlowFishInit(BLOWFISH_CTX, key, 128/32); + */ + function BlowFishInit(ctx, key, keysize) + { + for(let Row = 0; Row < 4; Row++) + { + ctx.sbox[Row] = []; + for(let Col = 0; Col < 256; Col++) + { + ctx.sbox[Row][Col] = ORIG_S[Row][Col]; + } + } + + let keyIndex = 0; + for(let index = 0; index < N + 2; index++) + { + ctx.pbox[index] = ORIG_P[index] ^ key[keyIndex]; + keyIndex++; + if(keyIndex >= keysize) + { + keyIndex = 0; + } + } + + let Data1 = 0; + let Data2 = 0; + let res = 0; + for(let i = 0; i < N + 2; i += 2) + { + res = BlowFish_Encrypt(ctx, Data1, Data2); + Data1 = res.left; + Data2 = res.right; + ctx.pbox[i] = Data1; + ctx.pbox[i + 1] = Data2; + } + + for(let i = 0; i < 4; i++) + { + for(let j = 0; j < 256; j += 2) + { + res = BlowFish_Encrypt(ctx, Data1, Data2); + Data1 = res.left; + Data2 = res.right; + ctx.sbox[i][j] = Data1; + ctx.sbox[i][j + 1] = Data2; + } + } + + return true; + } + + /** + * Blowfish block cipher algorithm. + */ + var Blowfish = C_algo.Blowfish = BlockCipher.extend({ + _doReset: function () { + // Skip reset of nRounds has been set before and key did not change + if (this._keyPriorReset === this._key) { + return; + } + + // Shortcuts + var key = this._keyPriorReset = this._key; + var keyWords = key.words; + var keySize = key.sigBytes / 4; + + //Initialization pbox and sbox + BlowFishInit(BLOWFISH_CTX, keyWords, keySize); + }, + + encryptBlock: function (M, offset) { + var res = BlowFish_Encrypt(BLOWFISH_CTX, M[offset], M[offset + 1]); + M[offset] = res.left; + M[offset + 1] = res.right; + }, + + decryptBlock: function (M, offset) { + var res = BlowFish_Decrypt(BLOWFISH_CTX, M[offset], M[offset + 1]); + M[offset] = res.left; + M[offset + 1] = res.right; + }, + + blockSize: 64/32, + + keySize: 128/32, + + ivSize: 64/32 + }); + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.Blowfish.encrypt(message, key, cfg); + * var plaintext = CryptoJS.Blowfish.decrypt(ciphertext, key, cfg); + */ + C.Blowfish = BlockCipher._createHelper(Blowfish); + }()); + + + return CryptoJS; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/docs/QuickStartGuide.wiki b/node_modules/crypto-js/docs/QuickStartGuide.wiki new file mode 100644 index 0000000..2bee35d --- /dev/null +++ b/node_modules/crypto-js/docs/QuickStartGuide.wiki @@ -0,0 +1,470 @@ + + +---- + += Quick-start Guide = + +== Hashers == + +=== The Hasher Algorithms === + +==== MD5 ==== + +MD5 is a widely used hash function. It's been used in a variety of security applications and is also commonly used to check the integrity of files. Though, MD5 is not collision resistant, and it isn't suitable for applications like SSL certificates or digital signatures that rely on this property. + +{{{ + + +}}} + +==== SHA-1 ==== + +The SHA hash functions were designed by the National Security Agency (NSA). SHA-1 is the most established of the existing SHA hash functions, and it's used in a variety of security applications and protocols. Though, SHA-1's collision resistance has been weakening as new attacks are discovered or improved. + +{{{ + + +}}} + +==== SHA-2 ==== + +SHA-256 is one of the four variants in the SHA-2 set. It isn't as widely used as SHA-1, though it appears to provide much better security. + +{{{ + + +}}} + +SHA-512 is largely identical to SHA-256 but operates on 64-bit words rather than 32. + +{{{ + + +}}} + +CryptoJS also supports SHA-224 and SHA-384, which are largely identical but truncated versions of SHA-256 and SHA-512 respectively. + +==== SHA-3 ==== + +SHA-3 is the winner of a five-year competition to select a new cryptographic hash algorithm where 64 competing designs were evaluated. + +{{{ + + +}}} + +SHA-3 can be configured to output hash lengths of one of 224, 256, 384, or 512 bits. The default is 512 bits. + +{{{ + + +}}} + +==== RIPEMD-160 ==== + +{{{ + + +}}} + +=== The Hasher Input === + +The hash algorithms accept either strings or instances of CryptoJS.lib.WordArray. A WordArray object represents an array of 32-bit words. When you pass a string, it's automatically converted to a WordArray encoded as UTF-8. + +=== The Hasher Output === + +The hash you get back isn't a string yet. It's a WordArray object. When you use a WordArray object in a string context, it's automatically converted to a hex string. + +{{{ + + +}}} + +You can convert a WordArray object to other formats by explicitly calling the toString method and passing an encoder. + +{{{ + + + +}}} + +=== Progressive Hashing === + +{{{ + + +}}} + +== HMAC == + +Keyed-hash message authentication codes (HMAC) is a mechanism for message authentication using cryptographic hash functions. + +HMAC can be used in combination with any iterated cryptographic hash function. + +{{{ + + + + + +}}} + +=== Progressive HMAC Hashing === + +{{{ + + +}}} + +== PBKDF2 == + +PBKDF2 is a password-based key derivation function. In many applications of cryptography, user security is ultimately dependent on a password, and because a password usually can't be used directly as a cryptographic key, some processing is required. + +A salt provides a large set of keys for any given password, and an iteration count increases the cost of producing keys from a password, thereby also increasing the difficulty of attack. + +{{{ + + +}}} + +== Ciphers == + +=== The Cipher Algorithms === + +==== AES ==== + +The Advanced Encryption Standard (AES) is a U.S. Federal Information Processing Standard (FIPS). It was selected after a 5-year process where 15 competing designs were evaluated. + +{{{ + + +}}} + +CryptoJS supports AES-128, AES-192, and AES-256. It will pick the variant by the size of the key you pass in. If you use a passphrase, then it will generate a 256-bit key. + +==== DES, Triple DES ==== + +DES is a previously dominant algorithm for encryption, and was published as an official Federal Information Processing Standard (FIPS). DES is now considered to be insecure due to the small key size. + +{{{ + + +}}} + +Triple DES applies DES three times to each block to increase the key size. The algorithm is believed to be secure in this form. + +{{{ + + +}}} + +==== Rabbit ==== + +Rabbit is a high-performance stream cipher and a finalist in the eSTREAM Portfolio. It is one of the four designs selected after a 3 1/2-year process where 22 designs were evaluated. + +{{{ + + +}}} + +==== RC4, RC4Drop ==== + +RC4 is a widely-used stream cipher. It's used in popular protocols such as SSL and WEP. Although remarkable for its simplicity and speed, the algorithm's history doesn't inspire confidence in its security. + +{{{ + + +}}} + +It was discovered that the first few bytes of keystream are strongly non-random and leak information about the key. We can defend against this attack by discarding the initial portion of the keystream. This modified algorithm is traditionally called RC4-drop. + +By default, 192 words (768 bytes) are dropped, but you can configure the algorithm to drop any number of words. + +{{{ + + +}}} + +=== Custom Key and IV === + +{{{ + + +}}} + +=== Block Modes and Padding === + +{{{ + + + + +}}} + +CryptoJS supports the following modes: + + * CBC (the default) + * CFB + * CTR + * OFB + * ECB + +And CryptoJS supports the following padding schemes: + + * Pkcs7 (the default) + * Iso97971 + * AnsiX923 + * Iso10126 + * ZeroPadding + * NoPadding + +=== The Cipher Input === + +For the plaintext message, the cipher algorithms accept either strings or instances of CryptoJS.lib.WordArray. + +For the key, when you pass a string, it's treated as a passphrase and used to derive an actual key and IV. Or you can pass a WordArray that represents the actual key. If you pass the actual key, you must also pass the actual IV. + +For the ciphertext, the cipher algorithms accept either strings or instances of CryptoJS.lib.CipherParams. A CipherParams object represents a collection of parameters such as the IV, a salt, and the raw ciphertext itself. When you pass a string, it's automatically converted to a CipherParams object according to a configurable format strategy. + +=== The Cipher Output === + +The plaintext you get back after decryption is a WordArray object. See Hashers' Output for more detail. + +The ciphertext you get back after encryption isn't a string yet. It's a CipherParams object. A CipherParams object gives you access to all the parameters used during encryption. When you use a CipherParams object in a string context, it's automatically converted to a string according to a format strategy. The default is an OpenSSL-compatible format. + +{{{ + + +}}} + +You can define your own formats in order to be compatible with other crypto implementations. A format is an object with two methods—stringify and parse—that converts between CipherParams objects and ciphertext strings. + +Here's how you might write a JSON formatter: + +{{{ + + +}}} + +=== Progressive Ciphering === + +{{{ + + +}}} + +=== Interoperability === + +==== With OpenSSL ==== + +Encrypt with OpenSSL: + +{{{ +openssl enc -aes-256-cbc -in infile -out outfile -pass pass:"Secret Passphrase" -e -base64 +}}} + +Decrypt with CryptoJS: + +{{{ + + +}}} + +== Encoders == + +CryptoJS can convert from encoding formats such as Base64, Latin1 or Hex to WordArray objects and vica versa. + +{{{ + + + + +}}} \ No newline at end of file diff --git a/node_modules/crypto-js/enc-base64.js b/node_modules/crypto-js/enc-base64.js new file mode 100644 index 0000000..0ffcd53 --- /dev/null +++ b/node_modules/crypto-js/enc-base64.js @@ -0,0 +1,136 @@ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var C_enc = C.enc; + + /** + * Base64 encoding strategy. + */ + var Base64 = C_enc.Base64 = { + /** + * Converts a word array to a Base64 string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The Base64 string. + * + * @static + * + * @example + * + * var base64String = CryptoJS.enc.Base64.stringify(wordArray); + */ + stringify: function (wordArray) { + // Shortcuts + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + var map = this._map; + + // Clamp excess bits + wordArray.clamp(); + + // Convert + var base64Chars = []; + for (var i = 0; i < sigBytes; i += 3) { + var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff; + var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff; + + var triplet = (byte1 << 16) | (byte2 << 8) | byte3; + + for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) { + base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f)); + } + } + + // Add padding + var paddingChar = map.charAt(64); + if (paddingChar) { + while (base64Chars.length % 4) { + base64Chars.push(paddingChar); + } + } + + return base64Chars.join(''); + }, + + /** + * Converts a Base64 string to a word array. + * + * @param {string} base64Str The Base64 string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Base64.parse(base64String); + */ + parse: function (base64Str) { + // Shortcuts + var base64StrLength = base64Str.length; + var map = this._map; + var reverseMap = this._reverseMap; + + if (!reverseMap) { + reverseMap = this._reverseMap = []; + for (var j = 0; j < map.length; j++) { + reverseMap[map.charCodeAt(j)] = j; + } + } + + // Ignore padding + var paddingChar = map.charAt(64); + if (paddingChar) { + var paddingIndex = base64Str.indexOf(paddingChar); + if (paddingIndex !== -1) { + base64StrLength = paddingIndex; + } + } + + // Convert + return parseLoop(base64Str, base64StrLength, reverseMap); + + }, + + _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=' + }; + + function parseLoop(base64Str, base64StrLength, reverseMap) { + var words = []; + var nBytes = 0; + for (var i = 0; i < base64StrLength; i++) { + if (i % 4) { + var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2); + var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2); + var bitsCombined = bits1 | bits2; + words[nBytes >>> 2] |= bitsCombined << (24 - (nBytes % 4) * 8); + nBytes++; + } + } + return WordArray.create(words, nBytes); + } + }()); + + + return CryptoJS.enc.Base64; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/enc-base64url.js b/node_modules/crypto-js/enc-base64url.js new file mode 100644 index 0000000..af682e3 --- /dev/null +++ b/node_modules/crypto-js/enc-base64url.js @@ -0,0 +1,148 @@ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var C_enc = C.enc; + + /** + * Base64url encoding strategy. + */ + var Base64url = C_enc.Base64url = { + /** + * Converts a word array to a Base64url string. + * + * @param {WordArray} wordArray The word array. + * + * @param {boolean} urlSafe Whether to use url safe + * + * @return {string} The Base64url string. + * + * @static + * + * @example + * + * var base64String = CryptoJS.enc.Base64url.stringify(wordArray); + */ + stringify: function (wordArray, urlSafe) { + if (urlSafe === undefined) { + urlSafe = true + } + // Shortcuts + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + var map = urlSafe ? this._safe_map : this._map; + + // Clamp excess bits + wordArray.clamp(); + + // Convert + var base64Chars = []; + for (var i = 0; i < sigBytes; i += 3) { + var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff; + var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff; + + var triplet = (byte1 << 16) | (byte2 << 8) | byte3; + + for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) { + base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f)); + } + } + + // Add padding + var paddingChar = map.charAt(64); + if (paddingChar) { + while (base64Chars.length % 4) { + base64Chars.push(paddingChar); + } + } + + return base64Chars.join(''); + }, + + /** + * Converts a Base64url string to a word array. + * + * @param {string} base64Str The Base64url string. + * + * @param {boolean} urlSafe Whether to use url safe + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Base64url.parse(base64String); + */ + parse: function (base64Str, urlSafe) { + if (urlSafe === undefined) { + urlSafe = true + } + + // Shortcuts + var base64StrLength = base64Str.length; + var map = urlSafe ? this._safe_map : this._map; + var reverseMap = this._reverseMap; + + if (!reverseMap) { + reverseMap = this._reverseMap = []; + for (var j = 0; j < map.length; j++) { + reverseMap[map.charCodeAt(j)] = j; + } + } + + // Ignore padding + var paddingChar = map.charAt(64); + if (paddingChar) { + var paddingIndex = base64Str.indexOf(paddingChar); + if (paddingIndex !== -1) { + base64StrLength = paddingIndex; + } + } + + // Convert + return parseLoop(base64Str, base64StrLength, reverseMap); + + }, + + _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=', + _safe_map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_', + }; + + function parseLoop(base64Str, base64StrLength, reverseMap) { + var words = []; + var nBytes = 0; + for (var i = 0; i < base64StrLength; i++) { + if (i % 4) { + var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2); + var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2); + var bitsCombined = bits1 | bits2; + words[nBytes >>> 2] |= bitsCombined << (24 - (nBytes % 4) * 8); + nBytes++; + } + } + return WordArray.create(words, nBytes); + } + }()); + + + return CryptoJS.enc.Base64url; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/enc-hex.js b/node_modules/crypto-js/enc-hex.js new file mode 100644 index 0000000..88161ff --- /dev/null +++ b/node_modules/crypto-js/enc-hex.js @@ -0,0 +1,18 @@ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + return CryptoJS.enc.Hex; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/enc-latin1.js b/node_modules/crypto-js/enc-latin1.js new file mode 100644 index 0000000..ade56dc --- /dev/null +++ b/node_modules/crypto-js/enc-latin1.js @@ -0,0 +1,18 @@ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + return CryptoJS.enc.Latin1; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/enc-utf16.js b/node_modules/crypto-js/enc-utf16.js new file mode 100644 index 0000000..7de6245 --- /dev/null +++ b/node_modules/crypto-js/enc-utf16.js @@ -0,0 +1,149 @@ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var C_enc = C.enc; + + /** + * UTF-16 BE encoding strategy. + */ + var Utf16BE = C_enc.Utf16 = C_enc.Utf16BE = { + /** + * Converts a word array to a UTF-16 BE string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The UTF-16 BE string. + * + * @static + * + * @example + * + * var utf16String = CryptoJS.enc.Utf16.stringify(wordArray); + */ + stringify: function (wordArray) { + // Shortcuts + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + + // Convert + var utf16Chars = []; + for (var i = 0; i < sigBytes; i += 2) { + var codePoint = (words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff; + utf16Chars.push(String.fromCharCode(codePoint)); + } + + return utf16Chars.join(''); + }, + + /** + * Converts a UTF-16 BE string to a word array. + * + * @param {string} utf16Str The UTF-16 BE string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Utf16.parse(utf16String); + */ + parse: function (utf16Str) { + // Shortcut + var utf16StrLength = utf16Str.length; + + // Convert + var words = []; + for (var i = 0; i < utf16StrLength; i++) { + words[i >>> 1] |= utf16Str.charCodeAt(i) << (16 - (i % 2) * 16); + } + + return WordArray.create(words, utf16StrLength * 2); + } + }; + + /** + * UTF-16 LE encoding strategy. + */ + C_enc.Utf16LE = { + /** + * Converts a word array to a UTF-16 LE string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The UTF-16 LE string. + * + * @static + * + * @example + * + * var utf16Str = CryptoJS.enc.Utf16LE.stringify(wordArray); + */ + stringify: function (wordArray) { + // Shortcuts + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + + // Convert + var utf16Chars = []; + for (var i = 0; i < sigBytes; i += 2) { + var codePoint = swapEndian((words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff); + utf16Chars.push(String.fromCharCode(codePoint)); + } + + return utf16Chars.join(''); + }, + + /** + * Converts a UTF-16 LE string to a word array. + * + * @param {string} utf16Str The UTF-16 LE string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Utf16LE.parse(utf16Str); + */ + parse: function (utf16Str) { + // Shortcut + var utf16StrLength = utf16Str.length; + + // Convert + var words = []; + for (var i = 0; i < utf16StrLength; i++) { + words[i >>> 1] |= swapEndian(utf16Str.charCodeAt(i) << (16 - (i % 2) * 16)); + } + + return WordArray.create(words, utf16StrLength * 2); + } + }; + + function swapEndian(word) { + return ((word << 8) & 0xff00ff00) | ((word >>> 8) & 0x00ff00ff); + } + }()); + + + return CryptoJS.enc.Utf16; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/enc-utf8.js b/node_modules/crypto-js/enc-utf8.js new file mode 100644 index 0000000..e7a251d --- /dev/null +++ b/node_modules/crypto-js/enc-utf8.js @@ -0,0 +1,18 @@ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + return CryptoJS.enc.Utf8; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/evpkdf.js b/node_modules/crypto-js/evpkdf.js new file mode 100644 index 0000000..578974a --- /dev/null +++ b/node_modules/crypto-js/evpkdf.js @@ -0,0 +1,134 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./sha1", "./hmac"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var Base = C_lib.Base; + var WordArray = C_lib.WordArray; + var C_algo = C.algo; + var MD5 = C_algo.MD5; + + /** + * This key derivation function is meant to conform with EVP_BytesToKey. + * www.openssl.org/docs/crypto/EVP_BytesToKey.html + */ + var EvpKDF = C_algo.EvpKDF = Base.extend({ + /** + * Configuration options. + * + * @property {number} keySize The key size in words to generate. Default: 4 (128 bits) + * @property {Hasher} hasher The hash algorithm to use. Default: MD5 + * @property {number} iterations The number of iterations to perform. Default: 1 + */ + cfg: Base.extend({ + keySize: 128/32, + hasher: MD5, + iterations: 1 + }), + + /** + * Initializes a newly created key derivation function. + * + * @param {Object} cfg (Optional) The configuration options to use for the derivation. + * + * @example + * + * var kdf = CryptoJS.algo.EvpKDF.create(); + * var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 }); + * var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 }); + */ + init: function (cfg) { + this.cfg = this.cfg.extend(cfg); + }, + + /** + * Derives a key from a password. + * + * @param {WordArray|string} password The password. + * @param {WordArray|string} salt A salt. + * + * @return {WordArray} The derived key. + * + * @example + * + * var key = kdf.compute(password, salt); + */ + compute: function (password, salt) { + var block; + + // Shortcut + var cfg = this.cfg; + + // Init hasher + var hasher = cfg.hasher.create(); + + // Initial values + var derivedKey = WordArray.create(); + + // Shortcuts + var derivedKeyWords = derivedKey.words; + var keySize = cfg.keySize; + var iterations = cfg.iterations; + + // Generate key + while (derivedKeyWords.length < keySize) { + if (block) { + hasher.update(block); + } + block = hasher.update(password).finalize(salt); + hasher.reset(); + + // Iterations + for (var i = 1; i < iterations; i++) { + block = hasher.finalize(block); + hasher.reset(); + } + + derivedKey.concat(block); + } + derivedKey.sigBytes = keySize * 4; + + return derivedKey; + } + }); + + /** + * Derives a key from a password. + * + * @param {WordArray|string} password The password. + * @param {WordArray|string} salt A salt. + * @param {Object} cfg (Optional) The configuration options to use for this computation. + * + * @return {WordArray} The derived key. + * + * @static + * + * @example + * + * var key = CryptoJS.EvpKDF(password, salt); + * var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 }); + * var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 }); + */ + C.EvpKDF = function (password, salt, cfg) { + return EvpKDF.create(cfg).compute(password, salt); + }; + }()); + + + return CryptoJS.EvpKDF; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/format-hex.js b/node_modules/crypto-js/format-hex.js new file mode 100644 index 0000000..2e9a861 --- /dev/null +++ b/node_modules/crypto-js/format-hex.js @@ -0,0 +1,66 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function (undefined) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var CipherParams = C_lib.CipherParams; + var C_enc = C.enc; + var Hex = C_enc.Hex; + var C_format = C.format; + + var HexFormatter = C_format.Hex = { + /** + * Converts the ciphertext of a cipher params object to a hexadecimally encoded string. + * + * @param {CipherParams} cipherParams The cipher params object. + * + * @return {string} The hexadecimally encoded string. + * + * @static + * + * @example + * + * var hexString = CryptoJS.format.Hex.stringify(cipherParams); + */ + stringify: function (cipherParams) { + return cipherParams.ciphertext.toString(Hex); + }, + + /** + * Converts a hexadecimally encoded ciphertext string to a cipher params object. + * + * @param {string} input The hexadecimally encoded string. + * + * @return {CipherParams} The cipher params object. + * + * @static + * + * @example + * + * var cipherParams = CryptoJS.format.Hex.parse(hexString); + */ + parse: function (input) { + var ciphertext = Hex.parse(input); + return CipherParams.create({ ciphertext: ciphertext }); + } + }; + }()); + + + return CryptoJS.format.Hex; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/format-openssl.js b/node_modules/crypto-js/format-openssl.js new file mode 100644 index 0000000..3373edc --- /dev/null +++ b/node_modules/crypto-js/format-openssl.js @@ -0,0 +1,18 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + return CryptoJS.format.OpenSSL; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/hmac-md5.js b/node_modules/crypto-js/hmac-md5.js new file mode 100644 index 0000000..ad7a90a --- /dev/null +++ b/node_modules/crypto-js/hmac-md5.js @@ -0,0 +1,18 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./md5"), require("./hmac")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./md5", "./hmac"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + return CryptoJS.HmacMD5; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/hmac-ripemd160.js b/node_modules/crypto-js/hmac-ripemd160.js new file mode 100644 index 0000000..73d55a7 --- /dev/null +++ b/node_modules/crypto-js/hmac-ripemd160.js @@ -0,0 +1,18 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./ripemd160"), require("./hmac")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./ripemd160", "./hmac"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + return CryptoJS.HmacRIPEMD160; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/hmac-sha1.js b/node_modules/crypto-js/hmac-sha1.js new file mode 100644 index 0000000..0b570cb --- /dev/null +++ b/node_modules/crypto-js/hmac-sha1.js @@ -0,0 +1,18 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./sha1", "./hmac"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + return CryptoJS.HmacSHA1; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/hmac-sha224.js b/node_modules/crypto-js/hmac-sha224.js new file mode 100644 index 0000000..3778863 --- /dev/null +++ b/node_modules/crypto-js/hmac-sha224.js @@ -0,0 +1,18 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./sha256"), require("./sha224"), require("./hmac")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./sha256", "./sha224", "./hmac"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + return CryptoJS.HmacSHA224; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/hmac-sha256.js b/node_modules/crypto-js/hmac-sha256.js new file mode 100644 index 0000000..33b0c9f --- /dev/null +++ b/node_modules/crypto-js/hmac-sha256.js @@ -0,0 +1,18 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./sha256"), require("./hmac")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./sha256", "./hmac"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + return CryptoJS.HmacSHA256; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/hmac-sha3.js b/node_modules/crypto-js/hmac-sha3.js new file mode 100644 index 0000000..1248804 --- /dev/null +++ b/node_modules/crypto-js/hmac-sha3.js @@ -0,0 +1,18 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./x64-core"), require("./sha3"), require("./hmac")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./x64-core", "./sha3", "./hmac"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + return CryptoJS.HmacSHA3; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/hmac-sha384.js b/node_modules/crypto-js/hmac-sha384.js new file mode 100644 index 0000000..0036e2b --- /dev/null +++ b/node_modules/crypto-js/hmac-sha384.js @@ -0,0 +1,18 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./x64-core"), require("./sha512"), require("./sha384"), require("./hmac")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./x64-core", "./sha512", "./sha384", "./hmac"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + return CryptoJS.HmacSHA384; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/hmac-sha512.js b/node_modules/crypto-js/hmac-sha512.js new file mode 100644 index 0000000..c1005b6 --- /dev/null +++ b/node_modules/crypto-js/hmac-sha512.js @@ -0,0 +1,18 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./x64-core"), require("./sha512"), require("./hmac")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./x64-core", "./sha512", "./hmac"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + return CryptoJS.HmacSHA512; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/hmac.js b/node_modules/crypto-js/hmac.js new file mode 100644 index 0000000..8c09851 --- /dev/null +++ b/node_modules/crypto-js/hmac.js @@ -0,0 +1,143 @@ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var Base = C_lib.Base; + var C_enc = C.enc; + var Utf8 = C_enc.Utf8; + var C_algo = C.algo; + + /** + * HMAC algorithm. + */ + var HMAC = C_algo.HMAC = Base.extend({ + /** + * Initializes a newly created HMAC. + * + * @param {Hasher} hasher The hash algorithm to use. + * @param {WordArray|string} key The secret key. + * + * @example + * + * var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key); + */ + init: function (hasher, key) { + // Init hasher + hasher = this._hasher = new hasher.init(); + + // Convert string to WordArray, else assume WordArray already + if (typeof key == 'string') { + key = Utf8.parse(key); + } + + // Shortcuts + var hasherBlockSize = hasher.blockSize; + var hasherBlockSizeBytes = hasherBlockSize * 4; + + // Allow arbitrary length keys + if (key.sigBytes > hasherBlockSizeBytes) { + key = hasher.finalize(key); + } + + // Clamp excess bits + key.clamp(); + + // Clone key for inner and outer pads + var oKey = this._oKey = key.clone(); + var iKey = this._iKey = key.clone(); + + // Shortcuts + var oKeyWords = oKey.words; + var iKeyWords = iKey.words; + + // XOR keys with pad constants + for (var i = 0; i < hasherBlockSize; i++) { + oKeyWords[i] ^= 0x5c5c5c5c; + iKeyWords[i] ^= 0x36363636; + } + oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes; + + // Set initial values + this.reset(); + }, + + /** + * Resets this HMAC to its initial state. + * + * @example + * + * hmacHasher.reset(); + */ + reset: function () { + // Shortcut + var hasher = this._hasher; + + // Reset + hasher.reset(); + hasher.update(this._iKey); + }, + + /** + * Updates this HMAC with a message. + * + * @param {WordArray|string} messageUpdate The message to append. + * + * @return {HMAC} This HMAC instance. + * + * @example + * + * hmacHasher.update('message'); + * hmacHasher.update(wordArray); + */ + update: function (messageUpdate) { + this._hasher.update(messageUpdate); + + // Chainable + return this; + }, + + /** + * Finalizes the HMAC computation. + * Note that the finalize operation is effectively a destructive, read-once operation. + * + * @param {WordArray|string} messageUpdate (Optional) A final message update. + * + * @return {WordArray} The HMAC. + * + * @example + * + * var hmac = hmacHasher.finalize(); + * var hmac = hmacHasher.finalize('message'); + * var hmac = hmacHasher.finalize(wordArray); + */ + finalize: function (messageUpdate) { + // Shortcut + var hasher = this._hasher; + + // Compute HMAC + var innerHash = hasher.finalize(messageUpdate); + hasher.reset(); + var hmac = hasher.finalize(this._oKey.clone().concat(innerHash)); + + return hmac; + } + }); + }()); + + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/index.js b/node_modules/crypto-js/index.js new file mode 100644 index 0000000..b696646 --- /dev/null +++ b/node_modules/crypto-js/index.js @@ -0,0 +1,18 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./x64-core"), require("./lib-typedarrays"), require("./enc-utf16"), require("./enc-base64"), require("./enc-base64url"), require("./md5"), require("./sha1"), require("./sha256"), require("./sha224"), require("./sha512"), require("./sha384"), require("./sha3"), require("./ripemd160"), require("./hmac"), require("./pbkdf2"), require("./evpkdf"), require("./cipher-core"), require("./mode-cfb"), require("./mode-ctr"), require("./mode-ctr-gladman"), require("./mode-ofb"), require("./mode-ecb"), require("./pad-ansix923"), require("./pad-iso10126"), require("./pad-iso97971"), require("./pad-zeropadding"), require("./pad-nopadding"), require("./format-hex"), require("./aes"), require("./tripledes"), require("./rc4"), require("./rabbit"), require("./rabbit-legacy"), require("./blowfish")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./x64-core", "./lib-typedarrays", "./enc-utf16", "./enc-base64", "./enc-base64url", "./md5", "./sha1", "./sha256", "./sha224", "./sha512", "./sha384", "./sha3", "./ripemd160", "./hmac", "./pbkdf2", "./evpkdf", "./cipher-core", "./mode-cfb", "./mode-ctr", "./mode-ctr-gladman", "./mode-ofb", "./mode-ecb", "./pad-ansix923", "./pad-iso10126", "./pad-iso97971", "./pad-zeropadding", "./pad-nopadding", "./format-hex", "./aes", "./tripledes", "./rc4", "./rabbit", "./rabbit-legacy", "./blowfish"], factory); + } + else { + // Global (browser) + root.CryptoJS = factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + return CryptoJS; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/lib-typedarrays.js b/node_modules/crypto-js/lib-typedarrays.js new file mode 100644 index 0000000..264b210 --- /dev/null +++ b/node_modules/crypto-js/lib-typedarrays.js @@ -0,0 +1,76 @@ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Check if typed arrays are supported + if (typeof ArrayBuffer != 'function') { + return; + } + + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + + // Reference original init + var superInit = WordArray.init; + + // Augment WordArray.init to handle typed arrays + var subInit = WordArray.init = function (typedArray) { + // Convert buffers to uint8 + if (typedArray instanceof ArrayBuffer) { + typedArray = new Uint8Array(typedArray); + } + + // Convert other array views to uint8 + if ( + typedArray instanceof Int8Array || + (typeof Uint8ClampedArray !== "undefined" && typedArray instanceof Uint8ClampedArray) || + typedArray instanceof Int16Array || + typedArray instanceof Uint16Array || + typedArray instanceof Int32Array || + typedArray instanceof Uint32Array || + typedArray instanceof Float32Array || + typedArray instanceof Float64Array + ) { + typedArray = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength); + } + + // Handle Uint8Array + if (typedArray instanceof Uint8Array) { + // Shortcut + var typedArrayByteLength = typedArray.byteLength; + + // Extract bytes + var words = []; + for (var i = 0; i < typedArrayByteLength; i++) { + words[i >>> 2] |= typedArray[i] << (24 - (i % 4) * 8); + } + + // Initialize this word array + superInit.call(this, words, typedArrayByteLength); + } else { + // Else call normal init + superInit.apply(this, arguments); + } + }; + + subInit.prototype = WordArray; + }()); + + + return CryptoJS.lib.WordArray; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/md5.js b/node_modules/crypto-js/md5.js new file mode 100644 index 0000000..72fce03 --- /dev/null +++ b/node_modules/crypto-js/md5.js @@ -0,0 +1,268 @@ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function (Math) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var Hasher = C_lib.Hasher; + var C_algo = C.algo; + + // Constants table + var T = []; + + // Compute constants + (function () { + for (var i = 0; i < 64; i++) { + T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0; + } + }()); + + /** + * MD5 hash algorithm. + */ + var MD5 = C_algo.MD5 = Hasher.extend({ + _doReset: function () { + this._hash = new WordArray.init([ + 0x67452301, 0xefcdab89, + 0x98badcfe, 0x10325476 + ]); + }, + + _doProcessBlock: function (M, offset) { + // Swap endian + for (var i = 0; i < 16; i++) { + // Shortcuts + var offset_i = offset + i; + var M_offset_i = M[offset_i]; + + M[offset_i] = ( + (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) | + (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00) + ); + } + + // Shortcuts + var H = this._hash.words; + + var M_offset_0 = M[offset + 0]; + var M_offset_1 = M[offset + 1]; + var M_offset_2 = M[offset + 2]; + var M_offset_3 = M[offset + 3]; + var M_offset_4 = M[offset + 4]; + var M_offset_5 = M[offset + 5]; + var M_offset_6 = M[offset + 6]; + var M_offset_7 = M[offset + 7]; + var M_offset_8 = M[offset + 8]; + var M_offset_9 = M[offset + 9]; + var M_offset_10 = M[offset + 10]; + var M_offset_11 = M[offset + 11]; + var M_offset_12 = M[offset + 12]; + var M_offset_13 = M[offset + 13]; + var M_offset_14 = M[offset + 14]; + var M_offset_15 = M[offset + 15]; + + // Working variables + var a = H[0]; + var b = H[1]; + var c = H[2]; + var d = H[3]; + + // Computation + a = FF(a, b, c, d, M_offset_0, 7, T[0]); + d = FF(d, a, b, c, M_offset_1, 12, T[1]); + c = FF(c, d, a, b, M_offset_2, 17, T[2]); + b = FF(b, c, d, a, M_offset_3, 22, T[3]); + a = FF(a, b, c, d, M_offset_4, 7, T[4]); + d = FF(d, a, b, c, M_offset_5, 12, T[5]); + c = FF(c, d, a, b, M_offset_6, 17, T[6]); + b = FF(b, c, d, a, M_offset_7, 22, T[7]); + a = FF(a, b, c, d, M_offset_8, 7, T[8]); + d = FF(d, a, b, c, M_offset_9, 12, T[9]); + c = FF(c, d, a, b, M_offset_10, 17, T[10]); + b = FF(b, c, d, a, M_offset_11, 22, T[11]); + a = FF(a, b, c, d, M_offset_12, 7, T[12]); + d = FF(d, a, b, c, M_offset_13, 12, T[13]); + c = FF(c, d, a, b, M_offset_14, 17, T[14]); + b = FF(b, c, d, a, M_offset_15, 22, T[15]); + + a = GG(a, b, c, d, M_offset_1, 5, T[16]); + d = GG(d, a, b, c, M_offset_6, 9, T[17]); + c = GG(c, d, a, b, M_offset_11, 14, T[18]); + b = GG(b, c, d, a, M_offset_0, 20, T[19]); + a = GG(a, b, c, d, M_offset_5, 5, T[20]); + d = GG(d, a, b, c, M_offset_10, 9, T[21]); + c = GG(c, d, a, b, M_offset_15, 14, T[22]); + b = GG(b, c, d, a, M_offset_4, 20, T[23]); + a = GG(a, b, c, d, M_offset_9, 5, T[24]); + d = GG(d, a, b, c, M_offset_14, 9, T[25]); + c = GG(c, d, a, b, M_offset_3, 14, T[26]); + b = GG(b, c, d, a, M_offset_8, 20, T[27]); + a = GG(a, b, c, d, M_offset_13, 5, T[28]); + d = GG(d, a, b, c, M_offset_2, 9, T[29]); + c = GG(c, d, a, b, M_offset_7, 14, T[30]); + b = GG(b, c, d, a, M_offset_12, 20, T[31]); + + a = HH(a, b, c, d, M_offset_5, 4, T[32]); + d = HH(d, a, b, c, M_offset_8, 11, T[33]); + c = HH(c, d, a, b, M_offset_11, 16, T[34]); + b = HH(b, c, d, a, M_offset_14, 23, T[35]); + a = HH(a, b, c, d, M_offset_1, 4, T[36]); + d = HH(d, a, b, c, M_offset_4, 11, T[37]); + c = HH(c, d, a, b, M_offset_7, 16, T[38]); + b = HH(b, c, d, a, M_offset_10, 23, T[39]); + a = HH(a, b, c, d, M_offset_13, 4, T[40]); + d = HH(d, a, b, c, M_offset_0, 11, T[41]); + c = HH(c, d, a, b, M_offset_3, 16, T[42]); + b = HH(b, c, d, a, M_offset_6, 23, T[43]); + a = HH(a, b, c, d, M_offset_9, 4, T[44]); + d = HH(d, a, b, c, M_offset_12, 11, T[45]); + c = HH(c, d, a, b, M_offset_15, 16, T[46]); + b = HH(b, c, d, a, M_offset_2, 23, T[47]); + + a = II(a, b, c, d, M_offset_0, 6, T[48]); + d = II(d, a, b, c, M_offset_7, 10, T[49]); + c = II(c, d, a, b, M_offset_14, 15, T[50]); + b = II(b, c, d, a, M_offset_5, 21, T[51]); + a = II(a, b, c, d, M_offset_12, 6, T[52]); + d = II(d, a, b, c, M_offset_3, 10, T[53]); + c = II(c, d, a, b, M_offset_10, 15, T[54]); + b = II(b, c, d, a, M_offset_1, 21, T[55]); + a = II(a, b, c, d, M_offset_8, 6, T[56]); + d = II(d, a, b, c, M_offset_15, 10, T[57]); + c = II(c, d, a, b, M_offset_6, 15, T[58]); + b = II(b, c, d, a, M_offset_13, 21, T[59]); + a = II(a, b, c, d, M_offset_4, 6, T[60]); + d = II(d, a, b, c, M_offset_11, 10, T[61]); + c = II(c, d, a, b, M_offset_2, 15, T[62]); + b = II(b, c, d, a, M_offset_9, 21, T[63]); + + // Intermediate hash value + H[0] = (H[0] + a) | 0; + H[1] = (H[1] + b) | 0; + H[2] = (H[2] + c) | 0; + H[3] = (H[3] + d) | 0; + }, + + _doFinalize: function () { + // Shortcuts + var data = this._data; + var dataWords = data.words; + + var nBitsTotal = this._nDataBytes * 8; + var nBitsLeft = data.sigBytes * 8; + + // Add padding + dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); + + var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000); + var nBitsTotalL = nBitsTotal; + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = ( + (((nBitsTotalH << 8) | (nBitsTotalH >>> 24)) & 0x00ff00ff) | + (((nBitsTotalH << 24) | (nBitsTotalH >>> 8)) & 0xff00ff00) + ); + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = ( + (((nBitsTotalL << 8) | (nBitsTotalL >>> 24)) & 0x00ff00ff) | + (((nBitsTotalL << 24) | (nBitsTotalL >>> 8)) & 0xff00ff00) + ); + + data.sigBytes = (dataWords.length + 1) * 4; + + // Hash final blocks + this._process(); + + // Shortcuts + var hash = this._hash; + var H = hash.words; + + // Swap endian + for (var i = 0; i < 4; i++) { + // Shortcut + var H_i = H[i]; + + H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) | + (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00); + } + + // Return final computed hash + return hash; + }, + + clone: function () { + var clone = Hasher.clone.call(this); + clone._hash = this._hash.clone(); + + return clone; + } + }); + + function FF(a, b, c, d, x, s, t) { + var n = a + ((b & c) | (~b & d)) + x + t; + return ((n << s) | (n >>> (32 - s))) + b; + } + + function GG(a, b, c, d, x, s, t) { + var n = a + ((b & d) | (c & ~d)) + x + t; + return ((n << s) | (n >>> (32 - s))) + b; + } + + function HH(a, b, c, d, x, s, t) { + var n = a + (b ^ c ^ d) + x + t; + return ((n << s) | (n >>> (32 - s))) + b; + } + + function II(a, b, c, d, x, s, t) { + var n = a + (c ^ (b | ~d)) + x + t; + return ((n << s) | (n >>> (32 - s))) + b; + } + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.MD5('message'); + * var hash = CryptoJS.MD5(wordArray); + */ + C.MD5 = Hasher._createHelper(MD5); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacMD5(message, key); + */ + C.HmacMD5 = Hasher._createHmacHelper(MD5); + }(Math)); + + + return CryptoJS.MD5; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/mode-cfb.js b/node_modules/crypto-js/mode-cfb.js new file mode 100644 index 0000000..444c9cb --- /dev/null +++ b/node_modules/crypto-js/mode-cfb.js @@ -0,0 +1,80 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + /** + * Cipher Feedback block mode. + */ + CryptoJS.mode.CFB = (function () { + var CFB = CryptoJS.lib.BlockCipherMode.extend(); + + CFB.Encryptor = CFB.extend({ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher; + var blockSize = cipher.blockSize; + + generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher); + + // Remember this block to use with next block + this._prevBlock = words.slice(offset, offset + blockSize); + } + }); + + CFB.Decryptor = CFB.extend({ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher; + var blockSize = cipher.blockSize; + + // Remember this block to use with next block + var thisBlock = words.slice(offset, offset + blockSize); + + generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher); + + // This block becomes the previous block + this._prevBlock = thisBlock; + } + }); + + function generateKeystreamAndEncrypt(words, offset, blockSize, cipher) { + var keystream; + + // Shortcut + var iv = this._iv; + + // Generate keystream + if (iv) { + keystream = iv.slice(0); + + // Remove IV for subsequent blocks + this._iv = undefined; + } else { + keystream = this._prevBlock; + } + cipher.encryptBlock(keystream, 0); + + // Encrypt + for (var i = 0; i < blockSize; i++) { + words[offset + i] ^= keystream[i]; + } + } + + return CFB; + }()); + + + return CryptoJS.mode.CFB; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/mode-ctr-gladman.js b/node_modules/crypto-js/mode-ctr-gladman.js new file mode 100644 index 0000000..bbc5687 --- /dev/null +++ b/node_modules/crypto-js/mode-ctr-gladman.js @@ -0,0 +1,116 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + /** @preserve + * Counter block mode compatible with Dr Brian Gladman fileenc.c + * derived from CryptoJS.mode.CTR + * Jan Hruby jhruby.web@gmail.com + */ + CryptoJS.mode.CTRGladman = (function () { + var CTRGladman = CryptoJS.lib.BlockCipherMode.extend(); + + function incWord(word) + { + if (((word >> 24) & 0xff) === 0xff) { //overflow + var b1 = (word >> 16)&0xff; + var b2 = (word >> 8)&0xff; + var b3 = word & 0xff; + + if (b1 === 0xff) // overflow b1 + { + b1 = 0; + if (b2 === 0xff) + { + b2 = 0; + if (b3 === 0xff) + { + b3 = 0; + } + else + { + ++b3; + } + } + else + { + ++b2; + } + } + else + { + ++b1; + } + + word = 0; + word += (b1 << 16); + word += (b2 << 8); + word += b3; + } + else + { + word += (0x01 << 24); + } + return word; + } + + function incCounter(counter) + { + if ((counter[0] = incWord(counter[0])) === 0) + { + // encr_data in fileenc.c from Dr Brian Gladman's counts only with DWORD j < 8 + counter[1] = incWord(counter[1]); + } + return counter; + } + + var Encryptor = CTRGladman.Encryptor = CTRGladman.extend({ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher + var blockSize = cipher.blockSize; + var iv = this._iv; + var counter = this._counter; + + // Generate keystream + if (iv) { + counter = this._counter = iv.slice(0); + + // Remove IV for subsequent blocks + this._iv = undefined; + } + + incCounter(counter); + + var keystream = counter.slice(0); + cipher.encryptBlock(keystream, 0); + + // Encrypt + for (var i = 0; i < blockSize; i++) { + words[offset + i] ^= keystream[i]; + } + } + }); + + CTRGladman.Decryptor = Encryptor; + + return CTRGladman; + }()); + + + + + return CryptoJS.mode.CTRGladman; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/mode-ctr.js b/node_modules/crypto-js/mode-ctr.js new file mode 100644 index 0000000..c3d470a --- /dev/null +++ b/node_modules/crypto-js/mode-ctr.js @@ -0,0 +1,58 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + /** + * Counter block mode. + */ + CryptoJS.mode.CTR = (function () { + var CTR = CryptoJS.lib.BlockCipherMode.extend(); + + var Encryptor = CTR.Encryptor = CTR.extend({ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher + var blockSize = cipher.blockSize; + var iv = this._iv; + var counter = this._counter; + + // Generate keystream + if (iv) { + counter = this._counter = iv.slice(0); + + // Remove IV for subsequent blocks + this._iv = undefined; + } + var keystream = counter.slice(0); + cipher.encryptBlock(keystream, 0); + + // Increment counter + counter[blockSize - 1] = (counter[blockSize - 1] + 1) | 0 + + // Encrypt + for (var i = 0; i < blockSize; i++) { + words[offset + i] ^= keystream[i]; + } + } + }); + + CTR.Decryptor = Encryptor; + + return CTR; + }()); + + + return CryptoJS.mode.CTR; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/mode-ecb.js b/node_modules/crypto-js/mode-ecb.js new file mode 100644 index 0000000..ff06921 --- /dev/null +++ b/node_modules/crypto-js/mode-ecb.js @@ -0,0 +1,40 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + /** + * Electronic Codebook block mode. + */ + CryptoJS.mode.ECB = (function () { + var ECB = CryptoJS.lib.BlockCipherMode.extend(); + + ECB.Encryptor = ECB.extend({ + processBlock: function (words, offset) { + this._cipher.encryptBlock(words, offset); + } + }); + + ECB.Decryptor = ECB.extend({ + processBlock: function (words, offset) { + this._cipher.decryptBlock(words, offset); + } + }); + + return ECB; + }()); + + + return CryptoJS.mode.ECB; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/mode-ofb.js b/node_modules/crypto-js/mode-ofb.js new file mode 100644 index 0000000..c01314c --- /dev/null +++ b/node_modules/crypto-js/mode-ofb.js @@ -0,0 +1,54 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + /** + * Output Feedback block mode. + */ + CryptoJS.mode.OFB = (function () { + var OFB = CryptoJS.lib.BlockCipherMode.extend(); + + var Encryptor = OFB.Encryptor = OFB.extend({ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher + var blockSize = cipher.blockSize; + var iv = this._iv; + var keystream = this._keystream; + + // Generate keystream + if (iv) { + keystream = this._keystream = iv.slice(0); + + // Remove IV for subsequent blocks + this._iv = undefined; + } + cipher.encryptBlock(keystream, 0); + + // Encrypt + for (var i = 0; i < blockSize; i++) { + words[offset + i] ^= keystream[i]; + } + } + }); + + OFB.Decryptor = Encryptor; + + return OFB; + }()); + + + return CryptoJS.mode.OFB; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/package.json b/node_modules/crypto-js/package.json new file mode 100644 index 0000000..4b9a8e2 --- /dev/null +++ b/node_modules/crypto-js/package.json @@ -0,0 +1,42 @@ +{ + "name": "crypto-js", + "version": "4.2.0", + "description": "JavaScript library of crypto standards.", + "license": "MIT", + "author": { + "name": "Evan Vosberg", + "url": "http://github.com/evanvosberg" + }, + "homepage": "http://github.com/brix/crypto-js", + "repository": { + "type": "git", + "url": "http://github.com/brix/crypto-js.git" + }, + "keywords": [ + "security", + "crypto", + "Hash", + "MD5", + "SHA1", + "SHA-1", + "SHA256", + "SHA-256", + "RC4", + "Rabbit", + "AES", + "DES", + "PBKDF2", + "HMAC", + "OFB", + "CFB", + "CTR", + "CBC", + "Base64", + "Base64url" + ], + "main": "index.js", + "dependencies": {}, + "browser": { + "crypto": false + } +} diff --git a/node_modules/crypto-js/pad-ansix923.js b/node_modules/crypto-js/pad-ansix923.js new file mode 100644 index 0000000..f01f21e --- /dev/null +++ b/node_modules/crypto-js/pad-ansix923.js @@ -0,0 +1,49 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + /** + * ANSI X.923 padding strategy. + */ + CryptoJS.pad.AnsiX923 = { + pad: function (data, blockSize) { + // Shortcuts + var dataSigBytes = data.sigBytes; + var blockSizeBytes = blockSize * 4; + + // Count padding bytes + var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes; + + // Compute last byte position + var lastBytePos = dataSigBytes + nPaddingBytes - 1; + + // Pad + data.clamp(); + data.words[lastBytePos >>> 2] |= nPaddingBytes << (24 - (lastBytePos % 4) * 8); + data.sigBytes += nPaddingBytes; + }, + + unpad: function (data) { + // Get number of padding bytes from last byte + var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff; + + // Remove padding + data.sigBytes -= nPaddingBytes; + } + }; + + + return CryptoJS.pad.Ansix923; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/pad-iso10126.js b/node_modules/crypto-js/pad-iso10126.js new file mode 100644 index 0000000..6e2aefd --- /dev/null +++ b/node_modules/crypto-js/pad-iso10126.js @@ -0,0 +1,44 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + /** + * ISO 10126 padding strategy. + */ + CryptoJS.pad.Iso10126 = { + pad: function (data, blockSize) { + // Shortcut + var blockSizeBytes = blockSize * 4; + + // Count padding bytes + var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes; + + // Pad + data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes - 1)). + concat(CryptoJS.lib.WordArray.create([nPaddingBytes << 24], 1)); + }, + + unpad: function (data) { + // Get number of padding bytes from last byte + var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff; + + // Remove padding + data.sigBytes -= nPaddingBytes; + } + }; + + + return CryptoJS.pad.Iso10126; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/pad-iso97971.js b/node_modules/crypto-js/pad-iso97971.js new file mode 100644 index 0000000..41049b4 --- /dev/null +++ b/node_modules/crypto-js/pad-iso97971.js @@ -0,0 +1,40 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + /** + * ISO/IEC 9797-1 Padding Method 2. + */ + CryptoJS.pad.Iso97971 = { + pad: function (data, blockSize) { + // Add 0x80 byte + data.concat(CryptoJS.lib.WordArray.create([0x80000000], 1)); + + // Zero pad the rest + CryptoJS.pad.ZeroPadding.pad(data, blockSize); + }, + + unpad: function (data) { + // Remove zero padding + CryptoJS.pad.ZeroPadding.unpad(data); + + // Remove one more byte -- the 0x80 byte + data.sigBytes--; + } + }; + + + return CryptoJS.pad.Iso97971; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/pad-nopadding.js b/node_modules/crypto-js/pad-nopadding.js new file mode 100644 index 0000000..c7787c9 --- /dev/null +++ b/node_modules/crypto-js/pad-nopadding.js @@ -0,0 +1,30 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + /** + * A noop padding strategy. + */ + CryptoJS.pad.NoPadding = { + pad: function () { + }, + + unpad: function () { + } + }; + + + return CryptoJS.pad.NoPadding; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/pad-pkcs7.js b/node_modules/crypto-js/pad-pkcs7.js new file mode 100644 index 0000000..3555168 --- /dev/null +++ b/node_modules/crypto-js/pad-pkcs7.js @@ -0,0 +1,18 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + return CryptoJS.pad.Pkcs7; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/pad-zeropadding.js b/node_modules/crypto-js/pad-zeropadding.js new file mode 100644 index 0000000..a1a459e --- /dev/null +++ b/node_modules/crypto-js/pad-zeropadding.js @@ -0,0 +1,47 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + /** + * Zero padding strategy. + */ + CryptoJS.pad.ZeroPadding = { + pad: function (data, blockSize) { + // Shortcut + var blockSizeBytes = blockSize * 4; + + // Pad + data.clamp(); + data.sigBytes += blockSizeBytes - ((data.sigBytes % blockSizeBytes) || blockSizeBytes); + }, + + unpad: function (data) { + // Shortcut + var dataWords = data.words; + + // Unpad + var i = data.sigBytes - 1; + for (var i = data.sigBytes - 1; i >= 0; i--) { + if (((dataWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff)) { + data.sigBytes = i + 1; + break; + } + } + } + }; + + + return CryptoJS.pad.ZeroPadding; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/pbkdf2.js b/node_modules/crypto-js/pbkdf2.js new file mode 100644 index 0000000..6850934 --- /dev/null +++ b/node_modules/crypto-js/pbkdf2.js @@ -0,0 +1,145 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./sha256"), require("./hmac")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./sha256", "./hmac"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var Base = C_lib.Base; + var WordArray = C_lib.WordArray; + var C_algo = C.algo; + var SHA256 = C_algo.SHA256; + var HMAC = C_algo.HMAC; + + /** + * Password-Based Key Derivation Function 2 algorithm. + */ + var PBKDF2 = C_algo.PBKDF2 = Base.extend({ + /** + * Configuration options. + * + * @property {number} keySize The key size in words to generate. Default: 4 (128 bits) + * @property {Hasher} hasher The hasher to use. Default: SHA256 + * @property {number} iterations The number of iterations to perform. Default: 250000 + */ + cfg: Base.extend({ + keySize: 128/32, + hasher: SHA256, + iterations: 250000 + }), + + /** + * Initializes a newly created key derivation function. + * + * @param {Object} cfg (Optional) The configuration options to use for the derivation. + * + * @example + * + * var kdf = CryptoJS.algo.PBKDF2.create(); + * var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8 }); + * var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8, iterations: 1000 }); + */ + init: function (cfg) { + this.cfg = this.cfg.extend(cfg); + }, + + /** + * Computes the Password-Based Key Derivation Function 2. + * + * @param {WordArray|string} password The password. + * @param {WordArray|string} salt A salt. + * + * @return {WordArray} The derived key. + * + * @example + * + * var key = kdf.compute(password, salt); + */ + compute: function (password, salt) { + // Shortcut + var cfg = this.cfg; + + // Init HMAC + var hmac = HMAC.create(cfg.hasher, password); + + // Initial values + var derivedKey = WordArray.create(); + var blockIndex = WordArray.create([0x00000001]); + + // Shortcuts + var derivedKeyWords = derivedKey.words; + var blockIndexWords = blockIndex.words; + var keySize = cfg.keySize; + var iterations = cfg.iterations; + + // Generate key + while (derivedKeyWords.length < keySize) { + var block = hmac.update(salt).finalize(blockIndex); + hmac.reset(); + + // Shortcuts + var blockWords = block.words; + var blockWordsLength = blockWords.length; + + // Iterations + var intermediate = block; + for (var i = 1; i < iterations; i++) { + intermediate = hmac.finalize(intermediate); + hmac.reset(); + + // Shortcut + var intermediateWords = intermediate.words; + + // XOR intermediate with block + for (var j = 0; j < blockWordsLength; j++) { + blockWords[j] ^= intermediateWords[j]; + } + } + + derivedKey.concat(block); + blockIndexWords[0]++; + } + derivedKey.sigBytes = keySize * 4; + + return derivedKey; + } + }); + + /** + * Computes the Password-Based Key Derivation Function 2. + * + * @param {WordArray|string} password The password. + * @param {WordArray|string} salt A salt. + * @param {Object} cfg (Optional) The configuration options to use for this computation. + * + * @return {WordArray} The derived key. + * + * @static + * + * @example + * + * var key = CryptoJS.PBKDF2(password, salt); + * var key = CryptoJS.PBKDF2(password, salt, { keySize: 8 }); + * var key = CryptoJS.PBKDF2(password, salt, { keySize: 8, iterations: 1000 }); + */ + C.PBKDF2 = function (password, salt, cfg) { + return PBKDF2.create(cfg).compute(password, salt); + }; + }()); + + + return CryptoJS.PBKDF2; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/rabbit-legacy.js b/node_modules/crypto-js/rabbit-legacy.js new file mode 100644 index 0000000..e118b6b --- /dev/null +++ b/node_modules/crypto-js/rabbit-legacy.js @@ -0,0 +1,190 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var StreamCipher = C_lib.StreamCipher; + var C_algo = C.algo; + + // Reusable objects + var S = []; + var C_ = []; + var G = []; + + /** + * Rabbit stream cipher algorithm. + * + * This is a legacy version that neglected to convert the key to little-endian. + * This error doesn't affect the cipher's security, + * but it does affect its compatibility with other implementations. + */ + var RabbitLegacy = C_algo.RabbitLegacy = StreamCipher.extend({ + _doReset: function () { + // Shortcuts + var K = this._key.words; + var iv = this.cfg.iv; + + // Generate initial state values + var X = this._X = [ + K[0], (K[3] << 16) | (K[2] >>> 16), + K[1], (K[0] << 16) | (K[3] >>> 16), + K[2], (K[1] << 16) | (K[0] >>> 16), + K[3], (K[2] << 16) | (K[1] >>> 16) + ]; + + // Generate initial counter values + var C = this._C = [ + (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff), + (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff), + (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff), + (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff) + ]; + + // Carry bit + this._b = 0; + + // Iterate the system four times + for (var i = 0; i < 4; i++) { + nextState.call(this); + } + + // Modify the counters + for (var i = 0; i < 8; i++) { + C[i] ^= X[(i + 4) & 7]; + } + + // IV setup + if (iv) { + // Shortcuts + var IV = iv.words; + var IV_0 = IV[0]; + var IV_1 = IV[1]; + + // Generate four subvectors + var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00); + var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00); + var i1 = (i0 >>> 16) | (i2 & 0xffff0000); + var i3 = (i2 << 16) | (i0 & 0x0000ffff); + + // Modify counter values + C[0] ^= i0; + C[1] ^= i1; + C[2] ^= i2; + C[3] ^= i3; + C[4] ^= i0; + C[5] ^= i1; + C[6] ^= i2; + C[7] ^= i3; + + // Iterate the system four times + for (var i = 0; i < 4; i++) { + nextState.call(this); + } + } + }, + + _doProcessBlock: function (M, offset) { + // Shortcut + var X = this._X; + + // Iterate the system + nextState.call(this); + + // Generate four keystream words + S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16); + S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16); + S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16); + S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16); + + for (var i = 0; i < 4; i++) { + // Swap endian + S[i] = (((S[i] << 8) | (S[i] >>> 24)) & 0x00ff00ff) | + (((S[i] << 24) | (S[i] >>> 8)) & 0xff00ff00); + + // Encrypt + M[offset + i] ^= S[i]; + } + }, + + blockSize: 128/32, + + ivSize: 64/32 + }); + + function nextState() { + // Shortcuts + var X = this._X; + var C = this._C; + + // Save old counter values + for (var i = 0; i < 8; i++) { + C_[i] = C[i]; + } + + // Calculate new counter values + C[0] = (C[0] + 0x4d34d34d + this._b) | 0; + C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0; + C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0; + C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0; + C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0; + C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0; + C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0; + C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0; + this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0; + + // Calculate the g-values + for (var i = 0; i < 8; i++) { + var gx = X[i] + C[i]; + + // Construct high and low argument for squaring + var ga = gx & 0xffff; + var gb = gx >>> 16; + + // Calculate high and low result of squaring + var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb; + var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0); + + // High XOR low + G[i] = gh ^ gl; + } + + // Calculate new state values + X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0; + X[1] = (G[1] + ((G[0] << 8) | (G[0] >>> 24)) + G[7]) | 0; + X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0; + X[3] = (G[3] + ((G[2] << 8) | (G[2] >>> 24)) + G[1]) | 0; + X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0; + X[5] = (G[5] + ((G[4] << 8) | (G[4] >>> 24)) + G[3]) | 0; + X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0; + X[7] = (G[7] + ((G[6] << 8) | (G[6] >>> 24)) + G[5]) | 0; + } + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.RabbitLegacy.encrypt(message, key, cfg); + * var plaintext = CryptoJS.RabbitLegacy.decrypt(ciphertext, key, cfg); + */ + C.RabbitLegacy = StreamCipher._createHelper(RabbitLegacy); + }()); + + + return CryptoJS.RabbitLegacy; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/rabbit.js b/node_modules/crypto-js/rabbit.js new file mode 100644 index 0000000..1b06833 --- /dev/null +++ b/node_modules/crypto-js/rabbit.js @@ -0,0 +1,192 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var StreamCipher = C_lib.StreamCipher; + var C_algo = C.algo; + + // Reusable objects + var S = []; + var C_ = []; + var G = []; + + /** + * Rabbit stream cipher algorithm + */ + var Rabbit = C_algo.Rabbit = StreamCipher.extend({ + _doReset: function () { + // Shortcuts + var K = this._key.words; + var iv = this.cfg.iv; + + // Swap endian + for (var i = 0; i < 4; i++) { + K[i] = (((K[i] << 8) | (K[i] >>> 24)) & 0x00ff00ff) | + (((K[i] << 24) | (K[i] >>> 8)) & 0xff00ff00); + } + + // Generate initial state values + var X = this._X = [ + K[0], (K[3] << 16) | (K[2] >>> 16), + K[1], (K[0] << 16) | (K[3] >>> 16), + K[2], (K[1] << 16) | (K[0] >>> 16), + K[3], (K[2] << 16) | (K[1] >>> 16) + ]; + + // Generate initial counter values + var C = this._C = [ + (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff), + (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff), + (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff), + (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff) + ]; + + // Carry bit + this._b = 0; + + // Iterate the system four times + for (var i = 0; i < 4; i++) { + nextState.call(this); + } + + // Modify the counters + for (var i = 0; i < 8; i++) { + C[i] ^= X[(i + 4) & 7]; + } + + // IV setup + if (iv) { + // Shortcuts + var IV = iv.words; + var IV_0 = IV[0]; + var IV_1 = IV[1]; + + // Generate four subvectors + var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00); + var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00); + var i1 = (i0 >>> 16) | (i2 & 0xffff0000); + var i3 = (i2 << 16) | (i0 & 0x0000ffff); + + // Modify counter values + C[0] ^= i0; + C[1] ^= i1; + C[2] ^= i2; + C[3] ^= i3; + C[4] ^= i0; + C[5] ^= i1; + C[6] ^= i2; + C[7] ^= i3; + + // Iterate the system four times + for (var i = 0; i < 4; i++) { + nextState.call(this); + } + } + }, + + _doProcessBlock: function (M, offset) { + // Shortcut + var X = this._X; + + // Iterate the system + nextState.call(this); + + // Generate four keystream words + S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16); + S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16); + S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16); + S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16); + + for (var i = 0; i < 4; i++) { + // Swap endian + S[i] = (((S[i] << 8) | (S[i] >>> 24)) & 0x00ff00ff) | + (((S[i] << 24) | (S[i] >>> 8)) & 0xff00ff00); + + // Encrypt + M[offset + i] ^= S[i]; + } + }, + + blockSize: 128/32, + + ivSize: 64/32 + }); + + function nextState() { + // Shortcuts + var X = this._X; + var C = this._C; + + // Save old counter values + for (var i = 0; i < 8; i++) { + C_[i] = C[i]; + } + + // Calculate new counter values + C[0] = (C[0] + 0x4d34d34d + this._b) | 0; + C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0; + C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0; + C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0; + C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0; + C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0; + C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0; + C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0; + this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0; + + // Calculate the g-values + for (var i = 0; i < 8; i++) { + var gx = X[i] + C[i]; + + // Construct high and low argument for squaring + var ga = gx & 0xffff; + var gb = gx >>> 16; + + // Calculate high and low result of squaring + var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb; + var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0); + + // High XOR low + G[i] = gh ^ gl; + } + + // Calculate new state values + X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0; + X[1] = (G[1] + ((G[0] << 8) | (G[0] >>> 24)) + G[7]) | 0; + X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0; + X[3] = (G[3] + ((G[2] << 8) | (G[2] >>> 24)) + G[1]) | 0; + X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0; + X[5] = (G[5] + ((G[4] << 8) | (G[4] >>> 24)) + G[3]) | 0; + X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0; + X[7] = (G[7] + ((G[6] << 8) | (G[6] >>> 24)) + G[5]) | 0; + } + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.Rabbit.encrypt(message, key, cfg); + * var plaintext = CryptoJS.Rabbit.decrypt(ciphertext, key, cfg); + */ + C.Rabbit = StreamCipher._createHelper(Rabbit); + }()); + + + return CryptoJS.Rabbit; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/rc4.js b/node_modules/crypto-js/rc4.js new file mode 100644 index 0000000..0e4bdff --- /dev/null +++ b/node_modules/crypto-js/rc4.js @@ -0,0 +1,139 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var StreamCipher = C_lib.StreamCipher; + var C_algo = C.algo; + + /** + * RC4 stream cipher algorithm. + */ + var RC4 = C_algo.RC4 = StreamCipher.extend({ + _doReset: function () { + // Shortcuts + var key = this._key; + var keyWords = key.words; + var keySigBytes = key.sigBytes; + + // Init sbox + var S = this._S = []; + for (var i = 0; i < 256; i++) { + S[i] = i; + } + + // Key setup + for (var i = 0, j = 0; i < 256; i++) { + var keyByteIndex = i % keySigBytes; + var keyByte = (keyWords[keyByteIndex >>> 2] >>> (24 - (keyByteIndex % 4) * 8)) & 0xff; + + j = (j + S[i] + keyByte) % 256; + + // Swap + var t = S[i]; + S[i] = S[j]; + S[j] = t; + } + + // Counters + this._i = this._j = 0; + }, + + _doProcessBlock: function (M, offset) { + M[offset] ^= generateKeystreamWord.call(this); + }, + + keySize: 256/32, + + ivSize: 0 + }); + + function generateKeystreamWord() { + // Shortcuts + var S = this._S; + var i = this._i; + var j = this._j; + + // Generate keystream word + var keystreamWord = 0; + for (var n = 0; n < 4; n++) { + i = (i + 1) % 256; + j = (j + S[i]) % 256; + + // Swap + var t = S[i]; + S[i] = S[j]; + S[j] = t; + + keystreamWord |= S[(S[i] + S[j]) % 256] << (24 - n * 8); + } + + // Update counters + this._i = i; + this._j = j; + + return keystreamWord; + } + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.RC4.encrypt(message, key, cfg); + * var plaintext = CryptoJS.RC4.decrypt(ciphertext, key, cfg); + */ + C.RC4 = StreamCipher._createHelper(RC4); + + /** + * Modified RC4 stream cipher algorithm. + */ + var RC4Drop = C_algo.RC4Drop = RC4.extend({ + /** + * Configuration options. + * + * @property {number} drop The number of keystream words to drop. Default 192 + */ + cfg: RC4.cfg.extend({ + drop: 192 + }), + + _doReset: function () { + RC4._doReset.call(this); + + // Drop + for (var i = this.cfg.drop; i > 0; i--) { + generateKeystreamWord.call(this); + } + } + }); + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.RC4Drop.encrypt(message, key, cfg); + * var plaintext = CryptoJS.RC4Drop.decrypt(ciphertext, key, cfg); + */ + C.RC4Drop = StreamCipher._createHelper(RC4Drop); + }()); + + + return CryptoJS.RC4; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/ripemd160.js b/node_modules/crypto-js/ripemd160.js new file mode 100644 index 0000000..24feb47 --- /dev/null +++ b/node_modules/crypto-js/ripemd160.js @@ -0,0 +1,267 @@ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + /** @preserve + (c) 2012 by Cédric Mesnil. All rights reserved. + + Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + + - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + (function (Math) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var Hasher = C_lib.Hasher; + var C_algo = C.algo; + + // Constants table + var _zl = WordArray.create([ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, + 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, + 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, + 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13]); + var _zr = WordArray.create([ + 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, + 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, + 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, + 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, + 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11]); + var _sl = WordArray.create([ + 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, + 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, + 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, + 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, + 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 ]); + var _sr = WordArray.create([ + 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, + 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, + 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, + 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, + 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 ]); + + var _hl = WordArray.create([ 0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E]); + var _hr = WordArray.create([ 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000]); + + /** + * RIPEMD160 hash algorithm. + */ + var RIPEMD160 = C_algo.RIPEMD160 = Hasher.extend({ + _doReset: function () { + this._hash = WordArray.create([0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]); + }, + + _doProcessBlock: function (M, offset) { + + // Swap endian + for (var i = 0; i < 16; i++) { + // Shortcuts + var offset_i = offset + i; + var M_offset_i = M[offset_i]; + + // Swap + M[offset_i] = ( + (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) | + (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00) + ); + } + // Shortcut + var H = this._hash.words; + var hl = _hl.words; + var hr = _hr.words; + var zl = _zl.words; + var zr = _zr.words; + var sl = _sl.words; + var sr = _sr.words; + + // Working variables + var al, bl, cl, dl, el; + var ar, br, cr, dr, er; + + ar = al = H[0]; + br = bl = H[1]; + cr = cl = H[2]; + dr = dl = H[3]; + er = el = H[4]; + // Computation + var t; + for (var i = 0; i < 80; i += 1) { + t = (al + M[offset+zl[i]])|0; + if (i<16){ + t += f1(bl,cl,dl) + hl[0]; + } else if (i<32) { + t += f2(bl,cl,dl) + hl[1]; + } else if (i<48) { + t += f3(bl,cl,dl) + hl[2]; + } else if (i<64) { + t += f4(bl,cl,dl) + hl[3]; + } else {// if (i<80) { + t += f5(bl,cl,dl) + hl[4]; + } + t = t|0; + t = rotl(t,sl[i]); + t = (t+el)|0; + al = el; + el = dl; + dl = rotl(cl, 10); + cl = bl; + bl = t; + + t = (ar + M[offset+zr[i]])|0; + if (i<16){ + t += f5(br,cr,dr) + hr[0]; + } else if (i<32) { + t += f4(br,cr,dr) + hr[1]; + } else if (i<48) { + t += f3(br,cr,dr) + hr[2]; + } else if (i<64) { + t += f2(br,cr,dr) + hr[3]; + } else {// if (i<80) { + t += f1(br,cr,dr) + hr[4]; + } + t = t|0; + t = rotl(t,sr[i]) ; + t = (t+er)|0; + ar = er; + er = dr; + dr = rotl(cr, 10); + cr = br; + br = t; + } + // Intermediate hash value + t = (H[1] + cl + dr)|0; + H[1] = (H[2] + dl + er)|0; + H[2] = (H[3] + el + ar)|0; + H[3] = (H[4] + al + br)|0; + H[4] = (H[0] + bl + cr)|0; + H[0] = t; + }, + + _doFinalize: function () { + // Shortcuts + var data = this._data; + var dataWords = data.words; + + var nBitsTotal = this._nDataBytes * 8; + var nBitsLeft = data.sigBytes * 8; + + // Add padding + dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = ( + (((nBitsTotal << 8) | (nBitsTotal >>> 24)) & 0x00ff00ff) | + (((nBitsTotal << 24) | (nBitsTotal >>> 8)) & 0xff00ff00) + ); + data.sigBytes = (dataWords.length + 1) * 4; + + // Hash final blocks + this._process(); + + // Shortcuts + var hash = this._hash; + var H = hash.words; + + // Swap endian + for (var i = 0; i < 5; i++) { + // Shortcut + var H_i = H[i]; + + // Swap + H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) | + (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00); + } + + // Return final computed hash + return hash; + }, + + clone: function () { + var clone = Hasher.clone.call(this); + clone._hash = this._hash.clone(); + + return clone; + } + }); + + + function f1(x, y, z) { + return ((x) ^ (y) ^ (z)); + + } + + function f2(x, y, z) { + return (((x)&(y)) | ((~x)&(z))); + } + + function f3(x, y, z) { + return (((x) | (~(y))) ^ (z)); + } + + function f4(x, y, z) { + return (((x) & (z)) | ((y)&(~(z)))); + } + + function f5(x, y, z) { + return ((x) ^ ((y) |(~(z)))); + + } + + function rotl(x,n) { + return (x<>>(32-n)); + } + + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.RIPEMD160('message'); + * var hash = CryptoJS.RIPEMD160(wordArray); + */ + C.RIPEMD160 = Hasher._createHelper(RIPEMD160); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacRIPEMD160(message, key); + */ + C.HmacRIPEMD160 = Hasher._createHmacHelper(RIPEMD160); + }(Math)); + + + return CryptoJS.RIPEMD160; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/sha1.js b/node_modules/crypto-js/sha1.js new file mode 100644 index 0000000..6691149 --- /dev/null +++ b/node_modules/crypto-js/sha1.js @@ -0,0 +1,150 @@ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var Hasher = C_lib.Hasher; + var C_algo = C.algo; + + // Reusable object + var W = []; + + /** + * SHA-1 hash algorithm. + */ + var SHA1 = C_algo.SHA1 = Hasher.extend({ + _doReset: function () { + this._hash = new WordArray.init([ + 0x67452301, 0xefcdab89, + 0x98badcfe, 0x10325476, + 0xc3d2e1f0 + ]); + }, + + _doProcessBlock: function (M, offset) { + // Shortcut + var H = this._hash.words; + + // Working variables + var a = H[0]; + var b = H[1]; + var c = H[2]; + var d = H[3]; + var e = H[4]; + + // Computation + for (var i = 0; i < 80; i++) { + if (i < 16) { + W[i] = M[offset + i] | 0; + } else { + var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]; + W[i] = (n << 1) | (n >>> 31); + } + + var t = ((a << 5) | (a >>> 27)) + e + W[i]; + if (i < 20) { + t += ((b & c) | (~b & d)) + 0x5a827999; + } else if (i < 40) { + t += (b ^ c ^ d) + 0x6ed9eba1; + } else if (i < 60) { + t += ((b & c) | (b & d) | (c & d)) - 0x70e44324; + } else /* if (i < 80) */ { + t += (b ^ c ^ d) - 0x359d3e2a; + } + + e = d; + d = c; + c = (b << 30) | (b >>> 2); + b = a; + a = t; + } + + // Intermediate hash value + H[0] = (H[0] + a) | 0; + H[1] = (H[1] + b) | 0; + H[2] = (H[2] + c) | 0; + H[3] = (H[3] + d) | 0; + H[4] = (H[4] + e) | 0; + }, + + _doFinalize: function () { + // Shortcuts + var data = this._data; + var dataWords = data.words; + + var nBitsTotal = this._nDataBytes * 8; + var nBitsLeft = data.sigBytes * 8; + + // Add padding + dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000); + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal; + data.sigBytes = dataWords.length * 4; + + // Hash final blocks + this._process(); + + // Return final computed hash + return this._hash; + }, + + clone: function () { + var clone = Hasher.clone.call(this); + clone._hash = this._hash.clone(); + + return clone; + } + }); + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.SHA1('message'); + * var hash = CryptoJS.SHA1(wordArray); + */ + C.SHA1 = Hasher._createHelper(SHA1); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacSHA1(message, key); + */ + C.HmacSHA1 = Hasher._createHmacHelper(SHA1); + }()); + + + return CryptoJS.SHA1; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/sha224.js b/node_modules/crypto-js/sha224.js new file mode 100644 index 0000000..d8ce988 --- /dev/null +++ b/node_modules/crypto-js/sha224.js @@ -0,0 +1,80 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./sha256")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./sha256"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var C_algo = C.algo; + var SHA256 = C_algo.SHA256; + + /** + * SHA-224 hash algorithm. + */ + var SHA224 = C_algo.SHA224 = SHA256.extend({ + _doReset: function () { + this._hash = new WordArray.init([ + 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, + 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4 + ]); + }, + + _doFinalize: function () { + var hash = SHA256._doFinalize.call(this); + + hash.sigBytes -= 4; + + return hash; + } + }); + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.SHA224('message'); + * var hash = CryptoJS.SHA224(wordArray); + */ + C.SHA224 = SHA256._createHelper(SHA224); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacSHA224(message, key); + */ + C.HmacSHA224 = SHA256._createHmacHelper(SHA224); + }()); + + + return CryptoJS.SHA224; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/sha256.js b/node_modules/crypto-js/sha256.js new file mode 100644 index 0000000..de2d7fc --- /dev/null +++ b/node_modules/crypto-js/sha256.js @@ -0,0 +1,199 @@ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function (Math) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var Hasher = C_lib.Hasher; + var C_algo = C.algo; + + // Initialization and round constants tables + var H = []; + var K = []; + + // Compute constants + (function () { + function isPrime(n) { + var sqrtN = Math.sqrt(n); + for (var factor = 2; factor <= sqrtN; factor++) { + if (!(n % factor)) { + return false; + } + } + + return true; + } + + function getFractionalBits(n) { + return ((n - (n | 0)) * 0x100000000) | 0; + } + + var n = 2; + var nPrime = 0; + while (nPrime < 64) { + if (isPrime(n)) { + if (nPrime < 8) { + H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2)); + } + K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3)); + + nPrime++; + } + + n++; + } + }()); + + // Reusable object + var W = []; + + /** + * SHA-256 hash algorithm. + */ + var SHA256 = C_algo.SHA256 = Hasher.extend({ + _doReset: function () { + this._hash = new WordArray.init(H.slice(0)); + }, + + _doProcessBlock: function (M, offset) { + // Shortcut + var H = this._hash.words; + + // Working variables + var a = H[0]; + var b = H[1]; + var c = H[2]; + var d = H[3]; + var e = H[4]; + var f = H[5]; + var g = H[6]; + var h = H[7]; + + // Computation + for (var i = 0; i < 64; i++) { + if (i < 16) { + W[i] = M[offset + i] | 0; + } else { + var gamma0x = W[i - 15]; + var gamma0 = ((gamma0x << 25) | (gamma0x >>> 7)) ^ + ((gamma0x << 14) | (gamma0x >>> 18)) ^ + (gamma0x >>> 3); + + var gamma1x = W[i - 2]; + var gamma1 = ((gamma1x << 15) | (gamma1x >>> 17)) ^ + ((gamma1x << 13) | (gamma1x >>> 19)) ^ + (gamma1x >>> 10); + + W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]; + } + + var ch = (e & f) ^ (~e & g); + var maj = (a & b) ^ (a & c) ^ (b & c); + + var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22)); + var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7) | (e >>> 25)); + + var t1 = h + sigma1 + ch + K[i] + W[i]; + var t2 = sigma0 + maj; + + h = g; + g = f; + f = e; + e = (d + t1) | 0; + d = c; + c = b; + b = a; + a = (t1 + t2) | 0; + } + + // Intermediate hash value + H[0] = (H[0] + a) | 0; + H[1] = (H[1] + b) | 0; + H[2] = (H[2] + c) | 0; + H[3] = (H[3] + d) | 0; + H[4] = (H[4] + e) | 0; + H[5] = (H[5] + f) | 0; + H[6] = (H[6] + g) | 0; + H[7] = (H[7] + h) | 0; + }, + + _doFinalize: function () { + // Shortcuts + var data = this._data; + var dataWords = data.words; + + var nBitsTotal = this._nDataBytes * 8; + var nBitsLeft = data.sigBytes * 8; + + // Add padding + dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000); + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal; + data.sigBytes = dataWords.length * 4; + + // Hash final blocks + this._process(); + + // Return final computed hash + return this._hash; + }, + + clone: function () { + var clone = Hasher.clone.call(this); + clone._hash = this._hash.clone(); + + return clone; + } + }); + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.SHA256('message'); + * var hash = CryptoJS.SHA256(wordArray); + */ + C.SHA256 = Hasher._createHelper(SHA256); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacSHA256(message, key); + */ + C.HmacSHA256 = Hasher._createHmacHelper(SHA256); + }(Math)); + + + return CryptoJS.SHA256; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/sha3.js b/node_modules/crypto-js/sha3.js new file mode 100644 index 0000000..34ad86c --- /dev/null +++ b/node_modules/crypto-js/sha3.js @@ -0,0 +1,326 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./x64-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./x64-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function (Math) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var Hasher = C_lib.Hasher; + var C_x64 = C.x64; + var X64Word = C_x64.Word; + var C_algo = C.algo; + + // Constants tables + var RHO_OFFSETS = []; + var PI_INDEXES = []; + var ROUND_CONSTANTS = []; + + // Compute Constants + (function () { + // Compute rho offset constants + var x = 1, y = 0; + for (var t = 0; t < 24; t++) { + RHO_OFFSETS[x + 5 * y] = ((t + 1) * (t + 2) / 2) % 64; + + var newX = y % 5; + var newY = (2 * x + 3 * y) % 5; + x = newX; + y = newY; + } + + // Compute pi index constants + for (var x = 0; x < 5; x++) { + for (var y = 0; y < 5; y++) { + PI_INDEXES[x + 5 * y] = y + ((2 * x + 3 * y) % 5) * 5; + } + } + + // Compute round constants + var LFSR = 0x01; + for (var i = 0; i < 24; i++) { + var roundConstantMsw = 0; + var roundConstantLsw = 0; + + for (var j = 0; j < 7; j++) { + if (LFSR & 0x01) { + var bitPosition = (1 << j) - 1; + if (bitPosition < 32) { + roundConstantLsw ^= 1 << bitPosition; + } else /* if (bitPosition >= 32) */ { + roundConstantMsw ^= 1 << (bitPosition - 32); + } + } + + // Compute next LFSR + if (LFSR & 0x80) { + // Primitive polynomial over GF(2): x^8 + x^6 + x^5 + x^4 + 1 + LFSR = (LFSR << 1) ^ 0x71; + } else { + LFSR <<= 1; + } + } + + ROUND_CONSTANTS[i] = X64Word.create(roundConstantMsw, roundConstantLsw); + } + }()); + + // Reusable objects for temporary values + var T = []; + (function () { + for (var i = 0; i < 25; i++) { + T[i] = X64Word.create(); + } + }()); + + /** + * SHA-3 hash algorithm. + */ + var SHA3 = C_algo.SHA3 = Hasher.extend({ + /** + * Configuration options. + * + * @property {number} outputLength + * The desired number of bits in the output hash. + * Only values permitted are: 224, 256, 384, 512. + * Default: 512 + */ + cfg: Hasher.cfg.extend({ + outputLength: 512 + }), + + _doReset: function () { + var state = this._state = [] + for (var i = 0; i < 25; i++) { + state[i] = new X64Word.init(); + } + + this.blockSize = (1600 - 2 * this.cfg.outputLength) / 32; + }, + + _doProcessBlock: function (M, offset) { + // Shortcuts + var state = this._state; + var nBlockSizeLanes = this.blockSize / 2; + + // Absorb + for (var i = 0; i < nBlockSizeLanes; i++) { + // Shortcuts + var M2i = M[offset + 2 * i]; + var M2i1 = M[offset + 2 * i + 1]; + + // Swap endian + M2i = ( + (((M2i << 8) | (M2i >>> 24)) & 0x00ff00ff) | + (((M2i << 24) | (M2i >>> 8)) & 0xff00ff00) + ); + M2i1 = ( + (((M2i1 << 8) | (M2i1 >>> 24)) & 0x00ff00ff) | + (((M2i1 << 24) | (M2i1 >>> 8)) & 0xff00ff00) + ); + + // Absorb message into state + var lane = state[i]; + lane.high ^= M2i1; + lane.low ^= M2i; + } + + // Rounds + for (var round = 0; round < 24; round++) { + // Theta + for (var x = 0; x < 5; x++) { + // Mix column lanes + var tMsw = 0, tLsw = 0; + for (var y = 0; y < 5; y++) { + var lane = state[x + 5 * y]; + tMsw ^= lane.high; + tLsw ^= lane.low; + } + + // Temporary values + var Tx = T[x]; + Tx.high = tMsw; + Tx.low = tLsw; + } + for (var x = 0; x < 5; x++) { + // Shortcuts + var Tx4 = T[(x + 4) % 5]; + var Tx1 = T[(x + 1) % 5]; + var Tx1Msw = Tx1.high; + var Tx1Lsw = Tx1.low; + + // Mix surrounding columns + var tMsw = Tx4.high ^ ((Tx1Msw << 1) | (Tx1Lsw >>> 31)); + var tLsw = Tx4.low ^ ((Tx1Lsw << 1) | (Tx1Msw >>> 31)); + for (var y = 0; y < 5; y++) { + var lane = state[x + 5 * y]; + lane.high ^= tMsw; + lane.low ^= tLsw; + } + } + + // Rho Pi + for (var laneIndex = 1; laneIndex < 25; laneIndex++) { + var tMsw; + var tLsw; + + // Shortcuts + var lane = state[laneIndex]; + var laneMsw = lane.high; + var laneLsw = lane.low; + var rhoOffset = RHO_OFFSETS[laneIndex]; + + // Rotate lanes + if (rhoOffset < 32) { + tMsw = (laneMsw << rhoOffset) | (laneLsw >>> (32 - rhoOffset)); + tLsw = (laneLsw << rhoOffset) | (laneMsw >>> (32 - rhoOffset)); + } else /* if (rhoOffset >= 32) */ { + tMsw = (laneLsw << (rhoOffset - 32)) | (laneMsw >>> (64 - rhoOffset)); + tLsw = (laneMsw << (rhoOffset - 32)) | (laneLsw >>> (64 - rhoOffset)); + } + + // Transpose lanes + var TPiLane = T[PI_INDEXES[laneIndex]]; + TPiLane.high = tMsw; + TPiLane.low = tLsw; + } + + // Rho pi at x = y = 0 + var T0 = T[0]; + var state0 = state[0]; + T0.high = state0.high; + T0.low = state0.low; + + // Chi + for (var x = 0; x < 5; x++) { + for (var y = 0; y < 5; y++) { + // Shortcuts + var laneIndex = x + 5 * y; + var lane = state[laneIndex]; + var TLane = T[laneIndex]; + var Tx1Lane = T[((x + 1) % 5) + 5 * y]; + var Tx2Lane = T[((x + 2) % 5) + 5 * y]; + + // Mix rows + lane.high = TLane.high ^ (~Tx1Lane.high & Tx2Lane.high); + lane.low = TLane.low ^ (~Tx1Lane.low & Tx2Lane.low); + } + } + + // Iota + var lane = state[0]; + var roundConstant = ROUND_CONSTANTS[round]; + lane.high ^= roundConstant.high; + lane.low ^= roundConstant.low; + } + }, + + _doFinalize: function () { + // Shortcuts + var data = this._data; + var dataWords = data.words; + var nBitsTotal = this._nDataBytes * 8; + var nBitsLeft = data.sigBytes * 8; + var blockSizeBits = this.blockSize * 32; + + // Add padding + dataWords[nBitsLeft >>> 5] |= 0x1 << (24 - nBitsLeft % 32); + dataWords[((Math.ceil((nBitsLeft + 1) / blockSizeBits) * blockSizeBits) >>> 5) - 1] |= 0x80; + data.sigBytes = dataWords.length * 4; + + // Hash final blocks + this._process(); + + // Shortcuts + var state = this._state; + var outputLengthBytes = this.cfg.outputLength / 8; + var outputLengthLanes = outputLengthBytes / 8; + + // Squeeze + var hashWords = []; + for (var i = 0; i < outputLengthLanes; i++) { + // Shortcuts + var lane = state[i]; + var laneMsw = lane.high; + var laneLsw = lane.low; + + // Swap endian + laneMsw = ( + (((laneMsw << 8) | (laneMsw >>> 24)) & 0x00ff00ff) | + (((laneMsw << 24) | (laneMsw >>> 8)) & 0xff00ff00) + ); + laneLsw = ( + (((laneLsw << 8) | (laneLsw >>> 24)) & 0x00ff00ff) | + (((laneLsw << 24) | (laneLsw >>> 8)) & 0xff00ff00) + ); + + // Squeeze state to retrieve hash + hashWords.push(laneLsw); + hashWords.push(laneMsw); + } + + // Return final computed hash + return new WordArray.init(hashWords, outputLengthBytes); + }, + + clone: function () { + var clone = Hasher.clone.call(this); + + var state = clone._state = this._state.slice(0); + for (var i = 0; i < 25; i++) { + state[i] = state[i].clone(); + } + + return clone; + } + }); + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.SHA3('message'); + * var hash = CryptoJS.SHA3(wordArray); + */ + C.SHA3 = Hasher._createHelper(SHA3); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacSHA3(message, key); + */ + C.HmacSHA3 = Hasher._createHmacHelper(SHA3); + }(Math)); + + + return CryptoJS.SHA3; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/sha384.js b/node_modules/crypto-js/sha384.js new file mode 100644 index 0000000..a0b95bf --- /dev/null +++ b/node_modules/crypto-js/sha384.js @@ -0,0 +1,83 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./x64-core"), require("./sha512")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./x64-core", "./sha512"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_x64 = C.x64; + var X64Word = C_x64.Word; + var X64WordArray = C_x64.WordArray; + var C_algo = C.algo; + var SHA512 = C_algo.SHA512; + + /** + * SHA-384 hash algorithm. + */ + var SHA384 = C_algo.SHA384 = SHA512.extend({ + _doReset: function () { + this._hash = new X64WordArray.init([ + new X64Word.init(0xcbbb9d5d, 0xc1059ed8), new X64Word.init(0x629a292a, 0x367cd507), + new X64Word.init(0x9159015a, 0x3070dd17), new X64Word.init(0x152fecd8, 0xf70e5939), + new X64Word.init(0x67332667, 0xffc00b31), new X64Word.init(0x8eb44a87, 0x68581511), + new X64Word.init(0xdb0c2e0d, 0x64f98fa7), new X64Word.init(0x47b5481d, 0xbefa4fa4) + ]); + }, + + _doFinalize: function () { + var hash = SHA512._doFinalize.call(this); + + hash.sigBytes -= 16; + + return hash; + } + }); + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.SHA384('message'); + * var hash = CryptoJS.SHA384(wordArray); + */ + C.SHA384 = SHA512._createHelper(SHA384); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacSHA384(message, key); + */ + C.HmacSHA384 = SHA512._createHmacHelper(SHA384); + }()); + + + return CryptoJS.SHA384; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/sha512.js b/node_modules/crypto-js/sha512.js new file mode 100644 index 0000000..d274ab0 --- /dev/null +++ b/node_modules/crypto-js/sha512.js @@ -0,0 +1,326 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./x64-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./x64-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var Hasher = C_lib.Hasher; + var C_x64 = C.x64; + var X64Word = C_x64.Word; + var X64WordArray = C_x64.WordArray; + var C_algo = C.algo; + + function X64Word_create() { + return X64Word.create.apply(X64Word, arguments); + } + + // Constants + var K = [ + X64Word_create(0x428a2f98, 0xd728ae22), X64Word_create(0x71374491, 0x23ef65cd), + X64Word_create(0xb5c0fbcf, 0xec4d3b2f), X64Word_create(0xe9b5dba5, 0x8189dbbc), + X64Word_create(0x3956c25b, 0xf348b538), X64Word_create(0x59f111f1, 0xb605d019), + X64Word_create(0x923f82a4, 0xaf194f9b), X64Word_create(0xab1c5ed5, 0xda6d8118), + X64Word_create(0xd807aa98, 0xa3030242), X64Word_create(0x12835b01, 0x45706fbe), + X64Word_create(0x243185be, 0x4ee4b28c), X64Word_create(0x550c7dc3, 0xd5ffb4e2), + X64Word_create(0x72be5d74, 0xf27b896f), X64Word_create(0x80deb1fe, 0x3b1696b1), + X64Word_create(0x9bdc06a7, 0x25c71235), X64Word_create(0xc19bf174, 0xcf692694), + X64Word_create(0xe49b69c1, 0x9ef14ad2), X64Word_create(0xefbe4786, 0x384f25e3), + X64Word_create(0x0fc19dc6, 0x8b8cd5b5), X64Word_create(0x240ca1cc, 0x77ac9c65), + X64Word_create(0x2de92c6f, 0x592b0275), X64Word_create(0x4a7484aa, 0x6ea6e483), + X64Word_create(0x5cb0a9dc, 0xbd41fbd4), X64Word_create(0x76f988da, 0x831153b5), + X64Word_create(0x983e5152, 0xee66dfab), X64Word_create(0xa831c66d, 0x2db43210), + X64Word_create(0xb00327c8, 0x98fb213f), X64Word_create(0xbf597fc7, 0xbeef0ee4), + X64Word_create(0xc6e00bf3, 0x3da88fc2), X64Word_create(0xd5a79147, 0x930aa725), + X64Word_create(0x06ca6351, 0xe003826f), X64Word_create(0x14292967, 0x0a0e6e70), + X64Word_create(0x27b70a85, 0x46d22ffc), X64Word_create(0x2e1b2138, 0x5c26c926), + X64Word_create(0x4d2c6dfc, 0x5ac42aed), X64Word_create(0x53380d13, 0x9d95b3df), + X64Word_create(0x650a7354, 0x8baf63de), X64Word_create(0x766a0abb, 0x3c77b2a8), + X64Word_create(0x81c2c92e, 0x47edaee6), X64Word_create(0x92722c85, 0x1482353b), + X64Word_create(0xa2bfe8a1, 0x4cf10364), X64Word_create(0xa81a664b, 0xbc423001), + X64Word_create(0xc24b8b70, 0xd0f89791), X64Word_create(0xc76c51a3, 0x0654be30), + X64Word_create(0xd192e819, 0xd6ef5218), X64Word_create(0xd6990624, 0x5565a910), + X64Word_create(0xf40e3585, 0x5771202a), X64Word_create(0x106aa070, 0x32bbd1b8), + X64Word_create(0x19a4c116, 0xb8d2d0c8), X64Word_create(0x1e376c08, 0x5141ab53), + X64Word_create(0x2748774c, 0xdf8eeb99), X64Word_create(0x34b0bcb5, 0xe19b48a8), + X64Word_create(0x391c0cb3, 0xc5c95a63), X64Word_create(0x4ed8aa4a, 0xe3418acb), + X64Word_create(0x5b9cca4f, 0x7763e373), X64Word_create(0x682e6ff3, 0xd6b2b8a3), + X64Word_create(0x748f82ee, 0x5defb2fc), X64Word_create(0x78a5636f, 0x43172f60), + X64Word_create(0x84c87814, 0xa1f0ab72), X64Word_create(0x8cc70208, 0x1a6439ec), + X64Word_create(0x90befffa, 0x23631e28), X64Word_create(0xa4506ceb, 0xde82bde9), + X64Word_create(0xbef9a3f7, 0xb2c67915), X64Word_create(0xc67178f2, 0xe372532b), + X64Word_create(0xca273ece, 0xea26619c), X64Word_create(0xd186b8c7, 0x21c0c207), + X64Word_create(0xeada7dd6, 0xcde0eb1e), X64Word_create(0xf57d4f7f, 0xee6ed178), + X64Word_create(0x06f067aa, 0x72176fba), X64Word_create(0x0a637dc5, 0xa2c898a6), + X64Word_create(0x113f9804, 0xbef90dae), X64Word_create(0x1b710b35, 0x131c471b), + X64Word_create(0x28db77f5, 0x23047d84), X64Word_create(0x32caab7b, 0x40c72493), + X64Word_create(0x3c9ebe0a, 0x15c9bebc), X64Word_create(0x431d67c4, 0x9c100d4c), + X64Word_create(0x4cc5d4be, 0xcb3e42b6), X64Word_create(0x597f299c, 0xfc657e2a), + X64Word_create(0x5fcb6fab, 0x3ad6faec), X64Word_create(0x6c44198c, 0x4a475817) + ]; + + // Reusable objects + var W = []; + (function () { + for (var i = 0; i < 80; i++) { + W[i] = X64Word_create(); + } + }()); + + /** + * SHA-512 hash algorithm. + */ + var SHA512 = C_algo.SHA512 = Hasher.extend({ + _doReset: function () { + this._hash = new X64WordArray.init([ + new X64Word.init(0x6a09e667, 0xf3bcc908), new X64Word.init(0xbb67ae85, 0x84caa73b), + new X64Word.init(0x3c6ef372, 0xfe94f82b), new X64Word.init(0xa54ff53a, 0x5f1d36f1), + new X64Word.init(0x510e527f, 0xade682d1), new X64Word.init(0x9b05688c, 0x2b3e6c1f), + new X64Word.init(0x1f83d9ab, 0xfb41bd6b), new X64Word.init(0x5be0cd19, 0x137e2179) + ]); + }, + + _doProcessBlock: function (M, offset) { + // Shortcuts + var H = this._hash.words; + + var H0 = H[0]; + var H1 = H[1]; + var H2 = H[2]; + var H3 = H[3]; + var H4 = H[4]; + var H5 = H[5]; + var H6 = H[6]; + var H7 = H[7]; + + var H0h = H0.high; + var H0l = H0.low; + var H1h = H1.high; + var H1l = H1.low; + var H2h = H2.high; + var H2l = H2.low; + var H3h = H3.high; + var H3l = H3.low; + var H4h = H4.high; + var H4l = H4.low; + var H5h = H5.high; + var H5l = H5.low; + var H6h = H6.high; + var H6l = H6.low; + var H7h = H7.high; + var H7l = H7.low; + + // Working variables + var ah = H0h; + var al = H0l; + var bh = H1h; + var bl = H1l; + var ch = H2h; + var cl = H2l; + var dh = H3h; + var dl = H3l; + var eh = H4h; + var el = H4l; + var fh = H5h; + var fl = H5l; + var gh = H6h; + var gl = H6l; + var hh = H7h; + var hl = H7l; + + // Rounds + for (var i = 0; i < 80; i++) { + var Wil; + var Wih; + + // Shortcut + var Wi = W[i]; + + // Extend message + if (i < 16) { + Wih = Wi.high = M[offset + i * 2] | 0; + Wil = Wi.low = M[offset + i * 2 + 1] | 0; + } else { + // Gamma0 + var gamma0x = W[i - 15]; + var gamma0xh = gamma0x.high; + var gamma0xl = gamma0x.low; + var gamma0h = ((gamma0xh >>> 1) | (gamma0xl << 31)) ^ ((gamma0xh >>> 8) | (gamma0xl << 24)) ^ (gamma0xh >>> 7); + var gamma0l = ((gamma0xl >>> 1) | (gamma0xh << 31)) ^ ((gamma0xl >>> 8) | (gamma0xh << 24)) ^ ((gamma0xl >>> 7) | (gamma0xh << 25)); + + // Gamma1 + var gamma1x = W[i - 2]; + var gamma1xh = gamma1x.high; + var gamma1xl = gamma1x.low; + var gamma1h = ((gamma1xh >>> 19) | (gamma1xl << 13)) ^ ((gamma1xh << 3) | (gamma1xl >>> 29)) ^ (gamma1xh >>> 6); + var gamma1l = ((gamma1xl >>> 19) | (gamma1xh << 13)) ^ ((gamma1xl << 3) | (gamma1xh >>> 29)) ^ ((gamma1xl >>> 6) | (gamma1xh << 26)); + + // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16] + var Wi7 = W[i - 7]; + var Wi7h = Wi7.high; + var Wi7l = Wi7.low; + + var Wi16 = W[i - 16]; + var Wi16h = Wi16.high; + var Wi16l = Wi16.low; + + Wil = gamma0l + Wi7l; + Wih = gamma0h + Wi7h + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0); + Wil = Wil + gamma1l; + Wih = Wih + gamma1h + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0); + Wil = Wil + Wi16l; + Wih = Wih + Wi16h + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0); + + Wi.high = Wih; + Wi.low = Wil; + } + + var chh = (eh & fh) ^ (~eh & gh); + var chl = (el & fl) ^ (~el & gl); + var majh = (ah & bh) ^ (ah & ch) ^ (bh & ch); + var majl = (al & bl) ^ (al & cl) ^ (bl & cl); + + var sigma0h = ((ah >>> 28) | (al << 4)) ^ ((ah << 30) | (al >>> 2)) ^ ((ah << 25) | (al >>> 7)); + var sigma0l = ((al >>> 28) | (ah << 4)) ^ ((al << 30) | (ah >>> 2)) ^ ((al << 25) | (ah >>> 7)); + var sigma1h = ((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9)); + var sigma1l = ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)); + + // t1 = h + sigma1 + ch + K[i] + W[i] + var Ki = K[i]; + var Kih = Ki.high; + var Kil = Ki.low; + + var t1l = hl + sigma1l; + var t1h = hh + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0); + var t1l = t1l + chl; + var t1h = t1h + chh + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0); + var t1l = t1l + Kil; + var t1h = t1h + Kih + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0); + var t1l = t1l + Wil; + var t1h = t1h + Wih + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0); + + // t2 = sigma0 + maj + var t2l = sigma0l + majl; + var t2h = sigma0h + majh + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0); + + // Update working variables + hh = gh; + hl = gl; + gh = fh; + gl = fl; + fh = eh; + fl = el; + el = (dl + t1l) | 0; + eh = (dh + t1h + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0; + dh = ch; + dl = cl; + ch = bh; + cl = bl; + bh = ah; + bl = al; + al = (t1l + t2l) | 0; + ah = (t1h + t2h + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0; + } + + // Intermediate hash value + H0l = H0.low = (H0l + al); + H0.high = (H0h + ah + ((H0l >>> 0) < (al >>> 0) ? 1 : 0)); + H1l = H1.low = (H1l + bl); + H1.high = (H1h + bh + ((H1l >>> 0) < (bl >>> 0) ? 1 : 0)); + H2l = H2.low = (H2l + cl); + H2.high = (H2h + ch + ((H2l >>> 0) < (cl >>> 0) ? 1 : 0)); + H3l = H3.low = (H3l + dl); + H3.high = (H3h + dh + ((H3l >>> 0) < (dl >>> 0) ? 1 : 0)); + H4l = H4.low = (H4l + el); + H4.high = (H4h + eh + ((H4l >>> 0) < (el >>> 0) ? 1 : 0)); + H5l = H5.low = (H5l + fl); + H5.high = (H5h + fh + ((H5l >>> 0) < (fl >>> 0) ? 1 : 0)); + H6l = H6.low = (H6l + gl); + H6.high = (H6h + gh + ((H6l >>> 0) < (gl >>> 0) ? 1 : 0)); + H7l = H7.low = (H7l + hl); + H7.high = (H7h + hh + ((H7l >>> 0) < (hl >>> 0) ? 1 : 0)); + }, + + _doFinalize: function () { + // Shortcuts + var data = this._data; + var dataWords = data.words; + + var nBitsTotal = this._nDataBytes * 8; + var nBitsLeft = data.sigBytes * 8; + + // Add padding + dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); + dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 30] = Math.floor(nBitsTotal / 0x100000000); + dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 31] = nBitsTotal; + data.sigBytes = dataWords.length * 4; + + // Hash final blocks + this._process(); + + // Convert hash to 32-bit word array before returning + var hash = this._hash.toX32(); + + // Return final computed hash + return hash; + }, + + clone: function () { + var clone = Hasher.clone.call(this); + clone._hash = this._hash.clone(); + + return clone; + }, + + blockSize: 1024/32 + }); + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.SHA512('message'); + * var hash = CryptoJS.SHA512(wordArray); + */ + C.SHA512 = Hasher._createHelper(SHA512); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacSHA512(message, key); + */ + C.HmacSHA512 = Hasher._createHmacHelper(SHA512); + }()); + + + return CryptoJS.SHA512; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/tripledes.js b/node_modules/crypto-js/tripledes.js new file mode 100644 index 0000000..1a92477 --- /dev/null +++ b/node_modules/crypto-js/tripledes.js @@ -0,0 +1,779 @@ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var BlockCipher = C_lib.BlockCipher; + var C_algo = C.algo; + + // Permuted Choice 1 constants + var PC1 = [ + 57, 49, 41, 33, 25, 17, 9, 1, + 58, 50, 42, 34, 26, 18, 10, 2, + 59, 51, 43, 35, 27, 19, 11, 3, + 60, 52, 44, 36, 63, 55, 47, 39, + 31, 23, 15, 7, 62, 54, 46, 38, + 30, 22, 14, 6, 61, 53, 45, 37, + 29, 21, 13, 5, 28, 20, 12, 4 + ]; + + // Permuted Choice 2 constants + var PC2 = [ + 14, 17, 11, 24, 1, 5, + 3, 28, 15, 6, 21, 10, + 23, 19, 12, 4, 26, 8, + 16, 7, 27, 20, 13, 2, + 41, 52, 31, 37, 47, 55, + 30, 40, 51, 45, 33, 48, + 44, 49, 39, 56, 34, 53, + 46, 42, 50, 36, 29, 32 + ]; + + // Cumulative bit shift constants + var BIT_SHIFTS = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28]; + + // SBOXes and round permutation constants + var SBOX_P = [ + { + 0x0: 0x808200, + 0x10000000: 0x8000, + 0x20000000: 0x808002, + 0x30000000: 0x2, + 0x40000000: 0x200, + 0x50000000: 0x808202, + 0x60000000: 0x800202, + 0x70000000: 0x800000, + 0x80000000: 0x202, + 0x90000000: 0x800200, + 0xa0000000: 0x8200, + 0xb0000000: 0x808000, + 0xc0000000: 0x8002, + 0xd0000000: 0x800002, + 0xe0000000: 0x0, + 0xf0000000: 0x8202, + 0x8000000: 0x0, + 0x18000000: 0x808202, + 0x28000000: 0x8202, + 0x38000000: 0x8000, + 0x48000000: 0x808200, + 0x58000000: 0x200, + 0x68000000: 0x808002, + 0x78000000: 0x2, + 0x88000000: 0x800200, + 0x98000000: 0x8200, + 0xa8000000: 0x808000, + 0xb8000000: 0x800202, + 0xc8000000: 0x800002, + 0xd8000000: 0x8002, + 0xe8000000: 0x202, + 0xf8000000: 0x800000, + 0x1: 0x8000, + 0x10000001: 0x2, + 0x20000001: 0x808200, + 0x30000001: 0x800000, + 0x40000001: 0x808002, + 0x50000001: 0x8200, + 0x60000001: 0x200, + 0x70000001: 0x800202, + 0x80000001: 0x808202, + 0x90000001: 0x808000, + 0xa0000001: 0x800002, + 0xb0000001: 0x8202, + 0xc0000001: 0x202, + 0xd0000001: 0x800200, + 0xe0000001: 0x8002, + 0xf0000001: 0x0, + 0x8000001: 0x808202, + 0x18000001: 0x808000, + 0x28000001: 0x800000, + 0x38000001: 0x200, + 0x48000001: 0x8000, + 0x58000001: 0x800002, + 0x68000001: 0x2, + 0x78000001: 0x8202, + 0x88000001: 0x8002, + 0x98000001: 0x800202, + 0xa8000001: 0x202, + 0xb8000001: 0x808200, + 0xc8000001: 0x800200, + 0xd8000001: 0x0, + 0xe8000001: 0x8200, + 0xf8000001: 0x808002 + }, + { + 0x0: 0x40084010, + 0x1000000: 0x4000, + 0x2000000: 0x80000, + 0x3000000: 0x40080010, + 0x4000000: 0x40000010, + 0x5000000: 0x40084000, + 0x6000000: 0x40004000, + 0x7000000: 0x10, + 0x8000000: 0x84000, + 0x9000000: 0x40004010, + 0xa000000: 0x40000000, + 0xb000000: 0x84010, + 0xc000000: 0x80010, + 0xd000000: 0x0, + 0xe000000: 0x4010, + 0xf000000: 0x40080000, + 0x800000: 0x40004000, + 0x1800000: 0x84010, + 0x2800000: 0x10, + 0x3800000: 0x40004010, + 0x4800000: 0x40084010, + 0x5800000: 0x40000000, + 0x6800000: 0x80000, + 0x7800000: 0x40080010, + 0x8800000: 0x80010, + 0x9800000: 0x0, + 0xa800000: 0x4000, + 0xb800000: 0x40080000, + 0xc800000: 0x40000010, + 0xd800000: 0x84000, + 0xe800000: 0x40084000, + 0xf800000: 0x4010, + 0x10000000: 0x0, + 0x11000000: 0x40080010, + 0x12000000: 0x40004010, + 0x13000000: 0x40084000, + 0x14000000: 0x40080000, + 0x15000000: 0x10, + 0x16000000: 0x84010, + 0x17000000: 0x4000, + 0x18000000: 0x4010, + 0x19000000: 0x80000, + 0x1a000000: 0x80010, + 0x1b000000: 0x40000010, + 0x1c000000: 0x84000, + 0x1d000000: 0x40004000, + 0x1e000000: 0x40000000, + 0x1f000000: 0x40084010, + 0x10800000: 0x84010, + 0x11800000: 0x80000, + 0x12800000: 0x40080000, + 0x13800000: 0x4000, + 0x14800000: 0x40004000, + 0x15800000: 0x40084010, + 0x16800000: 0x10, + 0x17800000: 0x40000000, + 0x18800000: 0x40084000, + 0x19800000: 0x40000010, + 0x1a800000: 0x40004010, + 0x1b800000: 0x80010, + 0x1c800000: 0x0, + 0x1d800000: 0x4010, + 0x1e800000: 0x40080010, + 0x1f800000: 0x84000 + }, + { + 0x0: 0x104, + 0x100000: 0x0, + 0x200000: 0x4000100, + 0x300000: 0x10104, + 0x400000: 0x10004, + 0x500000: 0x4000004, + 0x600000: 0x4010104, + 0x700000: 0x4010000, + 0x800000: 0x4000000, + 0x900000: 0x4010100, + 0xa00000: 0x10100, + 0xb00000: 0x4010004, + 0xc00000: 0x4000104, + 0xd00000: 0x10000, + 0xe00000: 0x4, + 0xf00000: 0x100, + 0x80000: 0x4010100, + 0x180000: 0x4010004, + 0x280000: 0x0, + 0x380000: 0x4000100, + 0x480000: 0x4000004, + 0x580000: 0x10000, + 0x680000: 0x10004, + 0x780000: 0x104, + 0x880000: 0x4, + 0x980000: 0x100, + 0xa80000: 0x4010000, + 0xb80000: 0x10104, + 0xc80000: 0x10100, + 0xd80000: 0x4000104, + 0xe80000: 0x4010104, + 0xf80000: 0x4000000, + 0x1000000: 0x4010100, + 0x1100000: 0x10004, + 0x1200000: 0x10000, + 0x1300000: 0x4000100, + 0x1400000: 0x100, + 0x1500000: 0x4010104, + 0x1600000: 0x4000004, + 0x1700000: 0x0, + 0x1800000: 0x4000104, + 0x1900000: 0x4000000, + 0x1a00000: 0x4, + 0x1b00000: 0x10100, + 0x1c00000: 0x4010000, + 0x1d00000: 0x104, + 0x1e00000: 0x10104, + 0x1f00000: 0x4010004, + 0x1080000: 0x4000000, + 0x1180000: 0x104, + 0x1280000: 0x4010100, + 0x1380000: 0x0, + 0x1480000: 0x10004, + 0x1580000: 0x4000100, + 0x1680000: 0x100, + 0x1780000: 0x4010004, + 0x1880000: 0x10000, + 0x1980000: 0x4010104, + 0x1a80000: 0x10104, + 0x1b80000: 0x4000004, + 0x1c80000: 0x4000104, + 0x1d80000: 0x4010000, + 0x1e80000: 0x4, + 0x1f80000: 0x10100 + }, + { + 0x0: 0x80401000, + 0x10000: 0x80001040, + 0x20000: 0x401040, + 0x30000: 0x80400000, + 0x40000: 0x0, + 0x50000: 0x401000, + 0x60000: 0x80000040, + 0x70000: 0x400040, + 0x80000: 0x80000000, + 0x90000: 0x400000, + 0xa0000: 0x40, + 0xb0000: 0x80001000, + 0xc0000: 0x80400040, + 0xd0000: 0x1040, + 0xe0000: 0x1000, + 0xf0000: 0x80401040, + 0x8000: 0x80001040, + 0x18000: 0x40, + 0x28000: 0x80400040, + 0x38000: 0x80001000, + 0x48000: 0x401000, + 0x58000: 0x80401040, + 0x68000: 0x0, + 0x78000: 0x80400000, + 0x88000: 0x1000, + 0x98000: 0x80401000, + 0xa8000: 0x400000, + 0xb8000: 0x1040, + 0xc8000: 0x80000000, + 0xd8000: 0x400040, + 0xe8000: 0x401040, + 0xf8000: 0x80000040, + 0x100000: 0x400040, + 0x110000: 0x401000, + 0x120000: 0x80000040, + 0x130000: 0x0, + 0x140000: 0x1040, + 0x150000: 0x80400040, + 0x160000: 0x80401000, + 0x170000: 0x80001040, + 0x180000: 0x80401040, + 0x190000: 0x80000000, + 0x1a0000: 0x80400000, + 0x1b0000: 0x401040, + 0x1c0000: 0x80001000, + 0x1d0000: 0x400000, + 0x1e0000: 0x40, + 0x1f0000: 0x1000, + 0x108000: 0x80400000, + 0x118000: 0x80401040, + 0x128000: 0x0, + 0x138000: 0x401000, + 0x148000: 0x400040, + 0x158000: 0x80000000, + 0x168000: 0x80001040, + 0x178000: 0x40, + 0x188000: 0x80000040, + 0x198000: 0x1000, + 0x1a8000: 0x80001000, + 0x1b8000: 0x80400040, + 0x1c8000: 0x1040, + 0x1d8000: 0x80401000, + 0x1e8000: 0x400000, + 0x1f8000: 0x401040 + }, + { + 0x0: 0x80, + 0x1000: 0x1040000, + 0x2000: 0x40000, + 0x3000: 0x20000000, + 0x4000: 0x20040080, + 0x5000: 0x1000080, + 0x6000: 0x21000080, + 0x7000: 0x40080, + 0x8000: 0x1000000, + 0x9000: 0x20040000, + 0xa000: 0x20000080, + 0xb000: 0x21040080, + 0xc000: 0x21040000, + 0xd000: 0x0, + 0xe000: 0x1040080, + 0xf000: 0x21000000, + 0x800: 0x1040080, + 0x1800: 0x21000080, + 0x2800: 0x80, + 0x3800: 0x1040000, + 0x4800: 0x40000, + 0x5800: 0x20040080, + 0x6800: 0x21040000, + 0x7800: 0x20000000, + 0x8800: 0x20040000, + 0x9800: 0x0, + 0xa800: 0x21040080, + 0xb800: 0x1000080, + 0xc800: 0x20000080, + 0xd800: 0x21000000, + 0xe800: 0x1000000, + 0xf800: 0x40080, + 0x10000: 0x40000, + 0x11000: 0x80, + 0x12000: 0x20000000, + 0x13000: 0x21000080, + 0x14000: 0x1000080, + 0x15000: 0x21040000, + 0x16000: 0x20040080, + 0x17000: 0x1000000, + 0x18000: 0x21040080, + 0x19000: 0x21000000, + 0x1a000: 0x1040000, + 0x1b000: 0x20040000, + 0x1c000: 0x40080, + 0x1d000: 0x20000080, + 0x1e000: 0x0, + 0x1f000: 0x1040080, + 0x10800: 0x21000080, + 0x11800: 0x1000000, + 0x12800: 0x1040000, + 0x13800: 0x20040080, + 0x14800: 0x20000000, + 0x15800: 0x1040080, + 0x16800: 0x80, + 0x17800: 0x21040000, + 0x18800: 0x40080, + 0x19800: 0x21040080, + 0x1a800: 0x0, + 0x1b800: 0x21000000, + 0x1c800: 0x1000080, + 0x1d800: 0x40000, + 0x1e800: 0x20040000, + 0x1f800: 0x20000080 + }, + { + 0x0: 0x10000008, + 0x100: 0x2000, + 0x200: 0x10200000, + 0x300: 0x10202008, + 0x400: 0x10002000, + 0x500: 0x200000, + 0x600: 0x200008, + 0x700: 0x10000000, + 0x800: 0x0, + 0x900: 0x10002008, + 0xa00: 0x202000, + 0xb00: 0x8, + 0xc00: 0x10200008, + 0xd00: 0x202008, + 0xe00: 0x2008, + 0xf00: 0x10202000, + 0x80: 0x10200000, + 0x180: 0x10202008, + 0x280: 0x8, + 0x380: 0x200000, + 0x480: 0x202008, + 0x580: 0x10000008, + 0x680: 0x10002000, + 0x780: 0x2008, + 0x880: 0x200008, + 0x980: 0x2000, + 0xa80: 0x10002008, + 0xb80: 0x10200008, + 0xc80: 0x0, + 0xd80: 0x10202000, + 0xe80: 0x202000, + 0xf80: 0x10000000, + 0x1000: 0x10002000, + 0x1100: 0x10200008, + 0x1200: 0x10202008, + 0x1300: 0x2008, + 0x1400: 0x200000, + 0x1500: 0x10000000, + 0x1600: 0x10000008, + 0x1700: 0x202000, + 0x1800: 0x202008, + 0x1900: 0x0, + 0x1a00: 0x8, + 0x1b00: 0x10200000, + 0x1c00: 0x2000, + 0x1d00: 0x10002008, + 0x1e00: 0x10202000, + 0x1f00: 0x200008, + 0x1080: 0x8, + 0x1180: 0x202000, + 0x1280: 0x200000, + 0x1380: 0x10000008, + 0x1480: 0x10002000, + 0x1580: 0x2008, + 0x1680: 0x10202008, + 0x1780: 0x10200000, + 0x1880: 0x10202000, + 0x1980: 0x10200008, + 0x1a80: 0x2000, + 0x1b80: 0x202008, + 0x1c80: 0x200008, + 0x1d80: 0x0, + 0x1e80: 0x10000000, + 0x1f80: 0x10002008 + }, + { + 0x0: 0x100000, + 0x10: 0x2000401, + 0x20: 0x400, + 0x30: 0x100401, + 0x40: 0x2100401, + 0x50: 0x0, + 0x60: 0x1, + 0x70: 0x2100001, + 0x80: 0x2000400, + 0x90: 0x100001, + 0xa0: 0x2000001, + 0xb0: 0x2100400, + 0xc0: 0x2100000, + 0xd0: 0x401, + 0xe0: 0x100400, + 0xf0: 0x2000000, + 0x8: 0x2100001, + 0x18: 0x0, + 0x28: 0x2000401, + 0x38: 0x2100400, + 0x48: 0x100000, + 0x58: 0x2000001, + 0x68: 0x2000000, + 0x78: 0x401, + 0x88: 0x100401, + 0x98: 0x2000400, + 0xa8: 0x2100000, + 0xb8: 0x100001, + 0xc8: 0x400, + 0xd8: 0x2100401, + 0xe8: 0x1, + 0xf8: 0x100400, + 0x100: 0x2000000, + 0x110: 0x100000, + 0x120: 0x2000401, + 0x130: 0x2100001, + 0x140: 0x100001, + 0x150: 0x2000400, + 0x160: 0x2100400, + 0x170: 0x100401, + 0x180: 0x401, + 0x190: 0x2100401, + 0x1a0: 0x100400, + 0x1b0: 0x1, + 0x1c0: 0x0, + 0x1d0: 0x2100000, + 0x1e0: 0x2000001, + 0x1f0: 0x400, + 0x108: 0x100400, + 0x118: 0x2000401, + 0x128: 0x2100001, + 0x138: 0x1, + 0x148: 0x2000000, + 0x158: 0x100000, + 0x168: 0x401, + 0x178: 0x2100400, + 0x188: 0x2000001, + 0x198: 0x2100000, + 0x1a8: 0x0, + 0x1b8: 0x2100401, + 0x1c8: 0x100401, + 0x1d8: 0x400, + 0x1e8: 0x2000400, + 0x1f8: 0x100001 + }, + { + 0x0: 0x8000820, + 0x1: 0x20000, + 0x2: 0x8000000, + 0x3: 0x20, + 0x4: 0x20020, + 0x5: 0x8020820, + 0x6: 0x8020800, + 0x7: 0x800, + 0x8: 0x8020000, + 0x9: 0x8000800, + 0xa: 0x20800, + 0xb: 0x8020020, + 0xc: 0x820, + 0xd: 0x0, + 0xe: 0x8000020, + 0xf: 0x20820, + 0x80000000: 0x800, + 0x80000001: 0x8020820, + 0x80000002: 0x8000820, + 0x80000003: 0x8000000, + 0x80000004: 0x8020000, + 0x80000005: 0x20800, + 0x80000006: 0x20820, + 0x80000007: 0x20, + 0x80000008: 0x8000020, + 0x80000009: 0x820, + 0x8000000a: 0x20020, + 0x8000000b: 0x8020800, + 0x8000000c: 0x0, + 0x8000000d: 0x8020020, + 0x8000000e: 0x8000800, + 0x8000000f: 0x20000, + 0x10: 0x20820, + 0x11: 0x8020800, + 0x12: 0x20, + 0x13: 0x800, + 0x14: 0x8000800, + 0x15: 0x8000020, + 0x16: 0x8020020, + 0x17: 0x20000, + 0x18: 0x0, + 0x19: 0x20020, + 0x1a: 0x8020000, + 0x1b: 0x8000820, + 0x1c: 0x8020820, + 0x1d: 0x20800, + 0x1e: 0x820, + 0x1f: 0x8000000, + 0x80000010: 0x20000, + 0x80000011: 0x800, + 0x80000012: 0x8020020, + 0x80000013: 0x20820, + 0x80000014: 0x20, + 0x80000015: 0x8020000, + 0x80000016: 0x8000000, + 0x80000017: 0x8000820, + 0x80000018: 0x8020820, + 0x80000019: 0x8000020, + 0x8000001a: 0x8000800, + 0x8000001b: 0x0, + 0x8000001c: 0x20800, + 0x8000001d: 0x820, + 0x8000001e: 0x20020, + 0x8000001f: 0x8020800 + } + ]; + + // Masks that select the SBOX input + var SBOX_MASK = [ + 0xf8000001, 0x1f800000, 0x01f80000, 0x001f8000, + 0x0001f800, 0x00001f80, 0x000001f8, 0x8000001f + ]; + + /** + * DES block cipher algorithm. + */ + var DES = C_algo.DES = BlockCipher.extend({ + _doReset: function () { + // Shortcuts + var key = this._key; + var keyWords = key.words; + + // Select 56 bits according to PC1 + var keyBits = []; + for (var i = 0; i < 56; i++) { + var keyBitPos = PC1[i] - 1; + keyBits[i] = (keyWords[keyBitPos >>> 5] >>> (31 - keyBitPos % 32)) & 1; + } + + // Assemble 16 subkeys + var subKeys = this._subKeys = []; + for (var nSubKey = 0; nSubKey < 16; nSubKey++) { + // Create subkey + var subKey = subKeys[nSubKey] = []; + + // Shortcut + var bitShift = BIT_SHIFTS[nSubKey]; + + // Select 48 bits according to PC2 + for (var i = 0; i < 24; i++) { + // Select from the left 28 key bits + subKey[(i / 6) | 0] |= keyBits[((PC2[i] - 1) + bitShift) % 28] << (31 - i % 6); + + // Select from the right 28 key bits + subKey[4 + ((i / 6) | 0)] |= keyBits[28 + (((PC2[i + 24] - 1) + bitShift) % 28)] << (31 - i % 6); + } + + // Since each subkey is applied to an expanded 32-bit input, + // the subkey can be broken into 8 values scaled to 32-bits, + // which allows the key to be used without expansion + subKey[0] = (subKey[0] << 1) | (subKey[0] >>> 31); + for (var i = 1; i < 7; i++) { + subKey[i] = subKey[i] >>> ((i - 1) * 4 + 3); + } + subKey[7] = (subKey[7] << 5) | (subKey[7] >>> 27); + } + + // Compute inverse subkeys + var invSubKeys = this._invSubKeys = []; + for (var i = 0; i < 16; i++) { + invSubKeys[i] = subKeys[15 - i]; + } + }, + + encryptBlock: function (M, offset) { + this._doCryptBlock(M, offset, this._subKeys); + }, + + decryptBlock: function (M, offset) { + this._doCryptBlock(M, offset, this._invSubKeys); + }, + + _doCryptBlock: function (M, offset, subKeys) { + // Get input + this._lBlock = M[offset]; + this._rBlock = M[offset + 1]; + + // Initial permutation + exchangeLR.call(this, 4, 0x0f0f0f0f); + exchangeLR.call(this, 16, 0x0000ffff); + exchangeRL.call(this, 2, 0x33333333); + exchangeRL.call(this, 8, 0x00ff00ff); + exchangeLR.call(this, 1, 0x55555555); + + // Rounds + for (var round = 0; round < 16; round++) { + // Shortcuts + var subKey = subKeys[round]; + var lBlock = this._lBlock; + var rBlock = this._rBlock; + + // Feistel function + var f = 0; + for (var i = 0; i < 8; i++) { + f |= SBOX_P[i][((rBlock ^ subKey[i]) & SBOX_MASK[i]) >>> 0]; + } + this._lBlock = rBlock; + this._rBlock = lBlock ^ f; + } + + // Undo swap from last round + var t = this._lBlock; + this._lBlock = this._rBlock; + this._rBlock = t; + + // Final permutation + exchangeLR.call(this, 1, 0x55555555); + exchangeRL.call(this, 8, 0x00ff00ff); + exchangeRL.call(this, 2, 0x33333333); + exchangeLR.call(this, 16, 0x0000ffff); + exchangeLR.call(this, 4, 0x0f0f0f0f); + + // Set output + M[offset] = this._lBlock; + M[offset + 1] = this._rBlock; + }, + + keySize: 64/32, + + ivSize: 64/32, + + blockSize: 64/32 + }); + + // Swap bits across the left and right words + function exchangeLR(offset, mask) { + var t = ((this._lBlock >>> offset) ^ this._rBlock) & mask; + this._rBlock ^= t; + this._lBlock ^= t << offset; + } + + function exchangeRL(offset, mask) { + var t = ((this._rBlock >>> offset) ^ this._lBlock) & mask; + this._lBlock ^= t; + this._rBlock ^= t << offset; + } + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.DES.encrypt(message, key, cfg); + * var plaintext = CryptoJS.DES.decrypt(ciphertext, key, cfg); + */ + C.DES = BlockCipher._createHelper(DES); + + /** + * Triple-DES block cipher algorithm. + */ + var TripleDES = C_algo.TripleDES = BlockCipher.extend({ + _doReset: function () { + // Shortcuts + var key = this._key; + var keyWords = key.words; + // Make sure the key length is valid (64, 128 or >= 192 bit) + if (keyWords.length !== 2 && keyWords.length !== 4 && keyWords.length < 6) { + throw new Error('Invalid key length - 3DES requires the key length to be 64, 128, 192 or >192.'); + } + + // Extend the key according to the keying options defined in 3DES standard + var key1 = keyWords.slice(0, 2); + var key2 = keyWords.length < 4 ? keyWords.slice(0, 2) : keyWords.slice(2, 4); + var key3 = keyWords.length < 6 ? keyWords.slice(0, 2) : keyWords.slice(4, 6); + + // Create DES instances + this._des1 = DES.createEncryptor(WordArray.create(key1)); + this._des2 = DES.createEncryptor(WordArray.create(key2)); + this._des3 = DES.createEncryptor(WordArray.create(key3)); + }, + + encryptBlock: function (M, offset) { + this._des1.encryptBlock(M, offset); + this._des2.decryptBlock(M, offset); + this._des3.encryptBlock(M, offset); + }, + + decryptBlock: function (M, offset) { + this._des3.decryptBlock(M, offset); + this._des2.encryptBlock(M, offset); + this._des1.decryptBlock(M, offset); + }, + + keySize: 192/32, + + ivSize: 64/32, + + blockSize: 64/32 + }); + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.TripleDES.encrypt(message, key, cfg); + * var plaintext = CryptoJS.TripleDES.decrypt(ciphertext, key, cfg); + */ + C.TripleDES = BlockCipher._createHelper(TripleDES); + }()); + + + return CryptoJS.TripleDES; + +})); \ No newline at end of file diff --git a/node_modules/crypto-js/x64-core.js b/node_modules/crypto-js/x64-core.js new file mode 100644 index 0000000..57dcc14 --- /dev/null +++ b/node_modules/crypto-js/x64-core.js @@ -0,0 +1,304 @@ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require("./core")); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function (undefined) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var Base = C_lib.Base; + var X32WordArray = C_lib.WordArray; + + /** + * x64 namespace. + */ + var C_x64 = C.x64 = {}; + + /** + * A 64-bit word. + */ + var X64Word = C_x64.Word = Base.extend({ + /** + * Initializes a newly created 64-bit word. + * + * @param {number} high The high 32 bits. + * @param {number} low The low 32 bits. + * + * @example + * + * var x64Word = CryptoJS.x64.Word.create(0x00010203, 0x04050607); + */ + init: function (high, low) { + this.high = high; + this.low = low; + } + + /** + * Bitwise NOTs this word. + * + * @return {X64Word} A new x64-Word object after negating. + * + * @example + * + * var negated = x64Word.not(); + */ + // not: function () { + // var high = ~this.high; + // var low = ~this.low; + + // return X64Word.create(high, low); + // }, + + /** + * Bitwise ANDs this word with the passed word. + * + * @param {X64Word} word The x64-Word to AND with this word. + * + * @return {X64Word} A new x64-Word object after ANDing. + * + * @example + * + * var anded = x64Word.and(anotherX64Word); + */ + // and: function (word) { + // var high = this.high & word.high; + // var low = this.low & word.low; + + // return X64Word.create(high, low); + // }, + + /** + * Bitwise ORs this word with the passed word. + * + * @param {X64Word} word The x64-Word to OR with this word. + * + * @return {X64Word} A new x64-Word object after ORing. + * + * @example + * + * var ored = x64Word.or(anotherX64Word); + */ + // or: function (word) { + // var high = this.high | word.high; + // var low = this.low | word.low; + + // return X64Word.create(high, low); + // }, + + /** + * Bitwise XORs this word with the passed word. + * + * @param {X64Word} word The x64-Word to XOR with this word. + * + * @return {X64Word} A new x64-Word object after XORing. + * + * @example + * + * var xored = x64Word.xor(anotherX64Word); + */ + // xor: function (word) { + // var high = this.high ^ word.high; + // var low = this.low ^ word.low; + + // return X64Word.create(high, low); + // }, + + /** + * Shifts this word n bits to the left. + * + * @param {number} n The number of bits to shift. + * + * @return {X64Word} A new x64-Word object after shifting. + * + * @example + * + * var shifted = x64Word.shiftL(25); + */ + // shiftL: function (n) { + // if (n < 32) { + // var high = (this.high << n) | (this.low >>> (32 - n)); + // var low = this.low << n; + // } else { + // var high = this.low << (n - 32); + // var low = 0; + // } + + // return X64Word.create(high, low); + // }, + + /** + * Shifts this word n bits to the right. + * + * @param {number} n The number of bits to shift. + * + * @return {X64Word} A new x64-Word object after shifting. + * + * @example + * + * var shifted = x64Word.shiftR(7); + */ + // shiftR: function (n) { + // if (n < 32) { + // var low = (this.low >>> n) | (this.high << (32 - n)); + // var high = this.high >>> n; + // } else { + // var low = this.high >>> (n - 32); + // var high = 0; + // } + + // return X64Word.create(high, low); + // }, + + /** + * Rotates this word n bits to the left. + * + * @param {number} n The number of bits to rotate. + * + * @return {X64Word} A new x64-Word object after rotating. + * + * @example + * + * var rotated = x64Word.rotL(25); + */ + // rotL: function (n) { + // return this.shiftL(n).or(this.shiftR(64 - n)); + // }, + + /** + * Rotates this word n bits to the right. + * + * @param {number} n The number of bits to rotate. + * + * @return {X64Word} A new x64-Word object after rotating. + * + * @example + * + * var rotated = x64Word.rotR(7); + */ + // rotR: function (n) { + // return this.shiftR(n).or(this.shiftL(64 - n)); + // }, + + /** + * Adds this word with the passed word. + * + * @param {X64Word} word The x64-Word to add with this word. + * + * @return {X64Word} A new x64-Word object after adding. + * + * @example + * + * var added = x64Word.add(anotherX64Word); + */ + // add: function (word) { + // var low = (this.low + word.low) | 0; + // var carry = (low >>> 0) < (this.low >>> 0) ? 1 : 0; + // var high = (this.high + word.high + carry) | 0; + + // return X64Word.create(high, low); + // } + }); + + /** + * An array of 64-bit words. + * + * @property {Array} words The array of CryptoJS.x64.Word objects. + * @property {number} sigBytes The number of significant bytes in this word array. + */ + var X64WordArray = C_x64.WordArray = Base.extend({ + /** + * Initializes a newly created word array. + * + * @param {Array} words (Optional) An array of CryptoJS.x64.Word objects. + * @param {number} sigBytes (Optional) The number of significant bytes in the words. + * + * @example + * + * var wordArray = CryptoJS.x64.WordArray.create(); + * + * var wordArray = CryptoJS.x64.WordArray.create([ + * CryptoJS.x64.Word.create(0x00010203, 0x04050607), + * CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f) + * ]); + * + * var wordArray = CryptoJS.x64.WordArray.create([ + * CryptoJS.x64.Word.create(0x00010203, 0x04050607), + * CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f) + * ], 10); + */ + init: function (words, sigBytes) { + words = this.words = words || []; + + if (sigBytes != undefined) { + this.sigBytes = sigBytes; + } else { + this.sigBytes = words.length * 8; + } + }, + + /** + * Converts this 64-bit word array to a 32-bit word array. + * + * @return {CryptoJS.lib.WordArray} This word array's data as a 32-bit word array. + * + * @example + * + * var x32WordArray = x64WordArray.toX32(); + */ + toX32: function () { + // Shortcuts + var x64Words = this.words; + var x64WordsLength = x64Words.length; + + // Convert + var x32Words = []; + for (var i = 0; i < x64WordsLength; i++) { + var x64Word = x64Words[i]; + x32Words.push(x64Word.high); + x32Words.push(x64Word.low); + } + + return X32WordArray.create(x32Words, this.sigBytes); + }, + + /** + * Creates a copy of this word array. + * + * @return {X64WordArray} The clone. + * + * @example + * + * var clone = x64WordArray.clone(); + */ + clone: function () { + var clone = Base.clone.call(this); + + // Clone "words" array + var words = clone.words = this.words.slice(0); + + // Clone each X64Word object + var wordsLength = words.length; + for (var i = 0; i < wordsLength; i++) { + words[i] = words[i].clone(); + } + + return clone; + } + }); + }()); + + + return CryptoJS; + +})); \ No newline at end of file diff --git a/node_modules/detect-libc/.npmignore b/node_modules/detect-libc/.npmignore new file mode 100644 index 0000000..8fc0e8d --- /dev/null +++ b/node_modules/detect-libc/.npmignore @@ -0,0 +1,7 @@ +.nyc_output +.travis.yml +coverage +test.js +node_modules +/.circleci +/tests/integration diff --git a/node_modules/detect-libc/LICENSE b/node_modules/detect-libc/LICENSE new file mode 100644 index 0000000..8dada3e --- /dev/null +++ b/node_modules/detect-libc/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/node_modules/detect-libc/README.md b/node_modules/detect-libc/README.md new file mode 100644 index 0000000..3176357 --- /dev/null +++ b/node_modules/detect-libc/README.md @@ -0,0 +1,78 @@ +# detect-libc + +Node.js module to detect the C standard library (libc) implementation +family and version in use on a given Linux system. + +Provides a value suitable for use with the `LIBC` option of +[prebuild](https://www.npmjs.com/package/prebuild), +[prebuild-ci](https://www.npmjs.com/package/prebuild-ci) and +[prebuild-install](https://www.npmjs.com/package/prebuild-install), +therefore allowing build and provision of pre-compiled binaries +for musl-based Linux e.g. Alpine as well as glibc-based. + +Currently supports libc detection of `glibc` and `musl`. + +## Install + +```sh +npm install detect-libc +``` + +## Usage + +### API + +```js +const { GLIBC, MUSL, family, version, isNonGlibcLinux } = require('detect-libc'); +``` + +* `GLIBC` is a String containing the value "glibc" for comparison with `family`. +* `MUSL` is a String containing the value "musl" for comparison with `family`. +* `family` is a String representing the system libc family. +* `version` is a String representing the system libc version number. +* `isNonGlibcLinux` is a Boolean representing whether the system is a non-glibc Linux, e.g. Alpine. + +### detect-libc command line tool + +When run on a Linux system with a non-glibc libc, +the child command will be run with the `LIBC` environment variable +set to the relevant value. + +On all other platforms will run the child command as-is. + +The command line feature requires `spawnSync` provided by Node v0.12+. + +```sh +detect-libc child-command +``` + +## Integrating with prebuild + +```json + "scripts": { + "install": "detect-libc prebuild-install || node-gyp rebuild", + "test": "mocha && detect-libc prebuild-ci" + }, + "dependencies": { + "detect-libc": "^1.0.2", + "prebuild-install": "^2.2.0" + }, + "devDependencies": { + "prebuild": "^6.2.1", + "prebuild-ci": "^2.2.3" + } +``` + +## Licence + +Copyright 2017 Lovell Fuller + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0.html) + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/node_modules/detect-libc/bin/detect-libc.js b/node_modules/detect-libc/bin/detect-libc.js new file mode 100644 index 0000000..5486127 --- /dev/null +++ b/node_modules/detect-libc/bin/detect-libc.js @@ -0,0 +1,18 @@ +#!/usr/bin/env node + +'use strict'; + +var spawnSync = require('child_process').spawnSync; +var libc = require('../'); + +var spawnOptions = { + env: process.env, + shell: true, + stdio: 'inherit' +}; + +if (libc.isNonGlibcLinux) { + spawnOptions.env.LIBC = process.env.LIBC || libc.family; +} + +process.exit(spawnSync(process.argv[2], process.argv.slice(3), spawnOptions).status); diff --git a/node_modules/detect-libc/lib/detect-libc.js b/node_modules/detect-libc/lib/detect-libc.js new file mode 100644 index 0000000..1855fe1 --- /dev/null +++ b/node_modules/detect-libc/lib/detect-libc.js @@ -0,0 +1,92 @@ +'use strict'; + +var platform = require('os').platform(); +var spawnSync = require('child_process').spawnSync; +var readdirSync = require('fs').readdirSync; + +var GLIBC = 'glibc'; +var MUSL = 'musl'; + +var spawnOptions = { + encoding: 'utf8', + env: process.env +}; + +if (!spawnSync) { + spawnSync = function () { + return { status: 126, stdout: '', stderr: '' }; + }; +} + +function contains (needle) { + return function (haystack) { + return haystack.indexOf(needle) !== -1; + }; +} + +function versionFromMuslLdd (out) { + return out.split(/[\r\n]+/)[1].trim().split(/\s/)[1]; +} + +function safeReaddirSync (path) { + try { + return readdirSync(path); + } catch (e) {} + return []; +} + +var family = ''; +var version = ''; +var method = ''; + +if (platform === 'linux') { + // Try getconf + var glibc = spawnSync('getconf', ['GNU_LIBC_VERSION'], spawnOptions); + if (glibc.status === 0) { + family = GLIBC; + version = glibc.stdout.trim().split(' ')[1]; + method = 'getconf'; + } else { + // Try ldd + var ldd = spawnSync('ldd', ['--version'], spawnOptions); + if (ldd.status === 0 && ldd.stdout.indexOf(MUSL) !== -1) { + family = MUSL; + version = versionFromMuslLdd(ldd.stdout); + method = 'ldd'; + } else if (ldd.status === 1 && ldd.stderr.indexOf(MUSL) !== -1) { + family = MUSL; + version = versionFromMuslLdd(ldd.stderr); + method = 'ldd'; + } else { + // Try filesystem (family only) + var lib = safeReaddirSync('/lib'); + if (lib.some(contains('-linux-gnu'))) { + family = GLIBC; + method = 'filesystem'; + } else if (lib.some(contains('libc.musl-'))) { + family = MUSL; + method = 'filesystem'; + } else if (lib.some(contains('ld-musl-'))) { + family = MUSL; + method = 'filesystem'; + } else { + var usrSbin = safeReaddirSync('/usr/sbin'); + if (usrSbin.some(contains('glibc'))) { + family = GLIBC; + method = 'filesystem'; + } + } + } + } +} + +var isNonGlibcLinux = (family !== '' && family !== GLIBC); + +module.exports = { + GLIBC: GLIBC, + MUSL: MUSL, + family: family, + version: version, + method: method, + isNonGlibcLinux: isNonGlibcLinux +}; diff --git a/node_modules/detect-libc/package.json b/node_modules/detect-libc/package.json new file mode 100644 index 0000000..cbd5cd1 --- /dev/null +++ b/node_modules/detect-libc/package.json @@ -0,0 +1,35 @@ +{ + "name": "detect-libc", + "version": "1.0.3", + "description": "Node.js module to detect the C standard library (libc) implementation family and version", + "main": "lib/detect-libc.js", + "bin": { + "detect-libc": "./bin/detect-libc.js" + }, + "scripts": { + "test": "semistandard && nyc --reporter=lcov ava" + }, + "repository": { + "type": "git", + "url": "git://github.com/lovell/detect-libc" + }, + "keywords": [ + "libc", + "glibc", + "musl" + ], + "author": "Lovell Fuller ", + "contributors": [ + "Niklas Salmoukas " + ], + "license": "Apache-2.0", + "devDependencies": { + "ava": "^0.23.0", + "nyc": "^11.3.0", + "proxyquire": "^1.8.0", + "semistandard": "^11.0.0" + }, + "engines": { + "node": ">=0.10" + } +} diff --git a/node_modules/fill-range/LICENSE b/node_modules/fill-range/LICENSE new file mode 100644 index 0000000..9af4a67 --- /dev/null +++ b/node_modules/fill-range/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014-present, Jon Schlinkert. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/fill-range/README.md b/node_modules/fill-range/README.md new file mode 100644 index 0000000..8d756fe --- /dev/null +++ b/node_modules/fill-range/README.md @@ -0,0 +1,237 @@ +# fill-range [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=W8YFZ425KND68) [![NPM version](https://img.shields.io/npm/v/fill-range.svg?style=flat)](https://www.npmjs.com/package/fill-range) [![NPM monthly downloads](https://img.shields.io/npm/dm/fill-range.svg?style=flat)](https://npmjs.org/package/fill-range) [![NPM total downloads](https://img.shields.io/npm/dt/fill-range.svg?style=flat)](https://npmjs.org/package/fill-range) [![Linux Build Status](https://img.shields.io/travis/jonschlinkert/fill-range.svg?style=flat&label=Travis)](https://travis-ci.org/jonschlinkert/fill-range) + +> Fill in a range of numbers or letters, optionally passing an increment or `step` to use, or create a regex-compatible range with `options.toRegex` + +Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support. + +## Install + +Install with [npm](https://www.npmjs.com/): + +```sh +$ npm install --save fill-range +``` + +## Usage + +Expands numbers and letters, optionally using a `step` as the last argument. _(Numbers may be defined as JavaScript numbers or strings)_. + +```js +const fill = require('fill-range'); +// fill(from, to[, step, options]); + +console.log(fill('1', '10')); //=> ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10'] +console.log(fill('1', '10', { toRegex: true })); //=> [1-9]|10 +``` + +**Params** + +* `from`: **{String|Number}** the number or letter to start with +* `to`: **{String|Number}** the number or letter to end with +* `step`: **{String|Number|Object|Function}** Optionally pass a [step](#optionsstep) to use. +* `options`: **{Object|Function}**: See all available [options](#options) + +## Examples + +By default, an array of values is returned. + +**Alphabetical ranges** + +```js +console.log(fill('a', 'e')); //=> ['a', 'b', 'c', 'd', 'e'] +console.log(fill('A', 'E')); //=> [ 'A', 'B', 'C', 'D', 'E' ] +``` + +**Numerical ranges** + +Numbers can be defined as actual numbers or strings. + +```js +console.log(fill(1, 5)); //=> [ 1, 2, 3, 4, 5 ] +console.log(fill('1', '5')); //=> [ 1, 2, 3, 4, 5 ] +``` + +**Negative ranges** + +Numbers can be defined as actual numbers or strings. + +```js +console.log(fill('-5', '-1')); //=> [ '-5', '-4', '-3', '-2', '-1' ] +console.log(fill('-5', '5')); //=> [ '-5', '-4', '-3', '-2', '-1', '0', '1', '2', '3', '4', '5' ] +``` + +**Steps (increments)** + +```js +// numerical ranges with increments +console.log(fill('0', '25', 4)); //=> [ '0', '4', '8', '12', '16', '20', '24' ] +console.log(fill('0', '25', 5)); //=> [ '0', '5', '10', '15', '20', '25' ] +console.log(fill('0', '25', 6)); //=> [ '0', '6', '12', '18', '24' ] + +// alphabetical ranges with increments +console.log(fill('a', 'z', 4)); //=> [ 'a', 'e', 'i', 'm', 'q', 'u', 'y' ] +console.log(fill('a', 'z', 5)); //=> [ 'a', 'f', 'k', 'p', 'u', 'z' ] +console.log(fill('a', 'z', 6)); //=> [ 'a', 'g', 'm', 's', 'y' ] +``` + +## Options + +### options.step + +**Type**: `number` (formatted as a string or number) + +**Default**: `undefined` + +**Description**: The increment to use for the range. Can be used with letters or numbers. + +**Example(s)** + +```js +// numbers +console.log(fill('1', '10', 2)); //=> [ '1', '3', '5', '7', '9' ] +console.log(fill('1', '10', 3)); //=> [ '1', '4', '7', '10' ] +console.log(fill('1', '10', 4)); //=> [ '1', '5', '9' ] + +// letters +console.log(fill('a', 'z', 5)); //=> [ 'a', 'f', 'k', 'p', 'u', 'z' ] +console.log(fill('a', 'z', 7)); //=> [ 'a', 'h', 'o', 'v' ] +console.log(fill('a', 'z', 9)); //=> [ 'a', 'j', 's' ] +``` + +### options.strictRanges + +**Type**: `boolean` + +**Default**: `false` + +**Description**: By default, `null` is returned when an invalid range is passed. Enable this option to throw a `RangeError` on invalid ranges. + +**Example(s)** + +The following are all invalid: + +```js +fill('1.1', '2'); // decimals not supported in ranges +fill('a', '2'); // incompatible range values +fill(1, 10, 'foo'); // invalid "step" argument +``` + +### options.stringify + +**Type**: `boolean` + +**Default**: `undefined` + +**Description**: Cast all returned values to strings. By default, integers are returned as numbers. + +**Example(s)** + +```js +console.log(fill(1, 5)); //=> [ 1, 2, 3, 4, 5 ] +console.log(fill(1, 5, { stringify: true })); //=> [ '1', '2', '3', '4', '5' ] +``` + +### options.toRegex + +**Type**: `boolean` + +**Default**: `undefined` + +**Description**: Create a regex-compatible source string, instead of expanding values to an array. + +**Example(s)** + +```js +// alphabetical range +console.log(fill('a', 'e', { toRegex: true })); //=> '[a-e]' +// alphabetical with step +console.log(fill('a', 'z', 3, { toRegex: true })); //=> 'a|d|g|j|m|p|s|v|y' +// numerical range +console.log(fill('1', '100', { toRegex: true })); //=> '[1-9]|[1-9][0-9]|100' +// numerical range with zero padding +console.log(fill('000001', '100000', { toRegex: true })); +//=> '0{5}[1-9]|0{4}[1-9][0-9]|0{3}[1-9][0-9]{2}|0{2}[1-9][0-9]{3}|0[1-9][0-9]{4}|100000' +``` + +### options.transform + +**Type**: `function` + +**Default**: `undefined` + +**Description**: Customize each value in the returned array (or [string](#optionstoRegex)). _(you can also pass this function as the last argument to `fill()`)_. + +**Example(s)** + +```js +// add zero padding +console.log(fill(1, 5, value => String(value).padStart(4, '0'))); +//=> ['0001', '0002', '0003', '0004', '0005'] +``` + +## About + +
+Contributing + +Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new). + +
+ +
+Running Tests + +Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command: + +```sh +$ npm install && npm test +``` + +
+ +
+Building docs + +_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_ + +To generate the readme, run the following command: + +```sh +$ npm install -g verbose/verb#dev verb-generate-readme && verb +``` + +
+ +### Contributors + +| **Commits** | **Contributor** | +| --- | --- | +| 116 | [jonschlinkert](https://github.com/jonschlinkert) | +| 4 | [paulmillr](https://github.com/paulmillr) | +| 2 | [realityking](https://github.com/realityking) | +| 2 | [bluelovers](https://github.com/bluelovers) | +| 1 | [edorivai](https://github.com/edorivai) | +| 1 | [wtgtybhertgeghgtwtg](https://github.com/wtgtybhertgeghgtwtg) | + +### Author + +**Jon Schlinkert** + +* [GitHub Profile](https://github.com/jonschlinkert) +* [Twitter Profile](https://twitter.com/jonschlinkert) +* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert) + +Please consider supporting me on Patreon, or [start your own Patreon page](https://patreon.com/invite/bxpbvm)! + + + + + +### License + +Copyright © 2019, [Jon Schlinkert](https://github.com/jonschlinkert). +Released under the [MIT License](LICENSE). + +*** + +_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on April 08, 2019._ \ No newline at end of file diff --git a/node_modules/fill-range/index.js b/node_modules/fill-range/index.js new file mode 100644 index 0000000..ddb212e --- /dev/null +++ b/node_modules/fill-range/index.js @@ -0,0 +1,248 @@ +/*! + * fill-range + * + * Copyright (c) 2014-present, Jon Schlinkert. + * Licensed under the MIT License. + */ + +'use strict'; + +const util = require('util'); +const toRegexRange = require('to-regex-range'); + +const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val); + +const transform = toNumber => { + return value => toNumber === true ? Number(value) : String(value); +}; + +const isValidValue = value => { + return typeof value === 'number' || (typeof value === 'string' && value !== ''); +}; + +const isNumber = num => Number.isInteger(+num); + +const zeros = input => { + let value = `${input}`; + let index = -1; + if (value[0] === '-') value = value.slice(1); + if (value === '0') return false; + while (value[++index] === '0'); + return index > 0; +}; + +const stringify = (start, end, options) => { + if (typeof start === 'string' || typeof end === 'string') { + return true; + } + return options.stringify === true; +}; + +const pad = (input, maxLength, toNumber) => { + if (maxLength > 0) { + let dash = input[0] === '-' ? '-' : ''; + if (dash) input = input.slice(1); + input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0')); + } + if (toNumber === false) { + return String(input); + } + return input; +}; + +const toMaxLen = (input, maxLength) => { + let negative = input[0] === '-' ? '-' : ''; + if (negative) { + input = input.slice(1); + maxLength--; + } + while (input.length < maxLength) input = '0' + input; + return negative ? ('-' + input) : input; +}; + +const toSequence = (parts, options, maxLen) => { + parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0); + parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0); + + let prefix = options.capture ? '' : '?:'; + let positives = ''; + let negatives = ''; + let result; + + if (parts.positives.length) { + positives = parts.positives.map(v => toMaxLen(String(v), maxLen)).join('|'); + } + + if (parts.negatives.length) { + negatives = `-(${prefix}${parts.negatives.map(v => toMaxLen(String(v), maxLen)).join('|')})`; + } + + if (positives && negatives) { + result = `${positives}|${negatives}`; + } else { + result = positives || negatives; + } + + if (options.wrap) { + return `(${prefix}${result})`; + } + + return result; +}; + +const toRange = (a, b, isNumbers, options) => { + if (isNumbers) { + return toRegexRange(a, b, { wrap: false, ...options }); + } + + let start = String.fromCharCode(a); + if (a === b) return start; + + let stop = String.fromCharCode(b); + return `[${start}-${stop}]`; +}; + +const toRegex = (start, end, options) => { + if (Array.isArray(start)) { + let wrap = options.wrap === true; + let prefix = options.capture ? '' : '?:'; + return wrap ? `(${prefix}${start.join('|')})` : start.join('|'); + } + return toRegexRange(start, end, options); +}; + +const rangeError = (...args) => { + return new RangeError('Invalid range arguments: ' + util.inspect(...args)); +}; + +const invalidRange = (start, end, options) => { + if (options.strictRanges === true) throw rangeError([start, end]); + return []; +}; + +const invalidStep = (step, options) => { + if (options.strictRanges === true) { + throw new TypeError(`Expected step "${step}" to be a number`); + } + return []; +}; + +const fillNumbers = (start, end, step = 1, options = {}) => { + let a = Number(start); + let b = Number(end); + + if (!Number.isInteger(a) || !Number.isInteger(b)) { + if (options.strictRanges === true) throw rangeError([start, end]); + return []; + } + + // fix negative zero + if (a === 0) a = 0; + if (b === 0) b = 0; + + let descending = a > b; + let startString = String(start); + let endString = String(end); + let stepString = String(step); + step = Math.max(Math.abs(step), 1); + + let padded = zeros(startString) || zeros(endString) || zeros(stepString); + let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0; + let toNumber = padded === false && stringify(start, end, options) === false; + let format = options.transform || transform(toNumber); + + if (options.toRegex && step === 1) { + return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options); + } + + let parts = { negatives: [], positives: [] }; + let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num)); + let range = []; + let index = 0; + + while (descending ? a >= b : a <= b) { + if (options.toRegex === true && step > 1) { + push(a); + } else { + range.push(pad(format(a, index), maxLen, toNumber)); + } + a = descending ? a - step : a + step; + index++; + } + + if (options.toRegex === true) { + return step > 1 + ? toSequence(parts, options, maxLen) + : toRegex(range, null, { wrap: false, ...options }); + } + + return range; +}; + +const fillLetters = (start, end, step = 1, options = {}) => { + if ((!isNumber(start) && start.length > 1) || (!isNumber(end) && end.length > 1)) { + return invalidRange(start, end, options); + } + + let format = options.transform || (val => String.fromCharCode(val)); + let a = `${start}`.charCodeAt(0); + let b = `${end}`.charCodeAt(0); + + let descending = a > b; + let min = Math.min(a, b); + let max = Math.max(a, b); + + if (options.toRegex && step === 1) { + return toRange(min, max, false, options); + } + + let range = []; + let index = 0; + + while (descending ? a >= b : a <= b) { + range.push(format(a, index)); + a = descending ? a - step : a + step; + index++; + } + + if (options.toRegex === true) { + return toRegex(range, null, { wrap: false, options }); + } + + return range; +}; + +const fill = (start, end, step, options = {}) => { + if (end == null && isValidValue(start)) { + return [start]; + } + + if (!isValidValue(start) || !isValidValue(end)) { + return invalidRange(start, end, options); + } + + if (typeof step === 'function') { + return fill(start, end, 1, { transform: step }); + } + + if (isObject(step)) { + return fill(start, end, 0, step); + } + + let opts = { ...options }; + if (opts.capture === true) opts.wrap = true; + step = step || opts.step || 1; + + if (!isNumber(step)) { + if (step != null && !isObject(step)) return invalidStep(step, opts); + return fill(start, end, 1, step); + } + + if (isNumber(start) && isNumber(end)) { + return fillNumbers(start, end, step, opts); + } + + return fillLetters(start, end, Math.max(Math.abs(step), 1), opts); +}; + +module.exports = fill; diff --git a/node_modules/fill-range/package.json b/node_modules/fill-range/package.json new file mode 100644 index 0000000..582357f --- /dev/null +++ b/node_modules/fill-range/package.json @@ -0,0 +1,74 @@ +{ + "name": "fill-range", + "description": "Fill in a range of numbers or letters, optionally passing an increment or `step` to use, or create a regex-compatible range with `options.toRegex`", + "version": "7.1.1", + "homepage": "https://github.com/jonschlinkert/fill-range", + "author": "Jon Schlinkert (https://github.com/jonschlinkert)", + "contributors": [ + "Edo Rivai (edo.rivai.nl)", + "Jon Schlinkert (http://twitter.com/jonschlinkert)", + "Paul Miller (paulmillr.com)", + "Rouven Weßling (www.rouvenwessling.de)", + "(https://github.com/wtgtybhertgeghgtwtg)" + ], + "repository": "jonschlinkert/fill-range", + "bugs": { + "url": "https://github.com/jonschlinkert/fill-range/issues" + }, + "license": "MIT", + "files": [ + "index.js" + ], + "main": "index.js", + "engines": { + "node": ">=8" + }, + "scripts": { + "lint": "eslint --cache --cache-location node_modules/.cache/.eslintcache --report-unused-disable-directives --ignore-path .gitignore .", + "mocha": "mocha --reporter dot", + "test": "npm run lint && npm run mocha", + "test:ci": "npm run test:cover", + "test:cover": "nyc npm run mocha" + }, + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "devDependencies": { + "gulp-format-md": "^2.0.0", + "mocha": "^6.1.1", + "nyc": "^15.1.0" + }, + "keywords": [ + "alpha", + "alphabetical", + "array", + "bash", + "brace", + "expand", + "expansion", + "fill", + "glob", + "match", + "matches", + "matching", + "number", + "numerical", + "range", + "ranges", + "regex", + "sh" + ], + "verb": { + "toc": false, + "layout": "default", + "tasks": [ + "readme" + ], + "plugins": [ + "gulp-format-md" + ], + "lint": { + "reflinks": true + } + } +} diff --git a/node_modules/immutable/LICENSE b/node_modules/immutable/LICENSE new file mode 100644 index 0000000..1e3c4f3 --- /dev/null +++ b/node_modules/immutable/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2014-present, Lee Byron and other contributors. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/node_modules/immutable/README.md b/node_modules/immutable/README.md new file mode 100644 index 0000000..b921657 --- /dev/null +++ b/node_modules/immutable/README.md @@ -0,0 +1,761 @@ +# Immutable collections for JavaScript + +[![Build Status](https://github.com/immutable-js/immutable-js/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/immutable-js/immutable-js/actions/workflows/ci.yml?query=branch%3Amain) [Chat on slack](https://immutable-js.slack.com) + +[Read the docs](https://immutable-js.com/docs/) and eat your vegetables. + +Docs are automatically generated from [README.md][] and [immutable.d.ts][]. +Please contribute! Also, don't miss the [wiki][] which contains articles on +additional specific topics. Can't find something? Open an [issue][]. + +**Table of contents:** + +- [Introduction](#introduction) +- [Getting started](#getting-started) +- [The case for Immutability](#the-case-for-immutability) +- [JavaScript-first API](#javascript-first-api) +- [Nested Structures](#nested-structures) +- [Equality treats Collections as Values](#equality-treats-collections-as-values) +- [Batching Mutations](#batching-mutations) +- [Lazy Seq](#lazy-seq) +- [Additional Tools and Resources](#additional-tools-and-resources) +- [Contributing](#contributing) + +## Introduction + +[Immutable][] data cannot be changed once created, leading to much simpler +application development, no defensive copying, and enabling advanced memoization +and change detection techniques with simple logic. [Persistent][] data presents +a mutative API which does not update the data in-place, but instead always +yields new updated data. + +Immutable.js provides many Persistent Immutable data structures including: +`List`, `Stack`, `Map`, `OrderedMap`, `Set`, `OrderedSet` and `Record`. + +These data structures are highly efficient on modern JavaScript VMs by using +structural sharing via [hash maps tries][] and [vector tries][] as popularized +by Clojure and Scala, minimizing the need to copy or cache data. + +Immutable.js also provides a lazy `Seq`, allowing efficient +chaining of collection methods like `map` and `filter` without creating +intermediate representations. Create some `Seq` with `Range` and `Repeat`. + +Want to hear more? Watch the presentation about Immutable.js: + +[![Immutable Data and React](website/public/Immutable-Data-and-React-YouTube.png)](https://youtu.be/I7IdS-PbEgI) + +[README.md]: https://github.com/immutable-js/immutable-js/blob/main/README.md +[immutable.d.ts]: https://github.com/immutable-js/immutable-js/blob/main/type-definitions/immutable.d.ts +[wiki]: https://github.com/immutable-js/immutable-js/wiki +[issue]: https://github.com/immutable-js/immutable-js/issues +[Persistent]: https://en.wikipedia.org/wiki/Persistent_data_structure +[Immutable]: https://en.wikipedia.org/wiki/Immutable_object +[hash maps tries]: https://en.wikipedia.org/wiki/Hash_array_mapped_trie +[vector tries]: https://hypirion.com/musings/understanding-persistent-vector-pt-1 + +## Getting started + +Install `immutable` using npm. + +```shell +# using npm +npm install immutable + +# using Yarn +yarn add immutable + +# using pnpm +pnpm add immutable + +# using Bun +bun add immutable +``` + +Then require it into any module. + + + +```js +const { Map } = require('immutable'); +const map1 = Map({ a: 1, b: 2, c: 3 }); +const map2 = map1.set('b', 50); +map1.get('b') + ' vs. ' + map2.get('b'); // 2 vs. 50 +``` + +### Browser + +Immutable.js has no dependencies, which makes it predictable to include in a Browser. + +It's highly recommended to use a module bundler like [webpack](https://webpack.js.org/), +[rollup](https://rollupjs.org/), or +[browserify](https://browserify.org/). The `immutable` npm module works +without any additional consideration. All examples throughout the documentation +will assume use of this kind of tool. + +Alternatively, Immutable.js may be directly included as a script tag. Download +or link to a CDN such as [CDNJS](https://cdnjs.com/libraries/immutable) +or [jsDelivr](https://www.jsdelivr.com/package/npm/immutable). + +Use a script tag to directly add `Immutable` to the global scope: + +```html + + +``` + +Or use an AMD-style loader (such as [RequireJS](https://requirejs.org/)): + +```js +require(['./immutable.min.js'], function (Immutable) { + var map1 = Immutable.Map({ a: 1, b: 2, c: 3 }); + var map2 = map1.set('b', 50); + map1.get('b'); // 2 + map2.get('b'); // 50 +}); +``` + +### Flow & TypeScript + +Use these Immutable collections and sequences as you would use native +collections in your [Flowtype](https://flowtype.org/) or [TypeScript](https://typescriptlang.org) programs while still taking +advantage of type generics, error detection, and auto-complete in your IDE. + +Installing `immutable` via npm brings with it type definitions for Flow (v0.55.0 or higher) +and TypeScript (v4.5 or higher), so you shouldn't need to do anything at all! + +#### Using TypeScript with Immutable.js v4+ + +Immutable.js type definitions embrace ES2015. While Immutable.js itself supports +legacy browsers and environments, its type definitions require TypeScript's 2015 +lib. Include either `"target": "es2015"` or `"lib": "es2015"` in your +`tsconfig.json`, or provide `--target es2015` or `--lib es2015` to the +`tsc` command. + + + +```js +const { Map } = require('immutable'); +const map1 = Map({ a: 1, b: 2, c: 3 }); +const map2 = map1.set('b', 50); +map1.get('b') + ' vs. ' + map2.get('b'); // 2 vs. 50 +``` + +#### Using TypeScript with Immutable.js v3 and earlier: + +Previous versions of Immutable.js include a reference file which you can include +via relative path to the type definitions at the top of your file. + +```js +/// +import { Map } from 'immutable'; +var map1: Map; +map1 = Map({ a: 1, b: 2, c: 3 }); +var map2 = map1.set('b', 50); +map1.get('b'); // 2 +map2.get('b'); // 50 +``` + +## The case for Immutability + +Much of what makes application development difficult is tracking mutation and +maintaining state. Developing with immutable data encourages you to think +differently about how data flows through your application. + +Subscribing to data events throughout your application creates a huge overhead of +book-keeping which can hurt performance, sometimes dramatically, and creates +opportunities for areas of your application to get out of sync with each other +due to easy to make programmer error. Since immutable data never changes, +subscribing to changes throughout the model is a dead-end and new data can only +ever be passed from above. + +This model of data flow aligns well with the architecture of [React][] +and especially well with an application designed using the ideas of [Flux][]. + +When data is passed from above rather than being subscribed to, and you're only +interested in doing work when something has changed, you can use equality. + +Immutable collections should be treated as _values_ rather than _objects_. While +objects represent some thing which could change over time, a value represents +the state of that thing at a particular instance of time. This principle is most +important to understanding the appropriate use of immutable data. In order to +treat Immutable.js collections as values, it's important to use the +`Immutable.is()` function or `.equals()` method to determine _value equality_ +instead of the `===` operator which determines object _reference identity_. + + + +```js +const { Map } = require('immutable'); +const map1 = Map({ a: 1, b: 2, c: 3 }); +const map2 = Map({ a: 1, b: 2, c: 3 }); +map1.equals(map2); // true +map1 === map2; // false +``` + +Note: As a performance optimization Immutable.js attempts to return the existing +collection when an operation would result in an identical collection, allowing +for using `===` reference equality to determine if something definitely has not +changed. This can be extremely useful when used within a memoization function +which would prefer to re-run the function if a deeper equality check could +potentially be more costly. The `===` equality check is also used internally by +`Immutable.is` and `.equals()` as a performance optimization. + + + +```js +const { Map } = require('immutable'); +const map1 = Map({ a: 1, b: 2, c: 3 }); +const map2 = map1.set('b', 2); // Set to same value +map1 === map2; // true +``` + +If an object is immutable, it can be "copied" simply by making another reference +to it instead of copying the entire object. Because a reference is much smaller +than the object itself, this results in memory savings and a potential boost in +execution speed for programs which rely on copies (such as an undo-stack). + + + +```js +const { Map } = require('immutable'); +const map = Map({ a: 1, b: 2, c: 3 }); +const mapCopy = map; // Look, "copies" are free! +``` + +[React]: https://reactjs.org/ +[Flux]: https://facebook.github.io/flux/docs/in-depth-overview/ + + +## JavaScript-first API + +While Immutable.js is inspired by Clojure, Scala, Haskell and other functional +programming environments, it's designed to bring these powerful concepts to +JavaScript, and therefore has an Object-Oriented API that closely mirrors that +of [ES2015][] [Array][], [Map][], and [Set][]. + +[es2015]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/New_in_JavaScript/ECMAScript_6_support_in_Mozilla +[array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array +[map]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map +[set]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set + +The difference for the immutable collections is that methods which would mutate +the collection, like `push`, `set`, `unshift` or `splice`, instead return a new +immutable collection. Methods which return new arrays, like `slice` or `concat`, +instead return new immutable collections. + + + +```js +const { List } = require('immutable'); +const list1 = List([1, 2]); +const list2 = list1.push(3, 4, 5); +const list3 = list2.unshift(0); +const list4 = list1.concat(list2, list3); +assert.equal(list1.size, 2); +assert.equal(list2.size, 5); +assert.equal(list3.size, 6); +assert.equal(list4.size, 13); +assert.equal(list4.get(0), 1); +``` + +Almost all of the methods on [Array][] will be found in similar form on +`Immutable.List`, those of [Map][] found on `Immutable.Map`, and those of [Set][] +found on `Immutable.Set`, including collection operations like `forEach()` +and `map()`. + + + +```js +const { Map } = require('immutable'); +const alpha = Map({ a: 1, b: 2, c: 3, d: 4 }); +alpha.map((v, k) => k.toUpperCase()).join(); +// 'A,B,C,D' +``` + +### Convert from raw JavaScript objects and arrays. + +Designed to inter-operate with your existing JavaScript, Immutable.js +accepts plain JavaScript Arrays and Objects anywhere a method expects a +`Collection`. + + + +```js +const { Map, List } = require('immutable'); +const map1 = Map({ a: 1, b: 2, c: 3, d: 4 }); +const map2 = Map({ c: 10, a: 20, t: 30 }); +const obj = { d: 100, o: 200, g: 300 }; +const map3 = map1.merge(map2, obj); +// Map { a: 20, b: 2, c: 10, d: 100, t: 30, o: 200, g: 300 } +const list1 = List([1, 2, 3]); +const list2 = List([4, 5, 6]); +const array = [7, 8, 9]; +const list3 = list1.concat(list2, array); +// List [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ] +``` + +This is possible because Immutable.js can treat any JavaScript Array or Object +as a Collection. You can take advantage of this in order to get sophisticated +collection methods on JavaScript Objects, which otherwise have a very sparse +native API. Because Seq evaluates lazily and does not cache intermediate +results, these operations can be extremely efficient. + + + +```js +const { Seq } = require('immutable'); +const myObject = { a: 1, b: 2, c: 3 }; +Seq(myObject) + .map(x => x * x) + .toObject(); +// { a: 1, b: 4, c: 9 } +``` + +Keep in mind, when using JS objects to construct Immutable Maps, that +JavaScript Object properties are always strings, even if written in a quote-less +shorthand, while Immutable Maps accept keys of any type. + + + +```js +const { fromJS } = require('immutable'); + +const obj = { 1: 'one' }; +console.log(Object.keys(obj)); // [ "1" ] +console.log(obj['1'], obj[1]); // "one", "one" + +const map = fromJS(obj); +console.log(map.get('1'), map.get(1)); // "one", undefined +``` + +Property access for JavaScript Objects first converts the key to a string, but +since Immutable Map keys can be of any type the argument to `get()` is +not altered. + +### Converts back to raw JavaScript objects. + +All Immutable.js Collections can be converted to plain JavaScript Arrays and +Objects shallowly with `toArray()` and `toObject()` or deeply with `toJS()`. +All Immutable Collections also implement `toJSON()` allowing them to be passed +to `JSON.stringify` directly. They also respect the custom `toJSON()` methods of +nested objects. + + + +```js +const { Map, List } = require('immutable'); +const deep = Map({ a: 1, b: 2, c: List([3, 4, 5]) }); +console.log(deep.toObject()); // { a: 1, b: 2, c: List [ 3, 4, 5 ] } +console.log(deep.toArray()); // [ 1, 2, List [ 3, 4, 5 ] ] +console.log(deep.toJS()); // { a: 1, b: 2, c: [ 3, 4, 5 ] } +JSON.stringify(deep); // '{"a":1,"b":2,"c":[3,4,5]}' +``` + +### Embraces ES2015 + +Immutable.js supports all JavaScript environments, including legacy +browsers (even IE11). However it also takes advantage of features added to +JavaScript in [ES2015][], the latest standard version of JavaScript, including +[Iterators][], [Arrow Functions][], [Classes][], and [Modules][]. It's inspired +by the native [Map][] and [Set][] collections added to ES2015. + +All examples in the Documentation are presented in ES2015. To run in all +browsers, they need to be translated to ES5. + +```js +// ES2015 +const mapped = foo.map(x => x * x); +// ES5 +var mapped = foo.map(function (x) { + return x * x; +}); +``` + +All Immutable.js collections are [Iterable][iterators], which allows them to be +used anywhere an Iterable is expected, such as when spreading into an Array. + + + +```js +const { List } = require('immutable'); +const aList = List([1, 2, 3]); +const anArray = [0, ...aList, 4, 5]; // [ 0, 1, 2, 3, 4, 5 ] +``` + +Note: A Collection is always iterated in the same order, however that order may +not always be well defined, as is the case for the `Map` and `Set`. + +[Iterators]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol +[Arrow Functions]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions +[Classes]: https://wiki.ecmascript.org/doku.php?id=strawman:maximally_minimal_classes +[Modules]: https://www.2ality.com/2014/09/es6-modules-final.html + + +## Nested Structures + +The collections in Immutable.js are intended to be nested, allowing for deep +trees of data, similar to JSON. + + + +```js +const { fromJS } = require('immutable'); +const nested = fromJS({ a: { b: { c: [3, 4, 5] } } }); +// Map { a: Map { b: Map { c: List [ 3, 4, 5 ] } } } +``` + +A few power-tools allow for reading and operating on nested data. The +most useful are `mergeDeep`, `getIn`, `setIn`, and `updateIn`, found on `List`, +`Map` and `OrderedMap`. + + + +```js +const { fromJS } = require('immutable'); +const nested = fromJS({ a: { b: { c: [3, 4, 5] } } }); + +const nested2 = nested.mergeDeep({ a: { b: { d: 6 } } }); +// Map { a: Map { b: Map { c: List [ 3, 4, 5 ], d: 6 } } } + +console.log(nested2.getIn(['a', 'b', 'd'])); // 6 + +const nested3 = nested2.updateIn(['a', 'b', 'd'], value => value + 1); +console.log(nested3); +// Map { a: Map { b: Map { c: List [ 3, 4, 5 ], d: 7 } } } + +const nested4 = nested3.updateIn(['a', 'b', 'c'], list => list.push(6)); +// Map { a: Map { b: Map { c: List [ 3, 4, 5, 6 ], d: 7 } } } +``` + +## Equality treats Collections as Values + +Immutable.js collections are treated as pure data _values_. Two immutable +collections are considered _value equal_ (via `.equals()` or `is()`) if they +represent the same collection of values. This differs from JavaScript's typical +_reference equal_ (via `===` or `==`) for Objects and Arrays which only +determines if two variables represent references to the same object instance. + +Consider the example below where two identical `Map` instances are not +_reference equal_ but are _value equal_. + + + +```js +// First consider: +const obj1 = { a: 1, b: 2, c: 3 }; +const obj2 = { a: 1, b: 2, c: 3 }; +obj1 !== obj2; // two different instances are always not equal with === + +const { Map, is } = require('immutable'); +const map1 = Map({ a: 1, b: 2, c: 3 }); +const map2 = Map({ a: 1, b: 2, c: 3 }); +map1 !== map2; // two different instances are not reference-equal +map1.equals(map2); // but are value-equal if they have the same values +is(map1, map2); // alternatively can use the is() function +``` + +Value equality allows Immutable.js collections to be used as keys in Maps or +values in Sets, and retrieved with different but equivalent collections: + + + +```js +const { Map, Set } = require('immutable'); +const map1 = Map({ a: 1, b: 2, c: 3 }); +const map2 = Map({ a: 1, b: 2, c: 3 }); +const set = Set().add(map1); +set.has(map2); // true because these are value-equal +``` + +Note: `is()` uses the same measure of equality as [Object.is][] for scalar +strings and numbers, but uses value equality for Immutable collections, +determining if both are immutable and all keys and values are equal +using the same measure of equality. + +[object.is]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is + +#### Performance tradeoffs + +While value equality is useful in many circumstances, it has different +performance characteristics than reference equality. Understanding these +tradeoffs may help you decide which to use in each case, especially when used +to memoize some operation. + +When comparing two collections, value equality may require considering every +item in each collection, on an `O(N)` time complexity. For large collections of +values, this could become a costly operation. Though if the two are not equal +and hardly similar, the inequality is determined very quickly. In contrast, when +comparing two collections with reference equality, only the initial references +to memory need to be compared which is not based on the size of the collections, +which has an `O(1)` time complexity. Checking reference equality is always very +fast, however just because two collections are not reference-equal does not rule +out the possibility that they may be value-equal. + +#### Return self on no-op optimization + +When possible, Immutable.js avoids creating new objects for updates where no +change in _value_ occurred, to allow for efficient _reference equality_ checking +to quickly determine if no change occurred. + + + +```js +const { Map } = require('immutable'); +const originalMap = Map({ a: 1, b: 2, c: 3 }); +const updatedMap = originalMap.set('b', 2); +updatedMap === originalMap; // No-op .set() returned the original reference. +``` + +However updates which do result in a change will return a new reference. Each +of these operations occur independently, so two similar updates will not return +the same reference: + + + +```js +const { Map } = require('immutable'); +const originalMap = Map({ a: 1, b: 2, c: 3 }); +const updatedMap = originalMap.set('b', 1000); +// New instance, leaving the original immutable. +updatedMap !== originalMap; +const anotherUpdatedMap = originalMap.set('b', 1000); +// Despite both the results of the same operation, each created a new reference. +anotherUpdatedMap !== updatedMap; +// However the two are value equal. +anotherUpdatedMap.equals(updatedMap); +``` + +## Batching Mutations + +> If a tree falls in the woods, does it make a sound? +> +> If a pure function mutates some local data in order to produce an immutable +> return value, is that ok? +> +> — Rich Hickey, Clojure + +Applying a mutation to create a new immutable object results in some overhead, +which can add up to a minor performance penalty. If you need to apply a series +of mutations locally before returning, Immutable.js gives you the ability to +create a temporary mutable (transient) copy of a collection and apply a batch of +mutations in a performant manner by using `withMutations`. In fact, this is +exactly how Immutable.js applies complex mutations itself. + +As an example, building `list2` results in the creation of 1, not 3, new +immutable Lists. + + + +```js +const { List } = require('immutable'); +const list1 = List([1, 2, 3]); +const list2 = list1.withMutations(function (list) { + list.push(4).push(5).push(6); +}); +assert.equal(list1.size, 3); +assert.equal(list2.size, 6); +``` + +Note: Immutable.js also provides `asMutable` and `asImmutable`, but only +encourages their use when `withMutations` will not suffice. Use caution to not +return a mutable copy, which could result in undesired behavior. + +_Important!_: Only a select few methods can be used in `withMutations` including +`set`, `push` and `pop`. These methods can be applied directly against a +persistent data-structure where other methods like `map`, `filter`, `sort`, +and `splice` will always return new immutable data-structures and never mutate +a mutable collection. + +## Lazy Seq + +`Seq` describes a lazy operation, allowing them to efficiently chain +use of all the higher-order collection methods (such as `map` and `filter`) +by not creating intermediate collections. + +**Seq is immutable** — Once a Seq is created, it cannot be +changed, appended to, rearranged or otherwise modified. Instead, any mutative +method called on a `Seq` will return a new `Seq`. + +**Seq is lazy** — `Seq` does as little work as necessary to respond to any +method call. Values are often created during iteration, including implicit +iteration when reducing or converting to a concrete data structure such as +a `List` or JavaScript `Array`. + +For example, the following performs no work, because the resulting +`Seq`'s values are never iterated: + +```js +const { Seq } = require('immutable'); +const oddSquares = Seq([1, 2, 3, 4, 5, 6, 7, 8]) + .filter(x => x % 2 !== 0) + .map(x => x * x); +``` + +Once the `Seq` is used, it performs only the work necessary. In this +example, no intermediate arrays are ever created, filter is called three +times, and map is only called once: + +```js +oddSquares.get(1); // 9 +``` + +Any collection can be converted to a lazy Seq with `Seq()`. + + + +```js +const { Map, Seq } = require('immutable'); +const map = Map({ a: 1, b: 2, c: 3 }); +const lazySeq = Seq(map); +``` + +`Seq` allows for the efficient chaining of operations, allowing for the +expression of logic that can otherwise be very tedious: + +```js +lazySeq + .flip() + .map(key => key.toUpperCase()) + .flip(); +// Seq { A: 1, B: 2, C: 3 } +``` + +As well as expressing logic that would otherwise seem memory or time +limited, for example `Range` is a special kind of Lazy sequence. + + + +```js +const { Range } = require('immutable'); +Range(1, Infinity) + .skip(1000) + .map(n => -n) + .filter(n => n % 2 === 0) + .take(2) + .reduce((r, n) => r * n, 1); +// 1006008 +``` + +## Comparison of filter(), groupBy(), and partition() + +The `filter()`, `groupBy()`, and `partition()` methods are similar in that they +all divide a collection into parts based on applying a function to each element. +All three call the predicate or grouping function once for each item in the +input collection. All three return zero or more collections of the same type as +their input. The returned collections are always distinct from the input +(according to `===`), even if the contents are identical. + +Of these methods, `filter()` is the only one that is lazy and the only one which +discards items from the input collection. It is the simplest to use, and the +fact that it returns exactly one collection makes it easy to combine with other +methods to form a pipeline of operations. + +The `partition()` method is similar to an eager version of `filter()`, but it +returns two collections; the first contains the items that would have been +discarded by `filter()`, and the second contains the items that would have been +kept. It always returns an array of exactly two collections, which can make it +easier to use than `groupBy()`. Compared to making two separate calls to +`filter()`, `partition()` makes half as many calls it the predicate passed to +it. + +The `groupBy()` method is a more generalized version of `partition()` that can +group by an arbitrary function rather than just a predicate. It returns a map +with zero or more entries, where the keys are the values returned by the +grouping function, and the values are nonempty collections of the corresponding +arguments. Although `groupBy()` is more powerful than `partition()`, it can be +harder to use because it is not always possible predict in advance how many +entries the returned map will have and what their keys will be. + +| Summary | `filter` | `partition` | `groupBy` | +|:------------------------------|:---------|:------------|:---------------| +| ease of use | easiest | moderate | hardest | +| generality | least | moderate | most | +| laziness | lazy | eager | eager | +| # of returned sub-collections | 1 | 2 | 0 or more | +| sub-collections may be empty | yes | yes | no | +| can discard items | yes | no | no | +| wrapping container | none | array | Map/OrderedMap | + +## Additional Tools and Resources + +- [Atom-store](https://github.com/jameshopkins/atom-store/) + - A Clojure-inspired atom implementation in Javascript with configurability + for external persistance. + +- [Chai Immutable](https://github.com/astorije/chai-immutable) + - If you are using the [Chai Assertion Library](https://chaijs.com/), this + provides a set of assertions to use against Immutable.js collections. + +- [Fantasy-land](https://github.com/fantasyland/fantasy-land) + - Specification for interoperability of common algebraic structures in JavaScript. + +- [Immutagen](https://github.com/pelotom/immutagen) + - A library for simulating immutable generators in JavaScript. + +- [Immutable-cursor](https://github.com/redbadger/immutable-cursor) + - Immutable cursors incorporating the Immutable.js interface over + Clojure-inspired atom. + +- [Immutable-ext](https://github.com/DrBoolean/immutable-ext) + - Fantasyland extensions for immutablejs + +- [Immutable-js-tools](https://github.com/madeinfree/immutable-js-tools) + - Util tools for immutable.js + +- [Immutable-Redux](https://github.com/gajus/redux-immutable) + - redux-immutable is used to create an equivalent function of Redux + combineReducers that works with Immutable.js state. + +- [Immutable-Treeutils](https://github.com/lukasbuenger/immutable-treeutils) + - Functional tree traversal helpers for ImmutableJS data structures. + +- [Irecord](https://github.com/ericelliott/irecord) + - An immutable store that exposes an RxJS observable. Great for React. + +- [Mudash](https://github.com/brianneisler/mudash) + - Lodash wrapper providing Immutable.JS support. + +- [React-Immutable-PropTypes](https://github.com/HurricaneJames/react-immutable-proptypes) + - PropType validators that work with Immutable.js. + +- [Redux-Immutablejs](https://github.com/indexiatech/redux-immutablejs) + - Redux Immutable facilities. + +- [Rxstate](https://github.com/yamalight/rxstate) + - Simple opinionated state management library based on RxJS and Immutable.js. + +- [Transit-Immutable-js](https://github.com/glenjamin/transit-immutable-js) + - Transit serialisation for Immutable.js. + - See also: [Transit-js](https://github.com/cognitect/transit-js) + +Have an additional tool designed to work with Immutable.js? +Submit a PR to add it to this list in alphabetical order. + +## Contributing + +Use [Github issues](https://github.com/immutable-js/immutable-js/issues) for requests. + +We actively welcome pull requests, learn how to [contribute](https://github.com/immutable-js/immutable-js/blob/main/.github/CONTRIBUTING.md). + +Immutable.js is maintained within the [Contributor Covenant's Code of Conduct](https://www.contributor-covenant.org/version/2/0/code_of_conduct/). + +### Changelog + +Changes are tracked as [Github releases](https://github.com/immutable-js/immutable-js/releases). + +### License + +Immutable.js is [MIT-licensed](./LICENSE). + +### Thanks + +[Phil Bagwell](https://www.youtube.com/watch?v=K2NYwP90bNs), for his inspiration +and research in persistent data structures. + +[Hugh Jackson](https://github.com/hughfdjackson/), for providing the npm package +name. If you're looking for his unsupported package, see [this repository](https://github.com/hughfdjackson/immutable). diff --git a/node_modules/immutable/dist/immutable.d.ts b/node_modules/immutable/dist/immutable.d.ts new file mode 100644 index 0000000..622fb01 --- /dev/null +++ b/node_modules/immutable/dist/immutable.d.ts @@ -0,0 +1,6249 @@ +/** @ignore we should disable this rules, but let's activate it to enable eslint first */ +/** + * Immutable data encourages pure functions (data-in, data-out) and lends itself + * to much simpler application development and enabling techniques from + * functional programming such as lazy evaluation. + * + * While designed to bring these powerful functional concepts to JavaScript, it + * presents an Object-Oriented API familiar to Javascript engineers and closely + * mirroring that of Array, Map, and Set. It is easy and efficient to convert to + * and from plain Javascript types. + * + * ## How to read these docs + * + * In order to better explain what kinds of values the Immutable.js API expects + * and produces, this documentation is presented in a statically typed dialect of + * JavaScript (like [Flow][] or [TypeScript][]). You *don't need* to use these + * type checking tools in order to use Immutable.js, however becoming familiar + * with their syntax will help you get a deeper understanding of this API. + * + * **A few examples and how to read them.** + * + * All methods describe the kinds of data they accept and the kinds of data + * they return. For example a function which accepts two numbers and returns + * a number would look like this: + * + * ```js + * sum(first: number, second: number): number + * ``` + * + * Sometimes, methods can accept different kinds of data or return different + * kinds of data, and this is described with a *type variable*, which is + * typically in all-caps. For example, a function which always returns the same + * kind of data it was provided would look like this: + * + * ```js + * identity(value: T): T + * ``` + * + * Type variables are defined with classes and referred to in methods. For + * example, a class that holds onto a value for you might look like this: + * + * ```js + * class Box { + * constructor(value: T) + * getValue(): T + * } + * ``` + * + * In order to manipulate Immutable data, methods that we're used to affecting + * a Collection instead return a new Collection of the same type. The type + * `this` refers to the same kind of class. For example, a List which returns + * new Lists when you `push` a value onto it might look like: + * + * ```js + * class List { + * push(value: T): this + * } + * ``` + * + * Many methods in Immutable.js accept values which implement the JavaScript + * [Iterable][] protocol, and might appear like `Iterable` for something + * which represents sequence of strings. Typically in JavaScript we use plain + * Arrays (`[]`) when an Iterable is expected, but also all of the Immutable.js + * collections are iterable themselves! + * + * For example, to get a value deep within a structure of data, we might use + * `getIn` which expects an `Iterable` path: + * + * ``` + * getIn(path: Iterable): unknown + * ``` + * + * To use this method, we could pass an array: `data.getIn([ "key", 2 ])`. + * + * + * Note: All examples are presented in the modern [ES2015][] version of + * JavaScript. Use tools like Babel to support older browsers. + * + * For example: + * + * ```js + * // ES2015 + * const mappedFoo = foo.map(x => x * x); + * // ES5 + * var mappedFoo = foo.map(function (x) { return x * x; }); + * ``` + * + * [ES2015]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/New_in_JavaScript/ECMAScript_6_support_in_Mozilla + * [TypeScript]: https://www.typescriptlang.org/ + * [Flow]: https://flowtype.org/ + * [Iterable]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols + */ + +declare namespace Immutable { + /** @ignore */ + type OnlyObject = Extract; + + /** @ignore */ + type ContainObject = + OnlyObject extends object + ? OnlyObject extends never + ? false + : true + : false; + + /** + * @ignore + * + * Used to convert deeply all immutable types to a plain TS type. + * Using `unknown` on object instead of recursive call as we have a circular reference issue + */ + export type DeepCopy = + T extends Record + ? // convert Record to DeepCopy plain JS object + { + [key in keyof R]: ContainObject extends true + ? unknown + : R[key]; + } + : T extends MapOf + ? // convert MapOf to DeepCopy plain JS object + { + [key in keyof R]: ContainObject extends true + ? unknown + : R[key]; + } + : T extends Collection.Keyed + ? // convert KeyedCollection to DeepCopy plain JS object + { + [key in KeyedKey extends PropertyKey + ? KeyedKey + : string]: V extends object ? unknown : V; + } + : // convert IndexedCollection or Immutable.Set to DeepCopy plain JS array + // eslint-disable-next-line @typescript-eslint/no-unused-vars + T extends Collection + ? Array> + : T extends string | number // Iterable scalar types : should be kept as is + ? T + : T extends Iterable // Iterable are converted to plain JS array + ? Array> + : T extends object // plain JS object are converted deeply + ? { + [ObjectKey in keyof T]: ContainObject< + T[ObjectKey] + > extends true + ? unknown + : T[ObjectKey]; + } + : // other case : should be kept as is + T; + + /** + * Describes which item in a pair should be placed first when sorting + * + * @ignore + */ + export enum PairSorting { + LeftThenRight = -1, + RightThenLeft = +1, + } + + /** + * Function comparing two items of the same type. It can return: + * + * * a PairSorting value, to indicate whether the left-hand item or the right-hand item should be placed before the other + * + * * the traditional numeric return value - especially -1, 0, or 1 + * + * @ignore + */ + export type Comparator = (left: T, right: T) => PairSorting | number; + + /** + * @ignore + * + * KeyPath allowed for `xxxIn` methods + */ + export type KeyPath = OrderedCollection | ArrayLike; + + /** + * Lists are ordered indexed dense collections, much like a JavaScript + * Array. + * + * Lists are immutable and fully persistent with O(log32 N) gets and sets, + * and O(1) push and pop. + * + * Lists implement Deque, with efficient addition and removal from both the + * end (`push`, `pop`) and beginning (`unshift`, `shift`). + * + * Unlike a JavaScript Array, there is no distinction between an + * "unset" index and an index set to `undefined`. `List#forEach` visits all + * indices from 0 to size, regardless of whether they were explicitly defined. + */ + namespace List { + /** + * True if the provided value is a List + * + * + * ```js + * const { List } = require('immutable'); + * List.isList([]); // false + * List.isList(List()); // true + * ``` + */ + function isList(maybeList: unknown): maybeList is List; + + /** + * Creates a new List containing `values`. + * + * + * ```js + * const { List } = require('immutable'); + * List.of(1, 2, 3, 4) + * // List [ 1, 2, 3, 4 ] + * ``` + * + * Note: Values are not altered or converted in any way. + * + * + * ```js + * const { List } = require('immutable'); + * List.of({x:1}, 2, [3], 4) + * // List [ { x: 1 }, 2, [ 3 ], 4 ] + * ``` + */ + function of(...values: Array): List; + } + + /** + * Create a new immutable List containing the values of the provided + * collection-like. + * + * Note: `List` is a factory function and not a class, and does not use the + * `new` keyword during construction. + * + * + * ```js + * const { List, Set } = require('immutable') + * + * const emptyList = List() + * // List [] + * + * const plainArray = [ 1, 2, 3, 4 ] + * const listFromPlainArray = List(plainArray) + * // List [ 1, 2, 3, 4 ] + * + * const plainSet = Set([ 1, 2, 3, 4 ]) + * const listFromPlainSet = List(plainSet) + * // List [ 1, 2, 3, 4 ] + * + * const arrayIterator = plainArray[Symbol.iterator]() + * const listFromCollectionArray = List(arrayIterator) + * // List [ 1, 2, 3, 4 ] + * + * listFromPlainArray.equals(listFromCollectionArray) // true + * listFromPlainSet.equals(listFromCollectionArray) // true + * listFromPlainSet.equals(listFromPlainArray) // true + * ``` + */ + function List(collection?: Iterable | ArrayLike): List; + + interface List extends Collection.Indexed { + /** + * The number of items in this List. + */ + readonly size: number; + + // Persistent changes + + /** + * Returns a new List which includes `value` at `index`. If `index` already + * exists in this List, it will be replaced. + * + * `index` may be a negative number, which indexes back from the end of the + * List. `v.set(-1, "value")` sets the last item in the List. + * + * If `index` larger than `size`, the returned List's `size` will be large + * enough to include the `index`. + * + * + * ```js + * const originalList = List([ 0 ]); + * // List [ 0 ] + * originalList.set(1, 1); + * // List [ 0, 1 ] + * originalList.set(0, 'overwritten'); + * // List [ "overwritten" ] + * originalList.set(2, 2); + * // List [ 0, undefined, 2 ] + * + * List().set(50000, 'value').size; + * // 50001 + * ``` + * + * Note: `set` can be used in `withMutations`. + */ + set(index: number, value: T): List; + + /** + * Returns a new List which excludes this `index` and with a size 1 less + * than this List. Values at indices above `index` are shifted down by 1 to + * fill the position. + * + * This is synonymous with `list.splice(index, 1)`. + * + * `index` may be a negative number, which indexes back from the end of the + * List. `v.delete(-1)` deletes the last item in the List. + * + * Note: `delete` cannot be safely used in IE8 + * + * + * ```js + * List([ 0, 1, 2, 3, 4 ]).delete(0); + * // List [ 1, 2, 3, 4 ] + * ``` + * + * Since `delete()` re-indexes values, it produces a complete copy, which + * has `O(N)` complexity. + * + * Note: `delete` *cannot* be used in `withMutations`. + * + * @alias remove + */ + delete(index: number): List; + remove(index: number): List; + + /** + * Returns a new List with `value` at `index` with a size 1 more than this + * List. Values at indices above `index` are shifted over by 1. + * + * This is synonymous with `list.splice(index, 0, value)`. + * + * + * ```js + * List([ 0, 1, 2, 3, 4 ]).insert(6, 5) + * // List [ 0, 1, 2, 3, 4, 5 ] + * ``` + * + * Since `insert()` re-indexes values, it produces a complete copy, which + * has `O(N)` complexity. + * + * Note: `insert` *cannot* be used in `withMutations`. + */ + insert(index: number, value: T): List; + + /** + * Returns a new List with 0 size and no values in constant time. + * + * + * ```js + * List([ 1, 2, 3, 4 ]).clear() + * // List [] + * ``` + * + * Note: `clear` can be used in `withMutations`. + */ + clear(): List; + + /** + * Returns a new List with the provided `values` appended, starting at this + * List's `size`. + * + * + * ```js + * List([ 1, 2, 3, 4 ]).push(5) + * // List [ 1, 2, 3, 4, 5 ] + * ``` + * + * Note: `push` can be used in `withMutations`. + */ + push(...values: Array): List; + + /** + * Returns a new List with a size ones less than this List, excluding + * the last index in this List. + * + * Note: this differs from `Array#pop` because it returns a new + * List rather than the removed value. Use `last()` to get the last value + * in this List. + * + * ```js + * List([ 1, 2, 3, 4 ]).pop() + * // List[ 1, 2, 3 ] + * ``` + * + * Note: `pop` can be used in `withMutations`. + */ + pop(): List; + + /** + * Returns a new List with the provided `values` prepended, shifting other + * values ahead to higher indices. + * + * + * ```js + * List([ 2, 3, 4]).unshift(1); + * // List [ 1, 2, 3, 4 ] + * ``` + * + * Note: `unshift` can be used in `withMutations`. + */ + unshift(...values: Array): List; + + /** + * Returns a new List with a size ones less than this List, excluding + * the first index in this List, shifting all other values to a lower index. + * + * Note: this differs from `Array#shift` because it returns a new + * List rather than the removed value. Use `first()` to get the first + * value in this List. + * + * + * ```js + * List([ 0, 1, 2, 3, 4 ]).shift(); + * // List [ 1, 2, 3, 4 ] + * ``` + * + * Note: `shift` can be used in `withMutations`. + */ + shift(): List; + + /** + * Returns a new List with an updated value at `index` with the return + * value of calling `updater` with the existing value, or `notSetValue` if + * `index` was not set. If called with a single argument, `updater` is + * called with the List itself. + * + * `index` may be a negative number, which indexes back from the end of the + * List. `v.update(-1)` updates the last item in the List. + * + * + * ```js + * const list = List([ 'a', 'b', 'c' ]) + * const result = list.update(2, val => val.toUpperCase()) + * // List [ "a", "b", "C" ] + * ``` + * + * This can be very useful as a way to "chain" a normal function into a + * sequence of methods. RxJS calls this "let" and lodash calls it "thru". + * + * For example, to sum a List after mapping and filtering: + * + * + * ```js + * function sum(collection) { + * return collection.reduce((sum, x) => sum + x, 0) + * } + * + * List([ 1, 2, 3 ]) + * .map(x => x + 1) + * .filter(x => x % 2 === 0) + * .update(sum) + * // 6 + * ``` + * + * Note: `update(index)` can be used in `withMutations`. + * + * @see `Map#update` + */ + update(index: number, notSetValue: T, updater: (value: T) => T): this; + update( + index: number, + updater: (value: T | undefined) => T | undefined + ): this; + update(updater: (value: this) => R): R; + + /** + * Returns a new List with size `size`. If `size` is less than this + * List's size, the new List will exclude values at the higher indices. + * If `size` is greater than this List's size, the new List will have + * undefined values for the newly available indices. + * + * When building a new List and the final size is known up front, `setSize` + * used in conjunction with `withMutations` may result in the more + * performant construction. + */ + setSize(size: number): List; + + // Deep persistent changes + + /** + * Returns a new List having set `value` at this `keyPath`. If any keys in + * `keyPath` do not exist, a new immutable Map will be created at that key. + * + * Index numbers are used as keys to determine the path to follow in + * the List. + * + * + * ```js + * const { List } = require('immutable') + * const list = List([ 0, 1, 2, List([ 3, 4 ])]) + * list.setIn([3, 0], 999); + * // List [ 0, 1, 2, List [ 999, 4 ] ] + * ``` + * + * Plain JavaScript Object or Arrays may be nested within an Immutable.js + * Collection, and setIn() can update those values as well, treating them + * immutably by creating new copies of those values with the changes applied. + * + * + * ```js + * const { List } = require('immutable') + * const list = List([ 0, 1, 2, { plain: 'object' }]) + * list.setIn([3, 'plain'], 'value'); + * // List([ 0, 1, 2, { plain: 'value' }]) + * ``` + * + * Note: `setIn` can be used in `withMutations`. + */ + setIn(keyPath: Iterable, value: unknown): this; + + /** + * Returns a new List having removed the value at this `keyPath`. If any + * keys in `keyPath` do not exist, no change will occur. + * + * + * ```js + * const { List } = require('immutable') + * const list = List([ 0, 1, 2, List([ 3, 4 ])]) + * list.deleteIn([3, 0]); + * // List [ 0, 1, 2, List [ 4 ] ] + * ``` + * + * Plain JavaScript Object or Arrays may be nested within an Immutable.js + * Collection, and removeIn() can update those values as well, treating them + * immutably by creating new copies of those values with the changes applied. + * + * + * ```js + * const { List } = require('immutable') + * const list = List([ 0, 1, 2, { plain: 'object' }]) + * list.removeIn([3, 'plain']); + * // List([ 0, 1, 2, {}]) + * ``` + * + * Note: `deleteIn` *cannot* be safely used in `withMutations`. + * + * @alias removeIn + */ + deleteIn(keyPath: Iterable): this; + removeIn(keyPath: Iterable): this; + + /** + * Note: `updateIn` can be used in `withMutations`. + * + * @see `Map#updateIn` + */ + updateIn( + keyPath: Iterable, + notSetValue: unknown, + updater: (value: unknown) => unknown + ): this; + updateIn( + keyPath: Iterable, + updater: (value: unknown) => unknown + ): this; + + /** + * Note: `mergeIn` can be used in `withMutations`. + * + * @see `Map#mergeIn` + */ + mergeIn(keyPath: Iterable, ...collections: Array): this; + + /** + * Note: `mergeDeepIn` can be used in `withMutations`. + * + * @see `Map#mergeDeepIn` + */ + mergeDeepIn( + keyPath: Iterable, + ...collections: Array + ): this; + + // Transient changes + + /** + * Note: Not all methods can be safely used on a mutable collection or within + * `withMutations`! Check the documentation for each method to see if it + * allows being used in `withMutations`. + * + * @see `Map#withMutations` + */ + withMutations(mutator: (mutable: this) => unknown): this; + + /** + * An alternative API for withMutations() + * + * Note: Not all methods can be safely used on a mutable collection or within + * `withMutations`! Check the documentation for each method to see if it + * allows being used in `withMutations`. + * + * @see `Map#asMutable` + */ + asMutable(): this; + + /** + * @see `Map#wasAltered` + */ + wasAltered(): boolean; + + /** + * @see `Map#asImmutable` + */ + asImmutable(): this; + + // Sequence algorithms + + /** + * Returns a new List with other values or collections concatenated to this one. + * + * Note: `concat` can be used in `withMutations`. + * + * @alias merge + */ + concat(...valuesOrCollections: Array | C>): List; + merge(...collections: Array>): List; + + /** + * Returns a new List with values passed through a + * `mapper` function. + * + * + * ```js + * List([ 1, 2 ]).map(x => 10 * x) + * // List [ 10, 20 ] + * ``` + */ + map( + mapper: (value: T, key: number, iter: this) => M, + context?: unknown + ): List; + + /** + * Flat-maps the List, returning a new List. + * + * Similar to `list.map(...).flatten(true)`. + */ + flatMap( + mapper: (value: T, key: number, iter: this) => Iterable, + context?: unknown + ): List; + + /** + * Returns a new List with only the values for which the `predicate` + * function returns true. + * + * Note: `filter()` always returns a new instance, even if it results in + * not filtering out any values. + */ + filter( + predicate: (value: T, index: number, iter: this) => value is F, + context?: unknown + ): List; + filter( + predicate: (value: T, index: number, iter: this) => unknown, + context?: unknown + ): this; + + /** + * Returns a new List with the values for which the `predicate` + * function returns false and another for which is returns true. + */ + partition( + predicate: (this: C, value: T, index: number, iter: this) => value is F, + context?: C + ): [List, List]; + partition( + predicate: (this: C, value: T, index: number, iter: this) => unknown, + context?: C + ): [this, this]; + + /** + * Returns a List "zipped" with the provided collection. + * + * Like `zipWith`, but using the default `zipper`: creating an `Array`. + * + * + * ```js + * const a = List([ 1, 2, 3 ]); + * const b = List([ 4, 5, 6 ]); + * const c = a.zip(b); // List [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ] + * ``` + */ + zip(other: Collection): List<[T, U]>; + zip( + other: Collection, + other2: Collection + ): List<[T, U, V]>; + zip(...collections: Array>): List; + + /** + * Returns a List "zipped" with the provided collections. + * + * Unlike `zip`, `zipAll` continues zipping until the longest collection is + * exhausted. Missing values from shorter collections are filled with `undefined`. + * + * + * ```js + * const a = List([ 1, 2 ]); + * const b = List([ 3, 4, 5 ]); + * const c = a.zipAll(b); // List [ [ 1, 3 ], [ 2, 4 ], [ undefined, 5 ] ] + * ``` + * + * Note: Since zipAll will return a collection as large as the largest + * input, some results may contain undefined values. TypeScript cannot + * account for these without cases (as of v2.5). + */ + zipAll(other: Collection): List<[T, U]>; + zipAll( + other: Collection, + other2: Collection + ): List<[T, U, V]>; + zipAll(...collections: Array>): List; + + /** + * Returns a List "zipped" with the provided collections by using a + * custom `zipper` function. + * + * + * ```js + * const a = List([ 1, 2, 3 ]); + * const b = List([ 4, 5, 6 ]); + * const c = a.zipWith((a, b) => a + b, b); + * // List [ 5, 7, 9 ] + * ``` + */ + zipWith( + zipper: (value: T, otherValue: U) => Z, + otherCollection: Collection + ): List; + zipWith( + zipper: (value: T, otherValue: U, thirdValue: V) => Z, + otherCollection: Collection, + thirdCollection: Collection + ): List; + zipWith( + zipper: (...values: Array) => Z, + ...collections: Array> + ): List; + + /** + * Returns a new List with its values shuffled thanks to the + * [Fisher–Yates](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle) + * algorithm. + * It uses Math.random, but you can provide your own random number generator. + */ + shuffle(random?: () => number): this; + } + + /** + * Immutable Map is an unordered Collection.Keyed of (key, value) pairs with + * `O(log32 N)` gets and `O(log32 N)` persistent sets. + * + * Iteration order of a Map is undefined, however is stable. Multiple + * iterations of the same Map will iterate in the same order. + * + * Map's keys can be of any type, and use `Immutable.is` to determine key + * equality. This allows the use of any value (including NaN) as a key. + * + * Because `Immutable.is` returns equality based on value semantics, and + * Immutable collections are treated as values, any Immutable collection may + * be used as a key. + * + * + * ```js + * const { Map, List } = require('immutable'); + * Map().set(List([ 1 ]), 'listofone').get(List([ 1 ])); + * // 'listofone' + * ``` + * + * Any JavaScript object may be used as a key, however strict identity is used + * to evaluate key equality. Two similar looking objects will represent two + * different keys. + * + * Implemented by a hash-array mapped trie. + */ + namespace Map { + /** + * True if the provided value is a Map + * + * + * ```js + * const { Map } = require('immutable') + * Map.isMap({}) // false + * Map.isMap(Map()) // true + * ``` + */ + function isMap(maybeMap: unknown): maybeMap is Map; + } + + /** + * Creates a new Immutable Map. + * + * Created with the same key value pairs as the provided Collection.Keyed or + * JavaScript Object or expects a Collection of [K, V] tuple entries. + * + * Note: `Map` is a factory function and not a class, and does not use the + * `new` keyword during construction. + * + * + * ```js + * const { Map } = require('immutable') + * Map({ key: "value" }) + * Map([ [ "key", "value" ] ]) + * ``` + * + * Keep in mind, when using JS objects to construct Immutable Maps, that + * JavaScript Object properties are always strings, even if written in a + * quote-less shorthand, while Immutable Maps accept keys of any type. + * + * + * ```js + * let obj = { 1: "one" } + * Object.keys(obj) // [ "1" ] + * assert.equal(obj["1"], obj[1]) // "one" === "one" + * + * let map = Map(obj) + * assert.notEqual(map.get("1"), map.get(1)) // "one" !== undefined + * ``` + * + * Property access for JavaScript Objects first converts the key to a string, + * but since Immutable Map keys can be of any type the argument to `get()` is + * not altered. + */ + function Map(collection?: Iterable<[K, V]>): Map; + function Map(obj: R): MapOf; + function Map(obj: { [key: string]: V }): Map; + function Map(obj: { [P in K]?: V }): Map; + + /** + * Represent a Map constructed by an object + * + * @ignore + */ + interface MapOf + extends Map { + /** + * Returns the value associated with the provided key, or notSetValue if + * the Collection does not contain this key. + * + * Note: it is possible a key may be associated with an `undefined` value, + * so if `notSetValue` is not provided and this method returns `undefined`, + * that does not guarantee the key was not found. + */ + get(key: K, notSetValue?: unknown): R[K]; + get(key: unknown, notSetValue: NSV): NSV; + + // TODO `` can be used after dropping support for TypeScript 4.x + // reference: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-0.html#const-type-parameters + // after this change, `as const` assertions can be remove from the type tests + getIn

>( + searchKeyPath: [...P], + notSetValue?: unknown + ): RetrievePath; + + set(key: K, value: R[K]): this; + + update(updater: (value: this) => this): this; + update(key: K, updater: (value: R[K]) => R[K]): this; + update( + key: K, + notSetValue: NSV, + updater: (value: R[K]) => R[K] + ): this; + + // Possible best type is MapOf> but Omit seems to broke other function calls + // and generate recursion error with other methods (update, merge, etc.) until those functions are defined in MapOf + delete( + key: K + ): Extract extends never ? never : this; + remove( + key: K + ): Extract extends never ? never : this; + + toJS(): { [K in keyof R]: DeepCopy }; + + toJSON(): { [K in keyof R]: R[K] }; + } + + // Loosely based off of this work. + // https://github.com/immutable-js/immutable-js/issues/1462#issuecomment-584123268 + + /** + * @ignore + * Convert an immutable type to the equivalent plain TS type + * - MapOf -> object + * - List -> Array + */ + type GetNativeType = + S extends MapOf ? T : S extends List ? Array : S; + + /** @ignore */ + type Head> = T extends [ + infer H, + ...Array, + ] + ? H + : never; + /** @ignore */ + type Tail> = T extends [unknown, ...infer I] + ? I + : Array; + /** @ignore */ + type RetrievePathReducer< + T, + C, + L extends ReadonlyArray, + NT = GetNativeType, + > = + // we can not retrieve a path from a primitive type + T extends string | number | boolean | null | undefined + ? never + : C extends keyof NT + ? L extends [] // L extends [] means we are at the end of the path, lets return the current type + ? NT[C] + : // we are not at the end of the path, lets continue with the next key + RetrievePathReducer, Tail> + : // C is not a "key" of NT, so the path is invalid + never; + + /** @ignore */ + type RetrievePath> = P extends [] + ? P + : RetrievePathReducer, Tail

>; + + interface Map extends Collection.Keyed { + /** + * The number of entries in this Map. + */ + readonly size: number; + + // Persistent changes + + /** + * Returns a new Map also containing the new key, value pair. If an equivalent + * key already exists in this Map, it will be replaced. + * + * + * ```js + * const { Map } = require('immutable') + * const originalMap = Map() + * const newerMap = originalMap.set('key', 'value') + * const newestMap = newerMap.set('key', 'newer value') + * + * originalMap + * // Map {} + * newerMap + * // Map { "key": "value" } + * newestMap + * // Map { "key": "newer value" } + * ``` + * + * Note: `set` can be used in `withMutations`. + */ + set(key: K, value: V): this; + + /** + * Returns a new Map which excludes this `key`. + * + * Note: `delete` cannot be safely used in IE8, but is provided to mirror + * the ES6 collection API. + * + * + * ```js + * const { Map } = require('immutable') + * const originalMap = Map({ + * key: 'value', + * otherKey: 'other value' + * }) + * // Map { "key": "value", "otherKey": "other value" } + * originalMap.delete('otherKey') + * // Map { "key": "value" } + * ``` + * + * Note: `delete` can be used in `withMutations`. + * + * @alias remove + */ + delete(key: K): this; + remove(key: K): this; + + /** + * Returns a new Map which excludes the provided `keys`. + * + * + * ```js + * const { Map } = require('immutable') + * const names = Map({ a: "Aaron", b: "Barry", c: "Connor" }) + * names.deleteAll([ 'a', 'c' ]) + * // Map { "b": "Barry" } + * ``` + * + * Note: `deleteAll` can be used in `withMutations`. + * + * @alias removeAll + */ + deleteAll(keys: Iterable): this; + removeAll(keys: Iterable): this; + + /** + * Returns a new Map containing no keys or values. + * + * + * ```js + * const { Map } = require('immutable') + * Map({ key: 'value' }).clear() + * // Map {} + * ``` + * + * Note: `clear` can be used in `withMutations`. + */ + clear(): this; + + /** + * Returns a new Map having updated the value at this `key` with the return + * value of calling `updater` with the existing value. + * + * Similar to: `map.set(key, updater(map.get(key)))`. + * + * + * ```js + * const { Map } = require('immutable') + * const aMap = Map({ key: 'value' }) + * const newMap = aMap.update('key', value => value + value) + * // Map { "key": "valuevalue" } + * ``` + * + * This is most commonly used to call methods on collections within a + * structure of data. For example, in order to `.push()` onto a nested `List`, + * `update` and `push` can be used together: + * + * + * ```js + * const aMap = Map({ nestedList: List([ 1, 2, 3 ]) }) + * const newMap = aMap.update('nestedList', list => list.push(4)) + * // Map { "nestedList": List [ 1, 2, 3, 4 ] } + * ``` + * + * When a `notSetValue` is provided, it is provided to the `updater` + * function when the value at the key does not exist in the Map. + * + * + * ```js + * const aMap = Map({ key: 'value' }) + * const newMap = aMap.update('noKey', 'no value', value => value + value) + * // Map { "key": "value", "noKey": "no valueno value" } + * ``` + * + * However, if the `updater` function returns the same value it was called + * with, then no change will occur. This is still true if `notSetValue` + * is provided. + * + * + * ```js + * const aMap = Map({ apples: 10 }) + * const newMap = aMap.update('oranges', 0, val => val) + * // Map { "apples": 10 } + * assert.strictEqual(newMap, map); + * ``` + * + * For code using ES2015 or later, using `notSetValue` is discourged in + * favor of function parameter default values. This helps to avoid any + * potential confusion with identify functions as described above. + * + * The previous example behaves differently when written with default values: + * + * + * ```js + * const aMap = Map({ apples: 10 }) + * const newMap = aMap.update('oranges', (val = 0) => val) + * // Map { "apples": 10, "oranges": 0 } + * ``` + * + * If no key is provided, then the `updater` function return value is + * returned as well. + * + * + * ```js + * const aMap = Map({ key: 'value' }) + * const result = aMap.update(aMap => aMap.get('key')) + * // "value" + * ``` + * + * This can be very useful as a way to "chain" a normal function into a + * sequence of methods. RxJS calls this "let" and lodash calls it "thru". + * + * For example, to sum the values in a Map + * + * + * ```js + * function sum(collection) { + * return collection.reduce((sum, x) => sum + x, 0) + * } + * + * Map({ x: 1, y: 2, z: 3 }) + * .map(x => x + 1) + * .filter(x => x % 2 === 0) + * .update(sum) + * // 6 + * ``` + * + * Note: `update(key)` can be used in `withMutations`. + */ + update(key: K, notSetValue: V, updater: (value: V) => V): this; + update(key: K, updater: (value: V | undefined) => V | undefined): this; + update(updater: (value: this) => R): R; + + /** + * Returns a new Map resulting from merging the provided Collections + * (or JS objects) into this Map. In other words, this takes each entry of + * each collection and sets it on this Map. + * + * Note: Values provided to `merge` are shallowly converted before being + * merged. No nested values are altered. + * + * + * ```js + * const { Map } = require('immutable') + * const one = Map({ a: 10, b: 20, c: 30 }) + * const two = Map({ b: 40, a: 50, d: 60 }) + * one.merge(two) // Map { "a": 50, "b": 40, "c": 30, "d": 60 } + * two.merge(one) // Map { "b": 20, "a": 10, "d": 60, "c": 30 } + * ``` + * + * Note: `merge` can be used in `withMutations`. + * + * @alias concat + */ + merge( + ...collections: Array> + ): Map | VC>; + merge( + ...collections: Array<{ [key: string]: C }> + ): Map | C>; + + concat( + ...collections: Array> + ): Map | VC>; + concat( + ...collections: Array<{ [key: string]: C }> + ): Map | C>; + + /** + * Like `merge()`, `mergeWith()` returns a new Map resulting from merging + * the provided Collections (or JS objects) into this Map, but uses the + * `merger` function for dealing with conflicts. + * + * + * ```js + * const { Map } = require('immutable') + * const one = Map({ a: 10, b: 20, c: 30 }) + * const two = Map({ b: 40, a: 50, d: 60 }) + * one.mergeWith((oldVal, newVal) => oldVal / newVal, two) + * // { "a": 0.2, "b": 0.5, "c": 30, "d": 60 } + * two.mergeWith((oldVal, newVal) => oldVal / newVal, one) + * // { "b": 2, "a": 5, "d": 60, "c": 30 } + * ``` + * + * Note: `mergeWith` can be used in `withMutations`. + */ + mergeWith( + merger: (oldVal: V, newVal: VC, key: K) => VCC, + ...collections: Array> + ): Map; + mergeWith( + merger: (oldVal: V, newVal: C, key: string) => CC, + ...collections: Array<{ [key: string]: C }> + ): Map; + + /** + * Like `merge()`, but when two compatible collections are encountered with + * the same key, it merges them as well, recursing deeply through the nested + * data. Two collections are considered to be compatible (and thus will be + * merged together) if they both fall into one of three categories: keyed + * (e.g., `Map`s, `Record`s, and objects), indexed (e.g., `List`s and + * arrays), or set-like (e.g., `Set`s). If they fall into separate + * categories, `mergeDeep` will replace the existing collection with the + * collection being merged in. This behavior can be customized by using + * `mergeDeepWith()`. + * + * Note: Indexed and set-like collections are merged using + * `concat()`/`union()` and therefore do not recurse. + * + * + * ```js + * const { Map } = require('immutable') + * const one = Map({ a: Map({ x: 10, y: 10 }), b: Map({ x: 20, y: 50 }) }) + * const two = Map({ a: Map({ x: 2 }), b: Map({ y: 5 }), c: Map({ z: 3 }) }) + * one.mergeDeep(two) + * // Map { + * // "a": Map { "x": 2, "y": 10 }, + * // "b": Map { "x": 20, "y": 5 }, + * // "c": Map { "z": 3 } + * // } + * ``` + * + * Note: `mergeDeep` can be used in `withMutations`. + */ + mergeDeep( + ...collections: Array> + ): Map; + mergeDeep( + ...collections: Array<{ [key: string]: C }> + ): Map; + + /** + * Like `mergeDeep()`, but when two non-collections or incompatible + * collections are encountered at the same key, it uses the `merger` + * function to determine the resulting value. Collections are considered + * incompatible if they fall into separate categories between keyed, + * indexed, and set-like. + * + * + * ```js + * const { Map } = require('immutable') + * const one = Map({ a: Map({ x: 10, y: 10 }), b: Map({ x: 20, y: 50 }) }) + * const two = Map({ a: Map({ x: 2 }), b: Map({ y: 5 }), c: Map({ z: 3 }) }) + * one.mergeDeepWith((oldVal, newVal) => oldVal / newVal, two) + * // Map { + * // "a": Map { "x": 5, "y": 10 }, + * // "b": Map { "x": 20, "y": 10 }, + * // "c": Map { "z": 3 } + * // } + * ``` + * + * Note: `mergeDeepWith` can be used in `withMutations`. + */ + mergeDeepWith( + merger: (oldVal: unknown, newVal: unknown, key: unknown) => unknown, + ...collections: Array | { [key: string]: V }> + ): this; + + // Deep persistent changes + + /** + * Returns a new Map having set `value` at this `keyPath`. If any keys in + * `keyPath` do not exist, a new immutable Map will be created at that key. + * + * + * ```js + * const { Map } = require('immutable') + * const originalMap = Map({ + * subObject: Map({ + * subKey: 'subvalue', + * subSubObject: Map({ + * subSubKey: 'subSubValue' + * }) + * }) + * }) + * + * const newMap = originalMap.setIn(['subObject', 'subKey'], 'ha ha!') + * // Map { + * // "subObject": Map { + * // "subKey": "ha ha!", + * // "subSubObject": Map { "subSubKey": "subSubValue" } + * // } + * // } + * + * const newerMap = originalMap.setIn( + * ['subObject', 'subSubObject', 'subSubKey'], + * 'ha ha ha!' + * ) + * // Map { + * // "subObject": Map { + * // "subKey": "subvalue", + * // "subSubObject": Map { "subSubKey": "ha ha ha!" } + * // } + * // } + * ``` + * + * Plain JavaScript Object or Arrays may be nested within an Immutable.js + * Collection, and setIn() can update those values as well, treating them + * immutably by creating new copies of those values with the changes applied. + * + * + * ```js + * const { Map } = require('immutable') + * const originalMap = Map({ + * subObject: { + * subKey: 'subvalue', + * subSubObject: { + * subSubKey: 'subSubValue' + * } + * } + * }) + * + * originalMap.setIn(['subObject', 'subKey'], 'ha ha!') + * // Map { + * // "subObject": { + * // subKey: "ha ha!", + * // subSubObject: { subSubKey: "subSubValue" } + * // } + * // } + * ``` + * + * If any key in the path exists but cannot be updated (such as a primitive + * like number or a custom Object like Date), an error will be thrown. + * + * Note: `setIn` can be used in `withMutations`. + */ + setIn(keyPath: Iterable, value: unknown): this; + + /** + * Returns a new Map having removed the value at this `keyPath`. If any keys + * in `keyPath` do not exist, no change will occur. + * + * Note: `deleteIn` can be used in `withMutations`. + * + * @alias removeIn + */ + deleteIn(keyPath: Iterable): this; + removeIn(keyPath: Iterable): this; + + /** + * Returns a new Map having applied the `updater` to the entry found at the + * keyPath. + * + * This is most commonly used to call methods on collections nested within a + * structure of data. For example, in order to `.push()` onto a nested `List`, + * `updateIn` and `push` can be used together: + * + * + * ```js + * const { Map, List } = require('immutable') + * const map = Map({ inMap: Map({ inList: List([ 1, 2, 3 ]) }) }) + * const newMap = map.updateIn(['inMap', 'inList'], list => list.push(4)) + * // Map { "inMap": Map { "inList": List [ 1, 2, 3, 4 ] } } + * ``` + * + * If any keys in `keyPath` do not exist, new Immutable `Map`s will + * be created at those keys. If the `keyPath` does not already contain a + * value, the `updater` function will be called with `notSetValue`, if + * provided, otherwise `undefined`. + * + * + * ```js + * const map = Map({ a: Map({ b: Map({ c: 10 }) }) }) + * const newMap = map.updateIn(['a', 'b', 'c'], val => val * 2) + * // Map { "a": Map { "b": Map { "c": 20 } } } + * ``` + * + * If the `updater` function returns the same value it was called with, then + * no change will occur. This is still true if `notSetValue` is provided. + * + * + * ```js + * const map = Map({ a: Map({ b: Map({ c: 10 }) }) }) + * const newMap = map.updateIn(['a', 'b', 'x'], 100, val => val) + * // Map { "a": Map { "b": Map { "c": 10 } } } + * assert.strictEqual(newMap, aMap) + * ``` + * + * For code using ES2015 or later, using `notSetValue` is discourged in + * favor of function parameter default values. This helps to avoid any + * potential confusion with identify functions as described above. + * + * The previous example behaves differently when written with default values: + * + * + * ```js + * const map = Map({ a: Map({ b: Map({ c: 10 }) }) }) + * const newMap = map.updateIn(['a', 'b', 'x'], (val = 100) => val) + * // Map { "a": Map { "b": Map { "c": 10, "x": 100 } } } + * ``` + * + * Plain JavaScript Object or Arrays may be nested within an Immutable.js + * Collection, and updateIn() can update those values as well, treating them + * immutably by creating new copies of those values with the changes applied. + * + * + * ```js + * const map = Map({ a: { b: { c: 10 } } }) + * const newMap = map.updateIn(['a', 'b', 'c'], val => val * 2) + * // Map { "a": { b: { c: 20 } } } + * ``` + * + * If any key in the path exists but cannot be updated (such as a primitive + * like number or a custom Object like Date), an error will be thrown. + * + * Note: `updateIn` can be used in `withMutations`. + */ + updateIn( + keyPath: Iterable, + notSetValue: unknown, + updater: (value: unknown) => unknown + ): this; + updateIn( + keyPath: Iterable, + updater: (value: unknown) => unknown + ): this; + + /** + * A combination of `updateIn` and `merge`, returning a new Map, but + * performing the merge at a point arrived at by following the keyPath. + * In other words, these two lines are equivalent: + * + * ```js + * map.updateIn(['a', 'b', 'c'], abc => abc.merge(y)) + * map.mergeIn(['a', 'b', 'c'], y) + * ``` + * + * Note: `mergeIn` can be used in `withMutations`. + */ + mergeIn(keyPath: Iterable, ...collections: Array): this; + + /** + * A combination of `updateIn` and `mergeDeep`, returning a new Map, but + * performing the deep merge at a point arrived at by following the keyPath. + * In other words, these two lines are equivalent: + * + * ```js + * map.updateIn(['a', 'b', 'c'], abc => abc.mergeDeep(y)) + * map.mergeDeepIn(['a', 'b', 'c'], y) + * ``` + * + * Note: `mergeDeepIn` can be used in `withMutations`. + */ + mergeDeepIn( + keyPath: Iterable, + ...collections: Array + ): this; + + // Transient changes + + /** + * Every time you call one of the above functions, a new immutable Map is + * created. If a pure function calls a number of these to produce a final + * return value, then a penalty on performance and memory has been paid by + * creating all of the intermediate immutable Maps. + * + * If you need to apply a series of mutations to produce a new immutable + * Map, `withMutations()` creates a temporary mutable copy of the Map which + * can apply mutations in a highly performant manner. In fact, this is + * exactly how complex mutations like `merge` are done. + * + * As an example, this results in the creation of 2, not 4, new Maps: + * + * + * ```js + * const { Map } = require('immutable') + * const map1 = Map() + * const map2 = map1.withMutations(map => { + * map.set('a', 1).set('b', 2).set('c', 3) + * }) + * assert.equal(map1.size, 0) + * assert.equal(map2.size, 3) + * ``` + * + * Note: Not all methods can be used on a mutable collection or within + * `withMutations`! Read the documentation for each method to see if it + * is safe to use in `withMutations`. + */ + withMutations(mutator: (mutable: this) => unknown): this; + + /** + * Another way to avoid creation of intermediate Immutable maps is to create + * a mutable copy of this collection. Mutable copies *always* return `this`, + * and thus shouldn't be used for equality. Your function should never return + * a mutable copy of a collection, only use it internally to create a new + * collection. + * + * If possible, use `withMutations` to work with temporary mutable copies as + * it provides an easier to use API and considers many common optimizations. + * + * Note: if the collection is already mutable, `asMutable` returns itself. + * + * Note: Not all methods can be used on a mutable collection or within + * `withMutations`! Read the documentation for each method to see if it + * is safe to use in `withMutations`. + * + * @see `Map#asImmutable` + */ + asMutable(): this; + + /** + * Returns true if this is a mutable copy (see `asMutable()`) and mutative + * alterations have been applied. + * + * @see `Map#asMutable` + */ + wasAltered(): boolean; + + /** + * The yin to `asMutable`'s yang. Because it applies to mutable collections, + * this operation is *mutable* and may return itself (though may not + * return itself, i.e. if the result is an empty collection). Once + * performed, the original mutable copy must no longer be mutated since it + * may be the immutable result. + * + * If possible, use `withMutations` to work with temporary mutable copies as + * it provides an easier to use API and considers many common optimizations. + * + * @see `Map#asMutable` + */ + asImmutable(): this; + + // Sequence algorithms + + /** + * Returns a new Map with values passed through a + * `mapper` function. + * + * Map({ a: 1, b: 2 }).map(x => 10 * x) + * // Map { a: 10, b: 20 } + */ + map( + mapper: (value: V, key: K, iter: this) => M, + context?: unknown + ): Map; + + /** + * @see Collection.Keyed.mapKeys + */ + mapKeys( + mapper: (key: K, value: V, iter: this) => M, + context?: unknown + ): Map; + + /** + * @see Collection.Keyed.mapEntries + */ + mapEntries( + mapper: ( + entry: [K, V], + index: number, + iter: this + ) => [KM, VM] | undefined, + context?: unknown + ): Map; + + /** + * Flat-maps the Map, returning a new Map. + * + * Similar to `data.map(...).flatten(true)`. + */ + flatMap( + mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>, + context?: unknown + ): Map; + + /** + * Returns a new Map with only the entries for which the `predicate` + * function returns true. + * + * Note: `filter()` always returns a new instance, even if it results in + * not filtering out any values. + */ + filter( + predicate: (value: V, key: K, iter: this) => value is F, + context?: unknown + ): Map; + filter( + predicate: (value: V, key: K, iter: this) => unknown, + context?: unknown + ): this; + + /** + * Returns a new Map with the values for which the `predicate` + * function returns false and another for which is returns true. + */ + partition( + predicate: (this: C, value: V, key: K, iter: this) => value is F, + context?: C + ): [Map, Map]; + partition( + predicate: (this: C, value: V, key: K, iter: this) => unknown, + context?: C + ): [this, this]; + + /** + * @see Collection.Keyed.flip + */ + flip(): Map; + + /** + * Returns an OrderedMap of the same type which includes the same entries, + * stably sorted by using a `comparator`. + * + * If a `comparator` is not provided, a default comparator uses `<` and `>`. + * + * `comparator(valueA, valueB)`: + * + * * Returns `0` if the elements should not be swapped. + * * Returns `-1` (or any negative number) if `valueA` comes before `valueB` + * * Returns `1` (or any positive number) if `valueA` comes after `valueB` + * * Alternatively, can return a value of the `PairSorting` enum type + * * Is pure, i.e. it must always return the same value for the same pair + * of values. + * + * + * ```js + * const { Map } = require('immutable') + * Map({ "c": 3, "a": 1, "b": 2 }).sort((a, b) => { + * if (a < b) { return -1; } + * if (a > b) { return 1; } + * if (a === b) { return 0; } + * }); + * // OrderedMap { "a": 1, "b": 2, "c": 3 } + * ``` + * + * Note: `sort()` Always returns a new instance, even if the original was + * already sorted. + * + * Note: This is always an eager operation. + */ + sort(comparator?: Comparator): this & OrderedMap; + + /** + * Like `sort`, but also accepts a `comparatorValueMapper` which allows for + * sorting by more sophisticated means: + * + * + * ```js + * const { Map } = require('immutable') + * const beattles = Map({ + * John: { name: "Lennon" }, + * Paul: { name: "McCartney" }, + * George: { name: "Harrison" }, + * Ringo: { name: "Starr" }, + * }); + * beattles.sortBy(member => member.name); + * ``` + * + * Note: `sortBy()` Always returns a new instance, even if the original was + * already sorted. + * + * Note: This is always an eager operation. + */ + sortBy( + comparatorValueMapper: (value: V, key: K, iter: this) => C, + comparator?: (valueA: C, valueB: C) => number + ): this & OrderedMap; + } + + /** + * A type of Map that has the additional guarantee that the iteration order of + * entries will be the order in which they were set(). + * + * The iteration behavior of OrderedMap is the same as native ES6 Map and + * JavaScript Object. + * + * Note that `OrderedMap` are more expensive than non-ordered `Map` and may + * consume more memory. `OrderedMap#set` is amortized O(log32 N), but not + * stable. + */ + namespace OrderedMap { + /** + * True if the provided value is an OrderedMap. + */ + function isOrderedMap( + maybeOrderedMap: unknown + ): maybeOrderedMap is OrderedMap; + } + + /** + * Creates a new Immutable OrderedMap. + * + * Created with the same key value pairs as the provided Collection.Keyed or + * JavaScript Object or expects a Collection of [K, V] tuple entries. + * + * The iteration order of key-value pairs provided to this constructor will + * be preserved in the OrderedMap. + * + * let newOrderedMap = OrderedMap({key: "value"}) + * let newOrderedMap = OrderedMap([["key", "value"]]) + * + * Note: `OrderedMap` is a factory function and not a class, and does not use + * the `new` keyword during construction. + */ + function OrderedMap(collection?: Iterable<[K, V]>): OrderedMap; + function OrderedMap(obj: { [key: string]: V }): OrderedMap; + + interface OrderedMap extends Map, OrderedCollection<[K, V]> { + /** + * The number of entries in this OrderedMap. + */ + readonly size: number; + + /** + * Returns a new OrderedMap also containing the new key, value pair. If an + * equivalent key already exists in this OrderedMap, it will be replaced + * while maintaining the existing order. + * + * + * ```js + * const { OrderedMap } = require('immutable') + * const originalMap = OrderedMap({a:1, b:1, c:1}) + * const updatedMap = originalMap.set('b', 2) + * + * originalMap + * // OrderedMap {a: 1, b: 1, c: 1} + * updatedMap + * // OrderedMap {a: 1, b: 2, c: 1} + * ``` + * + * Note: `set` can be used in `withMutations`. + */ + set(key: K, value: V): this; + + /** + * Returns a new OrderedMap resulting from merging the provided Collections + * (or JS objects) into this OrderedMap. In other words, this takes each + * entry of each collection and sets it on this OrderedMap. + * + * Note: Values provided to `merge` are shallowly converted before being + * merged. No nested values are altered. + * + * + * ```js + * const { OrderedMap } = require('immutable') + * const one = OrderedMap({ a: 10, b: 20, c: 30 }) + * const two = OrderedMap({ b: 40, a: 50, d: 60 }) + * one.merge(two) // OrderedMap { "a": 50, "b": 40, "c": 30, "d": 60 } + * two.merge(one) // OrderedMap { "b": 20, "a": 10, "d": 60, "c": 30 } + * ``` + * + * Note: `merge` can be used in `withMutations`. + * + * @alias concat + */ + merge( + ...collections: Array> + ): OrderedMap | VC>; + merge( + ...collections: Array<{ [key: string]: C }> + ): OrderedMap | C>; + + concat( + ...collections: Array> + ): OrderedMap | VC>; + concat( + ...collections: Array<{ [key: string]: C }> + ): OrderedMap | C>; + + mergeWith( + merger: (oldVal: V, newVal: VC, key: K) => VCC, + ...collections: Array> + ): OrderedMap; + mergeWith( + merger: (oldVal: V, newVal: C, key: string) => CC, + ...collections: Array<{ [key: string]: C }> + ): OrderedMap; + + mergeDeep( + ...collections: Array> + ): OrderedMap; + mergeDeep( + ...collections: Array<{ [key: string]: C }> + ): OrderedMap; + + // Sequence algorithms + + /** + * Returns a new OrderedMap with values passed through a + * `mapper` function. + * + * OrderedMap({ a: 1, b: 2 }).map(x => 10 * x) + * // OrderedMap { "a": 10, "b": 20 } + * + * Note: `map()` always returns a new instance, even if it produced the same + * value at every step. + */ + map( + mapper: (value: V, key: K, iter: this) => M, + context?: unknown + ): OrderedMap; + + /** + * @see Collection.Keyed.mapKeys + */ + mapKeys( + mapper: (key: K, value: V, iter: this) => M, + context?: unknown + ): OrderedMap; + + /** + * @see Collection.Keyed.mapEntries + */ + mapEntries( + mapper: ( + entry: [K, V], + index: number, + iter: this + ) => [KM, VM] | undefined, + context?: unknown + ): OrderedMap; + + /** + * Flat-maps the OrderedMap, returning a new OrderedMap. + * + * Similar to `data.map(...).flatten(true)`. + */ + flatMap( + mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>, + context?: unknown + ): OrderedMap; + + /** + * Returns a new OrderedMap with only the entries for which the `predicate` + * function returns true. + * + * Note: `filter()` always returns a new instance, even if it results in + * not filtering out any values. + */ + filter( + predicate: (value: V, key: K, iter: this) => value is F, + context?: unknown + ): OrderedMap; + filter( + predicate: (value: V, key: K, iter: this) => unknown, + context?: unknown + ): this; + + /** + * Returns a new OrderedMap with the values for which the `predicate` + * function returns false and another for which is returns true. + */ + partition( + predicate: (this: C, value: V, key: K, iter: this) => value is F, + context?: C + ): [OrderedMap, OrderedMap]; + partition( + predicate: (this: C, value: V, key: K, iter: this) => unknown, + context?: C + ): [this, this]; + + /** + * @see Collection.Keyed.flip + */ + flip(): OrderedMap; + } + + /** + * A Collection of unique values with `O(log32 N)` adds and has. + * + * When iterating a Set, the entries will be (value, value) pairs. Iteration + * order of a Set is undefined, however is stable. Multiple iterations of the + * same Set will iterate in the same order. + * + * Set values, like Map keys, may be of any type. Equality is determined using + * `Immutable.is`, enabling Sets to uniquely include other Immutable + * collections, custom value types, and NaN. + */ + namespace Set { + /** + * True if the provided value is a Set + */ + function isSet(maybeSet: unknown): maybeSet is Set; + + /** + * Creates a new Set containing `values`. + */ + function of(...values: Array): Set; + + /** + * `Set.fromKeys()` creates a new immutable Set containing the keys from + * this Collection or JavaScript Object. + */ + function fromKeys(iter: Collection.Keyed): Set; + function fromKeys(iter: Collection): Set; + function fromKeys(obj: { [key: string]: unknown }): Set; + + /** + * `Set.intersect()` creates a new immutable Set that is the intersection of + * a collection of other sets. + * + * ```js + * const { Set } = require('immutable') + * const intersected = Set.intersect([ + * Set([ 'a', 'b', 'c' ]) + * Set([ 'c', 'a', 't' ]) + * ]) + * // Set [ "a", "c" ] + * ``` + */ + function intersect(sets: Iterable>): Set; + + /** + * `Set.union()` creates a new immutable Set that is the union of a + * collection of other sets. + * + * ```js + * const { Set } = require('immutable') + * const unioned = Set.union([ + * Set([ 'a', 'b', 'c' ]) + * Set([ 'c', 'a', 't' ]) + * ]) + * // Set [ "a", "b", "c", "t" ] + * ``` + */ + function union(sets: Iterable>): Set; + } + + /** + * Create a new immutable Set containing the values of the provided + * collection-like. + * + * Note: `Set` is a factory function and not a class, and does not use the + * `new` keyword during construction. + */ + function Set(collection?: Iterable | ArrayLike): Set; + + interface Set extends Collection.Set { + /** + * The number of items in this Set. + */ + readonly size: number; + + // Persistent changes + + /** + * Returns a new Set which also includes this value. + * + * Note: `add` can be used in `withMutations`. + */ + add(value: T): this; + + /** + * Returns a new Set which excludes this value. + * + * Note: `delete` can be used in `withMutations`. + * + * Note: `delete` **cannot** be safely used in IE8, use `remove` if + * supporting old browsers. + * + * @alias remove + */ + delete(value: T): this; + remove(value: T): this; + + /** + * Returns a new Set containing no values. + * + * Note: `clear` can be used in `withMutations`. + */ + clear(): this; + + /** + * Returns a Set including any value from `collections` that does not already + * exist in this Set. + * + * Note: `union` can be used in `withMutations`. + * @alias merge + * @alias concat + */ + union(...collections: Array>): Set; + merge(...collections: Array>): Set; + concat(...collections: Array>): Set; + + /** + * Returns a Set which has removed any values not also contained + * within `collections`. + * + * Note: `intersect` can be used in `withMutations`. + */ + intersect(...collections: Array>): this; + + /** + * Returns a Set excluding any values contained within `collections`. + * + * + * ```js + * const { OrderedSet } = require('immutable') + * OrderedSet([ 1, 2, 3 ]).subtract([1, 3]) + * // OrderedSet [2] + * ``` + * + * Note: `subtract` can be used in `withMutations`. + */ + subtract(...collections: Array>): this; + + // Transient changes + + /** + * Note: Not all methods can be used on a mutable collection or within + * `withMutations`! Check the documentation for each method to see if it + * mentions being safe to use in `withMutations`. + * + * @see `Map#withMutations` + */ + withMutations(mutator: (mutable: this) => unknown): this; + + /** + * Note: Not all methods can be used on a mutable collection or within + * `withMutations`! Check the documentation for each method to see if it + * mentions being safe to use in `withMutations`. + * + * @see `Map#asMutable` + */ + asMutable(): this; + + /** + * @see `Map#wasAltered` + */ + wasAltered(): boolean; + + /** + * @see `Map#asImmutable` + */ + asImmutable(): this; + + // Sequence algorithms + + /** + * Returns a new Set with values passed through a + * `mapper` function. + * + * Set([1,2]).map(x => 10 * x) + * // Set [10,20] + */ + map( + mapper: (value: T, key: T, iter: this) => M, + context?: unknown + ): Set; + + /** + * Flat-maps the Set, returning a new Set. + * + * Similar to `set.map(...).flatten(true)`. + */ + flatMap( + mapper: (value: T, key: T, iter: this) => Iterable, + context?: unknown + ): Set; + + /** + * Returns a new Set with only the values for which the `predicate` + * function returns true. + * + * Note: `filter()` always returns a new instance, even if it results in + * not filtering out any values. + */ + filter( + predicate: (value: T, key: T, iter: this) => value is F, + context?: unknown + ): Set; + filter( + predicate: (value: T, key: T, iter: this) => unknown, + context?: unknown + ): this; + + /** + * Returns a new Set with the values for which the `predicate` function + * returns false and another for which is returns true. + */ + partition( + predicate: (this: C, value: T, key: T, iter: this) => value is F, + context?: C + ): [Set, Set]; + partition( + predicate: (this: C, value: T, key: T, iter: this) => unknown, + context?: C + ): [this, this]; + + /** + * Returns an OrderedSet of the same type which includes the same entries, + * stably sorted by using a `comparator`. + * + * If a `comparator` is not provided, a default comparator uses `<` and `>`. + * + * `comparator(valueA, valueB)`: + * + * * Returns `0` if the elements should not be swapped. + * * Returns `-1` (or any negative number) if `valueA` comes before `valueB` + * * Returns `1` (or any positive number) if `valueA` comes after `valueB` + * * Alternatively, can return a value of the `PairSorting` enum type + * * Is pure, i.e. it must always return the same value for the same pair + * of values. + * + * + * ```js + * const { Set } = require('immutable') + * Set(['b', 'a', 'c']).sort((a, b) => { + * if (a < b) { return -1; } + * if (a > b) { return 1; } + * if (a === b) { return 0; } + * }); + * // OrderedSet { "a":, "b", "c" } + * ``` + * + * Note: `sort()` Always returns a new instance, even if the original was + * already sorted. + * + * Note: This is always an eager operation. + */ + sort(comparator?: Comparator): this & OrderedSet; + + /** + * Like `sort`, but also accepts a `comparatorValueMapper` which allows for + * sorting by more sophisticated means: + * + * + * ```js + * const { Set } = require('immutable') + * const beattles = Set([ + * { name: "Lennon" }, + * { name: "McCartney" }, + * { name: "Harrison" }, + * { name: "Starr" }, + * ]); + * beattles.sortBy(member => member.name); + * ``` + * + * Note: `sortBy()` Always returns a new instance, even if the original was + * already sorted. + * + * Note: This is always an eager operation. + */ + sortBy( + comparatorValueMapper: (value: T, key: T, iter: this) => C, + comparator?: (valueA: C, valueB: C) => number + ): this & OrderedSet; + } + + /** + * A type of Set that has the additional guarantee that the iteration order of + * values will be the order in which they were `add`ed. + * + * The iteration behavior of OrderedSet is the same as native ES6 Set. + * + * Note that `OrderedSet` are more expensive than non-ordered `Set` and may + * consume more memory. `OrderedSet#add` is amortized O(log32 N), but not + * stable. + */ + namespace OrderedSet { + /** + * True if the provided value is an OrderedSet. + */ + function isOrderedSet( + maybeOrderedSet: unknown + ): maybeOrderedSet is OrderedSet; + + /** + * Creates a new OrderedSet containing `values`. + */ + function of(...values: Array): OrderedSet; + + /** + * `OrderedSet.fromKeys()` creates a new immutable OrderedSet containing + * the keys from this Collection or JavaScript Object. + */ + function fromKeys(iter: Collection.Keyed): OrderedSet; + function fromKeys(iter: Collection): OrderedSet; + function fromKeys(obj: { [key: string]: unknown }): OrderedSet; + } + + /** + * Create a new immutable OrderedSet containing the values of the provided + * collection-like. + * + * Note: `OrderedSet` is a factory function and not a class, and does not use + * the `new` keyword during construction. + */ + function OrderedSet( + collection?: Iterable | ArrayLike + ): OrderedSet; + + interface OrderedSet extends Set, OrderedCollection { + /** + * The number of items in this OrderedSet. + */ + readonly size: number; + + /** + * Returns an OrderedSet including any value from `collections` that does + * not already exist in this OrderedSet. + * + * Note: `union` can be used in `withMutations`. + * @alias merge + * @alias concat + */ + union(...collections: Array>): OrderedSet; + merge(...collections: Array>): OrderedSet; + concat(...collections: Array>): OrderedSet; + + // Sequence algorithms + + /** + * Returns a new Set with values passed through a + * `mapper` function. + * + * OrderedSet([ 1, 2 ]).map(x => 10 * x) + * // OrderedSet [10, 20] + */ + map( + mapper: (value: T, key: T, iter: this) => M, + context?: unknown + ): OrderedSet; + + /** + * Flat-maps the OrderedSet, returning a new OrderedSet. + * + * Similar to `set.map(...).flatten(true)`. + */ + flatMap( + mapper: (value: T, key: T, iter: this) => Iterable, + context?: unknown + ): OrderedSet; + + /** + * Returns a new OrderedSet with only the values for which the `predicate` + * function returns true. + * + * Note: `filter()` always returns a new instance, even if it results in + * not filtering out any values. + */ + filter( + predicate: (value: T, key: T, iter: this) => value is F, + context?: unknown + ): OrderedSet; + filter( + predicate: (value: T, key: T, iter: this) => unknown, + context?: unknown + ): this; + + /** + * Returns a new OrderedSet with the values for which the `predicate` + * function returns false and another for which is returns true. + */ + partition( + predicate: (this: C, value: T, key: T, iter: this) => value is F, + context?: C + ): [OrderedSet, OrderedSet]; + partition( + predicate: (this: C, value: T, key: T, iter: this) => unknown, + context?: C + ): [this, this]; + + /** + * Returns an OrderedSet of the same type "zipped" with the provided + * collections. + * + * Like `zipWith`, but using the default `zipper`: creating an `Array`. + * + * ```js + * const a = OrderedSet([ 1, 2, 3 ]) + * const b = OrderedSet([ 4, 5, 6 ]) + * const c = a.zip(b) + * // OrderedSet [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ] + * ``` + */ + zip(other: Collection): OrderedSet<[T, U]>; + zip( + other1: Collection, + other2: Collection + ): OrderedSet<[T, U, V]>; + zip( + ...collections: Array> + ): OrderedSet; + + /** + * Returns a OrderedSet of the same type "zipped" with the provided + * collections. + * + * Unlike `zip`, `zipAll` continues zipping until the longest collection is + * exhausted. Missing values from shorter collections are filled with `undefined`. + * + * ```js + * const a = OrderedSet([ 1, 2 ]); + * const b = OrderedSet([ 3, 4, 5 ]); + * const c = a.zipAll(b); // OrderedSet [ [ 1, 3 ], [ 2, 4 ], [ undefined, 5 ] ] + * ``` + * + * Note: Since zipAll will return a collection as large as the largest + * input, some results may contain undefined values. TypeScript cannot + * account for these without cases (as of v2.5). + */ + zipAll(other: Collection): OrderedSet<[T, U]>; + zipAll( + other1: Collection, + other2: Collection + ): OrderedSet<[T, U, V]>; + zipAll( + ...collections: Array> + ): OrderedSet; + + /** + * Returns an OrderedSet of the same type "zipped" with the provided + * collections by using a custom `zipper` function. + * + * @see Seq.Indexed.zipWith + */ + zipWith( + zipper: (value: T, otherValue: U) => Z, + otherCollection: Collection + ): OrderedSet; + zipWith( + zipper: (value: T, otherValue: U, thirdValue: V) => Z, + otherCollection: Collection, + thirdCollection: Collection + ): OrderedSet; + zipWith( + zipper: (...values: Array) => Z, + ...collections: Array> + ): OrderedSet; + } + + /** + * Stacks are indexed collections which support very efficient O(1) addition + * and removal from the front using `unshift(v)` and `shift()`. + * + * For familiarity, Stack also provides `push(v)`, `pop()`, and `peek()`, but + * be aware that they also operate on the front of the list, unlike List or + * a JavaScript Array. + * + * Note: `reverse()` or any inherent reverse traversal (`reduceRight`, + * `lastIndexOf`, etc.) is not efficient with a Stack. + * + * Stack is implemented with a Single-Linked List. + */ + namespace Stack { + /** + * True if the provided value is a Stack + */ + function isStack(maybeStack: unknown): maybeStack is Stack; + + /** + * Creates a new Stack containing `values`. + */ + function of(...values: Array): Stack; + } + + /** + * Create a new immutable Stack containing the values of the provided + * collection-like. + * + * The iteration order of the provided collection is preserved in the + * resulting `Stack`. + * + * Note: `Stack` is a factory function and not a class, and does not use the + * `new` keyword during construction. + */ + function Stack(collection?: Iterable | ArrayLike): Stack; + + interface Stack extends Collection.Indexed { + /** + * The number of items in this Stack. + */ + readonly size: number; + + // Reading values + + /** + * Alias for `Stack.first()`. + */ + peek(): T | undefined; + + // Persistent changes + + /** + * Returns a new Stack with 0 size and no values. + * + * Note: `clear` can be used in `withMutations`. + */ + clear(): Stack; + + /** + * Returns a new Stack with the provided `values` prepended, shifting other + * values ahead to higher indices. + * + * This is very efficient for Stack. + * + * Note: `unshift` can be used in `withMutations`. + */ + unshift(...values: Array): Stack; + + /** + * Like `Stack#unshift`, but accepts a collection rather than varargs. + * + * Note: `unshiftAll` can be used in `withMutations`. + */ + unshiftAll(iter: Iterable): Stack; + + /** + * Returns a new Stack with a size ones less than this Stack, excluding + * the first item in this Stack, shifting all other values to a lower index. + * + * Note: this differs from `Array#shift` because it returns a new + * Stack rather than the removed value. Use `first()` or `peek()` to get the + * first value in this Stack. + * + * Note: `shift` can be used in `withMutations`. + */ + shift(): Stack; + + /** + * Alias for `Stack#unshift` and is not equivalent to `List#push`. + */ + push(...values: Array): Stack; + + /** + * Alias for `Stack#unshiftAll`. + */ + pushAll(iter: Iterable): Stack; + + /** + * Alias for `Stack#shift` and is not equivalent to `List#pop`. + */ + pop(): Stack; + + // Transient changes + + /** + * Note: Not all methods can be used on a mutable collection or within + * `withMutations`! Check the documentation for each method to see if it + * mentions being safe to use in `withMutations`. + * + * @see `Map#withMutations` + */ + withMutations(mutator: (mutable: this) => unknown): this; + + /** + * Note: Not all methods can be used on a mutable collection or within + * `withMutations`! Check the documentation for each method to see if it + * mentions being safe to use in `withMutations`. + * + * @see `Map#asMutable` + */ + asMutable(): this; + + /** + * @see `Map#wasAltered` + */ + wasAltered(): boolean; + + /** + * @see `Map#asImmutable` + */ + asImmutable(): this; + + // Sequence algorithms + + /** + * Returns a new Stack with other collections concatenated to this one. + */ + concat(...valuesOrCollections: Array | C>): Stack; + + /** + * Returns a new Stack with values passed through a + * `mapper` function. + * + * Stack([ 1, 2 ]).map(x => 10 * x) + * // Stack [ 10, 20 ] + * + * Note: `map()` always returns a new instance, even if it produced the same + * value at every step. + */ + map( + mapper: (value: T, key: number, iter: this) => M, + context?: unknown + ): Stack; + + /** + * Flat-maps the Stack, returning a new Stack. + * + * Similar to `stack.map(...).flatten(true)`. + */ + flatMap( + mapper: (value: T, key: number, iter: this) => Iterable, + context?: unknown + ): Stack; + + /** + * Returns a new Set with only the values for which the `predicate` + * function returns true. + * + * Note: `filter()` always returns a new instance, even if it results in + * not filtering out any values. + */ + filter( + predicate: (value: T, index: number, iter: this) => value is F, + context?: unknown + ): Set; + filter( + predicate: (value: T, index: number, iter: this) => unknown, + context?: unknown + ): this; + + /** + * Returns a Stack "zipped" with the provided collections. + * + * Like `zipWith`, but using the default `zipper`: creating an `Array`. + * + * ```js + * const a = Stack([ 1, 2, 3 ]); + * const b = Stack([ 4, 5, 6 ]); + * const c = a.zip(b); // Stack [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ] + * ``` + */ + zip(other: Collection): Stack<[T, U]>; + zip( + other: Collection, + other2: Collection + ): Stack<[T, U, V]>; + zip(...collections: Array>): Stack; + + /** + * Returns a Stack "zipped" with the provided collections. + * + * Unlike `zip`, `zipAll` continues zipping until the longest collection is + * exhausted. Missing values from shorter collections are filled with `undefined`. + * + * ```js + * const a = Stack([ 1, 2 ]); + * const b = Stack([ 3, 4, 5 ]); + * const c = a.zipAll(b); // Stack [ [ 1, 3 ], [ 2, 4 ], [ undefined, 5 ] ] + * ``` + * + * Note: Since zipAll will return a collection as large as the largest + * input, some results may contain undefined values. TypeScript cannot + * account for these without cases (as of v2.5). + */ + zipAll(other: Collection): Stack<[T, U]>; + zipAll( + other: Collection, + other2: Collection + ): Stack<[T, U, V]>; + zipAll(...collections: Array>): Stack; + + /** + * Returns a Stack "zipped" with the provided collections by using a + * custom `zipper` function. + * + * ```js + * const a = Stack([ 1, 2, 3 ]); + * const b = Stack([ 4, 5, 6 ]); + * const c = a.zipWith((a, b) => a + b, b); + * // Stack [ 5, 7, 9 ] + * ``` + */ + zipWith( + zipper: (value: T, otherValue: U) => Z, + otherCollection: Collection + ): Stack; + zipWith( + zipper: (value: T, otherValue: U, thirdValue: V) => Z, + otherCollection: Collection, + thirdCollection: Collection + ): Stack; + zipWith( + zipper: (...values: Array) => Z, + ...collections: Array> + ): Stack; + } + + /** + * Returns a Seq.Indexed of numbers from `start` (inclusive) to `end` + * (exclusive), by `step`, where `start` defaults to 0, `step` to 1, and `end` to + * infinity. When `start` is equal to `end`, returns empty range. + * + * Note: `Range` is a factory function and not a class, and does not use the + * `new` keyword during construction. + * + * ```js + * const { Range } = require('immutable') + * Range() // [ 0, 1, 2, 3, ... ] + * Range(10) // [ 10, 11, 12, 13, ... ] + * Range(10, 15) // [ 10, 11, 12, 13, 14 ] + * Range(10, 30, 5) // [ 10, 15, 20, 25 ] + * Range(30, 10, 5) // [ 30, 25, 20, 15 ] + * Range(30, 30, 5) // [] + * ``` + */ + function Range( + start: number, + end: number, + step?: number + ): Seq.Indexed; + + /** + * Returns a Seq.Indexed of `value` repeated `times` times. When `times` is + * not defined, returns an infinite `Seq` of `value`. + * + * Note: `Repeat` is a factory function and not a class, and does not use the + * `new` keyword during construction. + * + * ```js + * const { Repeat } = require('immutable') + * Repeat('foo') // [ 'foo', 'foo', 'foo', ... ] + * Repeat('bar', 4) // [ 'bar', 'bar', 'bar', 'bar' ] + * ``` + */ + function Repeat(value: T, times?: number): Seq.Indexed; + + /** + * A record is similar to a JS object, but enforces a specific set of allowed + * string keys, and has default values. + * + * The `Record()` function produces new Record Factories, which when called + * create Record instances. + * + * ```js + * const { Record } = require('immutable') + * const ABRecord = Record({ a: 1, b: 2 }) + * const myRecord = ABRecord({ b: 3 }) + * ``` + * + * Records always have a value for the keys they define. `remove`ing a key + * from a record simply resets it to the default value for that key. + * + * ```js + * myRecord.get('a') // 1 + * myRecord.get('b') // 3 + * const myRecordWithoutB = myRecord.remove('b') + * myRecordWithoutB.get('b') // 2 + * ``` + * + * Values provided to the constructor not found in the Record type will + * be ignored. For example, in this case, ABRecord is provided a key "x" even + * though only "a" and "b" have been defined. The value for "x" will be + * ignored for this record. + * + * ```js + * const myRecord = ABRecord({ b: 3, x: 10 }) + * myRecord.get('x') // undefined + * ``` + * + * Because Records have a known set of string keys, property get access works + * as expected, however property sets will throw an Error. + * + * Note: IE8 does not support property access. Only use `get()` when + * supporting IE8. + * + * ```js + * myRecord.b // 3 + * myRecord.b = 5 // throws Error + * ``` + * + * Record Types can be extended as well, allowing for custom methods on your + * Record. This is not a common pattern in functional environments, but is in + * many JS programs. + * + * However Record Types are more restricted than typical JavaScript classes. + * They do not use a class constructor, which also means they cannot use + * class properties (since those are technically part of a constructor). + * + * While Record Types can be syntactically created with the JavaScript `class` + * form, the resulting Record function is actually a factory function, not a + * class constructor. Even though Record Types are not classes, JavaScript + * currently requires the use of `new` when creating new Record instances if + * they are defined as a `class`. + * + * ``` + * class ABRecord extends Record({ a: 1, b: 2 }) { + * getAB() { + * return this.a + this.b; + * } + * } + * + * var myRecord = new ABRecord({b: 3}) + * myRecord.getAB() // 4 + * ``` + * + * + * **Flow Typing Records:** + * + * Immutable.js exports two Flow types designed to make it easier to use + * Records with flow typed code, `RecordOf` and `RecordFactory`. + * + * When defining a new kind of Record factory function, use a flow type that + * describes the values the record contains along with `RecordFactory`. + * To type instances of the Record (which the factory function returns), + * use `RecordOf`. + * + * Typically, new Record definitions will export both the Record factory + * function as well as the Record instance type for use in other code. + * + * ```js + * import type { RecordFactory, RecordOf } from 'immutable'; + * + * // Use RecordFactory for defining new Record factory functions. + * type Point3DProps = { x: number, y: number, z: number }; + * const defaultValues: Point3DProps = { x: 0, y: 0, z: 0 }; + * const makePoint3D: RecordFactory = Record(defaultValues); + * export makePoint3D; + * + * // Use RecordOf for defining new instances of that Record. + * export type Point3D = RecordOf; + * const some3DPoint: Point3D = makePoint3D({ x: 10, y: 20, z: 30 }); + * ``` + * + * **Flow Typing Record Subclasses:** + * + * Records can be subclassed as a means to add additional methods to Record + * instances. This is generally discouraged in favor of a more functional API, + * since Subclasses have some minor overhead. However the ability to create + * a rich API on Record types can be quite valuable. + * + * When using Flow to type Subclasses, do not use `RecordFactory`, + * instead apply the props type when subclassing: + * + * ```js + * type PersonProps = {name: string, age: number}; + * const defaultValues: PersonProps = {name: 'Aristotle', age: 2400}; + * const PersonRecord = Record(defaultValues); + * class Person extends PersonRecord { + * getName(): string { + * return this.get('name') + * } + * + * setName(name: string): this { + * return this.set('name', name); + * } + * } + * ``` + * + * **Choosing Records vs plain JavaScript objects** + * + * Records offer a persistently immutable alternative to plain JavaScript + * objects, however they're not required to be used within Immutable.js + * collections. In fact, the deep-access and deep-updating functions + * like `getIn()` and `setIn()` work with plain JavaScript Objects as well. + * + * Deciding to use Records or Objects in your application should be informed + * by the tradeoffs and relative benefits of each: + * + * - *Runtime immutability*: plain JS objects may be carefully treated as + * immutable, however Record instances will *throw* if attempted to be + * mutated directly. Records provide this additional guarantee, however at + * some marginal runtime cost. While JS objects are mutable by nature, the + * use of type-checking tools like [Flow](https://medium.com/@gcanti/immutability-with-flow-faa050a1aef4) + * can help gain confidence in code written to favor immutability. + * + * - *Value equality*: Records use value equality when compared with `is()` + * or `record.equals()`. That is, two Records with the same keys and values + * are equal. Plain objects use *reference equality*. Two objects with the + * same keys and values are not equal since they are different objects. + * This is important to consider when using objects as keys in a `Map` or + * values in a `Set`, which use equality when retrieving values. + * + * - *API methods*: Records have a full featured API, with methods like + * `.getIn()`, and `.equals()`. These can make working with these values + * easier, but comes at the cost of not allowing keys with those names. + * + * - *Default values*: Records provide default values for every key, which + * can be useful when constructing Records with often unchanging values. + * However default values can make using Flow and TypeScript more laborious. + * + * - *Serialization*: Records use a custom internal representation to + * efficiently store and update their values. Converting to and from this + * form isn't free. If converting Records to plain objects is common, + * consider sticking with plain objects to begin with. + */ + namespace Record { + /** + * True if `maybeRecord` is an instance of a Record. + */ + function isRecord(maybeRecord: unknown): maybeRecord is Record; + + /** + * Records allow passing a second parameter to supply a descriptive name + * that appears when converting a Record to a string or in any error + * messages. A descriptive name for any record can be accessed by using this + * method. If one was not provided, the string "Record" is returned. + * + * ```js + * const { Record } = require('immutable') + * const Person = Record({ + * name: null + * }, 'Person') + * + * var me = Person({ name: 'My Name' }) + * me.toString() // "Person { "name": "My Name" }" + * Record.getDescriptiveName(me) // "Person" + * ``` + */ + function getDescriptiveName( + record: RecordOf + ): string; + + /** + * A Record.Factory is created by the `Record()` function. Record instances + * are created by passing it some of the accepted values for that Record + * type: + * + * + * ```js + * // makePerson is a Record Factory function + * const makePerson = Record({ name: null, favoriteColor: 'unknown' }); + * + * // alan is a Record instance + * const alan = makePerson({ name: 'Alan' }); + * ``` + * + * Note that Record Factories return `Record & Readonly`, + * this allows use of both the Record instance API, and direct property + * access on the resulting instances: + * + * + * ```js + * // Use the Record API + * console.log('Record API: ' + alan.get('name')) + * + * // Or direct property access (Readonly) + * console.log('property access: ' + alan.name) + * ``` + * + * **Flow Typing Records:** + * + * Use the `RecordFactory` Flow type to get high quality type checking of + * Records: + * + * ```js + * import type { RecordFactory, RecordOf } from 'immutable'; + * + * // Use RecordFactory for defining new Record factory functions. + * type PersonProps = { name: ?string, favoriteColor: string }; + * const makePerson: RecordFactory = Record({ name: null, favoriteColor: 'unknown' }); + * + * // Use RecordOf for defining new instances of that Record. + * type Person = RecordOf; + * const alan: Person = makePerson({ name: 'Alan' }); + * ``` + */ + namespace Factory {} + + interface Factory { + ( + values?: Partial | Iterable<[string, unknown]> + ): RecordOf; + new ( + values?: Partial | Iterable<[string, unknown]> + ): RecordOf; + + /** + * The name provided to `Record(values, name)` can be accessed with + * `displayName`. + */ + displayName: string; + } + + function Factory( + values?: Partial | Iterable<[string, unknown]> + ): RecordOf; + } + + /** + * Unlike other types in Immutable.js, the `Record()` function creates a new + * Record Factory, which is a function that creates Record instances. + * + * See above for examples of using `Record()`. + * + * Note: `Record` is a factory function and not a class, and does not use the + * `new` keyword during construction. + */ + function Record( + defaultValues: TProps, + name?: string + ): Record.Factory; + + interface Record { + // Reading values + + has(key: string): key is keyof TProps & string; + + /** + * Returns the value associated with the provided key, which may be the + * default value defined when creating the Record factory function. + * + * If the requested key is not defined by this Record type, then + * notSetValue will be returned if provided. Note that this scenario would + * produce an error when using Flow or TypeScript. + */ + get(key: K, notSetValue?: unknown): TProps[K]; + get(key: string, notSetValue: T): T; + + // Reading deep values + + hasIn(keyPath: Iterable): boolean; + getIn(keyPath: Iterable): unknown; + + // Value equality + + equals(other: unknown): boolean; + hashCode(): number; + + // Persistent changes + + set(key: K, value: TProps[K]): this; + update( + key: K, + updater: (value: TProps[K]) => TProps[K] + ): this; + merge( + ...collections: Array | Iterable<[string, unknown]>> + ): this; + mergeDeep( + ...collections: Array | Iterable<[string, unknown]>> + ): this; + + mergeWith( + merger: (oldVal: unknown, newVal: unknown, key: keyof TProps) => unknown, + ...collections: Array | Iterable<[string, unknown]>> + ): this; + mergeDeepWith( + merger: (oldVal: unknown, newVal: unknown, key: unknown) => unknown, + ...collections: Array | Iterable<[string, unknown]>> + ): this; + + /** + * Returns a new instance of this Record type with the value for the + * specific key set to its default value. + * + * @alias remove + */ + delete(key: K): this; + remove(key: K): this; + + /** + * Returns a new instance of this Record type with all values set + * to their default values. + */ + clear(): this; + + // Deep persistent changes + + setIn(keyPath: Iterable, value: unknown): this; + updateIn( + keyPath: Iterable, + updater: (value: unknown) => unknown + ): this; + mergeIn(keyPath: Iterable, ...collections: Array): this; + mergeDeepIn( + keyPath: Iterable, + ...collections: Array + ): this; + + /** + * @alias removeIn + */ + deleteIn(keyPath: Iterable): this; + removeIn(keyPath: Iterable): this; + + // Conversion to JavaScript types + + /** + * Deeply converts this Record to equivalent native JavaScript Object. + * + * Note: This method may not be overridden. Objects with custom + * serialization to plain JS may override toJSON() instead. + */ + toJS(): DeepCopy; + + /** + * Shallowly converts this Record to equivalent native JavaScript Object. + */ + toJSON(): TProps; + + /** + * Shallowly converts this Record to equivalent JavaScript Object. + */ + toObject(): TProps; + + // Transient changes + + /** + * Note: Not all methods can be used on a mutable collection or within + * `withMutations`! Only `set` may be used mutatively. + * + * @see `Map#withMutations` + */ + withMutations(mutator: (mutable: this) => unknown): this; + + /** + * @see `Map#asMutable` + */ + asMutable(): this; + + /** + * @see `Map#wasAltered` + */ + wasAltered(): boolean; + + /** + * @see `Map#asImmutable` + */ + asImmutable(): this; + + // Sequence algorithms + + toSeq(): Seq.Keyed; + + [Symbol.iterator](): IterableIterator<[keyof TProps, TProps[keyof TProps]]>; + } + + /** + * RecordOf is used in TypeScript to define interfaces expecting an + * instance of record with type T. + * + * This is equivalent to an instance of a record created by a Record Factory. + */ + type RecordOf = Record & Readonly; + + /** + * `Seq` describes a lazy operation, allowing them to efficiently chain + * use of all the higher-order collection methods (such as `map` and `filter`) + * by not creating intermediate collections. + * + * **Seq is immutable** — Once a Seq is created, it cannot be + * changed, appended to, rearranged or otherwise modified. Instead, any + * mutative method called on a `Seq` will return a new `Seq`. + * + * **Seq is lazy** — `Seq` does as little work as necessary to respond to any + * method call. Values are often created during iteration, including implicit + * iteration when reducing or converting to a concrete data structure such as + * a `List` or JavaScript `Array`. + * + * For example, the following performs no work, because the resulting + * `Seq`'s values are never iterated: + * + * ```js + * const { Seq } = require('immutable') + * const oddSquares = Seq([ 1, 2, 3, 4, 5, 6, 7, 8 ]) + * .filter(x => x % 2 !== 0) + * .map(x => x * x) + * ``` + * + * Once the `Seq` is used, it performs only the work necessary. In this + * example, no intermediate arrays are ever created, filter is called three + * times, and map is only called once: + * + * ```js + * oddSquares.get(1); // 9 + * ``` + * + * Any collection can be converted to a lazy Seq with `Seq()`. + * + * + * ```js + * const { Map } = require('immutable') + * const map = Map({ a: 1, b: 2, c: 3 }) + * const lazySeq = Seq(map) + * ``` + * + * `Seq` allows for the efficient chaining of operations, allowing for the + * expression of logic that can otherwise be very tedious: + * + * ```js + * lazySeq + * .flip() + * .map(key => key.toUpperCase()) + * .flip() + * // Seq { A: 1, B: 1, C: 1 } + * ``` + * + * As well as expressing logic that would otherwise seem memory or time + * limited, for example `Range` is a special kind of Lazy sequence. + * + * + * ```js + * const { Range } = require('immutable') + * Range(1, Infinity) + * .skip(1000) + * .map(n => -n) + * .filter(n => n % 2 === 0) + * .take(2) + * .reduce((r, n) => r * n, 1) + * // 1006008 + * ``` + * + * Seq is often used to provide a rich collection API to JavaScript Object. + * + * ```js + * Seq({ x: 0, y: 1, z: 2 }).map(v => v * 2).toObject(); + * // { x: 0, y: 2, z: 4 } + * ``` + */ + + namespace Seq { + /** + * True if `maybeSeq` is a Seq, it is not backed by a concrete + * structure such as Map, List, or Set. + */ + function isSeq( + maybeSeq: unknown + ): maybeSeq is + | Seq.Indexed + | Seq.Keyed + | Seq.Set; + + /** + * `Seq` which represents key-value pairs. + */ + namespace Keyed {} + + /** + * Always returns a Seq.Keyed, if input is not keyed, expects an + * collection of [K, V] tuples. + * + * Note: `Seq.Keyed` is a conversion function and not a class, and does not + * use the `new` keyword during construction. + */ + function Keyed(collection?: Iterable<[K, V]>): Seq.Keyed; + function Keyed(obj: { [key: string]: V }): Seq.Keyed; + + interface Keyed extends Seq, Collection.Keyed { + /** + * Deeply converts this Keyed Seq to equivalent native JavaScript Object. + * + * Converts keys to Strings. + */ + toJS(): { [key in PropertyKey]: DeepCopy }; + + /** + * Shallowly converts this Keyed Seq to equivalent native JavaScript Object. + * + * Converts keys to Strings. + */ + toJSON(): { [key in PropertyKey]: V }; + + /** + * Shallowly converts this collection to an Array. + */ + toArray(): Array<[K, V]>; + + /** + * Returns itself + */ + toSeq(): this; + + /** + * Returns a new Seq with other collections concatenated to this one. + * + * All entries will be present in the resulting Seq, even if they + * have the same key. + */ + concat( + ...collections: Array> + ): Seq.Keyed; + concat( + ...collections: Array<{ [key: string]: C }> + ): Seq.Keyed; + + /** + * Returns a new Seq.Keyed with values passed through a + * `mapper` function. + * + * ```js + * const { Seq } = require('immutable') + * Seq.Keyed({ a: 1, b: 2 }).map(x => 10 * x) + * // Seq { "a": 10, "b": 20 } + * ``` + * + * Note: `map()` always returns a new instance, even if it produced the + * same value at every step. + */ + map( + mapper: (value: V, key: K, iter: this) => M, + context?: unknown + ): Seq.Keyed; + + /** + * @see Collection.Keyed.mapKeys + */ + mapKeys( + mapper: (key: K, value: V, iter: this) => M, + context?: unknown + ): Seq.Keyed; + + /** + * @see Collection.Keyed.mapEntries + */ + mapEntries( + mapper: ( + entry: [K, V], + index: number, + iter: this + ) => [KM, VM] | undefined, + context?: unknown + ): Seq.Keyed; + + /** + * Flat-maps the Seq, returning a Seq of the same type. + * + * Similar to `seq.map(...).flatten(true)`. + */ + flatMap( + mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>, + context?: unknown + ): Seq.Keyed; + + /** + * Returns a new Seq with only the entries for which the `predicate` + * function returns true. + * + * Note: `filter()` always returns a new instance, even if it results in + * not filtering out any values. + */ + filter( + predicate: (value: V, key: K, iter: this) => value is F, + context?: unknown + ): Seq.Keyed; + filter( + predicate: (value: V, key: K, iter: this) => unknown, + context?: unknown + ): this; + + /** + * Returns a new keyed Seq with the values for which the `predicate` + * function returns false and another for which is returns true. + */ + partition( + predicate: (this: C, value: V, key: K, iter: this) => value is F, + context?: C + ): [Seq.Keyed, Seq.Keyed]; + partition( + predicate: (this: C, value: V, key: K, iter: this) => unknown, + context?: C + ): [this, this]; + + /** + * @see Collection.Keyed.flip + */ + flip(): Seq.Keyed; + + [Symbol.iterator](): IterableIterator<[K, V]>; + } + + /** + * `Seq` which represents an ordered indexed list of values. + */ + namespace Indexed { + /** + * Provides an Seq.Indexed of the values provided. + */ + function of(...values: Array): Seq.Indexed; + } + + /** + * Always returns Seq.Indexed, discarding associated keys and + * supplying incrementing indices. + * + * Note: `Seq.Indexed` is a conversion function and not a class, and does + * not use the `new` keyword during construction. + */ + function Indexed( + collection?: Iterable | ArrayLike + ): Seq.Indexed; + + interface Indexed extends Seq, Collection.Indexed { + /** + * Deeply converts this Indexed Seq to equivalent native JavaScript Array. + */ + toJS(): Array>; + + /** + * Shallowly converts this Indexed Seq to equivalent native JavaScript Array. + */ + toJSON(): Array; + + /** + * Shallowly converts this collection to an Array. + */ + toArray(): Array; + + /** + * Returns itself + */ + toSeq(): this; + + /** + * Returns a new Seq with other collections concatenated to this one. + */ + concat( + ...valuesOrCollections: Array | C> + ): Seq.Indexed; + + /** + * Returns a new Seq.Indexed with values passed through a + * `mapper` function. + * + * ```js + * const { Seq } = require('immutable') + * Seq.Indexed([ 1, 2 ]).map(x => 10 * x) + * // Seq [ 10, 20 ] + * ``` + * + * Note: `map()` always returns a new instance, even if it produced the + * same value at every step. + */ + map( + mapper: (value: T, key: number, iter: this) => M, + context?: unknown + ): Seq.Indexed; + + /** + * Flat-maps the Seq, returning a a Seq of the same type. + * + * Similar to `seq.map(...).flatten(true)`. + */ + flatMap( + mapper: (value: T, key: number, iter: this) => Iterable, + context?: unknown + ): Seq.Indexed; + + /** + * Returns a new Seq with only the values for which the `predicate` + * function returns true. + * + * Note: `filter()` always returns a new instance, even if it results in + * not filtering out any values. + */ + filter( + predicate: (value: T, index: number, iter: this) => value is F, + context?: unknown + ): Seq.Indexed; + filter( + predicate: (value: T, index: number, iter: this) => unknown, + context?: unknown + ): this; + + /** + * Returns a new indexed Seq with the values for which the `predicate` + * function returns false and another for which is returns true. + */ + partition( + predicate: (this: C, value: T, index: number, iter: this) => value is F, + context?: C + ): [Seq.Indexed, Seq.Indexed]; + partition( + predicate: (this: C, value: T, index: number, iter: this) => unknown, + context?: C + ): [this, this]; + + /** + * Returns a Seq "zipped" with the provided collections. + * + * Like `zipWith`, but using the default `zipper`: creating an `Array`. + * + * ```js + * const a = Seq([ 1, 2, 3 ]); + * const b = Seq([ 4, 5, 6 ]); + * const c = a.zip(b); // Seq [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ] + * ``` + */ + zip(other: Collection): Seq.Indexed<[T, U]>; + zip( + other: Collection, + other2: Collection + ): Seq.Indexed<[T, U, V]>; + zip( + ...collections: Array> + ): Seq.Indexed; + + /** + * Returns a Seq "zipped" with the provided collections. + * + * Unlike `zip`, `zipAll` continues zipping until the longest collection is + * exhausted. Missing values from shorter collections are filled with `undefined`. + * + * ```js + * const a = Seq([ 1, 2 ]); + * const b = Seq([ 3, 4, 5 ]); + * const c = a.zipAll(b); // Seq [ [ 1, 3 ], [ 2, 4 ], [ undefined, 5 ] ] + * ``` + */ + zipAll(other: Collection): Seq.Indexed<[T, U]>; + zipAll( + other: Collection, + other2: Collection + ): Seq.Indexed<[T, U, V]>; + zipAll( + ...collections: Array> + ): Seq.Indexed; + + /** + * Returns a Seq "zipped" with the provided collections by using a + * custom `zipper` function. + * + * ```js + * const a = Seq([ 1, 2, 3 ]); + * const b = Seq([ 4, 5, 6 ]); + * const c = a.zipWith((a, b) => a + b, b); + * // Seq [ 5, 7, 9 ] + * ``` + */ + zipWith( + zipper: (value: T, otherValue: U) => Z, + otherCollection: Collection + ): Seq.Indexed; + zipWith( + zipper: (value: T, otherValue: U, thirdValue: V) => Z, + otherCollection: Collection, + thirdCollection: Collection + ): Seq.Indexed; + zipWith( + zipper: (...values: Array) => Z, + ...collections: Array> + ): Seq.Indexed; + + [Symbol.iterator](): IterableIterator; + } + + /** + * `Seq` which represents a set of values. + * + * Because `Seq` are often lazy, `Seq.Set` does not provide the same guarantee + * of value uniqueness as the concrete `Set`. + */ + namespace Set { + /** + * Returns a Seq.Set of the provided values + */ + function of(...values: Array): Seq.Set; + } + + /** + * Always returns a Seq.Set, discarding associated indices or keys. + * + * Note: `Seq.Set` is a conversion function and not a class, and does not + * use the `new` keyword during construction. + */ + function Set(collection?: Iterable | ArrayLike): Seq.Set; + + interface Set extends Seq, Collection.Set { + /** + * Deeply converts this Set Seq to equivalent native JavaScript Array. + */ + toJS(): Array>; + + /** + * Shallowly converts this Set Seq to equivalent native JavaScript Array. + */ + toJSON(): Array; + + /** + * Shallowly converts this collection to an Array. + */ + toArray(): Array; + + /** + * Returns itself + */ + toSeq(): this; + + /** + * Returns a new Seq with other collections concatenated to this one. + * + * All entries will be present in the resulting Seq, even if they + * are duplicates. + */ + concat(...collections: Array>): Seq.Set; + + /** + * Returns a new Seq.Set with values passed through a + * `mapper` function. + * + * ```js + * Seq.Set([ 1, 2 ]).map(x => 10 * x) + * // Seq { 10, 20 } + * ``` + * + * Note: `map()` always returns a new instance, even if it produced the + * same value at every step. + */ + map( + mapper: (value: T, key: T, iter: this) => M, + context?: unknown + ): Seq.Set; + + /** + * Flat-maps the Seq, returning a Seq of the same type. + * + * Similar to `seq.map(...).flatten(true)`. + */ + flatMap( + mapper: (value: T, key: T, iter: this) => Iterable, + context?: unknown + ): Seq.Set; + + /** + * Returns a new Seq with only the values for which the `predicate` + * function returns true. + * + * Note: `filter()` always returns a new instance, even if it results in + * not filtering out any values. + */ + filter( + predicate: (value: T, key: T, iter: this) => value is F, + context?: unknown + ): Seq.Set; + filter( + predicate: (value: T, key: T, iter: this) => unknown, + context?: unknown + ): this; + + /** + * Returns a new set Seq with the values for which the `predicate` + * function returns false and another for which is returns true. + */ + partition( + predicate: (this: C, value: T, key: T, iter: this) => value is F, + context?: C + ): [Seq.Set, Seq.Set]; + partition( + predicate: (this: C, value: T, key: T, iter: this) => unknown, + context?: C + ): [this, this]; + + [Symbol.iterator](): IterableIterator; + } + } + + /** + * Creates a Seq. + * + * Returns a particular kind of `Seq` based on the input. + * + * * If a `Seq`, that same `Seq`. + * * If an `Collection`, a `Seq` of the same kind (Keyed, Indexed, or Set). + * * If an Array-like, an `Seq.Indexed`. + * * If an Iterable Object, an `Seq.Indexed`. + * * If an Object, a `Seq.Keyed`. + * + * Note: An Iterator itself will be treated as an object, becoming a `Seq.Keyed`, + * which is usually not what you want. You should turn your Iterator Object into + * an iterable object by defining a Symbol.iterator (or @@iterator) method which + * returns `this`. + * + * Note: `Seq` is a conversion function and not a class, and does not use the + * `new` keyword during construction. + */ + function Seq>(seq: S): S; + function Seq(collection: Collection.Keyed): Seq.Keyed; + function Seq(collection: Collection.Set): Seq.Set; + function Seq( + collection: Collection.Indexed | Iterable | ArrayLike + ): Seq.Indexed; + function Seq(obj: { [key: string]: V }): Seq.Keyed; + function Seq(): Seq; + + interface Seq extends Collection { + /** + * Some Seqs can describe their size lazily. When this is the case, + * size will be an integer. Otherwise it will be undefined. + * + * For example, Seqs returned from `map()` or `reverse()` + * preserve the size of the original `Seq` while `filter()` does not. + * + * Note: `Range`, `Repeat` and `Seq`s made from `Array`s and `Object`s will + * always have a size. + */ + readonly size: number | undefined; + + // Force evaluation + + /** + * Because Sequences are lazy and designed to be chained together, they do + * not cache their results. For example, this map function is called a total + * of 6 times, as each `join` iterates the Seq of three values. + * + * var squares = Seq([ 1, 2, 3 ]).map(x => x * x) + * squares.join() + squares.join() + * + * If you know a `Seq` will be used multiple times, it may be more + * efficient to first cache it in memory. Here, the map function is called + * only 3 times. + * + * var squares = Seq([ 1, 2, 3 ]).map(x => x * x).cacheResult() + * squares.join() + squares.join() + * + * Use this method judiciously, as it must fully evaluate a Seq which can be + * a burden on memory and possibly performance. + * + * Note: after calling `cacheResult`, a Seq will always have a `size`. + */ + cacheResult(): this; + + // Sequence algorithms + + /** + * Returns a new Seq with values passed through a + * `mapper` function. + * + * ```js + * const { Seq } = require('immutable') + * Seq([ 1, 2 ]).map(x => 10 * x) + * // Seq [ 10, 20 ] + * ``` + * + * Note: `map()` always returns a new instance, even if it produced the same + * value at every step. + */ + map( + mapper: (value: V, key: K, iter: this) => M, + context?: unknown + ): Seq; + + /** + * Returns a new Seq with values passed through a + * `mapper` function. + * + * ```js + * const { Seq } = require('immutable') + * Seq([ 1, 2 ]).map(x => 10 * x) + * // Seq [ 10, 20 ] + * ``` + * + * Note: `map()` always returns a new instance, even if it produced the same + * value at every step. + * Note: used only for sets. + */ + map( + mapper: (value: V, key: K, iter: this) => M, + context?: unknown + ): Seq; + + /** + * Flat-maps the Seq, returning a Seq of the same type. + * + * Similar to `seq.map(...).flatten(true)`. + */ + flatMap( + mapper: (value: V, key: K, iter: this) => Iterable, + context?: unknown + ): Seq; + + /** + * Flat-maps the Seq, returning a Seq of the same type. + * + * Similar to `seq.map(...).flatten(true)`. + * Note: Used only for sets. + */ + flatMap( + mapper: (value: V, key: K, iter: this) => Iterable, + context?: unknown + ): Seq; + + /** + * Returns a new Seq with only the values for which the `predicate` + * function returns true. + * + * Note: `filter()` always returns a new instance, even if it results in + * not filtering out any values. + */ + filter( + predicate: (value: V, key: K, iter: this) => value is F, + context?: unknown + ): Seq; + filter( + predicate: (value: V, key: K, iter: this) => unknown, + context?: unknown + ): this; + + /** + * Returns a new Seq with the values for which the `predicate` function + * returns false and another for which is returns true. + */ + partition( + predicate: (this: C, value: V, key: K, iter: this) => value is F, + context?: C + ): [Seq, Seq]; + partition( + predicate: (this: C, value: V, key: K, iter: this) => unknown, + context?: C + ): [this, this]; + + /** + * Returns a new Sequence of the same type with other values and + * collection-like concatenated to this one. + * + * All entries will be present in the resulting Seq, even if they + * have the same key. + */ + concat(...valuesOrCollections: Array): Seq; + } + + /** + * The `Collection` is a set of (key, value) entries which can be iterated, and + * is the base class for all collections in `immutable`, allowing them to + * make use of all the Collection methods (such as `map` and `filter`). + * + * Note: A collection is always iterated in the same order, however that order + * may not always be well defined, as is the case for the `Map` and `Set`. + * + * Collection is the abstract base class for concrete data structures. It + * cannot be constructed directly. + * + * Implementations should extend one of the subclasses, `Collection.Keyed`, + * `Collection.Indexed`, or `Collection.Set`. + */ + namespace Collection { + /** + * Keyed Collections have discrete keys tied to each value. + * + * When iterating `Collection.Keyed`, each iteration will yield a `[K, V]` + * tuple, in other words, `Collection#entries` is the default iterator for + * Keyed Collections. + */ + namespace Keyed {} + + /** + * Creates a Collection.Keyed + * + * Similar to `Collection()`, however it expects collection-likes of [K, V] + * tuples if not constructed from a Collection.Keyed or JS Object. + * + * Note: `Collection.Keyed` is a conversion function and not a class, and + * does not use the `new` keyword during construction. + */ + function Keyed(collection?: Iterable<[K, V]>): Collection.Keyed; + function Keyed(obj: { [key: string]: V }): Collection.Keyed; + + interface Keyed extends Collection { + /** + * Deeply converts this Keyed collection to equivalent native JavaScript Object. + * + * Converts keys to Strings. + */ + toJS(): { [key in PropertyKey]: DeepCopy }; + + /** + * Shallowly converts this Keyed collection to equivalent native JavaScript Object. + * + * Converts keys to Strings. + */ + toJSON(): { [key in PropertyKey]: V }; + + /** + * Shallowly converts this collection to an Array. + */ + toArray(): Array<[K, V]>; + + /** + * Returns Seq.Keyed. + * @override + */ + toSeq(): Seq.Keyed; + + // Sequence functions + + /** + * Returns a new Collection.Keyed of the same type where the keys and values + * have been flipped. + * + * + * ```js + * const { Map } = require('immutable') + * Map({ a: 'z', b: 'y' }).flip() + * // Map { "z": "a", "y": "b" } + * ``` + */ + flip(): Collection.Keyed; + + /** + * Returns a new Collection with other collections concatenated to this one. + */ + concat( + ...collections: Array> + ): Collection.Keyed; + concat( + ...collections: Array<{ [key: string]: C }> + ): Collection.Keyed; + + /** + * Returns a new Collection.Keyed with values passed through a + * `mapper` function. + * + * ```js + * const { Collection } = require('immutable') + * Collection.Keyed({ a: 1, b: 2 }).map(x => 10 * x) + * // Seq { "a": 10, "b": 20 } + * ``` + * + * Note: `map()` always returns a new instance, even if it produced the + * same value at every step. + */ + map( + mapper: (value: V, key: K, iter: this) => M, + context?: unknown + ): Collection.Keyed; + + /** + * Returns a new Collection.Keyed of the same type with keys passed through + * a `mapper` function. + * + * + * ```js + * const { Map } = require('immutable') + * Map({ a: 1, b: 2 }).mapKeys(x => x.toUpperCase()) + * // Map { "A": 1, "B": 2 } + * ``` + * + * Note: `mapKeys()` always returns a new instance, even if it produced + * the same key at every step. + */ + mapKeys( + mapper: (key: K, value: V, iter: this) => M, + context?: unknown + ): Collection.Keyed; + + /** + * Returns a new Collection.Keyed of the same type with entries + * ([key, value] tuples) passed through a `mapper` function. + * + * + * ```js + * const { Map } = require('immutable') + * Map({ a: 1, b: 2 }) + * .mapEntries(([ k, v ]) => [ k.toUpperCase(), v * 2 ]) + * // Map { "A": 2, "B": 4 } + * ``` + * + * Note: `mapEntries()` always returns a new instance, even if it produced + * the same entry at every step. + * + * If the mapper function returns `undefined`, then the entry will be filtered + */ + mapEntries( + mapper: ( + entry: [K, V], + index: number, + iter: this + ) => [KM, VM] | undefined, + context?: unknown + ): Collection.Keyed; + + /** + * Flat-maps the Collection, returning a Collection of the same type. + * + * Similar to `collection.map(...).flatten(true)`. + */ + flatMap( + mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>, + context?: unknown + ): Collection.Keyed; + + /** + * Returns a new Collection with only the values for which the `predicate` + * function returns true. + * + * Note: `filter()` always returns a new instance, even if it results in + * not filtering out any values. + */ + filter( + predicate: (value: V, key: K, iter: this) => value is F, + context?: unknown + ): Collection.Keyed; + filter( + predicate: (value: V, key: K, iter: this) => unknown, + context?: unknown + ): this; + + /** + * Returns a new keyed Collection with the values for which the + * `predicate` function returns false and another for which is returns + * true. + */ + partition( + predicate: (this: C, value: V, key: K, iter: this) => value is F, + context?: C + ): [Collection.Keyed, Collection.Keyed]; + partition( + predicate: (this: C, value: V, key: K, iter: this) => unknown, + context?: C + ): [this, this]; + + [Symbol.iterator](): IterableIterator<[K, V]>; + } + + /** + * Indexed Collections have incrementing numeric keys. They exhibit + * slightly different behavior than `Collection.Keyed` for some methods in order + * to better mirror the behavior of JavaScript's `Array`, and add methods + * which do not make sense on non-indexed Collections such as `indexOf`. + * + * Unlike JavaScript arrays, `Collection.Indexed`s are always dense. "Unset" + * indices and `undefined` indices are indistinguishable, and all indices from + * 0 to `size` are visited when iterated. + * + * All Collection.Indexed methods return re-indexed Collections. In other words, + * indices always start at 0 and increment until size. If you wish to + * preserve indices, using them as keys, convert to a Collection.Keyed by + * calling `toKeyedSeq`. + */ + namespace Indexed {} + + /** + * Creates a new Collection.Indexed. + * + * Note: `Collection.Indexed` is a conversion function and not a class, and + * does not use the `new` keyword during construction. + */ + function Indexed( + collection?: Iterable | ArrayLike + ): Collection.Indexed; + + interface Indexed extends Collection, OrderedCollection { + /** + * Deeply converts this Indexed collection to equivalent native JavaScript Array. + */ + toJS(): Array>; + + /** + * Shallowly converts this Indexed collection to equivalent native JavaScript Array. + */ + toJSON(): Array; + + /** + * Shallowly converts this collection to an Array. + */ + toArray(): Array; + + // Reading values + + /** + * Returns the value associated with the provided index, or notSetValue if + * the index is beyond the bounds of the Collection. + * + * `index` may be a negative number, which indexes back from the end of the + * Collection. `s.get(-1)` gets the last item in the Collection. + */ + get(index: number, notSetValue: NSV): T | NSV; + get(index: number): T | undefined; + + // Conversion to Seq + + /** + * Returns Seq.Indexed. + * @override + */ + toSeq(): Seq.Indexed; + + /** + * If this is a collection of [key, value] entry tuples, it will return a + * Seq.Keyed of those entries. + */ + fromEntrySeq(): Seq.Keyed; + + // Combination + + /** + * Returns a Collection of the same type with `separator` between each item + * in this Collection. + */ + interpose(separator: T): this; + + /** + * Returns a Collection of the same type with the provided `collections` + * interleaved into this collection. + * + * The resulting Collection includes the first item from each, then the + * second from each, etc. + * + * + * ```js + * const { List } = require('immutable') + * List([ 1, 2, 3 ]).interleave(List([ 'A', 'B', 'C' ])) + * // List [ 1, "A", 2, "B", 3, "C" ] + * ``` + * + * The shortest Collection stops interleave. + * + * + * ```js + * List([ 1, 2, 3 ]).interleave( + * List([ 'A', 'B' ]), + * List([ 'X', 'Y', 'Z' ]) + * ) + * // List [ 1, "A", "X", 2, "B", "Y" ] + * ``` + * + * Since `interleave()` re-indexes values, it produces a complete copy, + * which has `O(N)` complexity. + * + * Note: `interleave` *cannot* be used in `withMutations`. + */ + interleave(...collections: Array>): this; + + /** + * Splice returns a new indexed Collection by replacing a region of this + * Collection with new values. If values are not provided, it only skips the + * region to be removed. + * + * `index` may be a negative number, which indexes back from the end of the + * Collection. `s.splice(-2)` splices after the second to last item. + * + * + * ```js + * const { List } = require('immutable') + * List([ 'a', 'b', 'c', 'd' ]).splice(1, 2, 'q', 'r', 's') + * // List [ "a", "q", "r", "s", "d" ] + * ``` + * + * Since `splice()` re-indexes values, it produces a complete copy, which + * has `O(N)` complexity. + * + * Note: `splice` *cannot* be used in `withMutations`. + */ + splice(index: number, removeNum: number, ...values: Array): this; + + /** + * Returns a Collection of the same type "zipped" with the provided + * collections. + * + * Like `zipWith`, but using the default `zipper`: creating an `Array`. + * + * + * + * ```js + * const a = List([ 1, 2, 3 ]); + * const b = List([ 4, 5, 6 ]); + * const c = a.zip(b); // List [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ] + * ``` + */ + zip(other: Collection): Collection.Indexed<[T, U]>; + zip( + other: Collection, + other2: Collection + ): Collection.Indexed<[T, U, V]>; + zip( + ...collections: Array> + ): Collection.Indexed; + + /** + * Returns a Collection "zipped" with the provided collections. + * + * Unlike `zip`, `zipAll` continues zipping until the longest collection is + * exhausted. Missing values from shorter collections are filled with `undefined`. + * + * ```js + * const a = List([ 1, 2 ]); + * const b = List([ 3, 4, 5 ]); + * const c = a.zipAll(b); // List [ [ 1, 3 ], [ 2, 4 ], [ undefined, 5 ] ] + * ``` + */ + zipAll(other: Collection): Collection.Indexed<[T, U]>; + zipAll( + other: Collection, + other2: Collection + ): Collection.Indexed<[T, U, V]>; + zipAll( + ...collections: Array> + ): Collection.Indexed; + + /** + * Returns a Collection of the same type "zipped" with the provided + * collections by using a custom `zipper` function. + * + * + * ```js + * const a = List([ 1, 2, 3 ]); + * const b = List([ 4, 5, 6 ]); + * const c = a.zipWith((a, b) => a + b, b); + * // List [ 5, 7, 9 ] + * ``` + */ + zipWith( + zipper: (value: T, otherValue: U) => Z, + otherCollection: Collection + ): Collection.Indexed; + zipWith( + zipper: (value: T, otherValue: U, thirdValue: V) => Z, + otherCollection: Collection, + thirdCollection: Collection + ): Collection.Indexed; + zipWith( + zipper: (...values: Array) => Z, + ...collections: Array> + ): Collection.Indexed; + + // Search for value + + /** + * Returns the first index at which a given value can be found in the + * Collection, or -1 if it is not present. + */ + indexOf(searchValue: T): number; + + /** + * Returns the last index at which a given value can be found in the + * Collection, or -1 if it is not present. + */ + lastIndexOf(searchValue: T): number; + + /** + * Returns the first index in the Collection where a value satisfies the + * provided predicate function. Otherwise -1 is returned. + */ + findIndex( + predicate: (value: T, index: number, iter: this) => boolean, + context?: unknown + ): number; + + /** + * Returns the last index in the Collection where a value satisfies the + * provided predicate function. Otherwise -1 is returned. + */ + findLastIndex( + predicate: (value: T, index: number, iter: this) => boolean, + context?: unknown + ): number; + + // Sequence algorithms + + /** + * Returns a new Collection with other collections concatenated to this one. + */ + concat( + ...valuesOrCollections: Array | C> + ): Collection.Indexed; + + /** + * Returns a new Collection.Indexed with values passed through a + * `mapper` function. + * + * ```js + * const { Collection } = require('immutable') + * Collection.Indexed([1,2]).map(x => 10 * x) + * // Seq [ 1, 2 ] + * ``` + * + * Note: `map()` always returns a new instance, even if it produced the + * same value at every step. + */ + map( + mapper: (value: T, key: number, iter: this) => M, + context?: unknown + ): Collection.Indexed; + + /** + * Flat-maps the Collection, returning a Collection of the same type. + * + * Similar to `collection.map(...).flatten(true)`. + */ + flatMap( + mapper: (value: T, key: number, iter: this) => Iterable, + context?: unknown + ): Collection.Indexed; + + /** + * Returns a new Collection with only the values for which the `predicate` + * function returns true. + * + * Note: `filter()` always returns a new instance, even if it results in + * not filtering out any values. + */ + filter( + predicate: (value: T, index: number, iter: this) => value is F, + context?: unknown + ): Collection.Indexed; + filter( + predicate: (value: T, index: number, iter: this) => unknown, + context?: unknown + ): this; + + /** + * Returns a new indexed Collection with the values for which the + * `predicate` function returns false and another for which is returns + * true. + */ + partition( + predicate: (this: C, value: T, index: number, iter: this) => value is F, + context?: C + ): [Collection.Indexed, Collection.Indexed]; + partition( + predicate: (this: C, value: T, index: number, iter: this) => unknown, + context?: C + ): [this, this]; + + [Symbol.iterator](): IterableIterator; + } + + /** + * Set Collections only represent values. They have no associated keys or + * indices. Duplicate values are possible in the lazy `Seq.Set`s, however + * the concrete `Set` Collection does not allow duplicate values. + * + * Collection methods on Collection.Set such as `map` and `forEach` will provide + * the value as both the first and second arguments to the provided function. + * + * ```js + * const { Collection } = require('immutable') + * const seq = Collection.Set([ 'A', 'B', 'C' ]) + * // Seq { "A", "B", "C" } + * seq.forEach((v, k) => + * assert.equal(v, k) + * ) + * ``` + */ + namespace Set {} + + /** + * Similar to `Collection()`, but always returns a Collection.Set. + * + * Note: `Collection.Set` is a factory function and not a class, and does + * not use the `new` keyword during construction. + */ + function Set(collection?: Iterable | ArrayLike): Collection.Set; + + interface Set extends Collection { + /** + * Deeply converts this Set collection to equivalent native JavaScript Array. + */ + toJS(): Array>; + + /** + * Shallowly converts this Set collection to equivalent native JavaScript Array. + */ + toJSON(): Array; + + /** + * Shallowly converts this collection to an Array. + */ + toArray(): Array; + + /** + * Returns Seq.Set. + * @override + */ + toSeq(): Seq.Set; + + // Sequence algorithms + + /** + * Returns a new Collection with other collections concatenated to this one. + */ + concat(...collections: Array>): Collection.Set; + + /** + * Returns a new Collection.Set with values passed through a + * `mapper` function. + * + * ``` + * Collection.Set([ 1, 2 ]).map(x => 10 * x) + * // Seq { 1, 2 } + * ``` + * + * Note: `map()` always returns a new instance, even if it produced the + * same value at every step. + */ + map( + mapper: (value: T, key: T, iter: this) => M, + context?: unknown + ): Collection.Set; + + /** + * Flat-maps the Collection, returning a Collection of the same type. + * + * Similar to `collection.map(...).flatten(true)`. + */ + flatMap( + mapper: (value: T, key: T, iter: this) => Iterable, + context?: unknown + ): Collection.Set; + + /** + * Returns a new Collection with only the values for which the `predicate` + * function returns true. + * + * Note: `filter()` always returns a new instance, even if it results in + * not filtering out any values. + */ + filter( + predicate: (value: T, key: T, iter: this) => value is F, + context?: unknown + ): Collection.Set; + filter( + predicate: (value: T, key: T, iter: this) => unknown, + context?: unknown + ): this; + + /** + * Returns a new set Collection with the values for which the + * `predicate` function returns false and another for which is returns + * true. + */ + partition( + predicate: (this: C, value: T, key: T, iter: this) => value is F, + context?: C + ): [Collection.Set, Collection.Set]; + partition( + predicate: (this: C, value: T, key: T, iter: this) => unknown, + context?: C + ): [this, this]; + + [Symbol.iterator](): IterableIterator; + } + } + + /** + * Creates a Collection. + * + * The type of Collection created is based on the input. + * + * * If an `Collection`, that same `Collection`. + * * If an Array-like, an `Collection.Indexed`. + * * If an Object with an Iterator defined, an `Collection.Indexed`. + * * If an Object, an `Collection.Keyed`. + * + * This methods forces the conversion of Objects and Strings to Collections. + * If you want to ensure that a Collection of one item is returned, use + * `Seq.of`. + * + * Note: An Iterator itself will be treated as an object, becoming a `Seq.Keyed`, + * which is usually not what you want. You should turn your Iterator Object into + * an iterable object by defining a Symbol.iterator (or @@iterator) method which + * returns `this`. + * + * Note: `Collection` is a conversion function and not a class, and does not + * use the `new` keyword during construction. + */ + function Collection>(collection: I): I; + function Collection( + collection: Iterable | ArrayLike + ): Collection.Indexed; + function Collection(obj: { + [key: string]: V; + }): Collection.Keyed; + function Collection(): Collection; + + interface Collection extends ValueObject { + // Value equality + + /** + * True if this and the other Collection have value equality, as defined + * by `Immutable.is()`. + * + * Note: This is equivalent to `Immutable.is(this, other)`, but provided to + * allow for chained expressions. + */ + equals(other: unknown): boolean; + + /** + * Computes and returns the hashed identity for this Collection. + * + * The `hashCode` of a Collection is used to determine potential equality, + * and is used when adding this to a `Set` or as a key in a `Map`, enabling + * lookup via a different instance. + * + * + * ```js + * const a = List([ 1, 2, 3 ]); + * const b = List([ 1, 2, 3 ]); + * assert.notStrictEqual(a, b); // different instances + * const set = Set([ a ]); + * assert.equal(set.has(b), true); + * ``` + * + * If two values have the same `hashCode`, they are [not guaranteed + * to be equal][Hash Collision]. If two values have different `hashCode`s, + * they must not be equal. + * + * [Hash Collision]: https://en.wikipedia.org/wiki/Collision_(computer_science) + */ + hashCode(): number; + + // Reading values + + /** + * Returns the value associated with the provided key, or notSetValue if + * the Collection does not contain this key. + * + * Note: it is possible a key may be associated with an `undefined` value, + * so if `notSetValue` is not provided and this method returns `undefined`, + * that does not guarantee the key was not found. + */ + get(key: K, notSetValue: NSV): V | NSV; + get(key: K): V | undefined; + + /** + * True if a key exists within this `Collection`, using `Immutable.is` + * to determine equality + */ + has(key: K): boolean; + + /** + * True if a value exists within this `Collection`, using `Immutable.is` + * to determine equality + * @alias contains + */ + includes(value: V): boolean; + contains(value: V): boolean; + + /** + * In case the `Collection` is not empty returns the first element of the + * `Collection`. + * In case the `Collection` is empty returns the optional default + * value if provided, if no default value is provided returns undefined. + */ + first(notSetValue: NSV): V | NSV; + first(): V | undefined; + + /** + * In case the `Collection` is not empty returns the last element of the + * `Collection`. + * In case the `Collection` is empty returns the optional default + * value if provided, if no default value is provided returns undefined. + */ + last(notSetValue: NSV): V | NSV; + last(): V | undefined; + + // Reading deep values + + /** + * Returns the value found by following a path of keys or indices through + * nested Collections. + * + * + * ```js + * const { Map, List } = require('immutable') + * const deepData = Map({ x: List([ Map({ y: 123 }) ]) }); + * deepData.getIn(['x', 0, 'y']) // 123 + * ``` + * + * Plain JavaScript Object or Arrays may be nested within an Immutable.js + * Collection, and getIn() can access those values as well: + * + * + * ```js + * const { Map, List } = require('immutable') + * const deepData = Map({ x: [ { y: 123 } ] }); + * deepData.getIn(['x', 0, 'y']) // 123 + * ``` + */ + getIn(searchKeyPath: Iterable, notSetValue?: unknown): unknown; + + /** + * True if the result of following a path of keys or indices through nested + * Collections results in a set value. + */ + hasIn(searchKeyPath: Iterable): boolean; + + // Persistent changes + + /** + * This can be very useful as a way to "chain" a normal function into a + * sequence of methods. RxJS calls this "let" and lodash calls it "thru". + * + * For example, to sum a Seq after mapping and filtering: + * + * + * ```js + * const { Seq } = require('immutable') + * + * function sum(collection) { + * return collection.reduce((sum, x) => sum + x, 0) + * } + * + * Seq([ 1, 2, 3 ]) + * .map(x => x + 1) + * .filter(x => x % 2 === 0) + * .update(sum) + * // 6 + * ``` + */ + update(updater: (value: this) => R): R; + + // Conversion to JavaScript types + + /** + * Deeply converts this Collection to equivalent native JavaScript Array or Object. + * + * `Collection.Indexed`, and `Collection.Set` become `Array`, while + * `Collection.Keyed` become `Object`, converting keys to Strings. + */ + toJS(): Array> | { [key in PropertyKey]: DeepCopy }; + + /** + * Shallowly converts this Collection to equivalent native JavaScript Array or Object. + * + * `Collection.Indexed`, and `Collection.Set` become `Array`, while + * `Collection.Keyed` become `Object`, converting keys to Strings. + */ + toJSON(): Array | { [key in PropertyKey]: V }; + + /** + * Shallowly converts this collection to an Array. + * + * `Collection.Indexed`, and `Collection.Set` produce an Array of values. + * `Collection.Keyed` produce an Array of [key, value] tuples. + */ + toArray(): Array | Array<[K, V]>; + + /** + * Shallowly converts this Collection to an Object. + * + * Converts keys to Strings. + */ + toObject(): { [key: string]: V }; + + // Conversion to Collections + + /** + * Converts this Collection to a Map, Throws if keys are not hashable. + * + * Note: This is equivalent to `Map(this.toKeyedSeq())`, but provided + * for convenience and to allow for chained expressions. + */ + toMap(): Map; + + /** + * Converts this Collection to a Map, maintaining the order of iteration. + * + * Note: This is equivalent to `OrderedMap(this.toKeyedSeq())`, but + * provided for convenience and to allow for chained expressions. + */ + toOrderedMap(): OrderedMap; + + /** + * Converts this Collection to a Set, discarding keys. Throws if values + * are not hashable. + * + * Note: This is equivalent to `Set(this)`, but provided to allow for + * chained expressions. + */ + toSet(): Set; + + /** + * Converts this Collection to a Set, maintaining the order of iteration and + * discarding keys. + * + * Note: This is equivalent to `OrderedSet(this.valueSeq())`, but provided + * for convenience and to allow for chained expressions. + */ + toOrderedSet(): OrderedSet; + + /** + * Converts this Collection to a List, discarding keys. + * + * This is similar to `List(collection)`, but provided to allow for chained + * expressions. However, when called on `Map` or other keyed collections, + * `collection.toList()` discards the keys and creates a list of only the + * values, whereas `List(collection)` creates a list of entry tuples. + * + * + * ```js + * const { Map, List } = require('immutable') + * var myMap = Map({ a: 'Apple', b: 'Banana' }) + * List(myMap) // List [ [ "a", "Apple" ], [ "b", "Banana" ] ] + * myMap.toList() // List [ "Apple", "Banana" ] + * ``` + */ + toList(): List; + + /** + * Converts this Collection to a Stack, discarding keys. Throws if values + * are not hashable. + * + * Note: This is equivalent to `Stack(this)`, but provided to allow for + * chained expressions. + */ + toStack(): Stack; + + // Conversion to Seq + + /** + * Converts this Collection to a Seq of the same kind (indexed, + * keyed, or set). + */ + toSeq(): Seq; + + /** + * Returns a Seq.Keyed from this Collection where indices are treated as keys. + * + * This is useful if you want to operate on an + * Collection.Indexed and preserve the [index, value] pairs. + * + * The returned Seq will have identical iteration order as + * this Collection. + * + * + * ```js + * const { Seq } = require('immutable') + * const indexedSeq = Seq([ 'A', 'B', 'C' ]) + * // Seq [ "A", "B", "C" ] + * indexedSeq.filter(v => v === 'B') + * // Seq [ "B" ] + * const keyedSeq = indexedSeq.toKeyedSeq() + * // Seq { 0: "A", 1: "B", 2: "C" } + * keyedSeq.filter(v => v === 'B') + * // Seq { 1: "B" } + * ``` + */ + toKeyedSeq(): Seq.Keyed; + + /** + * Returns an Seq.Indexed of the values of this Collection, discarding keys. + */ + toIndexedSeq(): Seq.Indexed; + + /** + * Returns a Seq.Set of the values of this Collection, discarding keys. + */ + toSetSeq(): Seq.Set; + + // Iterators + + /** + * An iterator of this `Collection`'s keys. + * + * Note: this will return an ES6 iterator which does not support + * Immutable.js sequence algorithms. Use `keySeq` instead, if this is + * what you want. + */ + keys(): IterableIterator; + + /** + * An iterator of this `Collection`'s values. + * + * Note: this will return an ES6 iterator which does not support + * Immutable.js sequence algorithms. Use `valueSeq` instead, if this is + * what you want. + */ + values(): IterableIterator; + + /** + * An iterator of this `Collection`'s entries as `[ key, value ]` tuples. + * + * Note: this will return an ES6 iterator which does not support + * Immutable.js sequence algorithms. Use `entrySeq` instead, if this is + * what you want. + */ + entries(): IterableIterator<[K, V]>; + + [Symbol.iterator](): IterableIterator; + + // Collections (Seq) + + /** + * Returns a new Seq.Indexed of the keys of this Collection, + * discarding values. + */ + keySeq(): Seq.Indexed; + + /** + * Returns an Seq.Indexed of the values of this Collection, discarding keys. + */ + valueSeq(): Seq.Indexed; + + /** + * Returns a new Seq.Indexed of [key, value] tuples. + */ + entrySeq(): Seq.Indexed<[K, V]>; + + // Sequence algorithms + + /** + * Returns a new Collection of the same type with values passed through a + * `mapper` function. + * + * + * ```js + * const { Collection } = require('immutable') + * Collection({ a: 1, b: 2 }).map(x => 10 * x) + * // Seq { "a": 10, "b": 20 } + * ``` + * + * Note: `map()` always returns a new instance, even if it produced the same + * value at every step. + */ + map( + mapper: (value: V, key: K, iter: this) => M, + context?: unknown + ): Collection; + + /** + * Note: used only for sets, which return Collection but are otherwise + * identical to normal `map()`. + * + * @ignore + */ + map(...args: Array): unknown; + + /** + * Returns a new Collection of the same type with only the entries for which + * the `predicate` function returns true. + * + * + * ```js + * const { Map } = require('immutable') + * Map({ a: 1, b: 2, c: 3, d: 4}).filter(x => x % 2 === 0) + * // Map { "b": 2, "d": 4 } + * ``` + * + * Note: `filter()` always returns a new instance, even if it results in + * not filtering out any values. + */ + filter( + predicate: (value: V, key: K, iter: this) => value is F, + context?: unknown + ): Collection; + filter( + predicate: (value: V, key: K, iter: this) => unknown, + context?: unknown + ): this; + + /** + * Returns a new Collection of the same type with only the entries for which + * the `predicate` function returns false. + * + * + * ```js + * const { Map } = require('immutable') + * Map({ a: 1, b: 2, c: 3, d: 4}).filterNot(x => x % 2 === 0) + * // Map { "a": 1, "c": 3 } + * ``` + * + * Note: `filterNot()` always returns a new instance, even if it results in + * not filtering out any values. + */ + filterNot( + predicate: (value: V, key: K, iter: this) => boolean, + context?: unknown + ): this; + + /** + * Returns a new Collection with the values for which the `predicate` + * function returns false and another for which is returns true. + */ + partition( + predicate: (this: C, value: V, key: K, iter: this) => value is F, + context?: C + ): [Collection, Collection]; + partition( + predicate: (this: C, value: V, key: K, iter: this) => unknown, + context?: C + ): [this, this]; + + /** + * Returns a new Collection of the same type in reverse order. + */ + reverse(): this; + + /** + * Returns a new Collection of the same type which includes the same entries, + * stably sorted by using a `comparator`. + * + * If a `comparator` is not provided, a default comparator uses `<` and `>`. + * + * `comparator(valueA, valueB)`: + * + * * Returns `0` if the elements should not be swapped. + * * Returns `-1` (or any negative number) if `valueA` comes before `valueB` + * * Returns `1` (or any positive number) if `valueA` comes after `valueB` + * * Alternatively, can return a value of the `PairSorting` enum type + * * Is pure, i.e. it must always return the same value for the same pair + * of values. + * + * When sorting collections which have no defined order, their ordered + * equivalents will be returned. e.g. `map.sort()` returns OrderedMap. + * + * + * ```js + * const { Map } = require('immutable') + * Map({ "c": 3, "a": 1, "b": 2 }).sort((a, b) => { + * if (a < b) { return -1; } + * if (a > b) { return 1; } + * if (a === b) { return 0; } + * }); + * // OrderedMap { "a": 1, "b": 2, "c": 3 } + * ``` + * + * Note: `sort()` Always returns a new instance, even if the original was + * already sorted. + * + * Note: This is always an eager operation. + */ + sort(comparator?: Comparator): this; + + /** + * Like `sort`, but also accepts a `comparatorValueMapper` which allows for + * sorting by more sophisticated means: + * + * + * ```js + * const { Map } = require('immutable') + * const beattles = Map({ + * John: { name: "Lennon" }, + * Paul: { name: "McCartney" }, + * George: { name: "Harrison" }, + * Ringo: { name: "Starr" }, + * }); + * beattles.sortBy(member => member.name); + * ``` + * + * Note: `sortBy()` Always returns a new instance, even if the original was + * already sorted. + * + * Note: This is always an eager operation. + */ + sortBy( + comparatorValueMapper: (value: V, key: K, iter: this) => C, + comparator?: Comparator + ): this; + + /** + * Returns a `Map` of `Collection`, grouped by the return + * value of the `grouper` function. + * + * Note: This is always an eager operation. + * + * + * ```js + * const { List, Map } = require('immutable') + * const listOfMaps = List([ + * Map({ v: 0 }), + * Map({ v: 1 }), + * Map({ v: 1 }), + * Map({ v: 0 }), + * Map({ v: 2 }) + * ]) + * const groupsOfMaps = listOfMaps.groupBy(x => x.get('v')) + * // Map { + * // 0: List [ Map{ "v": 0 }, Map { "v": 0 } ], + * // 1: List [ Map{ "v": 1 }, Map { "v": 1 } ], + * // 2: List [ Map{ "v": 2 } ], + * // } + * ``` + */ + groupBy( + grouper: (value: V, key: K, iter: this) => G, + context?: unknown + ): Map; + + // Side effects + + /** + * The `sideEffect` is executed for every entry in the Collection. + * + * Unlike `Array#forEach`, if any call of `sideEffect` returns + * `false`, the iteration will stop. Returns the number of entries iterated + * (including the last iteration which returned false). + */ + forEach( + sideEffect: (value: V, key: K, iter: this) => unknown, + context?: unknown + ): number; + + // Creating subsets + + /** + * Returns a new Collection of the same type representing a portion of this + * Collection from start up to but not including end. + * + * If begin is negative, it is offset from the end of the Collection. e.g. + * `slice(-2)` returns a Collection of the last two entries. If it is not + * provided the new Collection will begin at the beginning of this Collection. + * + * If end is negative, it is offset from the end of the Collection. e.g. + * `slice(0, -1)` returns a Collection of everything but the last entry. If + * it is not provided, the new Collection will continue through the end of + * this Collection. + * + * If the requested slice is equivalent to the current Collection, then it + * will return itself. + */ + slice(begin?: number, end?: number): this; + + /** + * Returns a new Collection of the same type containing all entries except + * the first. + */ + rest(): this; + + /** + * Returns a new Collection of the same type containing all entries except + * the last. + */ + butLast(): this; + + /** + * Returns a new Collection of the same type which excludes the first `amount` + * entries from this Collection. + */ + skip(amount: number): this; + + /** + * Returns a new Collection of the same type which excludes the last `amount` + * entries from this Collection. + */ + skipLast(amount: number): this; + + /** + * Returns a new Collection of the same type which includes entries starting + * from when `predicate` first returns false. + * + * + * ```js + * const { List } = require('immutable') + * List([ 'dog', 'frog', 'cat', 'hat', 'god' ]) + * .skipWhile(x => x.match(/g/)) + * // List [ "cat", "hat", "god" ] + * ``` + */ + skipWhile( + predicate: (value: V, key: K, iter: this) => boolean, + context?: unknown + ): this; + + /** + * Returns a new Collection of the same type which includes entries starting + * from when `predicate` first returns true. + * + * + * ```js + * const { List } = require('immutable') + * List([ 'dog', 'frog', 'cat', 'hat', 'god' ]) + * .skipUntil(x => x.match(/hat/)) + * // List [ "hat", "god" ] + * ``` + */ + skipUntil( + predicate: (value: V, key: K, iter: this) => boolean, + context?: unknown + ): this; + + /** + * Returns a new Collection of the same type which includes the first `amount` + * entries from this Collection. + */ + take(amount: number): this; + + /** + * Returns a new Collection of the same type which includes the last `amount` + * entries from this Collection. + */ + takeLast(amount: number): this; + + /** + * Returns a new Collection of the same type which includes entries from this + * Collection as long as the `predicate` returns true. + * + * + * ```js + * const { List } = require('immutable') + * List([ 'dog', 'frog', 'cat', 'hat', 'god' ]) + * .takeWhile(x => x.match(/o/)) + * // List [ "dog", "frog" ] + * ``` + */ + takeWhile( + predicate: (value: V, key: K, iter: this) => boolean, + context?: unknown + ): this; + + /** + * Returns a new Collection of the same type which includes entries from this + * Collection as long as the `predicate` returns false. + * + * + * ```js + * const { List } = require('immutable') + * List([ 'dog', 'frog', 'cat', 'hat', 'god' ]) + * .takeUntil(x => x.match(/at/)) + * // List [ "dog", "frog" ] + * ``` + */ + takeUntil( + predicate: (value: V, key: K, iter: this) => boolean, + context?: unknown + ): this; + + // Combination + + /** + * Returns a new Collection of the same type with other values and + * collection-like concatenated to this one. + * + * For Seqs, all entries will be present in the resulting Seq, even if they + * have the same key. + */ + concat( + ...valuesOrCollections: Array + ): Collection; + + /** + * Flattens nested Collections. + * + * Will deeply flatten the Collection by default, returning a Collection of the + * same type, but a `depth` can be provided in the form of a number or + * boolean (where true means to shallowly flatten one level). A depth of 0 + * (or shallow: false) will deeply flatten. + * + * Flattens only others Collection, not Arrays or Objects. + * + * Note: `flatten(true)` operates on Collection> and + * returns Collection + */ + flatten(depth?: number): Collection; + flatten(shallow?: boolean): Collection; + + /** + * Flat-maps the Collection, returning a Collection of the same type. + * + * Similar to `collection.map(...).flatten(true)`. + */ + flatMap( + mapper: (value: V, key: K, iter: this) => Iterable, + context?: unknown + ): Collection; + + /** + * Flat-maps the Collection, returning a Collection of the same type. + * + * Similar to `collection.map(...).flatten(true)`. + * Used for Dictionaries only. + */ + flatMap( + mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>, + context?: unknown + ): Collection; + + // Reducing a value + + /** + * Reduces the Collection to a value by calling the `reducer` for every entry + * in the Collection and passing along the reduced value. + * + * If `initialReduction` is not provided, the first item in the + * Collection will be used. + * + * @see `Array#reduce`. + */ + reduce( + reducer: (reduction: R, value: V, key: K, iter: this) => R, + initialReduction: R, + context?: unknown + ): R; + reduce( + reducer: (reduction: V | R, value: V, key: K, iter: this) => R + ): R; + + /** + * Reduces the Collection in reverse (from the right side). + * + * Note: Similar to this.reverse().reduce(), and provided for parity + * with `Array#reduceRight`. + */ + reduceRight( + reducer: (reduction: R, value: V, key: K, iter: this) => R, + initialReduction: R, + context?: unknown + ): R; + reduceRight( + reducer: (reduction: V | R, value: V, key: K, iter: this) => R + ): R; + + /** + * True if `predicate` returns true for all entries in the Collection. + */ + every( + predicate: (value: V, key: K, iter: this) => boolean, + context?: unknown + ): boolean; + + /** + * True if `predicate` returns true for any entry in the Collection. + */ + some( + predicate: (value: V, key: K, iter: this) => boolean, + context?: unknown + ): boolean; + + /** + * Joins values together as a string, inserting a separator between each. + * The default separator is `","`. + */ + join(separator?: string): string; + + /** + * Returns true if this Collection includes no values. + * + * For some lazy `Seq`, `isEmpty` might need to iterate to determine + * emptiness. At most one iteration will occur. + */ + isEmpty(): boolean; + + /** + * Returns the size of this Collection. + * + * Regardless of if this Collection can describe its size lazily (some Seqs + * cannot), this method will always return the correct size. E.g. it + * evaluates a lazy `Seq` if necessary. + * + * If `predicate` is provided, then this returns the count of entries in the + * Collection for which the `predicate` returns true. + */ + count(): number; + count( + predicate: (value: V, key: K, iter: this) => boolean, + context?: unknown + ): number; + + /** + * Returns a `Seq.Keyed` of counts, grouped by the return value of + * the `grouper` function. + * + * Note: This is not a lazy operation. + */ + countBy( + grouper: (value: V, key: K, iter: this) => G, + context?: unknown + ): Map; + + // Search for value + + /** + * Returns the first value for which the `predicate` returns true. + */ + find( + predicate: (value: V, key: K, iter: this) => boolean, + context?: unknown, + notSetValue?: V + ): V | undefined; + + /** + * Returns the last value for which the `predicate` returns true. + * + * Note: `predicate` will be called for each entry in reverse. + */ + findLast( + predicate: (value: V, key: K, iter: this) => boolean, + context?: unknown, + notSetValue?: V + ): V | undefined; + + /** + * Returns the first [key, value] entry for which the `predicate` returns true. + */ + findEntry( + predicate: (value: V, key: K, iter: this) => boolean, + context?: unknown, + notSetValue?: V + ): [K, V] | undefined; + + /** + * Returns the last [key, value] entry for which the `predicate` + * returns true. + * + * Note: `predicate` will be called for each entry in reverse. + */ + findLastEntry( + predicate: (value: V, key: K, iter: this) => boolean, + context?: unknown, + notSetValue?: V + ): [K, V] | undefined; + + /** + * Returns the key for which the `predicate` returns true. + */ + findKey( + predicate: (value: V, key: K, iter: this) => boolean, + context?: unknown + ): K | undefined; + + /** + * Returns the last key for which the `predicate` returns true. + * + * Note: `predicate` will be called for each entry in reverse. + */ + findLastKey( + predicate: (value: V, key: K, iter: this) => boolean, + context?: unknown + ): K | undefined; + + /** + * Returns the key associated with the search value, or undefined. + */ + keyOf(searchValue: V): K | undefined; + + /** + * Returns the last key associated with the search value, or undefined. + */ + lastKeyOf(searchValue: V): K | undefined; + + /** + * Returns the maximum value in this collection. If any values are + * comparatively equivalent, the first one found will be returned. + * + * The `comparator` is used in the same way as `Collection#sort`. If it is not + * provided, the default comparator is `>`. + * + * When two values are considered equivalent, the first encountered will be + * returned. Otherwise, `max` will operate independent of the order of input + * as long as the comparator is commutative. The default comparator `>` is + * commutative *only* when types do not differ. + * + * If `comparator` returns 0 and either value is NaN, undefined, or null, + * that value will be returned. + */ + max(comparator?: Comparator): V | undefined; + + /** + * Like `max`, but also accepts a `comparatorValueMapper` which allows for + * comparing by more sophisticated means: + * + * + * ```js + * const { List, } = require('immutable'); + * const l = List([ + * { name: 'Bob', avgHit: 1 }, + * { name: 'Max', avgHit: 3 }, + * { name: 'Lili', avgHit: 2 } , + * ]); + * l.maxBy(i => i.avgHit); // will output { name: 'Max', avgHit: 3 } + * ``` + */ + maxBy( + comparatorValueMapper: (value: V, key: K, iter: this) => C, + comparator?: Comparator + ): V | undefined; + + /** + * Returns the minimum value in this collection. If any values are + * comparatively equivalent, the first one found will be returned. + * + * The `comparator` is used in the same way as `Collection#sort`. If it is not + * provided, the default comparator is `<`. + * + * When two values are considered equivalent, the first encountered will be + * returned. Otherwise, `min` will operate independent of the order of input + * as long as the comparator is commutative. The default comparator `<` is + * commutative *only* when types do not differ. + * + * If `comparator` returns 0 and either value is NaN, undefined, or null, + * that value will be returned. + */ + min(comparator?: Comparator): V | undefined; + + /** + * Like `min`, but also accepts a `comparatorValueMapper` which allows for + * comparing by more sophisticated means: + * + * + * ```js + * const { List, } = require('immutable'); + * const l = List([ + * { name: 'Bob', avgHit: 1 }, + * { name: 'Max', avgHit: 3 }, + * { name: 'Lili', avgHit: 2 } , + * ]); + * l.minBy(i => i.avgHit); // will output { name: 'Bob', avgHit: 1 } + * ``` + */ + minBy( + comparatorValueMapper: (value: V, key: K, iter: this) => C, + comparator?: Comparator + ): V | undefined; + + // Comparison + + /** + * True if `iter` includes every value in this Collection. + */ + isSubset(iter: Iterable): boolean; + + /** + * True if this Collection includes every value in `iter`. + */ + isSuperset(iter: Iterable): boolean; + } + + /** + * The interface to fulfill to qualify as a Value Object. + */ + interface ValueObject { + /** + * True if this and the other Collection have value equality, as defined + * by `Immutable.is()`. + * + * Note: This is equivalent to `Immutable.is(this, other)`, but provided to + * allow for chained expressions. + */ + equals(other: unknown): boolean; + + /** + * Computes and returns the hashed identity for this Collection. + * + * The `hashCode` of a Collection is used to determine potential equality, + * and is used when adding this to a `Set` or as a key in a `Map`, enabling + * lookup via a different instance. + * + * + * ```js + * const { List, Set } = require('immutable'); + * const a = List([ 1, 2, 3 ]); + * const b = List([ 1, 2, 3 ]); + * assert.notStrictEqual(a, b); // different instances + * const set = Set([ a ]); + * assert.equal(set.has(b), true); + * ``` + * + * Note: hashCode() MUST return a Uint32 number. The easiest way to + * guarantee this is to return `myHash | 0` from a custom implementation. + * + * If two values have the same `hashCode`, they are [not guaranteed + * to be equal][Hash Collision]. If two values have different `hashCode`s, + * they must not be equal. + * + * Note: `hashCode()` is not guaranteed to always be called before + * `equals()`. Most but not all Immutable.js collections use hash codes to + * organize their internal data structures, while all Immutable.js + * collections use equality during lookups. + * + * [Hash Collision]: https://en.wikipedia.org/wiki/Collision_(computer_science) + */ + hashCode(): number; + } + + /** + * Interface representing all oredered collections. + * This includes `List`, `Stack`, `Map`, `OrderedMap`, `Set`, and `OrderedSet`. + * return of `isOrdered()` return true in that case. + */ + interface OrderedCollection { + /** + * Shallowly converts this collection to an Array. + */ + toArray(): Array; + + [Symbol.iterator](): IterableIterator; + } + + /** + * Deeply converts plain JS objects and arrays to Immutable Maps and Lists. + * + * `fromJS` will convert Arrays and [array-like objects][2] to a List, and + * plain objects (without a custom prototype) to a Map. [Iterable objects][3] + * may be converted to List, Map, or Set. + * + * If a `reviver` is optionally provided, it will be called with every + * collection as a Seq (beginning with the most nested collections + * and proceeding to the top-level collection itself), along with the key + * referring to each collection and the parent JS object provided as `this`. + * For the top level, object, the key will be `""`. This `reviver` is expected + * to return a new Immutable Collection, allowing for custom conversions from + * deep JS objects. Finally, a `path` is provided which is the sequence of + * keys to this value from the starting value. + * + * `reviver` acts similarly to the [same parameter in `JSON.parse`][1]. + * + * If `reviver` is not provided, the default behavior will convert Objects + * into Maps and Arrays into Lists like so: + * + * + * ```js + * const { fromJS, isKeyed } = require('immutable') + * function (key, value) { + * return isKeyed(value) ? value.toMap() : value.toList() + * } + * ``` + * + * Accordingly, this example converts native JS data to OrderedMap and List: + * + * + * ```js + * const { fromJS, isKeyed } = require('immutable') + * fromJS({ a: {b: [10, 20, 30]}, c: 40}, function (key, value, path) { + * console.log(key, value, path) + * return isKeyed(value) ? value.toOrderedMap() : value.toList() + * }) + * + * > "b", [ 10, 20, 30 ], [ "a", "b" ] + * > "a", {b: [10, 20, 30]}, [ "a" ] + * > "", {a: {b: [10, 20, 30]}, c: 40}, [] + * ``` + * + * Keep in mind, when using JS objects to construct Immutable Maps, that + * JavaScript Object properties are always strings, even if written in a + * quote-less shorthand, while Immutable Maps accept keys of any type. + * + * + * ```js + * const { Map } = require('immutable') + * let obj = { 1: "one" }; + * Object.keys(obj); // [ "1" ] + * assert.equal(obj["1"], obj[1]); // "one" === "one" + * + * let map = Map(obj); + * assert.notEqual(map.get("1"), map.get(1)); // "one" !== undefined + * ``` + * + * Property access for JavaScript Objects first converts the key to a string, + * but since Immutable Map keys can be of any type the argument to `get()` is + * not altered. + * + * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#Example.3A_Using_the_reviver_parameter + * "Using the reviver parameter" + * [2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Indexed_collections#working_with_array-like_objects + * "Working with array-like objects" + * [3]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_iterable_protocol + * "The iterable protocol" + */ + function fromJS( + jsValue: JSValue, + reviver?: undefined + ): FromJS; + function fromJS( + jsValue: unknown, + reviver?: ( + key: string | number, + sequence: Collection.Keyed | Collection.Indexed, + path?: Array + ) => unknown + ): Collection; + + type FromJS = JSValue extends FromJSNoTransform + ? JSValue + : JSValue extends Array + ? FromJSArray + : JSValue extends object + ? FromJSObject + : unknown; + + type FromJSNoTransform = + | Collection + | number + | string + | null + | undefined; + + type FromJSArray = + JSValue extends Array ? List> : never; + + type FromJSObject = JSValue extends object + ? Map> + : never; + + /** + * Value equality check with semantics similar to `Object.is`, but treats + * Immutable `Collection`s as values, equal if the second `Collection` includes + * equivalent values. + * + * It's used throughout Immutable when checking for equality, including `Map` + * key equality and `Set` membership. + * + * + * ```js + * const { Map, is } = require('immutable') + * const map1 = Map({ a: 1, b: 1, c: 1 }) + * const map2 = Map({ a: 1, b: 1, c: 1 }) + * assert.equal(map1 !== map2, true) + * assert.equal(Object.is(map1, map2), false) + * assert.equal(is(map1, map2), true) + * ``` + * + * `is()` compares primitive types like strings and numbers, Immutable.js + * collections like `Map` and `List`, but also any custom object which + * implements `ValueObject` by providing `equals()` and `hashCode()` methods. + * + * Note: Unlike `Object.is`, `Immutable.is` assumes `0` and `-0` are the same + * value, matching the behavior of ES6 Map key equality. + */ + function is(first: unknown, second: unknown): boolean; + + /** + * The `hash()` function is an important part of how Immutable determines if + * two values are equivalent and is used to determine how to store those + * values. Provided with any value, `hash()` will return a 31-bit integer. + * + * When designing Objects which may be equal, it's important that when a + * `.equals()` method returns true, that both values `.hashCode()` method + * return the same value. `hash()` may be used to produce those values. + * + * For non-Immutable Objects that do not provide a `.hashCode()` functions + * (including plain Objects, plain Arrays, Date objects, etc), a unique hash + * value will be created for each *instance*. That is, the create hash + * represents referential equality, and not value equality for Objects. This + * ensures that if that Object is mutated over time that its hash code will + * remain consistent, allowing Objects to be used as keys and values in + * Immutable.js collections. + * + * Note that `hash()` attempts to balance between speed and avoiding + * collisions, however it makes no attempt to produce secure hashes. + * + * *New in Version 4.0* + */ + function hash(value: unknown): number; + + /** + * True if `maybeImmutable` is an Immutable Collection or Record. + * + * Note: Still returns true even if the collections is within a `withMutations()`. + * + * + * ```js + * const { isImmutable, Map, List, Stack } = require('immutable'); + * isImmutable([]); // false + * isImmutable({}); // false + * isImmutable(Map()); // true + * isImmutable(List()); // true + * isImmutable(Stack()); // true + * isImmutable(Map().asMutable()); // true + * ``` + */ + function isImmutable( + maybeImmutable: unknown + ): maybeImmutable is Collection; + + /** + * True if `maybeCollection` is a Collection, or any of its subclasses. + * + * + * ```js + * const { isCollection, Map, List, Stack } = require('immutable'); + * isCollection([]); // false + * isCollection({}); // false + * isCollection(Map()); // true + * isCollection(List()); // true + * isCollection(Stack()); // true + * ``` + */ + function isCollection( + maybeCollection: unknown + ): maybeCollection is Collection; + + /** + * True if `maybeKeyed` is a Collection.Keyed, or any of its subclasses. + * + * + * ```js + * const { isKeyed, Map, List, Stack } = require('immutable'); + * isKeyed([]); // false + * isKeyed({}); // false + * isKeyed(Map()); // true + * isKeyed(List()); // false + * isKeyed(Stack()); // false + * ``` + */ + function isKeyed( + maybeKeyed: unknown + ): maybeKeyed is Collection.Keyed; + + /** + * True if `maybeIndexed` is a Collection.Indexed, or any of its subclasses. + * + * + * ```js + * const { isIndexed, Map, List, Stack, Set } = require('immutable'); + * isIndexed([]); // false + * isIndexed({}); // false + * isIndexed(Map()); // false + * isIndexed(List()); // true + * isIndexed(Stack()); // true + * isIndexed(Set()); // false + * ``` + */ + function isIndexed( + maybeIndexed: unknown + ): maybeIndexed is Collection.Indexed; + + /** + * True if `maybeAssociative` is either a Keyed or Indexed Collection. + * + * + * ```js + * const { isAssociative, Map, List, Stack, Set } = require('immutable'); + * isAssociative([]); // false + * isAssociative({}); // false + * isAssociative(Map()); // true + * isAssociative(List()); // true + * isAssociative(Stack()); // true + * isAssociative(Set()); // false + * ``` + */ + function isAssociative( + maybeAssociative: unknown + ): maybeAssociative is + | Collection.Keyed + | Collection.Indexed; + + /** + * True if `maybeOrdered` is a Collection where iteration order is well + * defined. True for Collection.Indexed as well as OrderedMap and OrderedSet. + * + * + * ```js + * const { isOrdered, Map, OrderedMap, List, Set } = require('immutable'); + * isOrdered([]); // false + * isOrdered({}); // false + * isOrdered(Map()); // false + * isOrdered(OrderedMap()); // true + * isOrdered(List()); // true + * isOrdered(Set()); // false + * ``` + */ + function isOrdered( + maybeOrdered: Iterable + ): maybeOrdered is OrderedCollection; + function isOrdered( + maybeOrdered: unknown + ): maybeOrdered is OrderedCollection; + + /** + * True if `maybeValue` is a JavaScript Object which has *both* `equals()` + * and `hashCode()` methods. + * + * Any two instances of *value objects* can be compared for value equality with + * `Immutable.is()` and can be used as keys in a `Map` or members in a `Set`. + */ + function isValueObject(maybeValue: unknown): maybeValue is ValueObject; + + /** + * True if `maybeSeq` is a Seq. + */ + function isSeq( + maybeSeq: unknown + ): maybeSeq is + | Seq.Indexed + | Seq.Keyed + | Seq.Set; + + /** + * True if `maybeList` is a List. + */ + function isList(maybeList: unknown): maybeList is List; + + /** + * True if `maybeMap` is a Map. + * + * Also true for OrderedMaps. + */ + function isMap(maybeMap: unknown): maybeMap is Map; + + /** + * True if `maybeOrderedMap` is an OrderedMap. + */ + function isOrderedMap( + maybeOrderedMap: unknown + ): maybeOrderedMap is OrderedMap; + + /** + * True if `maybeStack` is a Stack. + */ + function isStack(maybeStack: unknown): maybeStack is Stack; + + /** + * True if `maybeSet` is a Set. + * + * Also true for OrderedSets. + */ + function isSet(maybeSet: unknown): maybeSet is Set; + + /** + * True if `maybeOrderedSet` is an OrderedSet. + */ + function isOrderedSet( + maybeOrderedSet: unknown + ): maybeOrderedSet is OrderedSet; + + /** + * True if `maybeRecord` is a Record. + */ + function isRecord(maybeRecord: unknown): maybeRecord is Record; + + /** + * Returns the value within the provided collection associated with the + * provided key, or notSetValue if the key is not defined in the collection. + * + * A functional alternative to `collection.get(key)` which will also work on + * plain Objects and Arrays as an alternative for `collection[key]`. + * + * + * ```js + * const { get } = require('immutable') + * get([ 'dog', 'frog', 'cat' ], 2) // 'frog' + * get({ x: 123, y: 456 }, 'x') // 123 + * get({ x: 123, y: 456 }, 'z', 'ifNotSet') // 'ifNotSet' + * ``` + */ + function get(collection: Collection, key: K): V | undefined; + function get( + collection: Collection, + key: K, + notSetValue: NSV + ): V | NSV; + function get( + record: Record, + key: K, + notSetValue: unknown + ): TProps[K]; + function get(collection: Array, key: number): V | undefined; + function get( + collection: Array, + key: number, + notSetValue: NSV + ): V | NSV; + function get( + object: C, + key: K, + notSetValue: unknown + ): C[K]; + function get( + collection: { [key: PropertyKey]: V }, + key: string + ): V | undefined; + function get( + collection: { [key: PropertyKey]: V }, + key: string, + notSetValue: NSV + ): V | NSV; + + /** + * Returns true if the key is defined in the provided collection. + * + * A functional alternative to `collection.has(key)` which will also work with + * plain Objects and Arrays as an alternative for + * `collection.hasOwnProperty(key)`. + * + * + * ```js + * const { has } = require('immutable') + * has([ 'dog', 'frog', 'cat' ], 2) // true + * has([ 'dog', 'frog', 'cat' ], 5) // false + * has({ x: 123, y: 456 }, 'x') // true + * has({ x: 123, y: 456 }, 'z') // false + * ``` + */ + function has(collection: object, key: unknown): boolean; + + /** + * Returns a copy of the collection with the value at key removed. + * + * A functional alternative to `collection.remove(key)` which will also work + * with plain Objects and Arrays as an alternative for + * `delete collectionCopy[key]`. + * + * + * ```js + * const { remove } = require('immutable') + * const originalArray = [ 'dog', 'frog', 'cat' ] + * remove(originalArray, 1) // [ 'dog', 'cat' ] + * console.log(originalArray) // [ 'dog', 'frog', 'cat' ] + * const originalObject = { x: 123, y: 456 } + * remove(originalObject, 'x') // { y: 456 } + * console.log(originalObject) // { x: 123, y: 456 } + * ``` + */ + function remove>( + collection: C, + key: K + ): C; + function remove< + TProps extends object, + C extends Record, + K extends keyof TProps, + >(collection: C, key: K): C; + function remove>(collection: C, key: number): C; + function remove(collection: C, key: K): C; + function remove( + collection: C, + key: K + ): C; + + /** + * Returns a copy of the collection with the value at key set to the provided + * value. + * + * A functional alternative to `collection.set(key, value)` which will also + * work with plain Objects and Arrays as an alternative for + * `collectionCopy[key] = value`. + * + * + * ```js + * const { set } = require('immutable') + * const originalArray = [ 'dog', 'frog', 'cat' ] + * set(originalArray, 1, 'cow') // [ 'dog', 'cow', 'cat' ] + * console.log(originalArray) // [ 'dog', 'frog', 'cat' ] + * const originalObject = { x: 123, y: 456 } + * set(originalObject, 'x', 789) // { x: 789, y: 456 } + * console.log(originalObject) // { x: 123, y: 456 } + * ``` + */ + function set>( + collection: C, + key: K, + value: V + ): C; + function set< + TProps extends object, + C extends Record, + K extends keyof TProps, + >(record: C, key: K, value: TProps[K]): C; + function set>(collection: C, key: number, value: V): C; + function set(object: C, key: K, value: C[K]): C; + function set( + collection: C, + key: string, + value: V + ): C; + + /** + * Returns a copy of the collection with the value at key set to the result of + * providing the existing value to the updating function. + * + * A functional alternative to `collection.update(key, fn)` which will also + * work with plain Objects and Arrays as an alternative for + * `collectionCopy[key] = fn(collection[key])`. + * + * + * ```js + * const { update } = require('immutable') + * const originalArray = [ 'dog', 'frog', 'cat' ] + * update(originalArray, 1, val => val.toUpperCase()) // [ 'dog', 'FROG', 'cat' ] + * console.log(originalArray) // [ 'dog', 'frog', 'cat' ] + * const originalObject = { x: 123, y: 456 } + * update(originalObject, 'x', val => val * 6) // { x: 738, y: 456 } + * console.log(originalObject) // { x: 123, y: 456 } + * ``` + */ + function update>( + collection: C, + key: K, + updater: (value: V | undefined) => V | undefined + ): C; + function update, NSV>( + collection: C, + key: K, + notSetValue: NSV, + updater: (value: V | NSV) => V + ): C; + function update< + TProps extends object, + C extends Record, + K extends keyof TProps, + >(record: C, key: K, updater: (value: TProps[K]) => TProps[K]): C; + function update< + TProps extends object, + C extends Record, + K extends keyof TProps, + NSV, + >( + record: C, + key: K, + notSetValue: NSV, + updater: (value: TProps[K] | NSV) => TProps[K] + ): C; + function update( + collection: Array, + key: number, + updater: (value: V | undefined) => V | undefined + ): Array; + function update( + collection: Array, + key: number, + notSetValue: NSV, + updater: (value: V | NSV) => V + ): Array; + function update( + object: C, + key: K, + updater: (value: C[K]) => C[K] + ): C; + function update( + object: C, + key: K, + notSetValue: NSV, + updater: (value: C[K] | NSV) => C[K] + ): C; + function update( + collection: C, + key: K, + updater: (value: V) => V + ): { [key: string]: V }; + function update( + collection: C, + key: K, + notSetValue: NSV, + updater: (value: V | NSV) => V + ): { [key: string]: V }; + + // TODO `` can be used after dropping support for TypeScript 4.x + // reference: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-0.html#const-type-parameters + // after this change, `as const` assertions can be remove from the type tests + /** + * Returns the value at the provided key path starting at the provided + * collection, or notSetValue if the key path is not defined. + * + * A functional alternative to `collection.getIn(keypath)` which will also + * work with plain Objects and Arrays. + * + * + * ```js + * const { getIn } = require('immutable') + * getIn({ x: { y: { z: 123 }}}, ['x', 'y', 'z']) // 123 + * getIn({ x: { y: { z: 123 }}}, ['x', 'q', 'p'], 'ifNotSet') // 'ifNotSet' + * ``` + */ + function getIn>( + object: C, + keyPath: [...P] + ): RetrievePath; + function getIn>(object: C, keyPath: P): unknown; + function getIn, NSV>( + collection: C, + keyPath: [...P], + notSetValue: NSV + ): RetrievePath extends never ? NSV : RetrievePath; + function getIn, NSV>( + object: C, + keyPath: P, + notSetValue: NSV + ): unknown; + + /** + * Returns true if the key path is defined in the provided collection. + * + * A functional alternative to `collection.hasIn(keypath)` which will also + * work with plain Objects and Arrays. + * + * + * ```js + * const { hasIn } = require('immutable') + * hasIn({ x: { y: { z: 123 }}}, ['x', 'y', 'z']) // true + * hasIn({ x: { y: { z: 123 }}}, ['x', 'q', 'p']) // false + * ``` + */ + function hasIn( + collection: string | boolean | number, + keyPath: KeyPath + ): never; + function hasIn(collection: unknown, keyPath: KeyPath): boolean; + + /** + * Returns a copy of the collection with the value at the key path removed. + * + * A functional alternative to `collection.removeIn(keypath)` which will also + * work with plain Objects and Arrays. + * + * + * ```js + * const { removeIn } = require('immutable') + * const original = { x: { y: { z: 123 }}} + * removeIn(original, ['x', 'y', 'z']) // { x: { y: {}}} + * console.log(original) // { x: { y: { z: 123 }}} + * ``` + */ + function removeIn(collection: C, keyPath: Iterable): C; + + /** + * Returns a copy of the collection with the value at the key path set to the + * provided value. + * + * A functional alternative to `collection.setIn(keypath)` which will also + * work with plain Objects and Arrays. + * + * + * ```js + * const { setIn } = require('immutable') + * const original = { x: { y: { z: 123 }}} + * setIn(original, ['x', 'y', 'z'], 456) // { x: { y: { z: 456 }}} + * console.log(original) // { x: { y: { z: 123 }}} + * ``` + */ + function setIn( + collection: C, + keyPath: Iterable, + value: unknown + ): C; + + /** + * Returns a copy of the collection with the value at key path set to the + * result of providing the existing value to the updating function. + * + * A functional alternative to `collection.updateIn(keypath)` which will also + * work with plain Objects and Arrays. + * + * + * ```js + * const { updateIn } = require('immutable') + * const original = { x: { y: { z: 123 }}} + * updateIn(original, ['x', 'y', 'z'], val => val * 6) // { x: { y: { z: 738 }}} + * console.log(original) // { x: { y: { z: 123 }}} + * ``` + */ + function updateIn>( + collection: C, + keyPath: KeyPath, + updater: ( + value: RetrievePath> | undefined + ) => unknown | undefined + ): C; + function updateIn, NSV>( + collection: C, + keyPath: KeyPath, + notSetValue: NSV, + updater: (value: RetrievePath> | NSV) => unknown + ): C; + function updateIn< + TProps extends object, + C extends Record, + K extends keyof TProps, + >( + record: C, + keyPath: KeyPath, + updater: (value: RetrievePath>) => unknown + ): C; + function updateIn< + TProps extends object, + C extends Record, + K extends keyof TProps, + NSV, + >( + record: C, + keyPath: KeyPath, + notSetValue: NSV, + updater: (value: RetrievePath> | NSV) => unknown + ): C; + function updateIn>( + collection: Array, + keyPath: KeyPath, + updater: ( + value: RetrievePath> | undefined + ) => unknown | undefined + ): Array; + function updateIn, NSV>( + collection: Array, + keyPath: KeyPath, + notSetValue: NSV, + updater: (value: RetrievePath> | NSV) => unknown + ): Array; + function updateIn( + object: C, + keyPath: KeyPath, + updater: (value: RetrievePath>) => unknown + ): C; + function updateIn( + object: C, + keyPath: KeyPath, + notSetValue: NSV, + updater: (value: RetrievePath> | NSV) => unknown + ): C; + function updateIn< + K extends PropertyKey, + V, + C extends { [key: PropertyKey]: V }, + >( + collection: C, + keyPath: KeyPath, + updater: (value: RetrievePath>) => unknown + ): { [key: PropertyKey]: V }; + function updateIn< + K extends PropertyKey, + V, + C extends { [key: PropertyKey]: V }, + NSV, + >( + collection: C, + keyPath: KeyPath, + notSetValue: NSV, + updater: (value: RetrievePath> | NSV) => unknown + ): { [key: PropertyKey]: V }; + + /** + * Returns a copy of the collection with the remaining collections merged in. + * + * A functional alternative to `collection.merge()` which will also work with + * plain Objects and Arrays. + * + * + * ```js + * const { merge } = require('immutable') + * const original = { x: 123, y: 456 } + * merge(original, { y: 789, z: 'abc' }) // { x: 123, y: 789, z: 'abc' } + * console.log(original) // { x: 123, y: 456 } + * ``` + */ + function merge( + collection: C, + ...collections: Array< + | Iterable + | Iterable<[unknown, unknown]> + | { [key: string]: unknown } + > + ): C; + + /** + * Returns a copy of the collection with the remaining collections merged in, + * calling the `merger` function whenever an existing value is encountered. + * + * A functional alternative to `collection.mergeWith()` which will also work + * with plain Objects and Arrays. + * + * + * ```js + * const { mergeWith } = require('immutable') + * const original = { x: 123, y: 456 } + * mergeWith( + * (oldVal, newVal) => oldVal + newVal, + * original, + * { y: 789, z: 'abc' } + * ) // { x: 123, y: 1245, z: 'abc' } + * console.log(original) // { x: 123, y: 456 } + * ``` + */ + function mergeWith( + merger: (oldVal: unknown, newVal: unknown, key: unknown) => unknown, + collection: C, + ...collections: Array< + | Iterable + | Iterable<[unknown, unknown]> + | { [key: string]: unknown } + > + ): C; + + /** + * Like `merge()`, but when two compatible collections are encountered with + * the same key, it merges them as well, recursing deeply through the nested + * data. Two collections are considered to be compatible (and thus will be + * merged together) if they both fall into one of three categories: keyed + * (e.g., `Map`s, `Record`s, and objects), indexed (e.g., `List`s and + * arrays), or set-like (e.g., `Set`s). If they fall into separate + * categories, `mergeDeep` will replace the existing collection with the + * collection being merged in. This behavior can be customized by using + * `mergeDeepWith()`. + * + * Note: Indexed and set-like collections are merged using + * `concat()`/`union()` and therefore do not recurse. + * + * A functional alternative to `collection.mergeDeep()` which will also work + * with plain Objects and Arrays. + * + * + * ```js + * const { mergeDeep } = require('immutable') + * const original = { x: { y: 123 }} + * mergeDeep(original, { x: { z: 456 }}) // { x: { y: 123, z: 456 }} + * console.log(original) // { x: { y: 123 }} + * ``` + */ + function mergeDeep( + collection: C, + ...collections: Array< + | Iterable + | Iterable<[unknown, unknown]> + | { [key: string]: unknown } + > + ): C; + + /** + * Like `mergeDeep()`, but when two non-collections or incompatible + * collections are encountered at the same key, it uses the `merger` function + * to determine the resulting value. Collections are considered incompatible + * if they fall into separate categories between keyed, indexed, and set-like. + * + * A functional alternative to `collection.mergeDeepWith()` which will also + * work with plain Objects and Arrays. + * + * + * ```js + * const { mergeDeepWith } = require('immutable') + * const original = { x: { y: 123 }} + * mergeDeepWith( + * (oldVal, newVal) => oldVal + newVal, + * original, + * { x: { y: 456 }} + * ) // { x: { y: 579 }} + * console.log(original) // { x: { y: 123 }} + * ``` + */ + function mergeDeepWith( + merger: (oldVal: unknown, newVal: unknown, key: unknown) => unknown, + collection: C, + ...collections: Array< + | Iterable + | Iterable<[unknown, unknown]> + | { [key: string]: unknown } + > + ): C; +} + +/** + * Defines the main export of the immutable module to be the Immutable namespace + * This supports many common module import patterns: + * + * const Immutable = require("immutable"); + * const { List } = require("immutable"); + * import Immutable from "immutable"; + * import * as Immutable from "immutable"; + * import { List } from "immutable"; + * + */ +export = Immutable; + +/** + * A global "Immutable" namespace used by UMD modules which allows the use of + * the full Immutable API. + * + * If using Immutable as an imported module, prefer using: + * + * import Immutable from 'immutable' + * + */ +export as namespace Immutable; diff --git a/node_modules/immutable/dist/immutable.es.js b/node_modules/immutable/dist/immutable.es.js new file mode 100644 index 0000000..8cf8322 --- /dev/null +++ b/node_modules/immutable/dist/immutable.es.js @@ -0,0 +1,6225 @@ +/** + * @license + * MIT License + * + * Copyright (c) 2014-present, Lee Byron and other contributors. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +// Used for setting prototype methods that IE8 chokes on. +var DELETE = 'delete'; +// Constants describing the size of trie nodes. +var SHIFT = 5; // Resulted in best performance after ______? +var SIZE = 1 << SHIFT; +var MASK = SIZE - 1; +// A consistent shared value representing "not set" which equals nothing other +// than itself, and nothing that could be provided externally. +var NOT_SET = {}; +// Boolean references, Rough equivalent of `bool &`. +function MakeRef() { + return { value: false }; +} +function SetRef(ref) { + if (ref) { + ref.value = true; + } +} +// A function which returns a value representing an "owner" for transient writes +// to tries. The return value will only ever equal itself, and will not equal +// the return of any subsequent call of this function. +function OwnerID() { } +function ensureSize(iter) { + // @ts-expect-error size should exists on Collection + if (iter.size === undefined) { + // @ts-expect-error size should exists on Collection, __iterate does exist on Collection + iter.size = iter.__iterate(returnTrue); + } + // @ts-expect-error size should exists on Collection + return iter.size; +} +function wrapIndex(iter, index) { + // This implements "is array index" which the ECMAString spec defines as: + // + // A String property name P is an array index if and only if + // ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal + // to 2^32−1. + // + // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects + if (typeof index !== 'number') { + var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32 + if ('' + uint32Index !== index || uint32Index === 4294967295) { + return NaN; + } + index = uint32Index; + } + return index < 0 ? ensureSize(iter) + index : index; +} +function returnTrue() { + return true; +} +function wholeSlice(begin, end, size) { + return (((begin === 0 && !isNeg(begin)) || + (size !== undefined && begin <= -size)) && + (end === undefined || (size !== undefined && end >= size))); +} +function resolveBegin(begin, size) { + return resolveIndex(begin, size, 0); +} +function resolveEnd(end, size) { + return resolveIndex(end, size, size); +} +function resolveIndex(index, size, defaultIndex) { + // Sanitize indices using this shorthand for ToInt32(argument) + // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32 + return index === undefined + ? defaultIndex + : isNeg(index) + ? size === Infinity + ? size + : Math.max(0, size + index) | 0 + : size === undefined || size === index + ? index + : Math.min(size, index) | 0; +} +function isNeg(value) { + // Account for -0 which is negative, but not less than 0. + return value < 0 || (value === 0 && 1 / value === -Infinity); +} + +// Note: value is unchanged to not break immutable-devtools. +var IS_COLLECTION_SYMBOL = '@@__IMMUTABLE_ITERABLE__@@'; +/** + * True if `maybeCollection` is a Collection, or any of its subclasses. + * + * ```js + * import { isCollection, Map, List, Stack } from 'immutable'; + * + * isCollection([]); // false + * isCollection({}); // false + * isCollection(Map()); // true + * isCollection(List()); // true + * isCollection(Stack()); // true + * ``` + */ +function isCollection(maybeCollection) { + return Boolean(maybeCollection && + // @ts-expect-error: maybeCollection is typed as `{}`, need to change in 6.0 to `maybeCollection && typeof maybeCollection === 'object' && IS_COLLECTION_SYMBOL in maybeCollection` + maybeCollection[IS_COLLECTION_SYMBOL]); +} + +var IS_KEYED_SYMBOL = '@@__IMMUTABLE_KEYED__@@'; +/** + * True if `maybeKeyed` is a Collection.Keyed, or any of its subclasses. + * + * ```js + * import { isKeyed, Map, List, Stack } from 'immutable'; + * + * isKeyed([]); // false + * isKeyed({}); // false + * isKeyed(Map()); // true + * isKeyed(List()); // false + * isKeyed(Stack()); // false + * ``` + */ +function isKeyed(maybeKeyed) { + return Boolean(maybeKeyed && + // @ts-expect-error: maybeKeyed is typed as `{}`, need to change in 6.0 to `maybeKeyed && typeof maybeKeyed === 'object' && IS_KEYED_SYMBOL in maybeKeyed` + maybeKeyed[IS_KEYED_SYMBOL]); +} + +var IS_INDEXED_SYMBOL = '@@__IMMUTABLE_INDEXED__@@'; +/** + * True if `maybeIndexed` is a Collection.Indexed, or any of its subclasses. + * + * ```js + * import { isIndexed, Map, List, Stack, Set } from 'immutable'; + * + * isIndexed([]); // false + * isIndexed({}); // false + * isIndexed(Map()); // false + * isIndexed(List()); // true + * isIndexed(Stack()); // true + * isIndexed(Set()); // false + * ``` + */ +function isIndexed(maybeIndexed) { + return Boolean(maybeIndexed && + // @ts-expect-error: maybeIndexed is typed as `{}`, need to change in 6.0 to `maybeIndexed && typeof maybeIndexed === 'object' && IS_INDEXED_SYMBOL in maybeIndexed` + maybeIndexed[IS_INDEXED_SYMBOL]); +} + +/** + * True if `maybeAssociative` is either a Keyed or Indexed Collection. + * + * ```js + * import { isAssociative, Map, List, Stack, Set } from 'immutable'; + * + * isAssociative([]); // false + * isAssociative({}); // false + * isAssociative(Map()); // true + * isAssociative(List()); // true + * isAssociative(Stack()); // true + * isAssociative(Set()); // false + * ``` + */ +function isAssociative(maybeAssociative) { + return isKeyed(maybeAssociative) || isIndexed(maybeAssociative); +} + +var Collection = function Collection(value) { + // eslint-disable-next-line no-constructor-return + return isCollection(value) ? value : Seq(value); +}; + +var KeyedCollection = /*@__PURE__*/(function (Collection) { + function KeyedCollection(value) { + // eslint-disable-next-line no-constructor-return + return isKeyed(value) ? value : KeyedSeq(value); + } + + if ( Collection ) KeyedCollection.__proto__ = Collection; + KeyedCollection.prototype = Object.create( Collection && Collection.prototype ); + KeyedCollection.prototype.constructor = KeyedCollection; + + return KeyedCollection; +}(Collection)); + +var IndexedCollection = /*@__PURE__*/(function (Collection) { + function IndexedCollection(value) { + // eslint-disable-next-line no-constructor-return + return isIndexed(value) ? value : IndexedSeq(value); + } + + if ( Collection ) IndexedCollection.__proto__ = Collection; + IndexedCollection.prototype = Object.create( Collection && Collection.prototype ); + IndexedCollection.prototype.constructor = IndexedCollection; + + return IndexedCollection; +}(Collection)); + +var SetCollection = /*@__PURE__*/(function (Collection) { + function SetCollection(value) { + // eslint-disable-next-line no-constructor-return + return isCollection(value) && !isAssociative(value) ? value : SetSeq(value); + } + + if ( Collection ) SetCollection.__proto__ = Collection; + SetCollection.prototype = Object.create( Collection && Collection.prototype ); + SetCollection.prototype.constructor = SetCollection; + + return SetCollection; +}(Collection)); + +Collection.Keyed = KeyedCollection; +Collection.Indexed = IndexedCollection; +Collection.Set = SetCollection; + +var IS_SEQ_SYMBOL = '@@__IMMUTABLE_SEQ__@@'; +/** + * True if `maybeSeq` is a Seq. + */ +function isSeq(maybeSeq) { + return Boolean(maybeSeq && + // @ts-expect-error: maybeSeq is typed as `{}`, need to change in 6.0 to `maybeSeq && typeof maybeSeq === 'object' && MAYBE_SEQ_SYMBOL in maybeSeq` + maybeSeq[IS_SEQ_SYMBOL]); +} + +var IS_RECORD_SYMBOL = '@@__IMMUTABLE_RECORD__@@'; +/** + * True if `maybeRecord` is a Record. + */ +function isRecord(maybeRecord) { + return Boolean(maybeRecord && + // @ts-expect-error: maybeRecord is typed as `{}`, need to change in 6.0 to `maybeRecord && typeof maybeRecord === 'object' && IS_RECORD_SYMBOL in maybeRecord` + maybeRecord[IS_RECORD_SYMBOL]); +} + +/** + * True if `maybeImmutable` is an Immutable Collection or Record. + * + * Note: Still returns true even if the collections is within a `withMutations()`. + * + * ```js + * import { isImmutable, Map, List, Stack } from 'immutable'; + * isImmutable([]); // false + * isImmutable({}); // false + * isImmutable(Map()); // true + * isImmutable(List()); // true + * isImmutable(Stack()); // true + * isImmutable(Map().asMutable()); // true + * ``` + */ +function isImmutable(maybeImmutable) { + return isCollection(maybeImmutable) || isRecord(maybeImmutable); +} + +var IS_ORDERED_SYMBOL = '@@__IMMUTABLE_ORDERED__@@'; +function isOrdered(maybeOrdered) { + return Boolean(maybeOrdered && + // @ts-expect-error: maybeOrdered is typed as `{}`, need to change in 6.0 to `maybeOrdered && typeof maybeOrdered === 'object' && IS_ORDERED_SYMBOL in maybeOrdered` + maybeOrdered[IS_ORDERED_SYMBOL]); +} + +var ITERATE_KEYS = 0; +var ITERATE_VALUES = 1; +var ITERATE_ENTRIES = 2; + +var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator; +var FAUX_ITERATOR_SYMBOL = '@@iterator'; + +var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL; + +var Iterator = function Iterator(next) { + this.next = next; +}; + +Iterator.prototype.toString = function toString () { + return '[Iterator]'; +}; + +Iterator.KEYS = ITERATE_KEYS; +Iterator.VALUES = ITERATE_VALUES; +Iterator.ENTRIES = ITERATE_ENTRIES; + +Iterator.prototype.inspect = Iterator.prototype.toSource = function () { + return this.toString(); +}; +Iterator.prototype[ITERATOR_SYMBOL] = function () { + return this; +}; + +function iteratorValue(type, k, v, iteratorResult) { + var value = + type === ITERATE_KEYS ? k : type === ITERATE_VALUES ? v : [k, v]; + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + iteratorResult + ? (iteratorResult.value = value) + : (iteratorResult = { + value: value, + done: false, + }); + return iteratorResult; +} + +function iteratorDone() { + return { value: undefined, done: true }; +} + +function hasIterator(maybeIterable) { + if (Array.isArray(maybeIterable)) { + // IE11 trick as it does not support `Symbol.iterator` + return true; + } + + return !!getIteratorFn(maybeIterable); +} + +function isIterator(maybeIterator) { + return maybeIterator && typeof maybeIterator.next === 'function'; +} + +function getIterator(iterable) { + var iteratorFn = getIteratorFn(iterable); + return iteratorFn && iteratorFn.call(iterable); +} + +function getIteratorFn(iterable) { + var iteratorFn = + iterable && + ((REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) || + iterable[FAUX_ITERATOR_SYMBOL]); + if (typeof iteratorFn === 'function') { + return iteratorFn; + } +} + +function isEntriesIterable(maybeIterable) { + var iteratorFn = getIteratorFn(maybeIterable); + return iteratorFn && iteratorFn === maybeIterable.entries; +} + +function isKeysIterable(maybeIterable) { + var iteratorFn = getIteratorFn(maybeIterable); + return iteratorFn && iteratorFn === maybeIterable.keys; +} + +var hasOwnProperty = Object.prototype.hasOwnProperty; + +function isArrayLike(value) { + if (Array.isArray(value) || typeof value === 'string') { + return true; + } + // @ts-expect-error "Type 'unknown' is not assignable to type 'boolean'" : convert to Boolean + return (value && + typeof value === 'object' && + // @ts-expect-error check that `'length' in value &&` + Number.isInteger(value.length) && + // @ts-expect-error check that `'length' in value &&` + value.length >= 0 && + // @ts-expect-error check that `'length' in value &&` + (value.length === 0 + ? // Only {length: 0} is considered Array-like. + Object.keys(value).length === 1 + : // An object is only Array-like if it has a property where the last value + // in the array-like may be found (which could be undefined). + // @ts-expect-error check that `'length' in value &&` + value.hasOwnProperty(value.length - 1))); +} + +var Seq = /*@__PURE__*/(function (Collection) { + function Seq(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptySequence() + : isImmutable(value) + ? value.toSeq() + : seqFromValue(value); + } + + if ( Collection ) Seq.__proto__ = Collection; + Seq.prototype = Object.create( Collection && Collection.prototype ); + Seq.prototype.constructor = Seq; + + Seq.prototype.toSeq = function toSeq () { + return this; + }; + + Seq.prototype.toString = function toString () { + return this.__toString('Seq {', '}'); + }; + + Seq.prototype.cacheResult = function cacheResult () { + if (!this._cache && this.__iterateUncached) { + this._cache = this.entrySeq().toArray(); + this.size = this._cache.length; + } + return this; + }; + + // abstract __iterateUncached(fn, reverse) + + Seq.prototype.__iterate = function __iterate (fn, reverse) { + var cache = this._cache; + if (cache) { + var size = cache.length; + var i = 0; + while (i !== size) { + var entry = cache[reverse ? size - ++i : i++]; + if (fn(entry[1], entry[0], this) === false) { + break; + } + } + return i; + } + return this.__iterateUncached(fn, reverse); + }; + + // abstract __iteratorUncached(type, reverse) + + Seq.prototype.__iterator = function __iterator (type, reverse) { + var cache = this._cache; + if (cache) { + var size = cache.length; + var i = 0; + return new Iterator(function () { + if (i === size) { + return iteratorDone(); + } + var entry = cache[reverse ? size - ++i : i++]; + return iteratorValue(type, entry[0], entry[1]); + }); + } + return this.__iteratorUncached(type, reverse); + }; + + return Seq; +}(Collection)); + +var KeyedSeq = /*@__PURE__*/(function (Seq) { + function KeyedSeq(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptySequence().toKeyedSeq() + : isCollection(value) + ? isKeyed(value) + ? value.toSeq() + : value.fromEntrySeq() + : isRecord(value) + ? value.toSeq() + : keyedSeqFromValue(value); + } + + if ( Seq ) KeyedSeq.__proto__ = Seq; + KeyedSeq.prototype = Object.create( Seq && Seq.prototype ); + KeyedSeq.prototype.constructor = KeyedSeq; + + KeyedSeq.prototype.toKeyedSeq = function toKeyedSeq () { + return this; + }; + + return KeyedSeq; +}(Seq)); + +var IndexedSeq = /*@__PURE__*/(function (Seq) { + function IndexedSeq(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptySequence() + : isCollection(value) + ? isKeyed(value) + ? value.entrySeq() + : value.toIndexedSeq() + : isRecord(value) + ? value.toSeq().entrySeq() + : indexedSeqFromValue(value); + } + + if ( Seq ) IndexedSeq.__proto__ = Seq; + IndexedSeq.prototype = Object.create( Seq && Seq.prototype ); + IndexedSeq.prototype.constructor = IndexedSeq; + + IndexedSeq.of = function of (/*...values*/) { + return IndexedSeq(arguments); + }; + + IndexedSeq.prototype.toIndexedSeq = function toIndexedSeq () { + return this; + }; + + IndexedSeq.prototype.toString = function toString () { + return this.__toString('Seq [', ']'); + }; + + return IndexedSeq; +}(Seq)); + +var SetSeq = /*@__PURE__*/(function (Seq) { + function SetSeq(value) { + // eslint-disable-next-line no-constructor-return + return ( + isCollection(value) && !isAssociative(value) ? value : IndexedSeq(value) + ).toSetSeq(); + } + + if ( Seq ) SetSeq.__proto__ = Seq; + SetSeq.prototype = Object.create( Seq && Seq.prototype ); + SetSeq.prototype.constructor = SetSeq; + + SetSeq.of = function of (/*...values*/) { + return SetSeq(arguments); + }; + + SetSeq.prototype.toSetSeq = function toSetSeq () { + return this; + }; + + return SetSeq; +}(Seq)); + +Seq.isSeq = isSeq; +Seq.Keyed = KeyedSeq; +Seq.Set = SetSeq; +Seq.Indexed = IndexedSeq; + +Seq.prototype[IS_SEQ_SYMBOL] = true; + +// #pragma Root Sequences + +var ArraySeq = /*@__PURE__*/(function (IndexedSeq) { + function ArraySeq(array) { + this._array = array; + this.size = array.length; + } + + if ( IndexedSeq ) ArraySeq.__proto__ = IndexedSeq; + ArraySeq.prototype = Object.create( IndexedSeq && IndexedSeq.prototype ); + ArraySeq.prototype.constructor = ArraySeq; + + ArraySeq.prototype.get = function get (index, notSetValue) { + return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue; + }; + + ArraySeq.prototype.__iterate = function __iterate (fn, reverse) { + var array = this._array; + var size = array.length; + var i = 0; + while (i !== size) { + var ii = reverse ? size - ++i : i++; + if (fn(array[ii], ii, this) === false) { + break; + } + } + return i; + }; + + ArraySeq.prototype.__iterator = function __iterator (type, reverse) { + var array = this._array; + var size = array.length; + var i = 0; + return new Iterator(function () { + if (i === size) { + return iteratorDone(); + } + var ii = reverse ? size - ++i : i++; + return iteratorValue(type, ii, array[ii]); + }); + }; + + return ArraySeq; +}(IndexedSeq)); + +var ObjectSeq = /*@__PURE__*/(function (KeyedSeq) { + function ObjectSeq(object) { + var keys = Object.keys(object).concat( + Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : [] + ); + this._object = object; + this._keys = keys; + this.size = keys.length; + } + + if ( KeyedSeq ) ObjectSeq.__proto__ = KeyedSeq; + ObjectSeq.prototype = Object.create( KeyedSeq && KeyedSeq.prototype ); + ObjectSeq.prototype.constructor = ObjectSeq; + + ObjectSeq.prototype.get = function get (key, notSetValue) { + if (notSetValue !== undefined && !this.has(key)) { + return notSetValue; + } + return this._object[key]; + }; + + ObjectSeq.prototype.has = function has (key) { + return hasOwnProperty.call(this._object, key); + }; + + ObjectSeq.prototype.__iterate = function __iterate (fn, reverse) { + var object = this._object; + var keys = this._keys; + var size = keys.length; + var i = 0; + while (i !== size) { + var key = keys[reverse ? size - ++i : i++]; + if (fn(object[key], key, this) === false) { + break; + } + } + return i; + }; + + ObjectSeq.prototype.__iterator = function __iterator (type, reverse) { + var object = this._object; + var keys = this._keys; + var size = keys.length; + var i = 0; + return new Iterator(function () { + if (i === size) { + return iteratorDone(); + } + var key = keys[reverse ? size - ++i : i++]; + return iteratorValue(type, key, object[key]); + }); + }; + + return ObjectSeq; +}(KeyedSeq)); +ObjectSeq.prototype[IS_ORDERED_SYMBOL] = true; + +var CollectionSeq = /*@__PURE__*/(function (IndexedSeq) { + function CollectionSeq(collection) { + this._collection = collection; + this.size = collection.length || collection.size; + } + + if ( IndexedSeq ) CollectionSeq.__proto__ = IndexedSeq; + CollectionSeq.prototype = Object.create( IndexedSeq && IndexedSeq.prototype ); + CollectionSeq.prototype.constructor = CollectionSeq; + + CollectionSeq.prototype.__iterateUncached = function __iterateUncached (fn, reverse) { + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var collection = this._collection; + var iterator = getIterator(collection); + var iterations = 0; + if (isIterator(iterator)) { + var step; + while (!(step = iterator.next()).done) { + if (fn(step.value, iterations++, this) === false) { + break; + } + } + } + return iterations; + }; + + CollectionSeq.prototype.__iteratorUncached = function __iteratorUncached (type, reverse) { + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + var collection = this._collection; + var iterator = getIterator(collection); + if (!isIterator(iterator)) { + return new Iterator(iteratorDone); + } + var iterations = 0; + return new Iterator(function () { + var step = iterator.next(); + return step.done ? step : iteratorValue(type, iterations++, step.value); + }); + }; + + return CollectionSeq; +}(IndexedSeq)); + +// # pragma Helper functions + +var EMPTY_SEQ; + +function emptySequence() { + return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([])); +} + +function keyedSeqFromValue(value) { + var seq = maybeIndexedSeqFromValue(value); + if (seq) { + return seq.fromEntrySeq(); + } + if (typeof value === 'object') { + return new ObjectSeq(value); + } + throw new TypeError( + 'Expected Array or collection object of [k, v] entries, or keyed object: ' + + value + ); +} + +function indexedSeqFromValue(value) { + var seq = maybeIndexedSeqFromValue(value); + if (seq) { + return seq; + } + throw new TypeError( + 'Expected Array or collection object of values: ' + value + ); +} + +function seqFromValue(value) { + var seq = maybeIndexedSeqFromValue(value); + if (seq) { + return isEntriesIterable(value) + ? seq.fromEntrySeq() + : isKeysIterable(value) + ? seq.toSetSeq() + : seq; + } + if (typeof value === 'object') { + return new ObjectSeq(value); + } + throw new TypeError( + 'Expected Array or collection object of values, or keyed object: ' + value + ); +} + +function maybeIndexedSeqFromValue(value) { + return isArrayLike(value) + ? new ArraySeq(value) + : hasIterator(value) + ? new CollectionSeq(value) + : undefined; +} + +var IS_MAP_SYMBOL = '@@__IMMUTABLE_MAP__@@'; +/** + * True if `maybeMap` is a Map. + * + * Also true for OrderedMaps. + */ +function isMap(maybeMap) { + return Boolean(maybeMap && + // @ts-expect-error: maybeMap is typed as `{}`, need to change in 6.0 to `maybeMap && typeof maybeMap === 'object' && IS_MAP_SYMBOL in maybeMap` + maybeMap[IS_MAP_SYMBOL]); +} + +/** + * True if `maybeOrderedMap` is an OrderedMap. + */ +function isOrderedMap(maybeOrderedMap) { + return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap); +} + +/** + * True if `maybeValue` is a JavaScript Object which has *both* `equals()` + * and `hashCode()` methods. + * + * Any two instances of *value objects* can be compared for value equality with + * `Immutable.is()` and can be used as keys in a `Map` or members in a `Set`. + */ +function isValueObject(maybeValue) { + return Boolean(maybeValue && + // @ts-expect-error: maybeValue is typed as `{}` + typeof maybeValue.equals === 'function' && + // @ts-expect-error: maybeValue is typed as `{}` + typeof maybeValue.hashCode === 'function'); +} + +/** + * An extension of the "same-value" algorithm as [described for use by ES6 Map + * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality) + * + * NaN is considered the same as NaN, however -0 and 0 are considered the same + * value, which is different from the algorithm described by + * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). + * + * This is extended further to allow Objects to describe the values they + * represent, by way of `valueOf` or `equals` (and `hashCode`). + * + * Note: because of this extension, the key equality of Immutable.Map and the + * value equality of Immutable.Set will differ from ES6 Map and Set. + * + * ### Defining custom values + * + * The easiest way to describe the value an object represents is by implementing + * `valueOf`. For example, `Date` represents a value by returning a unix + * timestamp for `valueOf`: + * + * var date1 = new Date(1234567890000); // Fri Feb 13 2009 ... + * var date2 = new Date(1234567890000); + * date1.valueOf(); // 1234567890000 + * assert( date1 !== date2 ); + * assert( Immutable.is( date1, date2 ) ); + * + * Note: overriding `valueOf` may have other implications if you use this object + * where JavaScript expects a primitive, such as implicit string coercion. + * + * For more complex types, especially collections, implementing `valueOf` may + * not be performant. An alternative is to implement `equals` and `hashCode`. + * + * `equals` takes another object, presumably of similar type, and returns true + * if it is equal. Equality is symmetrical, so the same result should be + * returned if this and the argument are flipped. + * + * assert( a.equals(b) === b.equals(a) ); + * + * `hashCode` returns a 32bit integer number representing the object which will + * be used to determine how to store the value object in a Map or Set. You must + * provide both or neither methods, one must not exist without the other. + * + * Also, an important relationship between these methods must be upheld: if two + * values are equal, they *must* return the same hashCode. If the values are not + * equal, they might have the same hashCode; this is called a hash collision, + * and while undesirable for performance reasons, it is acceptable. + * + * if (a.equals(b)) { + * assert( a.hashCode() === b.hashCode() ); + * } + * + * All Immutable collections are Value Objects: they implement `equals()` + * and `hashCode()`. + */ +function is(valueA, valueB) { + if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) { + return true; + } + if (!valueA || !valueB) { + return false; + } + if (typeof valueA.valueOf === 'function' && + typeof valueB.valueOf === 'function') { + valueA = valueA.valueOf(); + valueB = valueB.valueOf(); + if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) { + return true; + } + if (!valueA || !valueB) { + return false; + } + } + return !!(isValueObject(valueA) && + isValueObject(valueB) && + valueA.equals(valueB)); +} + +var imul = + typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2 + ? Math.imul + : function imul(a, b) { + a |= 0; // int + b |= 0; // int + var c = a & 0xffff; + var d = b & 0xffff; + // Shift by 0 fixes the sign on the high part. + return (c * d + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0)) | 0; // int + }; + +// v8 has an optimization for storing 31-bit signed numbers. +// Values which have either 00 or 11 as the high order bits qualify. +// This function drops the highest order bit in a signed number, maintaining +// the sign bit. +function smi(i32) { + return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff); +} + +var defaultValueOf = Object.prototype.valueOf; + +function hash(o) { + // eslint-disable-next-line eqeqeq + if (o == null) { + return hashNullish(o); + } + + if (typeof o.hashCode === 'function') { + // Drop any high bits from accidentally long hash codes. + return smi(o.hashCode(o)); + } + + var v = valueOf(o); + + // eslint-disable-next-line eqeqeq + if (v == null) { + return hashNullish(v); + } + + switch (typeof v) { + case 'boolean': + // The hash values for built-in constants are a 1 value for each 5-byte + // shift region expect for the first, which encodes the value. This + // reduces the odds of a hash collision for these common values. + return v ? 0x42108421 : 0x42108420; + case 'number': + return hashNumber(v); + case 'string': + return v.length > STRING_HASH_CACHE_MIN_STRLEN + ? cachedHashString(v) + : hashString(v); + case 'object': + case 'function': + return hashJSObj(v); + case 'symbol': + return hashSymbol(v); + default: + if (typeof v.toString === 'function') { + return hashString(v.toString()); + } + throw new Error('Value type ' + typeof v + ' cannot be hashed.'); + } +} + +function hashNullish(nullish) { + return nullish === null ? 0x42108422 : /* undefined */ 0x42108423; +} + +// Compress arbitrarily large numbers into smi hashes. +function hashNumber(n) { + if (n !== n || n === Infinity) { + return 0; + } + var hash = n | 0; + if (hash !== n) { + hash ^= n * 0xffffffff; + } + while (n > 0xffffffff) { + n /= 0xffffffff; + hash ^= n; + } + return smi(hash); +} + +function cachedHashString(string) { + var hashed = stringHashCache[string]; + if (hashed === undefined) { + hashed = hashString(string); + if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) { + STRING_HASH_CACHE_SIZE = 0; + stringHashCache = {}; + } + STRING_HASH_CACHE_SIZE++; + stringHashCache[string] = hashed; + } + return hashed; +} + +// http://jsperf.com/hashing-strings +function hashString(string) { + // This is the hash from JVM + // The hash code for a string is computed as + // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1], + // where s[i] is the ith character of the string and n is the length of + // the string. We "mod" the result to make it between 0 (inclusive) and 2^31 + // (exclusive) by dropping high bits. + var hashed = 0; + for (var ii = 0; ii < string.length; ii++) { + hashed = (31 * hashed + string.charCodeAt(ii)) | 0; + } + return smi(hashed); +} + +function hashSymbol(sym) { + var hashed = symbolMap[sym]; + if (hashed !== undefined) { + return hashed; + } + + hashed = nextHash(); + + symbolMap[sym] = hashed; + + return hashed; +} + +function hashJSObj(obj) { + var hashed; + if (usingWeakMap) { + hashed = weakMap.get(obj); + if (hashed !== undefined) { + return hashed; + } + } + + hashed = obj[UID_HASH_KEY]; + if (hashed !== undefined) { + return hashed; + } + + if (!canDefineProperty) { + hashed = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY]; + if (hashed !== undefined) { + return hashed; + } + + hashed = getIENodeHash(obj); + if (hashed !== undefined) { + return hashed; + } + } + + hashed = nextHash(); + + if (usingWeakMap) { + weakMap.set(obj, hashed); + } else if (isExtensible !== undefined && isExtensible(obj) === false) { + throw new Error('Non-extensible objects are not allowed as keys.'); + } else if (canDefineProperty) { + Object.defineProperty(obj, UID_HASH_KEY, { + enumerable: false, + configurable: false, + writable: false, + value: hashed, + }); + } else if ( + obj.propertyIsEnumerable !== undefined && + obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable + ) { + // Since we can't define a non-enumerable property on the object + // we'll hijack one of the less-used non-enumerable properties to + // save our hash on it. Since this is a function it will not show up in + // `JSON.stringify` which is what we want. + obj.propertyIsEnumerable = function () { + return this.constructor.prototype.propertyIsEnumerable.apply( + this, + arguments + ); + }; + obj.propertyIsEnumerable[UID_HASH_KEY] = hashed; + } else if (obj.nodeType !== undefined) { + // At this point we couldn't get the IE `uniqueID` to use as a hash + // and we couldn't use a non-enumerable property to exploit the + // dontEnum bug so we simply add the `UID_HASH_KEY` on the node + // itself. + obj[UID_HASH_KEY] = hashed; + } else { + throw new Error('Unable to set a non-enumerable property on object.'); + } + + return hashed; +} + +// Get references to ES5 object methods. +var isExtensible = Object.isExtensible; + +// True if Object.defineProperty works as expected. IE8 fails this test. +var canDefineProperty = (function () { + try { + Object.defineProperty({}, '@', {}); + return true; + // eslint-disable-next-line @typescript-eslint/no-unused-vars + } catch (e) { + return false; + } +})(); + +// IE has a `uniqueID` property on DOM nodes. We can construct the hash from it +// and avoid memory leaks from the IE cloneNode bug. +function getIENodeHash(node) { + if (node && node.nodeType > 0) { + switch (node.nodeType) { + case 1: // Element + return node.uniqueID; + case 9: // Document + return node.documentElement && node.documentElement.uniqueID; + } + } +} + +function valueOf(obj) { + return obj.valueOf !== defaultValueOf && typeof obj.valueOf === 'function' + ? obj.valueOf(obj) + : obj; +} + +function nextHash() { + var nextHash = ++_objHashUID; + if (_objHashUID & 0x40000000) { + _objHashUID = 0; + } + return nextHash; +} + +// If possible, use a WeakMap. +var usingWeakMap = typeof WeakMap === 'function'; +var weakMap; +if (usingWeakMap) { + weakMap = new WeakMap(); +} + +var symbolMap = Object.create(null); + +var _objHashUID = 0; + +var UID_HASH_KEY = '__immutablehash__'; +if (typeof Symbol === 'function') { + UID_HASH_KEY = Symbol(UID_HASH_KEY); +} + +var STRING_HASH_CACHE_MIN_STRLEN = 16; +var STRING_HASH_CACHE_MAX_SIZE = 255; +var STRING_HASH_CACHE_SIZE = 0; +var stringHashCache = {}; + +var ToKeyedSequence = /*@__PURE__*/(function (KeyedSeq) { + function ToKeyedSequence(indexed, useKeys) { + this._iter = indexed; + this._useKeys = useKeys; + this.size = indexed.size; + } + + if ( KeyedSeq ) ToKeyedSequence.__proto__ = KeyedSeq; + ToKeyedSequence.prototype = Object.create( KeyedSeq && KeyedSeq.prototype ); + ToKeyedSequence.prototype.constructor = ToKeyedSequence; + + ToKeyedSequence.prototype.get = function get (key, notSetValue) { + return this._iter.get(key, notSetValue); + }; + + ToKeyedSequence.prototype.has = function has (key) { + return this._iter.has(key); + }; + + ToKeyedSequence.prototype.valueSeq = function valueSeq () { + return this._iter.valueSeq(); + }; + + ToKeyedSequence.prototype.reverse = function reverse () { + var this$1$1 = this; + + var reversedSequence = reverseFactory(this, true); + if (!this._useKeys) { + reversedSequence.valueSeq = function () { return this$1$1._iter.toSeq().reverse(); }; + } + return reversedSequence; + }; + + ToKeyedSequence.prototype.map = function map (mapper, context) { + var this$1$1 = this; + + var mappedSequence = mapFactory(this, mapper, context); + if (!this._useKeys) { + mappedSequence.valueSeq = function () { return this$1$1._iter.toSeq().map(mapper, context); }; + } + return mappedSequence; + }; + + ToKeyedSequence.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + return this._iter.__iterate(function (v, k) { return fn(v, k, this$1$1); }, reverse); + }; + + ToKeyedSequence.prototype.__iterator = function __iterator (type, reverse) { + return this._iter.__iterator(type, reverse); + }; + + return ToKeyedSequence; +}(KeyedSeq)); +ToKeyedSequence.prototype[IS_ORDERED_SYMBOL] = true; + +var ToIndexedSequence = /*@__PURE__*/(function (IndexedSeq) { + function ToIndexedSequence(iter) { + this._iter = iter; + this.size = iter.size; + } + + if ( IndexedSeq ) ToIndexedSequence.__proto__ = IndexedSeq; + ToIndexedSequence.prototype = Object.create( IndexedSeq && IndexedSeq.prototype ); + ToIndexedSequence.prototype.constructor = ToIndexedSequence; + + ToIndexedSequence.prototype.includes = function includes (value) { + return this._iter.includes(value); + }; + + ToIndexedSequence.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + var i = 0; + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + reverse && ensureSize(this); + return this._iter.__iterate( + function (v) { return fn(v, reverse ? this$1$1.size - ++i : i++, this$1$1); }, + reverse + ); + }; + + ToIndexedSequence.prototype.__iterator = function __iterator (type, reverse) { + var this$1$1 = this; + + var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); + var i = 0; + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + reverse && ensureSize(this); + return new Iterator(function () { + var step = iterator.next(); + return step.done + ? step + : iteratorValue( + type, + reverse ? this$1$1.size - ++i : i++, + step.value, + step + ); + }); + }; + + return ToIndexedSequence; +}(IndexedSeq)); + +var ToSetSequence = /*@__PURE__*/(function (SetSeq) { + function ToSetSequence(iter) { + this._iter = iter; + this.size = iter.size; + } + + if ( SetSeq ) ToSetSequence.__proto__ = SetSeq; + ToSetSequence.prototype = Object.create( SetSeq && SetSeq.prototype ); + ToSetSequence.prototype.constructor = ToSetSequence; + + ToSetSequence.prototype.has = function has (key) { + return this._iter.includes(key); + }; + + ToSetSequence.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + return this._iter.__iterate(function (v) { return fn(v, v, this$1$1); }, reverse); + }; + + ToSetSequence.prototype.__iterator = function __iterator (type, reverse) { + var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); + return new Iterator(function () { + var step = iterator.next(); + return step.done + ? step + : iteratorValue(type, step.value, step.value, step); + }); + }; + + return ToSetSequence; +}(SetSeq)); + +var FromEntriesSequence = /*@__PURE__*/(function (KeyedSeq) { + function FromEntriesSequence(entries) { + this._iter = entries; + this.size = entries.size; + } + + if ( KeyedSeq ) FromEntriesSequence.__proto__ = KeyedSeq; + FromEntriesSequence.prototype = Object.create( KeyedSeq && KeyedSeq.prototype ); + FromEntriesSequence.prototype.constructor = FromEntriesSequence; + + FromEntriesSequence.prototype.entrySeq = function entrySeq () { + return this._iter.toSeq(); + }; + + FromEntriesSequence.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + return this._iter.__iterate(function (entry) { + // Check if entry exists first so array access doesn't throw for holes + // in the parent iteration. + if (entry) { + validateEntry(entry); + var indexedCollection = isCollection(entry); + return fn( + indexedCollection ? entry.get(1) : entry[1], + indexedCollection ? entry.get(0) : entry[0], + this$1$1 + ); + } + }, reverse); + }; + + FromEntriesSequence.prototype.__iterator = function __iterator (type, reverse) { + var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); + return new Iterator(function () { + while (true) { + var step = iterator.next(); + if (step.done) { + return step; + } + var entry = step.value; + // Check if entry exists first so array access doesn't throw for holes + // in the parent iteration. + if (entry) { + validateEntry(entry); + var indexedCollection = isCollection(entry); + return iteratorValue( + type, + indexedCollection ? entry.get(0) : entry[0], + indexedCollection ? entry.get(1) : entry[1], + step + ); + } + } + }); + }; + + return FromEntriesSequence; +}(KeyedSeq)); + +ToIndexedSequence.prototype.cacheResult = + ToKeyedSequence.prototype.cacheResult = + ToSetSequence.prototype.cacheResult = + FromEntriesSequence.prototype.cacheResult = + cacheResultThrough; + +function flipFactory(collection) { + var flipSequence = makeSequence(collection); + flipSequence._iter = collection; + flipSequence.size = collection.size; + flipSequence.flip = function () { return collection; }; + flipSequence.reverse = function () { + var reversedSequence = collection.reverse.apply(this); // super.reverse() + reversedSequence.flip = function () { return collection.reverse(); }; + return reversedSequence; + }; + flipSequence.has = function (key) { return collection.includes(key); }; + flipSequence.includes = function (key) { return collection.has(key); }; + flipSequence.cacheResult = cacheResultThrough; + flipSequence.__iterateUncached = function (fn, reverse) { + var this$1$1 = this; + + return collection.__iterate(function (v, k) { return fn(k, v, this$1$1) !== false; }, reverse); + }; + flipSequence.__iteratorUncached = function (type, reverse) { + if (type === ITERATE_ENTRIES) { + var iterator = collection.__iterator(type, reverse); + return new Iterator(function () { + var step = iterator.next(); + if (!step.done) { + var k = step.value[0]; + step.value[0] = step.value[1]; + step.value[1] = k; + } + return step; + }); + } + return collection.__iterator( + type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES, + reverse + ); + }; + return flipSequence; +} + +function mapFactory(collection, mapper, context) { + var mappedSequence = makeSequence(collection); + mappedSequence.size = collection.size; + mappedSequence.has = function (key) { return collection.has(key); }; + mappedSequence.get = function (key, notSetValue) { + var v = collection.get(key, NOT_SET); + return v === NOT_SET + ? notSetValue + : mapper.call(context, v, key, collection); + }; + mappedSequence.__iterateUncached = function (fn, reverse) { + var this$1$1 = this; + + return collection.__iterate( + function (v, k, c) { return fn(mapper.call(context, v, k, c), k, this$1$1) !== false; }, + reverse + ); + }; + mappedSequence.__iteratorUncached = function (type, reverse) { + var iterator = collection.__iterator(ITERATE_ENTRIES, reverse); + return new Iterator(function () { + var step = iterator.next(); + if (step.done) { + return step; + } + var entry = step.value; + var key = entry[0]; + return iteratorValue( + type, + key, + mapper.call(context, entry[1], key, collection), + step + ); + }); + }; + return mappedSequence; +} + +function reverseFactory(collection, useKeys) { + var this$1$1 = this; + + var reversedSequence = makeSequence(collection); + reversedSequence._iter = collection; + reversedSequence.size = collection.size; + reversedSequence.reverse = function () { return collection; }; + if (collection.flip) { + reversedSequence.flip = function () { + var flipSequence = flipFactory(collection); + flipSequence.reverse = function () { return collection.flip(); }; + return flipSequence; + }; + } + reversedSequence.get = function (key, notSetValue) { return collection.get(useKeys ? key : -1 - key, notSetValue); }; + reversedSequence.has = function (key) { return collection.has(useKeys ? key : -1 - key); }; + reversedSequence.includes = function (value) { return collection.includes(value); }; + reversedSequence.cacheResult = cacheResultThrough; + reversedSequence.__iterate = function (fn, reverse) { + var this$1$1 = this; + + var i = 0; + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + reverse && ensureSize(collection); + return collection.__iterate( + function (v, k) { return fn(v, useKeys ? k : reverse ? this$1$1.size - ++i : i++, this$1$1); }, + !reverse + ); + }; + reversedSequence.__iterator = function (type, reverse) { + var i = 0; + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + reverse && ensureSize(collection); + var iterator = collection.__iterator(ITERATE_ENTRIES, !reverse); + return new Iterator(function () { + var step = iterator.next(); + if (step.done) { + return step; + } + var entry = step.value; + return iteratorValue( + type, + useKeys ? entry[0] : reverse ? this$1$1.size - ++i : i++, + entry[1], + step + ); + }); + }; + return reversedSequence; +} + +function filterFactory(collection, predicate, context, useKeys) { + var filterSequence = makeSequence(collection); + if (useKeys) { + filterSequence.has = function (key) { + var v = collection.get(key, NOT_SET); + return v !== NOT_SET && !!predicate.call(context, v, key, collection); + }; + filterSequence.get = function (key, notSetValue) { + var v = collection.get(key, NOT_SET); + return v !== NOT_SET && predicate.call(context, v, key, collection) + ? v + : notSetValue; + }; + } + filterSequence.__iterateUncached = function (fn, reverse) { + var this$1$1 = this; + + var iterations = 0; + collection.__iterate(function (v, k, c) { + if (predicate.call(context, v, k, c)) { + iterations++; + return fn(v, useKeys ? k : iterations - 1, this$1$1); + } + }, reverse); + return iterations; + }; + filterSequence.__iteratorUncached = function (type, reverse) { + var iterator = collection.__iterator(ITERATE_ENTRIES, reverse); + var iterations = 0; + return new Iterator(function () { + while (true) { + var step = iterator.next(); + if (step.done) { + return step; + } + var entry = step.value; + var key = entry[0]; + var value = entry[1]; + if (predicate.call(context, value, key, collection)) { + return iteratorValue(type, useKeys ? key : iterations++, value, step); + } + } + }); + }; + return filterSequence; +} + +function countByFactory(collection, grouper, context) { + var groups = Map().asMutable(); + collection.__iterate(function (v, k) { + groups.update(grouper.call(context, v, k, collection), 0, function (a) { return a + 1; }); + }); + return groups.asImmutable(); +} + +function groupByFactory(collection, grouper, context) { + var isKeyedIter = isKeyed(collection); + var groups = (isOrdered(collection) ? OrderedMap() : Map()).asMutable(); + collection.__iterate(function (v, k) { + groups.update( + grouper.call(context, v, k, collection), + function (a) { return ((a = a || []), a.push(isKeyedIter ? [k, v] : v), a); } + ); + }); + var coerce = collectionClass(collection); + return groups.map(function (arr) { return reify(collection, coerce(arr)); }).asImmutable(); +} + +function partitionFactory(collection, predicate, context) { + var isKeyedIter = isKeyed(collection); + var groups = [[], []]; + collection.__iterate(function (v, k) { + groups[predicate.call(context, v, k, collection) ? 1 : 0].push( + isKeyedIter ? [k, v] : v + ); + }); + var coerce = collectionClass(collection); + return groups.map(function (arr) { return reify(collection, coerce(arr)); }); +} + +function sliceFactory(collection, begin, end, useKeys) { + var originalSize = collection.size; + + if (wholeSlice(begin, end, originalSize)) { + return collection; + } + + // begin or end can not be resolved if they were provided as negative numbers and + // this collection's size is unknown. In that case, cache first so there is + // a known size and these do not resolve to NaN. + if (typeof originalSize === 'undefined' && (begin < 0 || end < 0)) { + return sliceFactory(collection.toSeq().cacheResult(), begin, end, useKeys); + } + + var resolvedBegin = resolveBegin(begin, originalSize); + var resolvedEnd = resolveEnd(end, originalSize); + + // Note: resolvedEnd is undefined when the original sequence's length is + // unknown and this slice did not supply an end and should contain all + // elements after resolvedBegin. + // In that case, resolvedSize will be NaN and sliceSize will remain undefined. + var resolvedSize = resolvedEnd - resolvedBegin; + var sliceSize; + if (resolvedSize === resolvedSize) { + sliceSize = resolvedSize < 0 ? 0 : resolvedSize; + } + + var sliceSeq = makeSequence(collection); + + // If collection.size is undefined, the size of the realized sliceSeq is + // unknown at this point unless the number of items to slice is 0 + sliceSeq.size = + sliceSize === 0 ? sliceSize : (collection.size && sliceSize) || undefined; + + if (!useKeys && isSeq(collection) && sliceSize >= 0) { + sliceSeq.get = function (index, notSetValue) { + index = wrapIndex(this, index); + return index >= 0 && index < sliceSize + ? collection.get(index + resolvedBegin, notSetValue) + : notSetValue; + }; + } + + sliceSeq.__iterateUncached = function (fn, reverse) { + var this$1$1 = this; + + if (sliceSize === 0) { + return 0; + } + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var skipped = 0; + var isSkipping = true; + var iterations = 0; + collection.__iterate(function (v, k) { + if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) { + iterations++; + return ( + fn(v, useKeys ? k : iterations - 1, this$1$1) !== false && + iterations !== sliceSize + ); + } + }); + return iterations; + }; + + sliceSeq.__iteratorUncached = function (type, reverse) { + if (sliceSize !== 0 && reverse) { + return this.cacheResult().__iterator(type, reverse); + } + // Don't bother instantiating parent iterator if taking 0. + if (sliceSize === 0) { + return new Iterator(iteratorDone); + } + var iterator = collection.__iterator(type, reverse); + var skipped = 0; + var iterations = 0; + return new Iterator(function () { + while (skipped++ < resolvedBegin) { + iterator.next(); + } + if (++iterations > sliceSize) { + return iteratorDone(); + } + var step = iterator.next(); + if (useKeys || type === ITERATE_VALUES || step.done) { + return step; + } + if (type === ITERATE_KEYS) { + return iteratorValue(type, iterations - 1, undefined, step); + } + return iteratorValue(type, iterations - 1, step.value[1], step); + }); + }; + + return sliceSeq; +} + +function takeWhileFactory(collection, predicate, context) { + var takeSequence = makeSequence(collection); + takeSequence.__iterateUncached = function (fn, reverse) { + var this$1$1 = this; + + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var iterations = 0; + collection.__iterate( + function (v, k, c) { return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$1$1); } + ); + return iterations; + }; + takeSequence.__iteratorUncached = function (type, reverse) { + var this$1$1 = this; + + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + var iterator = collection.__iterator(ITERATE_ENTRIES, reverse); + var iterating = true; + return new Iterator(function () { + if (!iterating) { + return iteratorDone(); + } + var step = iterator.next(); + if (step.done) { + return step; + } + var entry = step.value; + var k = entry[0]; + var v = entry[1]; + if (!predicate.call(context, v, k, this$1$1)) { + iterating = false; + return iteratorDone(); + } + return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step); + }); + }; + return takeSequence; +} + +function skipWhileFactory(collection, predicate, context, useKeys) { + var skipSequence = makeSequence(collection); + skipSequence.__iterateUncached = function (fn, reverse) { + var this$1$1 = this; + + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var isSkipping = true; + var iterations = 0; + collection.__iterate(function (v, k, c) { + if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) { + iterations++; + return fn(v, useKeys ? k : iterations - 1, this$1$1); + } + }); + return iterations; + }; + skipSequence.__iteratorUncached = function (type, reverse) { + var this$1$1 = this; + + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + var iterator = collection.__iterator(ITERATE_ENTRIES, reverse); + var skipping = true; + var iterations = 0; + return new Iterator(function () { + var step; + var k; + var v; + do { + step = iterator.next(); + if (step.done) { + if (useKeys || type === ITERATE_VALUES) { + return step; + } + if (type === ITERATE_KEYS) { + return iteratorValue(type, iterations++, undefined, step); + } + return iteratorValue(type, iterations++, step.value[1], step); + } + var entry = step.value; + k = entry[0]; + v = entry[1]; + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + skipping && (skipping = predicate.call(context, v, k, this$1$1)); + } while (skipping); + return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step); + }); + }; + return skipSequence; +} + +var ConcatSeq = /*@__PURE__*/(function (Seq) { + function ConcatSeq(iterables) { + this._wrappedIterables = iterables.flatMap(function (iterable) { + if (iterable._wrappedIterables) { + return iterable._wrappedIterables; + } + return [iterable]; + }); + this.size = this._wrappedIterables.reduce(function (sum, iterable) { + if (sum !== undefined) { + var size = iterable.size; + if (size !== undefined) { + return sum + size; + } + } + }, 0); + this[IS_KEYED_SYMBOL] = this._wrappedIterables[0][IS_KEYED_SYMBOL]; + this[IS_INDEXED_SYMBOL] = this._wrappedIterables[0][IS_INDEXED_SYMBOL]; + this[IS_ORDERED_SYMBOL] = this._wrappedIterables[0][IS_ORDERED_SYMBOL]; + } + + if ( Seq ) ConcatSeq.__proto__ = Seq; + ConcatSeq.prototype = Object.create( Seq && Seq.prototype ); + ConcatSeq.prototype.constructor = ConcatSeq; + + ConcatSeq.prototype.__iterateUncached = function __iterateUncached (fn, reverse) { + if (this._wrappedIterables.length === 0) { + return; + } + + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + + var iterableIndex = 0; + var useKeys = isKeyed(this); + var iteratorType = useKeys ? ITERATE_ENTRIES : ITERATE_VALUES; + var currentIterator = this._wrappedIterables[iterableIndex].__iterator( + iteratorType, + reverse + ); + + var keepGoing = true; + var index = 0; + while (keepGoing) { + var next = currentIterator.next(); + while (next.done) { + iterableIndex++; + if (iterableIndex === this._wrappedIterables.length) { + return index; + } + currentIterator = this._wrappedIterables[iterableIndex].__iterator( + iteratorType, + reverse + ); + next = currentIterator.next(); + } + var fnResult = useKeys + ? fn(next.value[1], next.value[0], this) + : fn(next.value, index, this); + keepGoing = fnResult !== false; + index++; + } + return index; + }; + + ConcatSeq.prototype.__iteratorUncached = function __iteratorUncached (type, reverse) { + var this$1$1 = this; + + if (this._wrappedIterables.length === 0) { + return new Iterator(iteratorDone); + } + + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + + var iterableIndex = 0; + var currentIterator = this._wrappedIterables[iterableIndex].__iterator( + type, + reverse + ); + return new Iterator(function () { + var next = currentIterator.next(); + while (next.done) { + iterableIndex++; + if (iterableIndex === this$1$1._wrappedIterables.length) { + return next; + } + currentIterator = this$1$1._wrappedIterables[iterableIndex].__iterator( + type, + reverse + ); + next = currentIterator.next(); + } + return next; + }); + }; + + return ConcatSeq; +}(Seq)); + +function concatFactory(collection, values) { + var isKeyedCollection = isKeyed(collection); + var iters = [collection] + .concat(values) + .map(function (v) { + if (!isCollection(v)) { + v = isKeyedCollection + ? keyedSeqFromValue(v) + : indexedSeqFromValue(Array.isArray(v) ? v : [v]); + } else if (isKeyedCollection) { + v = KeyedCollection(v); + } + return v; + }) + .filter(function (v) { return v.size !== 0; }); + + if (iters.length === 0) { + return collection; + } + + if (iters.length === 1) { + var singleton = iters[0]; + if ( + singleton === collection || + (isKeyedCollection && isKeyed(singleton)) || + (isIndexed(collection) && isIndexed(singleton)) + ) { + return singleton; + } + } + + return new ConcatSeq(iters); +} + +function flattenFactory(collection, depth, useKeys) { + var flatSequence = makeSequence(collection); + flatSequence.__iterateUncached = function (fn, reverse) { + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var iterations = 0; + var stopped = false; + function flatDeep(iter, currentDepth) { + iter.__iterate(function (v, k) { + if ((!depth || currentDepth < depth) && isCollection(v)) { + flatDeep(v, currentDepth + 1); + } else { + iterations++; + if (fn(v, useKeys ? k : iterations - 1, flatSequence) === false) { + stopped = true; + } + } + return !stopped; + }, reverse); + } + flatDeep(collection, 0); + return iterations; + }; + flatSequence.__iteratorUncached = function (type, reverse) { + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + var iterator = collection.__iterator(type, reverse); + var stack = []; + var iterations = 0; + return new Iterator(function () { + while (iterator) { + var step = iterator.next(); + if (step.done !== false) { + iterator = stack.pop(); + continue; + } + var v = step.value; + if (type === ITERATE_ENTRIES) { + v = v[1]; + } + if ((!depth || stack.length < depth) && isCollection(v)) { + stack.push(iterator); + iterator = v.__iterator(type, reverse); + } else { + return useKeys ? step : iteratorValue(type, iterations++, v, step); + } + } + return iteratorDone(); + }); + }; + return flatSequence; +} + +function flatMapFactory(collection, mapper, context) { + var coerce = collectionClass(collection); + return collection + .toSeq() + .map(function (v, k) { return coerce(mapper.call(context, v, k, collection)); }) + .flatten(true); +} + +function interposeFactory(collection, separator) { + var interposedSequence = makeSequence(collection); + interposedSequence.size = collection.size && collection.size * 2 - 1; + interposedSequence.__iterateUncached = function (fn, reverse) { + var this$1$1 = this; + + var iterations = 0; + collection.__iterate( + function (v) { return (!iterations || fn(separator, iterations++, this$1$1) !== false) && + fn(v, iterations++, this$1$1) !== false; }, + reverse + ); + return iterations; + }; + interposedSequence.__iteratorUncached = function (type, reverse) { + var iterator = collection.__iterator(ITERATE_VALUES, reverse); + var iterations = 0; + var step; + return new Iterator(function () { + if (!step || iterations % 2) { + step = iterator.next(); + if (step.done) { + return step; + } + } + return iterations % 2 + ? iteratorValue(type, iterations++, separator) + : iteratorValue(type, iterations++, step.value, step); + }); + }; + return interposedSequence; +} + +function sortFactory(collection, comparator, mapper) { + if (!comparator) { + comparator = defaultComparator; + } + var isKeyedCollection = isKeyed(collection); + var index = 0; + var entries = collection + .toSeq() + .map(function (v, k) { return [k, v, index++, mapper ? mapper(v, k, collection) : v]; }) + .valueSeq() + .toArray(); + entries + .sort(function (a, b) { return comparator(a[3], b[3]) || a[2] - b[2]; }) + .forEach( + isKeyedCollection + ? function (v, i) { + entries[i].length = 2; + } + : function (v, i) { + entries[i] = v[1]; + } + ); + return isKeyedCollection + ? KeyedSeq(entries) + : isIndexed(collection) + ? IndexedSeq(entries) + : SetSeq(entries); +} + +function maxFactory(collection, comparator, mapper) { + if (!comparator) { + comparator = defaultComparator; + } + if (mapper) { + var entry = collection + .toSeq() + .map(function (v, k) { return [v, mapper(v, k, collection)]; }) + .reduce(function (a, b) { return (maxCompare(comparator, a[1], b[1]) ? b : a); }); + return entry && entry[0]; + } + return collection.reduce(function (a, b) { return (maxCompare(comparator, a, b) ? b : a); }); +} + +function maxCompare(comparator, a, b) { + var comp = comparator(b, a); + // b is considered the new max if the comparator declares them equal, but + // they are not equal and b is in fact a nullish value. + return ( + (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) || + comp > 0 + ); +} + +function zipWithFactory(keyIter, zipper, iters, zipAll) { + var zipSequence = makeSequence(keyIter); + var sizes = new ArraySeq(iters).map(function (i) { return i.size; }); + zipSequence.size = zipAll ? sizes.max() : sizes.min(); + // Note: this a generic base implementation of __iterate in terms of + // __iterator which may be more generically useful in the future. + zipSequence.__iterate = function (fn, reverse) { + /* generic: + var iterator = this.__iterator(ITERATE_ENTRIES, reverse); + var step; + var iterations = 0; + while (!(step = iterator.next()).done) { + iterations++; + if (fn(step.value[1], step.value[0], this) === false) { + break; + } + } + return iterations; + */ + // indexed: + var iterator = this.__iterator(ITERATE_VALUES, reverse); + var step; + var iterations = 0; + while (!(step = iterator.next()).done) { + if (fn(step.value, iterations++, this) === false) { + break; + } + } + return iterations; + }; + zipSequence.__iteratorUncached = function (type, reverse) { + var iterators = iters.map( + function (i) { return ((i = Collection(i)), getIterator(reverse ? i.reverse() : i)); } + ); + var iterations = 0; + var isDone = false; + return new Iterator(function () { + var steps; + if (!isDone) { + steps = iterators.map(function (i) { return i.next(); }); + isDone = zipAll + ? steps.every(function (s) { return s.done; }) + : steps.some(function (s) { return s.done; }); + } + if (isDone) { + return iteratorDone(); + } + return iteratorValue( + type, + iterations++, + zipper.apply( + null, + steps.map(function (s) { return s.value; }) + ) + ); + }); + }; + return zipSequence; +} + +// #pragma Helper Functions + +function reify(iter, seq) { + return iter === seq ? iter : isSeq(iter) ? seq : iter.constructor(seq); +} + +function validateEntry(entry) { + if (entry !== Object(entry)) { + throw new TypeError('Expected [K, V] tuple: ' + entry); + } +} + +function collectionClass(collection) { + return isKeyed(collection) + ? KeyedCollection + : isIndexed(collection) + ? IndexedCollection + : SetCollection; +} + +function makeSequence(collection) { + return Object.create( + (isKeyed(collection) + ? KeyedSeq + : isIndexed(collection) + ? IndexedSeq + : SetSeq + ).prototype + ); +} + +function cacheResultThrough() { + if (this._iter.cacheResult) { + this._iter.cacheResult(); + this.size = this._iter.size; + return this; + } + return Seq.prototype.cacheResult.call(this); +} + +function defaultComparator(a, b) { + if (a === undefined && b === undefined) { + return 0; + } + + if (a === undefined) { + return 1; + } + + if (b === undefined) { + return -1; + } + + return a > b ? 1 : a < b ? -1 : 0; +} + +// http://jsperf.com/copy-array-inline +function arrCopy(arr, offset) { + offset = offset || 0; + var len = Math.max(0, arr.length - offset); + var newArr = new Array(len); + for (var ii = 0; ii < len; ii++) { + // @ts-expect-error We may want to guard for undefined values with `if (arr[ii + offset] !== undefined`, but ths should not happen by design + newArr[ii] = arr[ii + offset]; + } + return newArr; +} + +function invariant(condition, error) { + if (!condition) + { throw new Error(error); } +} + +function assertNotInfinite(size) { + invariant(size !== Infinity, 'Cannot perform this action with an infinite size.'); +} + +function coerceKeyPath(keyPath) { + if (isArrayLike(keyPath) && typeof keyPath !== 'string') { + return keyPath; + } + if (isOrdered(keyPath)) { + return keyPath.toArray(); + } + throw new TypeError('Invalid keyPath: expected Ordered Collection or Array: ' + keyPath); +} + +var toString = Object.prototype.toString; +function isPlainObject(value) { + // The base prototype's toString deals with Argument objects and native namespaces like Math + if (!value || + typeof value !== 'object' || + toString.call(value) !== '[object Object]') { + return false; + } + var proto = Object.getPrototypeOf(value); + if (proto === null) { + return true; + } + // Iteratively going up the prototype chain is needed for cross-realm environments (differing contexts, iframes, etc) + var parentProto = proto; + var nextProto = Object.getPrototypeOf(proto); + while (nextProto !== null) { + parentProto = nextProto; + nextProto = Object.getPrototypeOf(parentProto); + } + return parentProto === proto; +} + +/** + * Returns true if the value is a potentially-persistent data structure, either + * provided by Immutable.js or a plain Array or Object. + */ +function isDataStructure(value) { + return (typeof value === 'object' && + (isImmutable(value) || Array.isArray(value) || isPlainObject(value))); +} + +/** + * Converts a value to a string, adding quotes if a string was provided. + */ +function quoteString(value) { + try { + return typeof value === 'string' ? JSON.stringify(value) : String(value); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + } + catch (_ignoreError) { + return JSON.stringify(value); + } +} + +/** + * Returns true if the key is defined in the provided collection. + * + * A functional alternative to `collection.has(key)` which will also work with + * plain Objects and Arrays as an alternative for + * `collection.hasOwnProperty(key)`. + * + * + * ```js + * import { has } from 'immutable'; + * + * has([ 'dog', 'frog', 'cat' ], 2) // true + * has([ 'dog', 'frog', 'cat' ], 5) // false + * has({ x: 123, y: 456 }, 'x') // true + * has({ x: 123, y: 456 }, 'z') // false + * ``` + */ +function has(collection, key) { + return isImmutable(collection) + ? // @ts-expect-error key might be a number or symbol, which is not handled be Record key type + collection.has(key) + : // @ts-expect-error key might be anything else than PropertyKey, and will return false in that case but runtime is OK + isDataStructure(collection) && hasOwnProperty.call(collection, key); +} + +function get(collection, key, notSetValue) { + return isImmutable(collection) + ? collection.get(key, notSetValue) + : !has(collection, key) + ? notSetValue + : // @ts-expect-error weird "get" here, + typeof collection.get === 'function' + ? // @ts-expect-error weird "get" here, + collection.get(key) + : // @ts-expect-error key is unknown here, + collection[key]; +} + +function shallowCopy(from) { + if (Array.isArray(from)) { + return arrCopy(from); + } + var to = {}; + for (var key in from) { + if (hasOwnProperty.call(from, key)) { + to[key] = from[key]; + } + } + return to; +} + +function remove(collection, key) { + if (!isDataStructure(collection)) { + throw new TypeError('Cannot update non-data-structure value: ' + collection); + } + if (isImmutable(collection)) { + // @ts-expect-error weird "remove" here, + if (!collection.remove) { + throw new TypeError('Cannot update immutable value without .remove() method: ' + collection); + } + // @ts-expect-error weird "remove" here, + return collection.remove(key); + } + if (!hasOwnProperty.call(collection, key)) { + return collection; + } + var collectionCopy = shallowCopy(collection); + if (Array.isArray(collectionCopy)) { + // @ts-expect-error assert that key is a number here + collectionCopy.splice(key, 1); + } + else { + delete collectionCopy[key]; + } + return collectionCopy; +} + +function set(collection, key, value) { + if (!isDataStructure(collection)) { + throw new TypeError('Cannot update non-data-structure value: ' + collection); + } + if (isImmutable(collection)) { + // @ts-expect-error weird "set" here, + if (!collection.set) { + throw new TypeError('Cannot update immutable value without .set() method: ' + collection); + } + // @ts-expect-error weird "set" here, + return collection.set(key, value); + } + // @ts-expect-error mix of key and string here. Probably need a more fine type here + if (hasOwnProperty.call(collection, key) && value === collection[key]) { + return collection; + } + var collectionCopy = shallowCopy(collection); + // @ts-expect-error mix of key and string here. Probably need a more fine type here + collectionCopy[key] = value; + return collectionCopy; +} + +function updateIn$1(collection, keyPath, notSetValue, updater) { + if (!updater) { + // handle the fact that `notSetValue` is optional here, in that case `updater` is the updater function + // @ts-expect-error updater is a function here + updater = notSetValue; + notSetValue = undefined; + } + var updatedValue = updateInDeeply(isImmutable(collection), + // @ts-expect-error type issues with Record and mixed types + collection, coerceKeyPath(keyPath), 0, notSetValue, updater); + // @ts-expect-error mixed return type + return updatedValue === NOT_SET ? notSetValue : updatedValue; +} +function updateInDeeply(inImmutable, existing, keyPath, i, notSetValue, updater) { + var wasNotSet = existing === NOT_SET; + if (i === keyPath.length) { + var existingValue = wasNotSet ? notSetValue : existing; + // @ts-expect-error mixed type with optional value + var newValue = updater(existingValue); + // @ts-expect-error mixed type + return newValue === existingValue ? existing : newValue; + } + if (!wasNotSet && !isDataStructure(existing)) { + throw new TypeError('Cannot update within non-data-structure value in path [' + + Array.from(keyPath).slice(0, i).map(quoteString) + + ']: ' + + existing); + } + var key = keyPath[i]; + if (typeof key === 'undefined') { + throw new TypeError('Index can not be undefined in updateIn(). This should not happen'); + } + var nextExisting = wasNotSet ? NOT_SET : get(existing, key, NOT_SET); + var nextUpdated = updateInDeeply(nextExisting === NOT_SET ? inImmutable : isImmutable(nextExisting), + // @ts-expect-error mixed type + nextExisting, keyPath, i + 1, notSetValue, updater); + return nextUpdated === nextExisting + ? existing + : nextUpdated === NOT_SET + ? remove(existing, key) + : set(wasNotSet ? (inImmutable ? emptyMap() : {}) : existing, key, nextUpdated); +} + +/** + * Returns a copy of the collection with the value at the key path set to the + * provided value. + * + * A functional alternative to `collection.setIn(keypath)` which will also + * work with plain Objects and Arrays. + * + * + * ```js + * import { setIn } from 'immutable'; + * + * const original = { x: { y: { z: 123 }}} + * setIn(original, ['x', 'y', 'z'], 456) // { x: { y: { z: 456 }}} + * console.log(original) // { x: { y: { z: 123 }}} + * ``` + */ +function setIn$1(collection, keyPath, value) { + return updateIn$1(collection, keyPath, NOT_SET, function () { return value; }); +} + +function setIn(keyPath, v) { + return setIn$1(this, keyPath, v); +} + +/** + * Returns a copy of the collection with the value at the key path removed. + * + * A functional alternative to `collection.removeIn(keypath)` which will also + * work with plain Objects and Arrays. + * + * + * ```js + * import { removeIn } from 'immutable'; + * + * const original = { x: { y: { z: 123 }}} + * removeIn(original, ['x', 'y', 'z']) // { x: { y: {}}} + * console.log(original) // { x: { y: { z: 123 }}} + * ``` + */ +function removeIn(collection, keyPath) { + return updateIn$1(collection, keyPath, function () { return NOT_SET; }); +} + +function deleteIn(keyPath) { + return removeIn(this, keyPath); +} + +function update$1(collection, key, notSetValue, updater) { + return updateIn$1( + // @ts-expect-error Index signature for type string is missing in type V[] + collection, [key], notSetValue, updater); +} + +function update(key, notSetValue, updater) { + return arguments.length === 1 + ? key(this) + : update$1(this, key, notSetValue, updater); +} + +function updateIn(keyPath, notSetValue, updater) { + return updateIn$1(this, keyPath, notSetValue, updater); +} + +function merge$1() { + var iters = [], len = arguments.length; + while ( len-- ) iters[ len ] = arguments[ len ]; + + return mergeIntoKeyedWith(this, iters); +} + +function mergeWith$1(merger) { + var iters = [], len = arguments.length - 1; + while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ]; + + if (typeof merger !== 'function') { + throw new TypeError('Invalid merger function: ' + merger); + } + return mergeIntoKeyedWith(this, iters, merger); +} + +function mergeIntoKeyedWith(collection, collections, merger) { + var iters = []; + for (var ii = 0; ii < collections.length; ii++) { + var collection$1 = KeyedCollection(collections[ii]); + if (collection$1.size !== 0) { + iters.push(collection$1); + } + } + if (iters.length === 0) { + return collection; + } + if ( + collection.toSeq().size === 0 && + !collection.__ownerID && + iters.length === 1 + ) { + return collection.constructor(iters[0]); + } + return collection.withMutations(function (collection) { + var mergeIntoCollection = merger + ? function (value, key) { + update$1(collection, key, NOT_SET, function (oldVal) { return oldVal === NOT_SET ? value : merger(oldVal, value, key); } + ); + } + : function (value, key) { + collection.set(key, value); + }; + for (var ii = 0; ii < iters.length; ii++) { + iters[ii].forEach(mergeIntoCollection); + } + }); +} + +function merge(collection) { + var sources = [], len = arguments.length - 1; + while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ]; + + return mergeWithSources(collection, sources); +} + +function mergeWith(merger, collection) { + var sources = [], len = arguments.length - 2; + while ( len-- > 0 ) sources[ len ] = arguments[ len + 2 ]; + + return mergeWithSources(collection, sources, merger); +} + +function mergeDeep$1(collection) { + var sources = [], len = arguments.length - 1; + while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ]; + + return mergeDeepWithSources(collection, sources); +} + +function mergeDeepWith$1(merger, collection) { + var sources = [], len = arguments.length - 2; + while ( len-- > 0 ) sources[ len ] = arguments[ len + 2 ]; + + return mergeDeepWithSources(collection, sources, merger); +} + +function mergeDeepWithSources(collection, sources, merger) { + return mergeWithSources(collection, sources, deepMergerWith(merger)); +} + +function mergeWithSources(collection, sources, merger) { + if (!isDataStructure(collection)) { + throw new TypeError( + 'Cannot merge into non-data-structure value: ' + collection + ); + } + if (isImmutable(collection)) { + return typeof merger === 'function' && collection.mergeWith + ? collection.mergeWith.apply(collection, [ merger ].concat( sources )) + : collection.merge + ? collection.merge.apply(collection, sources) + : collection.concat.apply(collection, sources); + } + var isArray = Array.isArray(collection); + var merged = collection; + var Collection = isArray ? IndexedCollection : KeyedCollection; + var mergeItem = isArray + ? function (value) { + // Copy on write + if (merged === collection) { + merged = shallowCopy(merged); + } + merged.push(value); + } + : function (value, key) { + var hasVal = hasOwnProperty.call(merged, key); + var nextVal = + hasVal && merger ? merger(merged[key], value, key) : value; + if (!hasVal || nextVal !== merged[key]) { + // Copy on write + if (merged === collection) { + merged = shallowCopy(merged); + } + merged[key] = nextVal; + } + }; + for (var i = 0; i < sources.length; i++) { + Collection(sources[i]).forEach(mergeItem); + } + return merged; +} + +function deepMergerWith(merger) { + function deepMerger(oldValue, newValue, key) { + return isDataStructure(oldValue) && + isDataStructure(newValue) && + areMergeable(oldValue, newValue) + ? mergeWithSources(oldValue, [newValue], deepMerger) + : merger + ? merger(oldValue, newValue, key) + : newValue; + } + return deepMerger; +} + +/** + * It's unclear what the desired behavior is for merging two collections that + * fall into separate categories between keyed, indexed, or set-like, so we only + * consider them mergeable if they fall into the same category. + */ +function areMergeable(oldDataStructure, newDataStructure) { + var oldSeq = Seq(oldDataStructure); + var newSeq = Seq(newDataStructure); + // This logic assumes that a sequence can only fall into one of the three + // categories mentioned above (since there's no `isSetLike()` method). + return ( + isIndexed(oldSeq) === isIndexed(newSeq) && + isKeyed(oldSeq) === isKeyed(newSeq) + ); +} + +function mergeDeep() { + var iters = [], len = arguments.length; + while ( len-- ) iters[ len ] = arguments[ len ]; + + return mergeDeepWithSources(this, iters); +} + +function mergeDeepWith(merger) { + var iters = [], len = arguments.length - 1; + while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ]; + + return mergeDeepWithSources(this, iters, merger); +} + +function mergeIn(keyPath) { + var iters = [], len = arguments.length - 1; + while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ]; + + return updateIn$1(this, keyPath, emptyMap(), function (m) { return mergeWithSources(m, iters); }); +} + +function mergeDeepIn(keyPath) { + var iters = [], len = arguments.length - 1; + while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ]; + + return updateIn$1(this, keyPath, emptyMap(), function (m) { return mergeDeepWithSources(m, iters); } + ); +} + +function withMutations(fn) { + var mutable = this.asMutable(); + fn(mutable); + return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this; +} + +function asMutable() { + return this.__ownerID ? this : this.__ensureOwner(new OwnerID()); +} + +function asImmutable() { + return this.__ensureOwner(); +} + +function wasAltered() { + return this.__altered; +} + +var Map = /*@__PURE__*/(function (KeyedCollection) { + function Map(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptyMap() + : isMap(value) && !isOrdered(value) + ? value + : emptyMap().withMutations(function (map) { + var iter = KeyedCollection(value); + assertNotInfinite(iter.size); + iter.forEach(function (v, k) { return map.set(k, v); }); + }); + } + + if ( KeyedCollection ) Map.__proto__ = KeyedCollection; + Map.prototype = Object.create( KeyedCollection && KeyedCollection.prototype ); + Map.prototype.constructor = Map; + + Map.prototype.toString = function toString () { + return this.__toString('Map {', '}'); + }; + + // @pragma Access + + Map.prototype.get = function get (k, notSetValue) { + return this._root + ? this._root.get(0, undefined, k, notSetValue) + : notSetValue; + }; + + // @pragma Modification + + Map.prototype.set = function set (k, v) { + return updateMap(this, k, v); + }; + + Map.prototype.remove = function remove (k) { + return updateMap(this, k, NOT_SET); + }; + + Map.prototype.deleteAll = function deleteAll (keys) { + var collection = Collection(keys); + + if (collection.size === 0) { + return this; + } + + return this.withMutations(function (map) { + collection.forEach(function (key) { return map.remove(key); }); + }); + }; + + Map.prototype.clear = function clear () { + if (this.size === 0) { + return this; + } + if (this.__ownerID) { + this.size = 0; + this._root = null; + this.__hash = undefined; + this.__altered = true; + return this; + } + return emptyMap(); + }; + + // @pragma Composition + + Map.prototype.sort = function sort (comparator) { + // Late binding + return OrderedMap(sortFactory(this, comparator)); + }; + + Map.prototype.sortBy = function sortBy (mapper, comparator) { + // Late binding + return OrderedMap(sortFactory(this, comparator, mapper)); + }; + + Map.prototype.map = function map (mapper, context) { + var this$1$1 = this; + + return this.withMutations(function (map) { + map.forEach(function (value, key) { + map.set(key, mapper.call(context, value, key, this$1$1)); + }); + }); + }; + + // @pragma Mutability + + Map.prototype.__iterator = function __iterator (type, reverse) { + return new MapIterator(this, type, reverse); + }; + + Map.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + var iterations = 0; + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + this._root && + this._root.iterate(function (entry) { + iterations++; + return fn(entry[1], entry[0], this$1$1); + }, reverse); + return iterations; + }; + + Map.prototype.__ensureOwner = function __ensureOwner (ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + if (!ownerID) { + if (this.size === 0) { + return emptyMap(); + } + this.__ownerID = ownerID; + this.__altered = false; + return this; + } + return makeMap(this.size, this._root, ownerID, this.__hash); + }; + + return Map; +}(KeyedCollection)); + +Map.isMap = isMap; + +var MapPrototype = Map.prototype; +MapPrototype[IS_MAP_SYMBOL] = true; +MapPrototype[DELETE] = MapPrototype.remove; +MapPrototype.removeAll = MapPrototype.deleteAll; +MapPrototype.setIn = setIn; +MapPrototype.removeIn = MapPrototype.deleteIn = deleteIn; +MapPrototype.update = update; +MapPrototype.updateIn = updateIn; +MapPrototype.merge = MapPrototype.concat = merge$1; +MapPrototype.mergeWith = mergeWith$1; +MapPrototype.mergeDeep = mergeDeep; +MapPrototype.mergeDeepWith = mergeDeepWith; +MapPrototype.mergeIn = mergeIn; +MapPrototype.mergeDeepIn = mergeDeepIn; +MapPrototype.withMutations = withMutations; +MapPrototype.wasAltered = wasAltered; +MapPrototype.asImmutable = asImmutable; +MapPrototype['@@transducer/init'] = MapPrototype.asMutable = asMutable; +MapPrototype['@@transducer/step'] = function (result, arr) { + return result.set(arr[0], arr[1]); +}; +MapPrototype['@@transducer/result'] = function (obj) { + return obj.asImmutable(); +}; + +// #pragma Trie Nodes + +var ArrayMapNode = function ArrayMapNode(ownerID, entries) { + this.ownerID = ownerID; + this.entries = entries; +}; + +ArrayMapNode.prototype.get = function get (shift, keyHash, key, notSetValue) { + var entries = this.entries; + for (var ii = 0, len = entries.length; ii < len; ii++) { + if (is(key, entries[ii][0])) { + return entries[ii][1]; + } + } + return notSetValue; +}; + +ArrayMapNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + var removed = value === NOT_SET; + + var entries = this.entries; + var idx = 0; + var len = entries.length; + for (; idx < len; idx++) { + if (is(key, entries[idx][0])) { + break; + } + } + var exists = idx < len; + + if (exists ? entries[idx][1] === value : removed) { + return this; + } + + SetRef(didAlter); + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + (removed || !exists) && SetRef(didChangeSize); + + if (removed && entries.length === 1) { + return; // undefined + } + + if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) { + return createNodes(ownerID, entries, key, value); + } + + var isEditable = ownerID && ownerID === this.ownerID; + var newEntries = isEditable ? entries : arrCopy(entries); + + if (exists) { + if (removed) { + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + idx === len - 1 + ? newEntries.pop() + : (newEntries[idx] = newEntries.pop()); + } else { + newEntries[idx] = [key, value]; + } + } else { + newEntries.push([key, value]); + } + + if (isEditable) { + this.entries = newEntries; + return this; + } + + return new ArrayMapNode(ownerID, newEntries); +}; + +var BitmapIndexedNode = function BitmapIndexedNode(ownerID, bitmap, nodes) { + this.ownerID = ownerID; + this.bitmap = bitmap; + this.nodes = nodes; +}; + +BitmapIndexedNode.prototype.get = function get (shift, keyHash, key, notSetValue) { + if (keyHash === undefined) { + keyHash = hash(key); + } + var bit = 1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK); + var bitmap = this.bitmap; + return (bitmap & bit) === 0 + ? notSetValue + : this.nodes[popCount(bitmap & (bit - 1))].get( + shift + SHIFT, + keyHash, + key, + notSetValue + ); +}; + +BitmapIndexedNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + if (keyHash === undefined) { + keyHash = hash(key); + } + var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK; + var bit = 1 << keyHashFrag; + var bitmap = this.bitmap; + var exists = (bitmap & bit) !== 0; + + if (!exists && value === NOT_SET) { + return this; + } + + var idx = popCount(bitmap & (bit - 1)); + var nodes = this.nodes; + var node = exists ? nodes[idx] : undefined; + var newNode = updateNode( + node, + ownerID, + shift + SHIFT, + keyHash, + key, + value, + didChangeSize, + didAlter + ); + + if (newNode === node) { + return this; + } + + if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) { + return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode); + } + + if ( + exists && + !newNode && + nodes.length === 2 && + isLeafNode(nodes[idx ^ 1]) + ) { + return nodes[idx ^ 1]; + } + + if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) { + return newNode; + } + + var isEditable = ownerID && ownerID === this.ownerID; + var newBitmap = exists ? (newNode ? bitmap : bitmap ^ bit) : bitmap | bit; + var newNodes = exists + ? newNode + ? setAt(nodes, idx, newNode, isEditable) + : spliceOut(nodes, idx, isEditable) + : spliceIn(nodes, idx, newNode, isEditable); + + if (isEditable) { + this.bitmap = newBitmap; + this.nodes = newNodes; + return this; + } + + return new BitmapIndexedNode(ownerID, newBitmap, newNodes); +}; + +var HashArrayMapNode = function HashArrayMapNode(ownerID, count, nodes) { + this.ownerID = ownerID; + this.count = count; + this.nodes = nodes; +}; + +HashArrayMapNode.prototype.get = function get (shift, keyHash, key, notSetValue) { + if (keyHash === undefined) { + keyHash = hash(key); + } + var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK; + var node = this.nodes[idx]; + return node + ? node.get(shift + SHIFT, keyHash, key, notSetValue) + : notSetValue; +}; + +HashArrayMapNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + if (keyHash === undefined) { + keyHash = hash(key); + } + var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK; + var removed = value === NOT_SET; + var nodes = this.nodes; + var node = nodes[idx]; + + if (removed && !node) { + return this; + } + + var newNode = updateNode( + node, + ownerID, + shift + SHIFT, + keyHash, + key, + value, + didChangeSize, + didAlter + ); + if (newNode === node) { + return this; + } + + var newCount = this.count; + if (!node) { + newCount++; + } else if (!newNode) { + newCount--; + if (newCount < MIN_HASH_ARRAY_MAP_SIZE) { + return packNodes(ownerID, nodes, newCount, idx); + } + } + + var isEditable = ownerID && ownerID === this.ownerID; + var newNodes = setAt(nodes, idx, newNode, isEditable); + + if (isEditable) { + this.count = newCount; + this.nodes = newNodes; + return this; + } + + return new HashArrayMapNode(ownerID, newCount, newNodes); +}; + +var HashCollisionNode = function HashCollisionNode(ownerID, keyHash, entries) { + this.ownerID = ownerID; + this.keyHash = keyHash; + this.entries = entries; +}; + +HashCollisionNode.prototype.get = function get (shift, keyHash, key, notSetValue) { + var entries = this.entries; + for (var ii = 0, len = entries.length; ii < len; ii++) { + if (is(key, entries[ii][0])) { + return entries[ii][1]; + } + } + return notSetValue; +}; + +HashCollisionNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + if (keyHash === undefined) { + keyHash = hash(key); + } + + var removed = value === NOT_SET; + + if (keyHash !== this.keyHash) { + if (removed) { + return this; + } + SetRef(didAlter); + SetRef(didChangeSize); + return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]); + } + + var entries = this.entries; + var idx = 0; + var len = entries.length; + for (; idx < len; idx++) { + if (is(key, entries[idx][0])) { + break; + } + } + var exists = idx < len; + + if (exists ? entries[idx][1] === value : removed) { + return this; + } + + SetRef(didAlter); + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + (removed || !exists) && SetRef(didChangeSize); + + if (removed && len === 2) { + return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]); + } + + var isEditable = ownerID && ownerID === this.ownerID; + var newEntries = isEditable ? entries : arrCopy(entries); + + if (exists) { + if (removed) { + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + idx === len - 1 + ? newEntries.pop() + : (newEntries[idx] = newEntries.pop()); + } else { + newEntries[idx] = [key, value]; + } + } else { + newEntries.push([key, value]); + } + + if (isEditable) { + this.entries = newEntries; + return this; + } + + return new HashCollisionNode(ownerID, this.keyHash, newEntries); +}; + +var ValueNode = function ValueNode(ownerID, keyHash, entry) { + this.ownerID = ownerID; + this.keyHash = keyHash; + this.entry = entry; +}; + +ValueNode.prototype.get = function get (shift, keyHash, key, notSetValue) { + return is(key, this.entry[0]) ? this.entry[1] : notSetValue; +}; + +ValueNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + var removed = value === NOT_SET; + var keyMatch = is(key, this.entry[0]); + if (keyMatch ? value === this.entry[1] : removed) { + return this; + } + + SetRef(didAlter); + + if (removed) { + SetRef(didChangeSize); + return; // undefined + } + + if (keyMatch) { + if (ownerID && ownerID === this.ownerID) { + this.entry[1] = value; + return this; + } + return new ValueNode(ownerID, this.keyHash, [key, value]); + } + + SetRef(didChangeSize); + return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]); +}; + +// #pragma Iterators + +ArrayMapNode.prototype.iterate = HashCollisionNode.prototype.iterate = + function (fn, reverse) { + var entries = this.entries; + for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) { + if (fn(entries[reverse ? maxIndex - ii : ii]) === false) { + return false; + } + } + }; + +BitmapIndexedNode.prototype.iterate = HashArrayMapNode.prototype.iterate = + function (fn, reverse) { + var nodes = this.nodes; + for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) { + var node = nodes[reverse ? maxIndex - ii : ii]; + if (node && node.iterate(fn, reverse) === false) { + return false; + } + } + }; + +// eslint-disable-next-line @typescript-eslint/no-unused-vars +ValueNode.prototype.iterate = function (fn, reverse) { + return fn(this.entry); +}; + +var MapIterator = /*@__PURE__*/(function (Iterator) { + function MapIterator(map, type, reverse) { + this._type = type; + this._reverse = reverse; + this._stack = map._root && mapIteratorFrame(map._root); + } + + if ( Iterator ) MapIterator.__proto__ = Iterator; + MapIterator.prototype = Object.create( Iterator && Iterator.prototype ); + MapIterator.prototype.constructor = MapIterator; + + MapIterator.prototype.next = function next () { + var type = this._type; + var stack = this._stack; + while (stack) { + var node = stack.node; + var index = stack.index++; + var maxIndex = (void 0); + if (node.entry) { + if (index === 0) { + return mapIteratorValue(type, node.entry); + } + } else if (node.entries) { + maxIndex = node.entries.length - 1; + if (index <= maxIndex) { + return mapIteratorValue( + type, + node.entries[this._reverse ? maxIndex - index : index] + ); + } + } else { + maxIndex = node.nodes.length - 1; + if (index <= maxIndex) { + var subNode = node.nodes[this._reverse ? maxIndex - index : index]; + if (subNode) { + if (subNode.entry) { + return mapIteratorValue(type, subNode.entry); + } + stack = this._stack = mapIteratorFrame(subNode, stack); + } + continue; + } + } + stack = this._stack = this._stack.__prev; + } + return iteratorDone(); + }; + + return MapIterator; +}(Iterator)); + +function mapIteratorValue(type, entry) { + return iteratorValue(type, entry[0], entry[1]); +} + +function mapIteratorFrame(node, prev) { + return { + node: node, + index: 0, + __prev: prev, + }; +} + +function makeMap(size, root, ownerID, hash) { + var map = Object.create(MapPrototype); + map.size = size; + map._root = root; + map.__ownerID = ownerID; + map.__hash = hash; + map.__altered = false; + return map; +} + +var EMPTY_MAP; +function emptyMap() { + return EMPTY_MAP || (EMPTY_MAP = makeMap(0)); +} + +function updateMap(map, k, v) { + var newRoot; + var newSize; + if (!map._root) { + if (v === NOT_SET) { + return map; + } + newSize = 1; + newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]); + } else { + var didChangeSize = MakeRef(); + var didAlter = MakeRef(); + newRoot = updateNode( + map._root, + map.__ownerID, + 0, + undefined, + k, + v, + didChangeSize, + didAlter + ); + if (!didAlter.value) { + return map; + } + newSize = map.size + (didChangeSize.value ? (v === NOT_SET ? -1 : 1) : 0); + } + if (map.__ownerID) { + map.size = newSize; + map._root = newRoot; + map.__hash = undefined; + map.__altered = true; + return map; + } + return newRoot ? makeMap(newSize, newRoot) : emptyMap(); +} + +function updateNode( + node, + ownerID, + shift, + keyHash, + key, + value, + didChangeSize, + didAlter +) { + if (!node) { + if (value === NOT_SET) { + return node; + } + SetRef(didAlter); + SetRef(didChangeSize); + return new ValueNode(ownerID, keyHash, [key, value]); + } + return node.update( + ownerID, + shift, + keyHash, + key, + value, + didChangeSize, + didAlter + ); +} + +function isLeafNode(node) { + return ( + node.constructor === ValueNode || node.constructor === HashCollisionNode + ); +} + +function mergeIntoNode(node, ownerID, shift, keyHash, entry) { + if (node.keyHash === keyHash) { + return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]); + } + + var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK; + var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK; + + var newNode; + var nodes = + idx1 === idx2 + ? [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)] + : ((newNode = new ValueNode(ownerID, keyHash, entry)), + idx1 < idx2 ? [node, newNode] : [newNode, node]); + + return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes); +} + +function createNodes(ownerID, entries, key, value) { + if (!ownerID) { + ownerID = new OwnerID(); + } + var node = new ValueNode(ownerID, hash(key), [key, value]); + for (var ii = 0; ii < entries.length; ii++) { + var entry = entries[ii]; + node = node.update(ownerID, 0, undefined, entry[0], entry[1]); + } + return node; +} + +function packNodes(ownerID, nodes, count, excluding) { + var bitmap = 0; + var packedII = 0; + var packedNodes = new Array(count); + for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) { + var node = nodes[ii]; + if (node !== undefined && ii !== excluding) { + bitmap |= bit; + packedNodes[packedII++] = node; + } + } + return new BitmapIndexedNode(ownerID, bitmap, packedNodes); +} + +function expandNodes(ownerID, nodes, bitmap, including, node) { + var count = 0; + var expandedNodes = new Array(SIZE); + for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) { + expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined; + } + expandedNodes[including] = node; + return new HashArrayMapNode(ownerID, count + 1, expandedNodes); +} + +function popCount(x) { + x -= (x >> 1) & 0x55555555; + x = (x & 0x33333333) + ((x >> 2) & 0x33333333); + x = (x + (x >> 4)) & 0x0f0f0f0f; + x += x >> 8; + x += x >> 16; + return x & 0x7f; +} + +function setAt(array, idx, val, canEdit) { + var newArray = canEdit ? array : arrCopy(array); + newArray[idx] = val; + return newArray; +} + +function spliceIn(array, idx, val, canEdit) { + var newLen = array.length + 1; + if (canEdit && idx + 1 === newLen) { + array[idx] = val; + return array; + } + var newArray = new Array(newLen); + var after = 0; + for (var ii = 0; ii < newLen; ii++) { + if (ii === idx) { + newArray[ii] = val; + after = -1; + } else { + newArray[ii] = array[ii + after]; + } + } + return newArray; +} + +function spliceOut(array, idx, canEdit) { + var newLen = array.length - 1; + if (canEdit && idx === newLen) { + array.pop(); + return array; + } + var newArray = new Array(newLen); + var after = 0; + for (var ii = 0; ii < newLen; ii++) { + if (ii === idx) { + after = 1; + } + newArray[ii] = array[ii + after]; + } + return newArray; +} + +var MAX_ARRAY_MAP_SIZE = SIZE / 4; +var MAX_BITMAP_INDEXED_SIZE = SIZE / 2; +var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4; + +var IS_LIST_SYMBOL = '@@__IMMUTABLE_LIST__@@'; +/** + * True if `maybeList` is a List. + */ +function isList(maybeList) { + return Boolean(maybeList && + // @ts-expect-error: maybeList is typed as `{}`, need to change in 6.0 to `maybeList && typeof maybeList === 'object' && IS_LIST_SYMBOL in maybeList` + maybeList[IS_LIST_SYMBOL]); +} + +var List = /*@__PURE__*/(function (IndexedCollection) { + function List(value) { + var empty = emptyList(); + if (value === undefined || value === null) { + // eslint-disable-next-line no-constructor-return + return empty; + } + if (isList(value)) { + // eslint-disable-next-line no-constructor-return + return value; + } + var iter = IndexedCollection(value); + var size = iter.size; + if (size === 0) { + // eslint-disable-next-line no-constructor-return + return empty; + } + assertNotInfinite(size); + if (size > 0 && size < SIZE) { + // eslint-disable-next-line no-constructor-return + return makeList(0, size, SHIFT, null, new VNode(iter.toArray())); + } + // eslint-disable-next-line no-constructor-return + return empty.withMutations(function (list) { + list.setSize(size); + iter.forEach(function (v, i) { return list.set(i, v); }); + }); + } + + if ( IndexedCollection ) List.__proto__ = IndexedCollection; + List.prototype = Object.create( IndexedCollection && IndexedCollection.prototype ); + List.prototype.constructor = List; + + List.of = function of (/*...values*/) { + return this(arguments); + }; + + List.prototype.toString = function toString () { + return this.__toString('List [', ']'); + }; + + // @pragma Access + + List.prototype.get = function get (index, notSetValue) { + index = wrapIndex(this, index); + if (index >= 0 && index < this.size) { + index += this._origin; + var node = listNodeFor(this, index); + return node && node.array[index & MASK]; + } + return notSetValue; + }; + + // @pragma Modification + + List.prototype.set = function set (index, value) { + return updateList(this, index, value); + }; + + List.prototype.remove = function remove (index) { + return !this.has(index) + ? this + : index === 0 + ? this.shift() + : index === this.size - 1 + ? this.pop() + : this.splice(index, 1); + }; + + List.prototype.insert = function insert (index, value) { + return this.splice(index, 0, value); + }; + + List.prototype.clear = function clear () { + if (this.size === 0) { + return this; + } + if (this.__ownerID) { + this.size = this._origin = this._capacity = 0; + this._level = SHIFT; + this._root = this._tail = this.__hash = undefined; + this.__altered = true; + return this; + } + return emptyList(); + }; + + List.prototype.push = function push (/*...values*/) { + var values = arguments; + var oldSize = this.size; + return this.withMutations(function (list) { + setListBounds(list, 0, oldSize + values.length); + for (var ii = 0; ii < values.length; ii++) { + list.set(oldSize + ii, values[ii]); + } + }); + }; + + List.prototype.pop = function pop () { + return setListBounds(this, 0, -1); + }; + + List.prototype.unshift = function unshift (/*...values*/) { + var values = arguments; + return this.withMutations(function (list) { + setListBounds(list, -values.length); + for (var ii = 0; ii < values.length; ii++) { + list.set(ii, values[ii]); + } + }); + }; + + List.prototype.shift = function shift () { + return setListBounds(this, 1); + }; + + List.prototype.shuffle = function shuffle (random) { + if ( random === void 0 ) random = Math.random; + + return this.withMutations(function (mutable) { + // implementation of the Fisher-Yates shuffle: https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle + var current = mutable.size; + var destination; + var tmp; + + while (current) { + destination = Math.floor(random() * current--); + + tmp = mutable.get(destination); + mutable.set(destination, mutable.get(current)); + mutable.set(current, tmp); + } + }); + }; + + // @pragma Composition + + List.prototype.concat = function concat (/*...collections*/) { + var arguments$1 = arguments; + + var seqs = []; + for (var i = 0; i < arguments.length; i++) { + var argument = arguments$1[i]; + var seq = IndexedCollection( + typeof argument !== 'string' && hasIterator(argument) + ? argument + : [argument] + ); + if (seq.size !== 0) { + seqs.push(seq); + } + } + if (seqs.length === 0) { + return this; + } + if (this.size === 0 && !this.__ownerID && seqs.length === 1) { + return this.constructor(seqs[0]); + } + return this.withMutations(function (list) { + seqs.forEach(function (seq) { return seq.forEach(function (value) { return list.push(value); }); }); + }); + }; + + List.prototype.setSize = function setSize (size) { + return setListBounds(this, 0, size); + }; + + List.prototype.map = function map (mapper, context) { + var this$1$1 = this; + + return this.withMutations(function (list) { + for (var i = 0; i < this$1$1.size; i++) { + list.set(i, mapper.call(context, list.get(i), i, this$1$1)); + } + }); + }; + + // @pragma Iteration + + List.prototype.slice = function slice (begin, end) { + var size = this.size; + if (wholeSlice(begin, end, size)) { + return this; + } + return setListBounds( + this, + resolveBegin(begin, size), + resolveEnd(end, size) + ); + }; + + List.prototype.__iterator = function __iterator (type, reverse) { + var index = reverse ? this.size : 0; + var values = iterateList(this, reverse); + return new Iterator(function () { + var value = values(); + return value === DONE + ? iteratorDone() + : iteratorValue(type, reverse ? --index : index++, value); + }); + }; + + List.prototype.__iterate = function __iterate (fn, reverse) { + var index = reverse ? this.size : 0; + var values = iterateList(this, reverse); + var value; + while ((value = values()) !== DONE) { + if (fn(value, reverse ? --index : index++, this) === false) { + break; + } + } + return index; + }; + + List.prototype.__ensureOwner = function __ensureOwner (ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + if (!ownerID) { + if (this.size === 0) { + return emptyList(); + } + this.__ownerID = ownerID; + this.__altered = false; + return this; + } + return makeList( + this._origin, + this._capacity, + this._level, + this._root, + this._tail, + ownerID, + this.__hash + ); + }; + + return List; +}(IndexedCollection)); + +List.isList = isList; + +var ListPrototype = List.prototype; +ListPrototype[IS_LIST_SYMBOL] = true; +ListPrototype[DELETE] = ListPrototype.remove; +ListPrototype.merge = ListPrototype.concat; +ListPrototype.setIn = setIn; +ListPrototype.deleteIn = ListPrototype.removeIn = deleteIn; +ListPrototype.update = update; +ListPrototype.updateIn = updateIn; +ListPrototype.mergeIn = mergeIn; +ListPrototype.mergeDeepIn = mergeDeepIn; +ListPrototype.withMutations = withMutations; +ListPrototype.wasAltered = wasAltered; +ListPrototype.asImmutable = asImmutable; +ListPrototype['@@transducer/init'] = ListPrototype.asMutable = asMutable; +ListPrototype['@@transducer/step'] = function (result, arr) { + return result.push(arr); +}; +ListPrototype['@@transducer/result'] = function (obj) { + return obj.asImmutable(); +}; + +var VNode = function VNode(array, ownerID) { + this.array = array; + this.ownerID = ownerID; +}; + +// TODO: seems like these methods are very similar + +VNode.prototype.removeBefore = function removeBefore (ownerID, level, index) { + if ( + (index & ((1 << (level + SHIFT)) - 1)) === 0 || + this.array.length === 0 + ) { + return this; + } + var originIndex = (index >>> level) & MASK; + if (originIndex >= this.array.length) { + return new VNode([], ownerID); + } + var removingFirst = originIndex === 0; + var newChild; + if (level > 0) { + var oldChild = this.array[originIndex]; + newChild = + oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index); + if (newChild === oldChild && removingFirst) { + return this; + } + } + if (removingFirst && !newChild) { + return this; + } + var editable = editableVNode(this, ownerID); + if (!removingFirst) { + for (var ii = 0; ii < originIndex; ii++) { + editable.array[ii] = undefined; + } + } + if (newChild) { + editable.array[originIndex] = newChild; + } + return editable; +}; + +VNode.prototype.removeAfter = function removeAfter (ownerID, level, index) { + if ( + index === (level ? 1 << (level + SHIFT) : SIZE) || + this.array.length === 0 + ) { + return this; + } + var sizeIndex = ((index - 1) >>> level) & MASK; + if (sizeIndex >= this.array.length) { + return this; + } + + var newChild; + if (level > 0) { + var oldChild = this.array[sizeIndex]; + newChild = + oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index); + if (newChild === oldChild && sizeIndex === this.array.length - 1) { + return this; + } + } + + var editable = editableVNode(this, ownerID); + editable.array.splice(sizeIndex + 1); + if (newChild) { + editable.array[sizeIndex] = newChild; + } + return editable; +}; + +var DONE = {}; + +function iterateList(list, reverse) { + var left = list._origin; + var right = list._capacity; + var tailPos = getTailOffset(right); + var tail = list._tail; + + return iterateNodeOrLeaf(list._root, list._level, 0); + + function iterateNodeOrLeaf(node, level, offset) { + return level === 0 + ? iterateLeaf(node, offset) + : iterateNode(node, level, offset); + } + + function iterateLeaf(node, offset) { + var array = offset === tailPos ? tail && tail.array : node && node.array; + var from = offset > left ? 0 : left - offset; + var to = right - offset; + if (to > SIZE) { + to = SIZE; + } + return function () { + if (from === to) { + return DONE; + } + var idx = reverse ? --to : from++; + return array && array[idx]; + }; + } + + function iterateNode(node, level, offset) { + var values; + var array = node && node.array; + var from = offset > left ? 0 : (left - offset) >> level; + var to = ((right - offset) >> level) + 1; + if (to > SIZE) { + to = SIZE; + } + return function () { + while (true) { + if (values) { + var value = values(); + if (value !== DONE) { + return value; + } + values = null; + } + if (from === to) { + return DONE; + } + var idx = reverse ? --to : from++; + values = iterateNodeOrLeaf( + array && array[idx], + level - SHIFT, + offset + (idx << level) + ); + } + }; + } +} + +function makeList(origin, capacity, level, root, tail, ownerID, hash) { + var list = Object.create(ListPrototype); + list.size = capacity - origin; + list._origin = origin; + list._capacity = capacity; + list._level = level; + list._root = root; + list._tail = tail; + list.__ownerID = ownerID; + list.__hash = hash; + list.__altered = false; + return list; +} + +function emptyList() { + return makeList(0, 0, SHIFT); +} + +function updateList(list, index, value) { + index = wrapIndex(list, index); + + if (index !== index) { + return list; + } + + if (index >= list.size || index < 0) { + return list.withMutations(function (list) { + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + index < 0 + ? setListBounds(list, index).set(0, value) + : setListBounds(list, 0, index + 1).set(index, value); + }); + } + + index += list._origin; + + var newTail = list._tail; + var newRoot = list._root; + var didAlter = MakeRef(); + if (index >= getTailOffset(list._capacity)) { + newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter); + } else { + newRoot = updateVNode( + newRoot, + list.__ownerID, + list._level, + index, + value, + didAlter + ); + } + + if (!didAlter.value) { + return list; + } + + if (list.__ownerID) { + list._root = newRoot; + list._tail = newTail; + list.__hash = undefined; + list.__altered = true; + return list; + } + return makeList(list._origin, list._capacity, list._level, newRoot, newTail); +} + +function updateVNode(node, ownerID, level, index, value, didAlter) { + var idx = (index >>> level) & MASK; + var nodeHas = node && idx < node.array.length; + if (!nodeHas && value === undefined) { + return node; + } + + var newNode; + + if (level > 0) { + var lowerNode = node && node.array[idx]; + var newLowerNode = updateVNode( + lowerNode, + ownerID, + level - SHIFT, + index, + value, + didAlter + ); + if (newLowerNode === lowerNode) { + return node; + } + newNode = editableVNode(node, ownerID); + newNode.array[idx] = newLowerNode; + return newNode; + } + + if (nodeHas && node.array[idx] === value) { + return node; + } + + if (didAlter) { + SetRef(didAlter); + } + + newNode = editableVNode(node, ownerID); + if (value === undefined && idx === newNode.array.length - 1) { + newNode.array.pop(); + } else { + newNode.array[idx] = value; + } + return newNode; +} + +function editableVNode(node, ownerID) { + if (ownerID && node && ownerID === node.ownerID) { + return node; + } + return new VNode(node ? node.array.slice() : [], ownerID); +} + +function listNodeFor(list, rawIndex) { + if (rawIndex >= getTailOffset(list._capacity)) { + return list._tail; + } + if (rawIndex < 1 << (list._level + SHIFT)) { + var node = list._root; + var level = list._level; + while (node && level > 0) { + node = node.array[(rawIndex >>> level) & MASK]; + level -= SHIFT; + } + return node; + } +} + +function setListBounds(list, begin, end) { + // Sanitize begin & end using this shorthand for ToInt32(argument) + // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32 + if (begin !== undefined) { + begin |= 0; + } + if (end !== undefined) { + end |= 0; + } + var owner = list.__ownerID || new OwnerID(); + var oldOrigin = list._origin; + var oldCapacity = list._capacity; + var newOrigin = oldOrigin + begin; + var newCapacity = + end === undefined + ? oldCapacity + : end < 0 + ? oldCapacity + end + : oldOrigin + end; + if (newOrigin === oldOrigin && newCapacity === oldCapacity) { + return list; + } + + // If it's going to end after it starts, it's empty. + if (newOrigin >= newCapacity) { + return list.clear(); + } + + var newLevel = list._level; + var newRoot = list._root; + + // New origin might need creating a higher root. + var offsetShift = 0; + while (newOrigin + offsetShift < 0) { + newRoot = new VNode( + newRoot && newRoot.array.length ? [undefined, newRoot] : [], + owner + ); + newLevel += SHIFT; + offsetShift += 1 << newLevel; + } + if (offsetShift) { + newOrigin += offsetShift; + oldOrigin += offsetShift; + newCapacity += offsetShift; + oldCapacity += offsetShift; + } + + var oldTailOffset = getTailOffset(oldCapacity); + var newTailOffset = getTailOffset(newCapacity); + + // New size might need creating a higher root. + while (newTailOffset >= 1 << (newLevel + SHIFT)) { + newRoot = new VNode( + newRoot && newRoot.array.length ? [newRoot] : [], + owner + ); + newLevel += SHIFT; + } + + // Locate or create the new tail. + var oldTail = list._tail; + var newTail = + newTailOffset < oldTailOffset + ? listNodeFor(list, newCapacity - 1) + : newTailOffset > oldTailOffset + ? new VNode([], owner) + : oldTail; + + // Merge Tail into tree. + if ( + oldTail && + newTailOffset > oldTailOffset && + newOrigin < oldCapacity && + oldTail.array.length + ) { + newRoot = editableVNode(newRoot, owner); + var node = newRoot; + for (var level = newLevel; level > SHIFT; level -= SHIFT) { + var idx = (oldTailOffset >>> level) & MASK; + node = node.array[idx] = editableVNode(node.array[idx], owner); + } + node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail; + } + + // If the size has been reduced, there's a chance the tail needs to be trimmed. + if (newCapacity < oldCapacity) { + newTail = newTail && newTail.removeAfter(owner, 0, newCapacity); + } + + // If the new origin is within the tail, then we do not need a root. + if (newOrigin >= newTailOffset) { + newOrigin -= newTailOffset; + newCapacity -= newTailOffset; + newLevel = SHIFT; + newRoot = null; + newTail = newTail && newTail.removeBefore(owner, 0, newOrigin); + + // Otherwise, if the root has been trimmed, garbage collect. + } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) { + offsetShift = 0; + + // Identify the new top root node of the subtree of the old root. + while (newRoot) { + var beginIndex = (newOrigin >>> newLevel) & MASK; + if ((beginIndex !== newTailOffset >>> newLevel) & MASK) { + break; + } + if (beginIndex) { + offsetShift += (1 << newLevel) * beginIndex; + } + newLevel -= SHIFT; + newRoot = newRoot.array[beginIndex]; + } + + // Trim the new sides of the new root. + if (newRoot && newOrigin > oldOrigin) { + newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift); + } + if (newRoot && newTailOffset < oldTailOffset) { + newRoot = newRoot.removeAfter( + owner, + newLevel, + newTailOffset - offsetShift + ); + } + if (offsetShift) { + newOrigin -= offsetShift; + newCapacity -= offsetShift; + } + } + + if (list.__ownerID) { + list.size = newCapacity - newOrigin; + list._origin = newOrigin; + list._capacity = newCapacity; + list._level = newLevel; + list._root = newRoot; + list._tail = newTail; + list.__hash = undefined; + list.__altered = true; + return list; + } + return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail); +} + +function getTailOffset(size) { + return size < SIZE ? 0 : ((size - 1) >>> SHIFT) << SHIFT; +} + +var OrderedMap = /*@__PURE__*/(function (Map) { + function OrderedMap(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptyOrderedMap() + : isOrderedMap(value) + ? value + : emptyOrderedMap().withMutations(function (map) { + var iter = KeyedCollection(value); + assertNotInfinite(iter.size); + iter.forEach(function (v, k) { return map.set(k, v); }); + }); + } + + if ( Map ) OrderedMap.__proto__ = Map; + OrderedMap.prototype = Object.create( Map && Map.prototype ); + OrderedMap.prototype.constructor = OrderedMap; + + OrderedMap.of = function of (/*...values*/) { + return this(arguments); + }; + + OrderedMap.prototype.toString = function toString () { + return this.__toString('OrderedMap {', '}'); + }; + + // @pragma Access + + OrderedMap.prototype.get = function get (k, notSetValue) { + var index = this._map.get(k); + return index !== undefined ? this._list.get(index)[1] : notSetValue; + }; + + // @pragma Modification + + OrderedMap.prototype.clear = function clear () { + if (this.size === 0) { + return this; + } + if (this.__ownerID) { + this.size = 0; + this._map.clear(); + this._list.clear(); + this.__altered = true; + return this; + } + return emptyOrderedMap(); + }; + + OrderedMap.prototype.set = function set (k, v) { + return updateOrderedMap(this, k, v); + }; + + OrderedMap.prototype.remove = function remove (k) { + return updateOrderedMap(this, k, NOT_SET); + }; + + OrderedMap.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + return this._list.__iterate( + function (entry) { return entry && fn(entry[1], entry[0], this$1$1); }, + reverse + ); + }; + + OrderedMap.prototype.__iterator = function __iterator (type, reverse) { + return this._list.fromEntrySeq().__iterator(type, reverse); + }; + + OrderedMap.prototype.__ensureOwner = function __ensureOwner (ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + var newMap = this._map.__ensureOwner(ownerID); + var newList = this._list.__ensureOwner(ownerID); + if (!ownerID) { + if (this.size === 0) { + return emptyOrderedMap(); + } + this.__ownerID = ownerID; + this.__altered = false; + this._map = newMap; + this._list = newList; + return this; + } + return makeOrderedMap(newMap, newList, ownerID, this.__hash); + }; + + return OrderedMap; +}(Map)); + +OrderedMap.isOrderedMap = isOrderedMap; + +OrderedMap.prototype[IS_ORDERED_SYMBOL] = true; +OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove; + +function makeOrderedMap(map, list, ownerID, hash) { + var omap = Object.create(OrderedMap.prototype); + omap.size = map ? map.size : 0; + omap._map = map; + omap._list = list; + omap.__ownerID = ownerID; + omap.__hash = hash; + omap.__altered = false; + return omap; +} + +var EMPTY_ORDERED_MAP; +function emptyOrderedMap() { + return ( + EMPTY_ORDERED_MAP || + (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList())) + ); +} + +function updateOrderedMap(omap, k, v) { + var map = omap._map; + var list = omap._list; + var i = map.get(k); + var has = i !== undefined; + var newMap; + var newList; + if (v === NOT_SET) { + // removed + if (!has) { + return omap; + } + if (list.size >= SIZE && list.size >= map.size * 2) { + newList = list.filter(function (entry, idx) { return entry !== undefined && i !== idx; }); + newMap = newList + .toKeyedSeq() + .map(function (entry) { return entry[0]; }) + .flip() + .toMap(); + if (omap.__ownerID) { + newMap.__ownerID = newList.__ownerID = omap.__ownerID; + } + } else { + newMap = map.remove(k); + newList = i === list.size - 1 ? list.pop() : list.set(i, undefined); + } + } else if (has) { + if (v === list.get(i)[1]) { + return omap; + } + newMap = map; + newList = list.set(i, [k, v]); + } else { + newMap = map.set(k, list.size); + newList = list.set(list.size, [k, v]); + } + if (omap.__ownerID) { + omap.size = newMap.size; + omap._map = newMap; + omap._list = newList; + omap.__hash = undefined; + omap.__altered = true; + return omap; + } + return makeOrderedMap(newMap, newList); +} + +var IS_STACK_SYMBOL = '@@__IMMUTABLE_STACK__@@'; +/** + * True if `maybeStack` is a Stack. + */ +function isStack(maybeStack) { + return Boolean(maybeStack && + // @ts-expect-error: maybeStack is typed as `{}`, need to change in 6.0 to `maybeStack && typeof maybeStack === 'object' && MAYBE_STACK_SYMBOL in maybeStack` + maybeStack[IS_STACK_SYMBOL]); +} + +var Stack = /*@__PURE__*/(function (IndexedCollection) { + function Stack(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptyStack() + : isStack(value) + ? value + : emptyStack().pushAll(value); + } + + if ( IndexedCollection ) Stack.__proto__ = IndexedCollection; + Stack.prototype = Object.create( IndexedCollection && IndexedCollection.prototype ); + Stack.prototype.constructor = Stack; + + Stack.of = function of (/*...values*/) { + return this(arguments); + }; + + Stack.prototype.toString = function toString () { + return this.__toString('Stack [', ']'); + }; + + // @pragma Access + + Stack.prototype.get = function get (index, notSetValue) { + var head = this._head; + index = wrapIndex(this, index); + while (head && index--) { + head = head.next; + } + return head ? head.value : notSetValue; + }; + + Stack.prototype.peek = function peek () { + return this._head && this._head.value; + }; + + // @pragma Modification + + Stack.prototype.push = function push (/*...values*/) { + var arguments$1 = arguments; + + if (arguments.length === 0) { + return this; + } + var newSize = this.size + arguments.length; + var head = this._head; + for (var ii = arguments.length - 1; ii >= 0; ii--) { + head = { + value: arguments$1[ii], + next: head, + }; + } + if (this.__ownerID) { + this.size = newSize; + this._head = head; + this.__hash = undefined; + this.__altered = true; + return this; + } + return makeStack(newSize, head); + }; + + Stack.prototype.pushAll = function pushAll (iter) { + iter = IndexedCollection(iter); + if (iter.size === 0) { + return this; + } + if (this.size === 0 && isStack(iter)) { + return iter; + } + assertNotInfinite(iter.size); + var newSize = this.size; + var head = this._head; + iter.__iterate(function (value) { + newSize++; + head = { + value: value, + next: head, + }; + }, /* reverse */ true); + if (this.__ownerID) { + this.size = newSize; + this._head = head; + this.__hash = undefined; + this.__altered = true; + return this; + } + return makeStack(newSize, head); + }; + + Stack.prototype.pop = function pop () { + return this.slice(1); + }; + + Stack.prototype.clear = function clear () { + if (this.size === 0) { + return this; + } + if (this.__ownerID) { + this.size = 0; + this._head = undefined; + this.__hash = undefined; + this.__altered = true; + return this; + } + return emptyStack(); + }; + + Stack.prototype.slice = function slice (begin, end) { + if (wholeSlice(begin, end, this.size)) { + return this; + } + var resolvedBegin = resolveBegin(begin, this.size); + var resolvedEnd = resolveEnd(end, this.size); + if (resolvedEnd !== this.size) { + // super.slice(begin, end); + return IndexedCollection.prototype.slice.call(this, begin, end); + } + var newSize = this.size - resolvedBegin; + var head = this._head; + while (resolvedBegin--) { + head = head.next; + } + if (this.__ownerID) { + this.size = newSize; + this._head = head; + this.__hash = undefined; + this.__altered = true; + return this; + } + return makeStack(newSize, head); + }; + + // @pragma Mutability + + Stack.prototype.__ensureOwner = function __ensureOwner (ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + if (!ownerID) { + if (this.size === 0) { + return emptyStack(); + } + this.__ownerID = ownerID; + this.__altered = false; + return this; + } + return makeStack(this.size, this._head, ownerID, this.__hash); + }; + + // @pragma Iteration + + Stack.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + if (reverse) { + return new ArraySeq(this.toArray()).__iterate( + function (v, k) { return fn(v, k, this$1$1); }, + reverse + ); + } + var iterations = 0; + var node = this._head; + while (node) { + if (fn(node.value, iterations++, this) === false) { + break; + } + node = node.next; + } + return iterations; + }; + + Stack.prototype.__iterator = function __iterator (type, reverse) { + if (reverse) { + return new ArraySeq(this.toArray()).__iterator(type, reverse); + } + var iterations = 0; + var node = this._head; + return new Iterator(function () { + if (node) { + var value = node.value; + node = node.next; + return iteratorValue(type, iterations++, value); + } + return iteratorDone(); + }); + }; + + return Stack; +}(IndexedCollection)); + +Stack.isStack = isStack; + +var StackPrototype = Stack.prototype; +StackPrototype[IS_STACK_SYMBOL] = true; +StackPrototype.shift = StackPrototype.pop; +StackPrototype.unshift = StackPrototype.push; +StackPrototype.unshiftAll = StackPrototype.pushAll; +StackPrototype.withMutations = withMutations; +StackPrototype.wasAltered = wasAltered; +StackPrototype.asImmutable = asImmutable; +StackPrototype['@@transducer/init'] = StackPrototype.asMutable = asMutable; +StackPrototype['@@transducer/step'] = function (result, arr) { + return result.unshift(arr); +}; +StackPrototype['@@transducer/result'] = function (obj) { + return obj.asImmutable(); +}; + +function makeStack(size, head, ownerID, hash) { + var map = Object.create(StackPrototype); + map.size = size; + map._head = head; + map.__ownerID = ownerID; + map.__hash = hash; + map.__altered = false; + return map; +} + +var EMPTY_STACK; +function emptyStack() { + return EMPTY_STACK || (EMPTY_STACK = makeStack(0)); +} + +var IS_SET_SYMBOL = '@@__IMMUTABLE_SET__@@'; +/** + * True if `maybeSet` is a Set. + * + * Also true for OrderedSets. + */ +function isSet(maybeSet) { + return Boolean(maybeSet && + // @ts-expect-error: maybeSet is typed as `{}`, need to change in 6.0 to `maybeSeq && typeof maybeSet === 'object' && MAYBE_SET_SYMBOL in maybeSet` + maybeSet[IS_SET_SYMBOL]); +} + +/** + * True if `maybeOrderedSet` is an OrderedSet. + */ +function isOrderedSet(maybeOrderedSet) { + return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet); +} + +function deepEqual(a, b) { + if (a === b) { + return true; + } + if (!isCollection(b) || + // @ts-expect-error size should exists on Collection + (a.size !== undefined && b.size !== undefined && a.size !== b.size) || + // @ts-expect-error __hash exists on Collection + (a.__hash !== undefined && + // @ts-expect-error __hash exists on Collection + b.__hash !== undefined && + // @ts-expect-error __hash exists on Collection + a.__hash !== b.__hash) || + isKeyed(a) !== isKeyed(b) || + isIndexed(a) !== isIndexed(b) || + // @ts-expect-error Range extends Collection, which implements [Symbol.iterator], so it is valid + isOrdered(a) !== isOrdered(b)) { + return false; + } + // @ts-expect-error size should exists on Collection + if (a.size === 0 && b.size === 0) { + return true; + } + var notAssociative = !isAssociative(a); + // @ts-expect-error Range extends Collection, which implements [Symbol.iterator], so it is valid + if (isOrdered(a)) { + var entries = a.entries(); + // @ts-expect-error need to cast as boolean + return (b.every(function (v, k) { + var entry = entries.next().value; + return entry && is(entry[1], v) && (notAssociative || is(entry[0], k)); + }) && entries.next().done); + } + var flipped = false; + if (a.size === undefined) { + // @ts-expect-error size should exists on Collection + if (b.size === undefined) { + if (typeof a.cacheResult === 'function') { + a.cacheResult(); + } + } + else { + flipped = true; + var _ = a; + a = b; + b = _; + } + } + var allEqual = true; + var bSize = + // @ts-expect-error b is Range | Repeat | Collection as it may have been flipped, and __iterate is valid + b.__iterate(function (v, k) { + if (notAssociative + ? // @ts-expect-error has exists on Collection + !a.has(v) + : flipped + ? // @ts-expect-error type of `get` does not "catch" the version with `notSetValue` + !is(v, a.get(k, NOT_SET)) + : // @ts-expect-error type of `get` does not "catch" the version with `notSetValue` + !is(a.get(k, NOT_SET), v)) { + allEqual = false; + return false; + } + }); + return (allEqual && + // @ts-expect-error size should exists on Collection + a.size === bSize); +} + +/** + * Contributes additional methods to a constructor + */ +function mixin(ctor, +// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type +methods) { + var keyCopier = function (key) { + // @ts-expect-error how to handle symbol ? + ctor.prototype[key] = methods[key]; + }; + Object.keys(methods).forEach(keyCopier); + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + Object.getOwnPropertySymbols && + Object.getOwnPropertySymbols(methods).forEach(keyCopier); + return ctor; +} + +function toJS(value) { + if (!value || typeof value !== 'object') { + return value; + } + if (!isCollection(value)) { + if (!isDataStructure(value)) { + return value; + } + value = Seq(value); + } + if (isKeyed(value)) { + var result$1 = {}; + value.__iterate(function (v, k) { + result$1[k] = toJS(v); + }); + return result$1; + } + var result = []; + value.__iterate(function (v) { + result.push(toJS(v)); + }); + return result; +} + +var Set = /*@__PURE__*/(function (SetCollection) { + function Set(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptySet() + : isSet(value) && !isOrdered(value) + ? value + : emptySet().withMutations(function (set) { + var iter = SetCollection(value); + assertNotInfinite(iter.size); + iter.forEach(function (v) { return set.add(v); }); + }); + } + + if ( SetCollection ) Set.__proto__ = SetCollection; + Set.prototype = Object.create( SetCollection && SetCollection.prototype ); + Set.prototype.constructor = Set; + + Set.of = function of (/*...values*/) { + return this(arguments); + }; + + Set.fromKeys = function fromKeys (value) { + return this(KeyedCollection(value).keySeq()); + }; + + Set.intersect = function intersect (sets) { + sets = Collection(sets).toArray(); + return sets.length + ? SetPrototype.intersect.apply(Set(sets.pop()), sets) + : emptySet(); + }; + + Set.union = function union (sets) { + sets = Collection(sets).toArray(); + return sets.length + ? SetPrototype.union.apply(Set(sets.pop()), sets) + : emptySet(); + }; + + Set.prototype.toString = function toString () { + return this.__toString('Set {', '}'); + }; + + // @pragma Access + + Set.prototype.has = function has (value) { + return this._map.has(value); + }; + + // @pragma Modification + + Set.prototype.add = function add (value) { + return updateSet(this, this._map.set(value, value)); + }; + + Set.prototype.remove = function remove (value) { + return updateSet(this, this._map.remove(value)); + }; + + Set.prototype.clear = function clear () { + return updateSet(this, this._map.clear()); + }; + + // @pragma Composition + + Set.prototype.map = function map (mapper, context) { + var this$1$1 = this; + + // keep track if the set is altered by the map function + var didChanges = false; + + var newMap = updateSet( + this, + this._map.mapEntries(function (ref) { + var v = ref[1]; + + var mapped = mapper.call(context, v, v, this$1$1); + + if (mapped !== v) { + didChanges = true; + } + + return [mapped, mapped]; + }, context) + ); + + return didChanges ? newMap : this; + }; + + Set.prototype.union = function union () { + var iters = [], len = arguments.length; + while ( len-- ) iters[ len ] = arguments[ len ]; + + iters = iters.filter(function (x) { return x.size !== 0; }); + if (iters.length === 0) { + return this; + } + if (this.size === 0 && !this.__ownerID && iters.length === 1) { + return this.constructor(iters[0]); + } + return this.withMutations(function (set) { + for (var ii = 0; ii < iters.length; ii++) { + if (typeof iters[ii] === 'string') { + set.add(iters[ii]); + } else { + SetCollection(iters[ii]).forEach(function (value) { return set.add(value); }); + } + } + }); + }; + + Set.prototype.intersect = function intersect () { + var iters = [], len = arguments.length; + while ( len-- ) iters[ len ] = arguments[ len ]; + + if (iters.length === 0) { + return this; + } + iters = iters.map(function (iter) { return SetCollection(iter); }); + var toRemove = []; + this.forEach(function (value) { + if (!iters.every(function (iter) { return iter.includes(value); })) { + toRemove.push(value); + } + }); + return this.withMutations(function (set) { + toRemove.forEach(function (value) { + set.remove(value); + }); + }); + }; + + Set.prototype.subtract = function subtract () { + var iters = [], len = arguments.length; + while ( len-- ) iters[ len ] = arguments[ len ]; + + if (iters.length === 0) { + return this; + } + iters = iters.map(function (iter) { return SetCollection(iter); }); + var toRemove = []; + this.forEach(function (value) { + if (iters.some(function (iter) { return iter.includes(value); })) { + toRemove.push(value); + } + }); + return this.withMutations(function (set) { + toRemove.forEach(function (value) { + set.remove(value); + }); + }); + }; + + Set.prototype.sort = function sort (comparator) { + // Late binding + return OrderedSet(sortFactory(this, comparator)); + }; + + Set.prototype.sortBy = function sortBy (mapper, comparator) { + // Late binding + return OrderedSet(sortFactory(this, comparator, mapper)); + }; + + Set.prototype.wasAltered = function wasAltered () { + return this._map.wasAltered(); + }; + + Set.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + return this._map.__iterate(function (k) { return fn(k, k, this$1$1); }, reverse); + }; + + Set.prototype.__iterator = function __iterator (type, reverse) { + return this._map.__iterator(type, reverse); + }; + + Set.prototype.__ensureOwner = function __ensureOwner (ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + var newMap = this._map.__ensureOwner(ownerID); + if (!ownerID) { + if (this.size === 0) { + return this.__empty(); + } + this.__ownerID = ownerID; + this._map = newMap; + return this; + } + return this.__make(newMap, ownerID); + }; + + return Set; +}(SetCollection)); + +Set.isSet = isSet; + +var SetPrototype = Set.prototype; +SetPrototype[IS_SET_SYMBOL] = true; +SetPrototype[DELETE] = SetPrototype.remove; +SetPrototype.merge = SetPrototype.concat = SetPrototype.union; +SetPrototype.withMutations = withMutations; +SetPrototype.asImmutable = asImmutable; +SetPrototype['@@transducer/init'] = SetPrototype.asMutable = asMutable; +SetPrototype['@@transducer/step'] = function (result, arr) { + return result.add(arr); +}; +SetPrototype['@@transducer/result'] = function (obj) { + return obj.asImmutable(); +}; + +SetPrototype.__empty = emptySet; +SetPrototype.__make = makeSet; + +function updateSet(set, newMap) { + if (set.__ownerID) { + set.size = newMap.size; + set._map = newMap; + return set; + } + return newMap === set._map + ? set + : newMap.size === 0 + ? set.__empty() + : set.__make(newMap); +} + +function makeSet(map, ownerID) { + var set = Object.create(SetPrototype); + set.size = map ? map.size : 0; + set._map = map; + set.__ownerID = ownerID; + return set; +} + +var EMPTY_SET; +function emptySet() { + return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap())); +} + +/** + * Returns a lazy seq of nums from start (inclusive) to end + * (exclusive), by step, where start defaults to 0, step to 1, and end to + * infinity. When start is equal to end, returns empty list. + */ +var Range = /*@__PURE__*/(function (IndexedSeq) { + function Range(start, end, step) { + if ( step === void 0 ) step = 1; + + if (!(this instanceof Range)) { + // eslint-disable-next-line no-constructor-return + return new Range(start, end, step); + } + invariant(step !== 0, 'Cannot step a Range by 0'); + invariant( + start !== undefined, + 'You must define a start value when using Range' + ); + invariant( + end !== undefined, + 'You must define an end value when using Range' + ); + + step = Math.abs(step); + if (end < start) { + step = -step; + } + this._start = start; + this._end = end; + this._step = step; + this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1); + if (this.size === 0) { + if (EMPTY_RANGE) { + // eslint-disable-next-line no-constructor-return + return EMPTY_RANGE; + } + // eslint-disable-next-line @typescript-eslint/no-this-alias + EMPTY_RANGE = this; + } + } + + if ( IndexedSeq ) Range.__proto__ = IndexedSeq; + Range.prototype = Object.create( IndexedSeq && IndexedSeq.prototype ); + Range.prototype.constructor = Range; + + Range.prototype.toString = function toString () { + return this.size === 0 + ? 'Range []' + : ("Range [ " + (this._start) + "..." + (this._end) + (this._step !== 1 ? ' by ' + this._step : '') + " ]"); + }; + + Range.prototype.get = function get (index, notSetValue) { + return this.has(index) + ? this._start + wrapIndex(this, index) * this._step + : notSetValue; + }; + + Range.prototype.includes = function includes (searchValue) { + var possibleIndex = (searchValue - this._start) / this._step; + return ( + possibleIndex >= 0 && + possibleIndex < this.size && + possibleIndex === Math.floor(possibleIndex) + ); + }; + + Range.prototype.slice = function slice (begin, end) { + if (wholeSlice(begin, end, this.size)) { + return this; + } + begin = resolveBegin(begin, this.size); + end = resolveEnd(end, this.size); + if (end <= begin) { + return new Range(0, 0); + } + return new Range( + this.get(begin, this._end), + this.get(end, this._end), + this._step + ); + }; + + Range.prototype.indexOf = function indexOf (searchValue) { + var offsetValue = searchValue - this._start; + if (offsetValue % this._step === 0) { + var index = offsetValue / this._step; + if (index >= 0 && index < this.size) { + return index; + } + } + return -1; + }; + + Range.prototype.lastIndexOf = function lastIndexOf (searchValue) { + return this.indexOf(searchValue); + }; + + Range.prototype.__iterate = function __iterate (fn, reverse) { + var size = this.size; + var step = this._step; + var value = reverse ? this._start + (size - 1) * step : this._start; + var i = 0; + while (i !== size) { + if (fn(value, reverse ? size - ++i : i++, this) === false) { + break; + } + value += reverse ? -step : step; + } + return i; + }; + + Range.prototype.__iterator = function __iterator (type, reverse) { + var size = this.size; + var step = this._step; + var value = reverse ? this._start + (size - 1) * step : this._start; + var i = 0; + return new Iterator(function () { + if (i === size) { + return iteratorDone(); + } + var v = value; + value += reverse ? -step : step; + return iteratorValue(type, reverse ? size - ++i : i++, v); + }); + }; + + Range.prototype.equals = function equals (other) { + return other instanceof Range + ? this._start === other._start && + this._end === other._end && + this._step === other._step + : deepEqual(this, other); + }; + + return Range; +}(IndexedSeq)); + +var EMPTY_RANGE; + +/** + * Returns the value at the provided key path starting at the provided + * collection, or notSetValue if the key path is not defined. + * + * A functional alternative to `collection.getIn(keypath)` which will also + * work with plain Objects and Arrays. + * + * + * ```js + * import { getIn } from 'immutable'; + * + * getIn({ x: { y: { z: 123 }}}, ['x', 'y', 'z']) // 123 + * getIn({ x: { y: { z: 123 }}}, ['x', 'q', 'p'], 'ifNotSet') // 'ifNotSet' + * ``` + */ +function getIn$1(collection, searchKeyPath, notSetValue) { + var keyPath = coerceKeyPath(searchKeyPath); + var i = 0; + while (i !== keyPath.length) { + // @ts-expect-error keyPath[i++] can not be undefined by design + collection = get(collection, keyPath[i++], NOT_SET); + if (collection === NOT_SET) { + return notSetValue; + } + } + return collection; +} + +function getIn(searchKeyPath, notSetValue) { + return getIn$1(this, searchKeyPath, notSetValue); +} + +/** + * Returns true if the key path is defined in the provided collection. + * + * A functional alternative to `collection.hasIn(keypath)` which will also + * work with plain Objects and Arrays. + * + * + * ```js + * import { hasIn } from 'immutable'; + * + * hasIn({ x: { y: { z: 123 }}}, ['x', 'y', 'z']) // true + * hasIn({ x: { y: { z: 123 }}}, ['x', 'q', 'p']) // false + * ``` + */ +function hasIn$1(collection, keyPath) { + return getIn$1(collection, keyPath, NOT_SET) !== NOT_SET; +} + +function hasIn(searchKeyPath) { + return hasIn$1(this, searchKeyPath); +} + +function toObject() { + assertNotInfinite(this.size); + var object = {}; + this.__iterate(function (v, k) { + object[k] = v; + }); + return object; +} + +Collection.Iterator = Iterator; + +mixin(Collection, { + // ### Conversion to other types + + toArray: function toArray() { + assertNotInfinite(this.size); + var array = new Array(this.size || 0); + var useTuples = isKeyed(this); + var i = 0; + this.__iterate(function (v, k) { + // Keyed collections produce an array of tuples. + array[i++] = useTuples ? [k, v] : v; + }); + return array; + }, + + toIndexedSeq: function toIndexedSeq() { + return new ToIndexedSequence(this); + }, + + toJS: function toJS$1() { + return toJS(this); + }, + + toKeyedSeq: function toKeyedSeq() { + return new ToKeyedSequence(this, true); + }, + + toMap: function toMap() { + // Use Late Binding here to solve the circular dependency. + return Map(this.toKeyedSeq()); + }, + + toObject: toObject, + + toOrderedMap: function toOrderedMap() { + // Use Late Binding here to solve the circular dependency. + return OrderedMap(this.toKeyedSeq()); + }, + + toOrderedSet: function toOrderedSet() { + // Use Late Binding here to solve the circular dependency. + return OrderedSet(isKeyed(this) ? this.valueSeq() : this); + }, + + toSet: function toSet() { + // Use Late Binding here to solve the circular dependency. + return Set(isKeyed(this) ? this.valueSeq() : this); + }, + + toSetSeq: function toSetSeq() { + return new ToSetSequence(this); + }, + + toSeq: function toSeq() { + return isIndexed(this) + ? this.toIndexedSeq() + : isKeyed(this) + ? this.toKeyedSeq() + : this.toSetSeq(); + }, + + toStack: function toStack() { + // Use Late Binding here to solve the circular dependency. + return Stack(isKeyed(this) ? this.valueSeq() : this); + }, + + toList: function toList() { + // Use Late Binding here to solve the circular dependency. + return List(isKeyed(this) ? this.valueSeq() : this); + }, + + // ### Common JavaScript methods and properties + + toString: function toString() { + return '[Collection]'; + }, + + __toString: function __toString(head, tail) { + if (this.size === 0) { + return head + tail; + } + return ( + head + + ' ' + + this.toSeq().map(this.__toStringMapper).join(', ') + + ' ' + + tail + ); + }, + + // ### ES6 Collection methods (ES6 Array and Map) + + concat: function concat() { + var values = [], len = arguments.length; + while ( len-- ) values[ len ] = arguments[ len ]; + + return reify(this, concatFactory(this, values)); + }, + + includes: function includes(searchValue) { + return this.some(function (value) { return is(value, searchValue); }); + }, + + entries: function entries() { + return this.__iterator(ITERATE_ENTRIES); + }, + + every: function every(predicate, context) { + assertNotInfinite(this.size); + var returnValue = true; + this.__iterate(function (v, k, c) { + if (!predicate.call(context, v, k, c)) { + returnValue = false; + return false; + } + }); + return returnValue; + }, + + filter: function filter(predicate, context) { + return reify(this, filterFactory(this, predicate, context, true)); + }, + + partition: function partition(predicate, context) { + return partitionFactory(this, predicate, context); + }, + + find: function find(predicate, context, notSetValue) { + var entry = this.findEntry(predicate, context); + return entry ? entry[1] : notSetValue; + }, + + forEach: function forEach(sideEffect, context) { + assertNotInfinite(this.size); + return this.__iterate(context ? sideEffect.bind(context) : sideEffect); + }, + + join: function join(separator) { + assertNotInfinite(this.size); + separator = separator !== undefined ? '' + separator : ','; + var joined = ''; + var isFirst = true; + this.__iterate(function (v) { + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + isFirst ? (isFirst = false) : (joined += separator); + joined += v !== null && v !== undefined ? v.toString() : ''; + }); + return joined; + }, + + keys: function keys() { + return this.__iterator(ITERATE_KEYS); + }, + + map: function map(mapper, context) { + return reify(this, mapFactory(this, mapper, context)); + }, + + reduce: function reduce$1(reducer, initialReduction, context) { + return reduce( + this, + reducer, + initialReduction, + context, + arguments.length < 2, + false + ); + }, + + reduceRight: function reduceRight(reducer, initialReduction, context) { + return reduce( + this, + reducer, + initialReduction, + context, + arguments.length < 2, + true + ); + }, + + reverse: function reverse() { + return reify(this, reverseFactory(this, true)); + }, + + slice: function slice(begin, end) { + return reify(this, sliceFactory(this, begin, end, true)); + }, + + some: function some(predicate, context) { + assertNotInfinite(this.size); + var returnValue = false; + this.__iterate(function (v, k, c) { + if (predicate.call(context, v, k, c)) { + returnValue = true; + return false; + } + }); + return returnValue; + }, + + sort: function sort(comparator) { + return reify(this, sortFactory(this, comparator)); + }, + + values: function values() { + return this.__iterator(ITERATE_VALUES); + }, + + // ### More sequential methods + + butLast: function butLast() { + return this.slice(0, -1); + }, + + isEmpty: function isEmpty() { + return this.size !== undefined ? this.size === 0 : !this.some(function () { return true; }); + }, + + count: function count(predicate, context) { + return ensureSize( + predicate ? this.toSeq().filter(predicate, context) : this + ); + }, + + countBy: function countBy(grouper, context) { + return countByFactory(this, grouper, context); + }, + + equals: function equals(other) { + return deepEqual(this, other); + }, + + entrySeq: function entrySeq() { + // eslint-disable-next-line @typescript-eslint/no-this-alias + var collection = this; + if (collection._cache) { + // We cache as an entries array, so we can just return the cache! + return new ArraySeq(collection._cache); + } + var entriesSequence = collection.toSeq().map(entryMapper).toIndexedSeq(); + entriesSequence.fromEntrySeq = function () { return collection.toSeq(); }; + return entriesSequence; + }, + + filterNot: function filterNot(predicate, context) { + return this.filter(not(predicate), context); + }, + + findEntry: function findEntry(predicate, context, notSetValue) { + var found = notSetValue; + this.__iterate(function (v, k, c) { + if (predicate.call(context, v, k, c)) { + found = [k, v]; + return false; + } + }); + return found; + }, + + findKey: function findKey(predicate, context) { + var entry = this.findEntry(predicate, context); + return entry && entry[0]; + }, + + findLast: function findLast(predicate, context, notSetValue) { + return this.toKeyedSeq().reverse().find(predicate, context, notSetValue); + }, + + findLastEntry: function findLastEntry(predicate, context, notSetValue) { + return this.toKeyedSeq() + .reverse() + .findEntry(predicate, context, notSetValue); + }, + + findLastKey: function findLastKey(predicate, context) { + return this.toKeyedSeq().reverse().findKey(predicate, context); + }, + + first: function first(notSetValue) { + return this.find(returnTrue, null, notSetValue); + }, + + flatMap: function flatMap(mapper, context) { + return reify(this, flatMapFactory(this, mapper, context)); + }, + + flatten: function flatten(depth) { + return reify(this, flattenFactory(this, depth, true)); + }, + + fromEntrySeq: function fromEntrySeq() { + return new FromEntriesSequence(this); + }, + + get: function get(searchKey, notSetValue) { + return this.find(function (_, key) { return is(key, searchKey); }, undefined, notSetValue); + }, + + getIn: getIn, + + groupBy: function groupBy(grouper, context) { + return groupByFactory(this, grouper, context); + }, + + has: function has(searchKey) { + return this.get(searchKey, NOT_SET) !== NOT_SET; + }, + + hasIn: hasIn, + + isSubset: function isSubset(iter) { + iter = typeof iter.includes === 'function' ? iter : Collection(iter); + return this.every(function (value) { return iter.includes(value); }); + }, + + isSuperset: function isSuperset(iter) { + iter = typeof iter.isSubset === 'function' ? iter : Collection(iter); + return iter.isSubset(this); + }, + + keyOf: function keyOf(searchValue) { + return this.findKey(function (value) { return is(value, searchValue); }); + }, + + keySeq: function keySeq() { + return this.toSeq().map(keyMapper).toIndexedSeq(); + }, + + last: function last(notSetValue) { + return this.toSeq().reverse().first(notSetValue); + }, + + lastKeyOf: function lastKeyOf(searchValue) { + return this.toKeyedSeq().reverse().keyOf(searchValue); + }, + + max: function max(comparator) { + return maxFactory(this, comparator); + }, + + maxBy: function maxBy(mapper, comparator) { + return maxFactory(this, comparator, mapper); + }, + + min: function min(comparator) { + return maxFactory( + this, + comparator ? neg(comparator) : defaultNegComparator + ); + }, + + minBy: function minBy(mapper, comparator) { + return maxFactory( + this, + comparator ? neg(comparator) : defaultNegComparator, + mapper + ); + }, + + rest: function rest() { + return this.slice(1); + }, + + skip: function skip(amount) { + return amount === 0 ? this : this.slice(Math.max(0, amount)); + }, + + skipLast: function skipLast(amount) { + return amount === 0 ? this : this.slice(0, -Math.max(0, amount)); + }, + + skipWhile: function skipWhile(predicate, context) { + return reify(this, skipWhileFactory(this, predicate, context, true)); + }, + + skipUntil: function skipUntil(predicate, context) { + return this.skipWhile(not(predicate), context); + }, + + sortBy: function sortBy(mapper, comparator) { + return reify(this, sortFactory(this, comparator, mapper)); + }, + + take: function take(amount) { + return this.slice(0, Math.max(0, amount)); + }, + + takeLast: function takeLast(amount) { + return this.slice(-Math.max(0, amount)); + }, + + takeWhile: function takeWhile(predicate, context) { + return reify(this, takeWhileFactory(this, predicate, context)); + }, + + takeUntil: function takeUntil(predicate, context) { + return this.takeWhile(not(predicate), context); + }, + + update: function update(fn) { + return fn(this); + }, + + valueSeq: function valueSeq() { + return this.toIndexedSeq(); + }, + + // ### Hashable Object + + hashCode: function hashCode() { + return this.__hash || (this.__hash = hashCollection(this)); + }, + + // ### Internal + + // abstract __iterate(fn, reverse) + + // abstract __iterator(type, reverse) +}); + +var CollectionPrototype = Collection.prototype; +CollectionPrototype[IS_COLLECTION_SYMBOL] = true; +CollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.values; +CollectionPrototype.toJSON = CollectionPrototype.toArray; +CollectionPrototype.__toStringMapper = quoteString; +CollectionPrototype.inspect = CollectionPrototype.toSource = function () { + return this.toString(); +}; +CollectionPrototype.chain = CollectionPrototype.flatMap; +CollectionPrototype.contains = CollectionPrototype.includes; + +mixin(KeyedCollection, { + // ### More sequential methods + + flip: function flip() { + return reify(this, flipFactory(this)); + }, + + mapEntries: function mapEntries(mapper, context) { + var this$1$1 = this; + + var iterations = 0; + return reify( + this, + this.toSeq() + .map(function (v, k) { return mapper.call(context, [k, v], iterations++, this$1$1); }) + .fromEntrySeq() + ); + }, + + mapKeys: function mapKeys(mapper, context) { + var this$1$1 = this; + + return reify( + this, + this.toSeq() + .flip() + .map(function (k, v) { return mapper.call(context, k, v, this$1$1); }) + .flip() + ); + }, +}); + +var KeyedCollectionPrototype = KeyedCollection.prototype; +KeyedCollectionPrototype[IS_KEYED_SYMBOL] = true; +KeyedCollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.entries; +KeyedCollectionPrototype.toJSON = toObject; +KeyedCollectionPrototype.__toStringMapper = function (v, k) { return quoteString(k) + ': ' + quoteString(v); }; + +mixin(IndexedCollection, { + // ### Conversion to other types + + toKeyedSeq: function toKeyedSeq() { + return new ToKeyedSequence(this, false); + }, + + // ### ES6 Collection methods (ES6 Array and Map) + + filter: function filter(predicate, context) { + return reify(this, filterFactory(this, predicate, context, false)); + }, + + findIndex: function findIndex(predicate, context) { + var entry = this.findEntry(predicate, context); + return entry ? entry[0] : -1; + }, + + indexOf: function indexOf(searchValue) { + var key = this.keyOf(searchValue); + return key === undefined ? -1 : key; + }, + + lastIndexOf: function lastIndexOf(searchValue) { + var key = this.lastKeyOf(searchValue); + return key === undefined ? -1 : key; + }, + + reverse: function reverse() { + return reify(this, reverseFactory(this, false)); + }, + + slice: function slice(begin, end) { + return reify(this, sliceFactory(this, begin, end, false)); + }, + + splice: function splice(index, removeNum /*, ...values*/) { + var numArgs = arguments.length; + removeNum = Math.max(removeNum || 0, 0); + if (numArgs === 0 || (numArgs === 2 && !removeNum)) { + return this; + } + // If index is negative, it should resolve relative to the size of the + // collection. However size may be expensive to compute if not cached, so + // only call count() if the number is in fact negative. + index = resolveBegin(index, index < 0 ? this.count() : this.size); + var spliced = this.slice(0, index); + return reify( + this, + numArgs === 1 + ? spliced + : spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum)) + ); + }, + + // ### More collection methods + + findLastIndex: function findLastIndex(predicate, context) { + var entry = this.findLastEntry(predicate, context); + return entry ? entry[0] : -1; + }, + + first: function first(notSetValue) { + return this.get(0, notSetValue); + }, + + flatten: function flatten(depth) { + return reify(this, flattenFactory(this, depth, false)); + }, + + get: function get(index, notSetValue) { + index = wrapIndex(this, index); + return index < 0 || + this.size === Infinity || + (this.size !== undefined && index > this.size) + ? notSetValue + : this.find(function (_, key) { return key === index; }, undefined, notSetValue); + }, + + has: function has(index) { + index = wrapIndex(this, index); + return ( + index >= 0 && + (this.size !== undefined + ? this.size === Infinity || index < this.size + : this.indexOf(index) !== -1) + ); + }, + + interpose: function interpose(separator) { + return reify(this, interposeFactory(this, separator)); + }, + + interleave: function interleave(/*...collections*/) { + var collections = [this].concat(arrCopy(arguments)); + var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, collections); + var interleaved = zipped.flatten(true); + if (zipped.size) { + interleaved.size = zipped.size * collections.length; + } + return reify(this, interleaved); + }, + + keySeq: function keySeq() { + return Range(0, this.size); + }, + + last: function last(notSetValue) { + return this.get(-1, notSetValue); + }, + + skipWhile: function skipWhile(predicate, context) { + return reify(this, skipWhileFactory(this, predicate, context, false)); + }, + + zip: function zip(/*, ...collections */) { + var collections = [this].concat(arrCopy(arguments)); + return reify(this, zipWithFactory(this, defaultZipper, collections)); + }, + + zipAll: function zipAll(/*, ...collections */) { + var collections = [this].concat(arrCopy(arguments)); + return reify(this, zipWithFactory(this, defaultZipper, collections, true)); + }, + + zipWith: function zipWith(zipper /*, ...collections */) { + var collections = arrCopy(arguments); + collections[0] = this; + return reify(this, zipWithFactory(this, zipper, collections)); + }, +}); + +var IndexedCollectionPrototype = IndexedCollection.prototype; +IndexedCollectionPrototype[IS_INDEXED_SYMBOL] = true; +IndexedCollectionPrototype[IS_ORDERED_SYMBOL] = true; + +mixin(SetCollection, { + // ### ES6 Collection methods (ES6 Array and Map) + + get: function get(value, notSetValue) { + return this.has(value) ? value : notSetValue; + }, + + includes: function includes(value) { + return this.has(value); + }, + + // ### More sequential methods + + keySeq: function keySeq() { + return this.valueSeq(); + }, +}); + +var SetCollectionPrototype = SetCollection.prototype; +SetCollectionPrototype.has = CollectionPrototype.includes; +SetCollectionPrototype.contains = SetCollectionPrototype.includes; +SetCollectionPrototype.keys = SetCollectionPrototype.values; + +// Mixin subclasses + +mixin(KeyedSeq, KeyedCollectionPrototype); +mixin(IndexedSeq, IndexedCollectionPrototype); +mixin(SetSeq, SetCollectionPrototype); + +// #pragma Helper functions + +function reduce(collection, reducer, reduction, context, useFirst, reverse) { + assertNotInfinite(collection.size); + collection.__iterate(function (v, k, c) { + if (useFirst) { + useFirst = false; + reduction = v; + } else { + reduction = reducer.call(context, reduction, v, k, c); + } + }, reverse); + return reduction; +} + +function keyMapper(v, k) { + return k; +} + +function entryMapper(v, k) { + return [k, v]; +} + +function not(predicate) { + return function () { + return !predicate.apply(this, arguments); + }; +} + +function neg(predicate) { + return function () { + return -predicate.apply(this, arguments); + }; +} + +function defaultZipper() { + return arrCopy(arguments); +} + +function defaultNegComparator(a, b) { + return a < b ? 1 : a > b ? -1 : 0; +} + +function hashCollection(collection) { + if (collection.size === Infinity) { + return 0; + } + var ordered = isOrdered(collection); + var keyed = isKeyed(collection); + var h = ordered ? 1 : 0; + + collection.__iterate( + keyed + ? ordered + ? function (v, k) { + h = (31 * h + hashMerge(hash(v), hash(k))) | 0; + } + : function (v, k) { + h = (h + hashMerge(hash(v), hash(k))) | 0; + } + : ordered + ? function (v) { + h = (31 * h + hash(v)) | 0; + } + : function (v) { + h = (h + hash(v)) | 0; + } + ); + + return murmurHashOfSize(collection.size, h); +} + +function murmurHashOfSize(size, h) { + h = imul(h, 0xcc9e2d51); + h = imul((h << 15) | (h >>> -15), 0x1b873593); + h = imul((h << 13) | (h >>> -13), 5); + h = ((h + 0xe6546b64) | 0) ^ size; + h = imul(h ^ (h >>> 16), 0x85ebca6b); + h = imul(h ^ (h >>> 13), 0xc2b2ae35); + h = smi(h ^ (h >>> 16)); + return h; +} + +function hashMerge(a, b) { + return (a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2))) | 0; // int +} + +var OrderedSet = /*@__PURE__*/(function (Set) { + function OrderedSet(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptyOrderedSet() + : isOrderedSet(value) + ? value + : emptyOrderedSet().withMutations(function (set) { + var iter = SetCollection(value); + assertNotInfinite(iter.size); + iter.forEach(function (v) { return set.add(v); }); + }); + } + + if ( Set ) OrderedSet.__proto__ = Set; + OrderedSet.prototype = Object.create( Set && Set.prototype ); + OrderedSet.prototype.constructor = OrderedSet; + + OrderedSet.of = function of (/*...values*/) { + return this(arguments); + }; + + OrderedSet.fromKeys = function fromKeys (value) { + return this(KeyedCollection(value).keySeq()); + }; + + OrderedSet.prototype.toString = function toString () { + return this.__toString('OrderedSet {', '}'); + }; + + return OrderedSet; +}(Set)); + +OrderedSet.isOrderedSet = isOrderedSet; + +var OrderedSetPrototype = OrderedSet.prototype; +OrderedSetPrototype[IS_ORDERED_SYMBOL] = true; +OrderedSetPrototype.zip = IndexedCollectionPrototype.zip; +OrderedSetPrototype.zipWith = IndexedCollectionPrototype.zipWith; +OrderedSetPrototype.zipAll = IndexedCollectionPrototype.zipAll; + +OrderedSetPrototype.__empty = emptyOrderedSet; +OrderedSetPrototype.__make = makeOrderedSet; + +function makeOrderedSet(map, ownerID) { + var set = Object.create(OrderedSetPrototype); + set.size = map ? map.size : 0; + set._map = map; + set.__ownerID = ownerID; + return set; +} + +var EMPTY_ORDERED_SET; +function emptyOrderedSet() { + return ( + EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap())) + ); +} + +var PairSorting = { + LeftThenRight: -1, + RightThenLeft: 1, +}; + +function throwOnInvalidDefaultValues(defaultValues) { + if (isRecord(defaultValues)) { + throw new Error( + 'Can not call `Record` with an immutable Record as default values. Use a plain javascript object instead.' + ); + } + + if (isImmutable(defaultValues)) { + throw new Error( + 'Can not call `Record` with an immutable Collection as default values. Use a plain javascript object instead.' + ); + } + + if (defaultValues === null || typeof defaultValues !== 'object') { + throw new Error( + 'Can not call `Record` with a non-object as default values. Use a plain javascript object instead.' + ); + } +} + +var Record = function Record(defaultValues, name) { + var hasInitialized; + + throwOnInvalidDefaultValues(defaultValues); + + var RecordType = function Record(values) { + var this$1$1 = this; + + if (values instanceof RecordType) { + return values; + } + if (!(this instanceof RecordType)) { + return new RecordType(values); + } + if (!hasInitialized) { + hasInitialized = true; + var keys = Object.keys(defaultValues); + var indices = (RecordTypePrototype._indices = {}); + // Deprecated: left to attempt not to break any external code which + // relies on a ._name property existing on record instances. + // Use Record.getDescriptiveName() instead + RecordTypePrototype._name = name; + RecordTypePrototype._keys = keys; + RecordTypePrototype._defaultValues = defaultValues; + for (var i = 0; i < keys.length; i++) { + var propName = keys[i]; + indices[propName] = i; + if (RecordTypePrototype[propName]) { + /* eslint-disable no-console */ + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + typeof console === 'object' && + console.warn && + console.warn( + 'Cannot define ' + + recordName(this) + + ' with property "' + + propName + + '" since that property name is part of the Record API.' + ); + /* eslint-enable no-console */ + } else { + setProp(RecordTypePrototype, propName); + } + } + } + this.__ownerID = undefined; + this._values = List().withMutations(function (l) { + l.setSize(this$1$1._keys.length); + KeyedCollection(values).forEach(function (v, k) { + l.set(this$1$1._indices[k], v === this$1$1._defaultValues[k] ? undefined : v); + }); + }); + return this; + }; + + var RecordTypePrototype = (RecordType.prototype = + Object.create(RecordPrototype)); + RecordTypePrototype.constructor = RecordType; + + if (name) { + RecordType.displayName = name; + } + + // eslint-disable-next-line no-constructor-return + return RecordType; +}; + +Record.prototype.toString = function toString () { + var str = recordName(this) + ' { '; + var keys = this._keys; + var k; + for (var i = 0, l = keys.length; i !== l; i++) { + k = keys[i]; + str += (i ? ', ' : '') + k + ': ' + quoteString(this.get(k)); + } + return str + ' }'; +}; + +Record.prototype.equals = function equals (other) { + return ( + this === other || + (isRecord(other) && recordSeq(this).equals(recordSeq(other))) + ); +}; + +Record.prototype.hashCode = function hashCode () { + return recordSeq(this).hashCode(); +}; + +// @pragma Access + +Record.prototype.has = function has (k) { + return this._indices.hasOwnProperty(k); +}; + +Record.prototype.get = function get (k, notSetValue) { + if (!this.has(k)) { + return notSetValue; + } + var index = this._indices[k]; + var value = this._values.get(index); + return value === undefined ? this._defaultValues[k] : value; +}; + +// @pragma Modification + +Record.prototype.set = function set (k, v) { + if (this.has(k)) { + var newValues = this._values.set( + this._indices[k], + v === this._defaultValues[k] ? undefined : v + ); + if (newValues !== this._values && !this.__ownerID) { + return makeRecord(this, newValues); + } + } + return this; +}; + +Record.prototype.remove = function remove (k) { + return this.set(k); +}; + +Record.prototype.clear = function clear () { + var newValues = this._values.clear().setSize(this._keys.length); + + return this.__ownerID ? this : makeRecord(this, newValues); +}; + +Record.prototype.wasAltered = function wasAltered () { + return this._values.wasAltered(); +}; + +Record.prototype.toSeq = function toSeq () { + return recordSeq(this); +}; + +Record.prototype.toJS = function toJS$1 () { + return toJS(this); +}; + +Record.prototype.entries = function entries () { + return this.__iterator(ITERATE_ENTRIES); +}; + +Record.prototype.__iterator = function __iterator (type, reverse) { + return recordSeq(this).__iterator(type, reverse); +}; + +Record.prototype.__iterate = function __iterate (fn, reverse) { + return recordSeq(this).__iterate(fn, reverse); +}; + +Record.prototype.__ensureOwner = function __ensureOwner (ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + var newValues = this._values.__ensureOwner(ownerID); + if (!ownerID) { + this.__ownerID = ownerID; + this._values = newValues; + return this; + } + return makeRecord(this, newValues, ownerID); +}; + +Record.isRecord = isRecord; +Record.getDescriptiveName = recordName; +var RecordPrototype = Record.prototype; +RecordPrototype[IS_RECORD_SYMBOL] = true; +RecordPrototype[DELETE] = RecordPrototype.remove; +RecordPrototype.deleteIn = RecordPrototype.removeIn = deleteIn; +RecordPrototype.getIn = getIn; +RecordPrototype.hasIn = CollectionPrototype.hasIn; +RecordPrototype.merge = merge$1; +RecordPrototype.mergeWith = mergeWith$1; +RecordPrototype.mergeIn = mergeIn; +RecordPrototype.mergeDeep = mergeDeep; +RecordPrototype.mergeDeepWith = mergeDeepWith; +RecordPrototype.mergeDeepIn = mergeDeepIn; +RecordPrototype.setIn = setIn; +RecordPrototype.update = update; +RecordPrototype.updateIn = updateIn; +RecordPrototype.withMutations = withMutations; +RecordPrototype.asMutable = asMutable; +RecordPrototype.asImmutable = asImmutable; +RecordPrototype[ITERATOR_SYMBOL] = RecordPrototype.entries; +RecordPrototype.toJSON = RecordPrototype.toObject = + CollectionPrototype.toObject; +RecordPrototype.inspect = RecordPrototype.toSource = function () { + return this.toString(); +}; + +function makeRecord(likeRecord, values, ownerID) { + var record = Object.create(Object.getPrototypeOf(likeRecord)); + record._values = values; + record.__ownerID = ownerID; + return record; +} + +function recordName(record) { + return record.constructor.displayName || record.constructor.name || 'Record'; +} + +function recordSeq(record) { + return keyedSeqFromValue(record._keys.map(function (k) { return [k, record.get(k)]; })); +} + +function setProp(prototype, name) { + try { + Object.defineProperty(prototype, name, { + get: function () { + return this.get(name); + }, + set: function (value) { + invariant(this.__ownerID, 'Cannot set on an immutable record.'); + this.set(name, value); + }, + }); + // eslint-disable-next-line @typescript-eslint/no-unused-vars -- TODO enable eslint here + } catch (error) { + // Object.defineProperty failed. Probably IE8. + } +} + +/** + * Returns a lazy Seq of `value` repeated `times` times. When `times` is + * undefined, returns an infinite sequence of `value`. + */ +var Repeat = /*@__PURE__*/(function (IndexedSeq) { + function Repeat(value, times) { + if (!(this instanceof Repeat)) { + // eslint-disable-next-line no-constructor-return + return new Repeat(value, times); + } + this._value = value; + this.size = times === undefined ? Infinity : Math.max(0, times); + if (this.size === 0) { + if (EMPTY_REPEAT) { + // eslint-disable-next-line no-constructor-return + return EMPTY_REPEAT; + } + // eslint-disable-next-line @typescript-eslint/no-this-alias + EMPTY_REPEAT = this; + } + } + + if ( IndexedSeq ) Repeat.__proto__ = IndexedSeq; + Repeat.prototype = Object.create( IndexedSeq && IndexedSeq.prototype ); + Repeat.prototype.constructor = Repeat; + + Repeat.prototype.toString = function toString () { + if (this.size === 0) { + return 'Repeat []'; + } + return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]'; + }; + + Repeat.prototype.get = function get (index, notSetValue) { + return this.has(index) ? this._value : notSetValue; + }; + + Repeat.prototype.includes = function includes (searchValue) { + return is(this._value, searchValue); + }; + + Repeat.prototype.slice = function slice (begin, end) { + var size = this.size; + return wholeSlice(begin, end, size) + ? this + : new Repeat( + this._value, + resolveEnd(end, size) - resolveBegin(begin, size) + ); + }; + + Repeat.prototype.reverse = function reverse () { + return this; + }; + + Repeat.prototype.indexOf = function indexOf (searchValue) { + if (is(this._value, searchValue)) { + return 0; + } + return -1; + }; + + Repeat.prototype.lastIndexOf = function lastIndexOf (searchValue) { + if (is(this._value, searchValue)) { + return this.size; + } + return -1; + }; + + Repeat.prototype.__iterate = function __iterate (fn, reverse) { + var size = this.size; + var i = 0; + while (i !== size) { + if (fn(this._value, reverse ? size - ++i : i++, this) === false) { + break; + } + } + return i; + }; + + Repeat.prototype.__iterator = function __iterator (type, reverse) { + var this$1$1 = this; + + var size = this.size; + var i = 0; + return new Iterator(function () { return i === size + ? iteratorDone() + : iteratorValue(type, reverse ? size - ++i : i++, this$1$1._value); } + ); + }; + + Repeat.prototype.equals = function equals (other) { + return other instanceof Repeat + ? is(this._value, other._value) + : deepEqual(this, other); + }; + + return Repeat; +}(IndexedSeq)); + +var EMPTY_REPEAT; + +function fromJS(value, converter) { + return fromJSWith( + [], + converter || defaultConverter, + value, + '', + converter && converter.length > 2 ? [] : undefined, + { '': value } + ); +} + +function fromJSWith(stack, converter, value, key, keyPath, parentValue) { + if ( + typeof value !== 'string' && + !isImmutable(value) && + (isArrayLike(value) || hasIterator(value) || isPlainObject(value)) + ) { + if (~stack.indexOf(value)) { + throw new TypeError('Cannot convert circular structure to Immutable'); + } + stack.push(value); + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + keyPath && key !== '' && keyPath.push(key); + var converted = converter.call( + parentValue, + key, + Seq(value).map(function (v, k) { return fromJSWith(stack, converter, v, k, keyPath, value); } + ), + keyPath && keyPath.slice() + ); + stack.pop(); + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + keyPath && keyPath.pop(); + return converted; + } + return value; +} + +function defaultConverter(k, v) { + // Effectively the opposite of "Collection.toSeq()" + return isIndexed(v) ? v.toList() : isKeyed(v) ? v.toMap() : v.toSet(); +} + +var version = "5.1.1"; + +// Note: Iterable is deprecated +var Iterable = Collection; + +export { Collection, Iterable, List, Map, OrderedMap, OrderedSet, PairSorting, Range, Record, Repeat, Seq, Set, Stack, fromJS, get, getIn$1 as getIn, has, hasIn$1 as hasIn, hash, is, isAssociative, isCollection, isImmutable, isIndexed, isKeyed, isList, isMap, isOrdered, isOrderedMap, isOrderedSet, isPlainObject, isRecord, isSeq, isSet, isStack, isValueObject, merge, mergeDeep$1 as mergeDeep, mergeDeepWith$1 as mergeDeepWith, mergeWith, remove, removeIn, set, setIn$1 as setIn, update$1 as update, updateIn$1 as updateIn, version }; diff --git a/node_modules/immutable/dist/immutable.js b/node_modules/immutable/dist/immutable.js new file mode 100644 index 0000000..2c024cb --- /dev/null +++ b/node_modules/immutable/dist/immutable.js @@ -0,0 +1,6279 @@ +/** + * @license + * MIT License + * + * Copyright (c) 2014-present, Lee Byron and other contributors. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : + typeof define === 'function' && define.amd ? define(['exports'], factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Immutable = {})); +})(this, (function (exports) { 'use strict'; + + // Used for setting prototype methods that IE8 chokes on. + var DELETE = 'delete'; + // Constants describing the size of trie nodes. + var SHIFT = 5; // Resulted in best performance after ______? + var SIZE = 1 << SHIFT; + var MASK = SIZE - 1; + // A consistent shared value representing "not set" which equals nothing other + // than itself, and nothing that could be provided externally. + var NOT_SET = {}; + // Boolean references, Rough equivalent of `bool &`. + function MakeRef() { + return { value: false }; + } + function SetRef(ref) { + if (ref) { + ref.value = true; + } + } + // A function which returns a value representing an "owner" for transient writes + // to tries. The return value will only ever equal itself, and will not equal + // the return of any subsequent call of this function. + function OwnerID() { } + function ensureSize(iter) { + // @ts-expect-error size should exists on Collection + if (iter.size === undefined) { + // @ts-expect-error size should exists on Collection, __iterate does exist on Collection + iter.size = iter.__iterate(returnTrue); + } + // @ts-expect-error size should exists on Collection + return iter.size; + } + function wrapIndex(iter, index) { + // This implements "is array index" which the ECMAString spec defines as: + // + // A String property name P is an array index if and only if + // ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal + // to 2^32−1. + // + // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects + if (typeof index !== 'number') { + var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32 + if ('' + uint32Index !== index || uint32Index === 4294967295) { + return NaN; + } + index = uint32Index; + } + return index < 0 ? ensureSize(iter) + index : index; + } + function returnTrue() { + return true; + } + function wholeSlice(begin, end, size) { + return (((begin === 0 && !isNeg(begin)) || + (size !== undefined && begin <= -size)) && + (end === undefined || (size !== undefined && end >= size))); + } + function resolveBegin(begin, size) { + return resolveIndex(begin, size, 0); + } + function resolveEnd(end, size) { + return resolveIndex(end, size, size); + } + function resolveIndex(index, size, defaultIndex) { + // Sanitize indices using this shorthand for ToInt32(argument) + // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32 + return index === undefined + ? defaultIndex + : isNeg(index) + ? size === Infinity + ? size + : Math.max(0, size + index) | 0 + : size === undefined || size === index + ? index + : Math.min(size, index) | 0; + } + function isNeg(value) { + // Account for -0 which is negative, but not less than 0. + return value < 0 || (value === 0 && 1 / value === -Infinity); + } + + // Note: value is unchanged to not break immutable-devtools. + var IS_COLLECTION_SYMBOL = '@@__IMMUTABLE_ITERABLE__@@'; + /** + * True if `maybeCollection` is a Collection, or any of its subclasses. + * + * ```js + * import { isCollection, Map, List, Stack } from 'immutable'; + * + * isCollection([]); // false + * isCollection({}); // false + * isCollection(Map()); // true + * isCollection(List()); // true + * isCollection(Stack()); // true + * ``` + */ + function isCollection(maybeCollection) { + return Boolean(maybeCollection && + // @ts-expect-error: maybeCollection is typed as `{}`, need to change in 6.0 to `maybeCollection && typeof maybeCollection === 'object' && IS_COLLECTION_SYMBOL in maybeCollection` + maybeCollection[IS_COLLECTION_SYMBOL]); + } + + var IS_KEYED_SYMBOL = '@@__IMMUTABLE_KEYED__@@'; + /** + * True if `maybeKeyed` is a Collection.Keyed, or any of its subclasses. + * + * ```js + * import { isKeyed, Map, List, Stack } from 'immutable'; + * + * isKeyed([]); // false + * isKeyed({}); // false + * isKeyed(Map()); // true + * isKeyed(List()); // false + * isKeyed(Stack()); // false + * ``` + */ + function isKeyed(maybeKeyed) { + return Boolean(maybeKeyed && + // @ts-expect-error: maybeKeyed is typed as `{}`, need to change in 6.0 to `maybeKeyed && typeof maybeKeyed === 'object' && IS_KEYED_SYMBOL in maybeKeyed` + maybeKeyed[IS_KEYED_SYMBOL]); + } + + var IS_INDEXED_SYMBOL = '@@__IMMUTABLE_INDEXED__@@'; + /** + * True if `maybeIndexed` is a Collection.Indexed, or any of its subclasses. + * + * ```js + * import { isIndexed, Map, List, Stack, Set } from 'immutable'; + * + * isIndexed([]); // false + * isIndexed({}); // false + * isIndexed(Map()); // false + * isIndexed(List()); // true + * isIndexed(Stack()); // true + * isIndexed(Set()); // false + * ``` + */ + function isIndexed(maybeIndexed) { + return Boolean(maybeIndexed && + // @ts-expect-error: maybeIndexed is typed as `{}`, need to change in 6.0 to `maybeIndexed && typeof maybeIndexed === 'object' && IS_INDEXED_SYMBOL in maybeIndexed` + maybeIndexed[IS_INDEXED_SYMBOL]); + } + + /** + * True if `maybeAssociative` is either a Keyed or Indexed Collection. + * + * ```js + * import { isAssociative, Map, List, Stack, Set } from 'immutable'; + * + * isAssociative([]); // false + * isAssociative({}); // false + * isAssociative(Map()); // true + * isAssociative(List()); // true + * isAssociative(Stack()); // true + * isAssociative(Set()); // false + * ``` + */ + function isAssociative(maybeAssociative) { + return isKeyed(maybeAssociative) || isIndexed(maybeAssociative); + } + + var Collection = function Collection(value) { + // eslint-disable-next-line no-constructor-return + return isCollection(value) ? value : Seq(value); + }; + + var KeyedCollection = /*@__PURE__*/(function (Collection) { + function KeyedCollection(value) { + // eslint-disable-next-line no-constructor-return + return isKeyed(value) ? value : KeyedSeq(value); + } + + if ( Collection ) KeyedCollection.__proto__ = Collection; + KeyedCollection.prototype = Object.create( Collection && Collection.prototype ); + KeyedCollection.prototype.constructor = KeyedCollection; + + return KeyedCollection; + }(Collection)); + + var IndexedCollection = /*@__PURE__*/(function (Collection) { + function IndexedCollection(value) { + // eslint-disable-next-line no-constructor-return + return isIndexed(value) ? value : IndexedSeq(value); + } + + if ( Collection ) IndexedCollection.__proto__ = Collection; + IndexedCollection.prototype = Object.create( Collection && Collection.prototype ); + IndexedCollection.prototype.constructor = IndexedCollection; + + return IndexedCollection; + }(Collection)); + + var SetCollection = /*@__PURE__*/(function (Collection) { + function SetCollection(value) { + // eslint-disable-next-line no-constructor-return + return isCollection(value) && !isAssociative(value) ? value : SetSeq(value); + } + + if ( Collection ) SetCollection.__proto__ = Collection; + SetCollection.prototype = Object.create( Collection && Collection.prototype ); + SetCollection.prototype.constructor = SetCollection; + + return SetCollection; + }(Collection)); + + Collection.Keyed = KeyedCollection; + Collection.Indexed = IndexedCollection; + Collection.Set = SetCollection; + + var IS_SEQ_SYMBOL = '@@__IMMUTABLE_SEQ__@@'; + /** + * True if `maybeSeq` is a Seq. + */ + function isSeq(maybeSeq) { + return Boolean(maybeSeq && + // @ts-expect-error: maybeSeq is typed as `{}`, need to change in 6.0 to `maybeSeq && typeof maybeSeq === 'object' && MAYBE_SEQ_SYMBOL in maybeSeq` + maybeSeq[IS_SEQ_SYMBOL]); + } + + var IS_RECORD_SYMBOL = '@@__IMMUTABLE_RECORD__@@'; + /** + * True if `maybeRecord` is a Record. + */ + function isRecord(maybeRecord) { + return Boolean(maybeRecord && + // @ts-expect-error: maybeRecord is typed as `{}`, need to change in 6.0 to `maybeRecord && typeof maybeRecord === 'object' && IS_RECORD_SYMBOL in maybeRecord` + maybeRecord[IS_RECORD_SYMBOL]); + } + + /** + * True if `maybeImmutable` is an Immutable Collection or Record. + * + * Note: Still returns true even if the collections is within a `withMutations()`. + * + * ```js + * import { isImmutable, Map, List, Stack } from 'immutable'; + * isImmutable([]); // false + * isImmutable({}); // false + * isImmutable(Map()); // true + * isImmutable(List()); // true + * isImmutable(Stack()); // true + * isImmutable(Map().asMutable()); // true + * ``` + */ + function isImmutable(maybeImmutable) { + return isCollection(maybeImmutable) || isRecord(maybeImmutable); + } + + var IS_ORDERED_SYMBOL = '@@__IMMUTABLE_ORDERED__@@'; + function isOrdered(maybeOrdered) { + return Boolean(maybeOrdered && + // @ts-expect-error: maybeOrdered is typed as `{}`, need to change in 6.0 to `maybeOrdered && typeof maybeOrdered === 'object' && IS_ORDERED_SYMBOL in maybeOrdered` + maybeOrdered[IS_ORDERED_SYMBOL]); + } + + var ITERATE_KEYS = 0; + var ITERATE_VALUES = 1; + var ITERATE_ENTRIES = 2; + + var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator; + var FAUX_ITERATOR_SYMBOL = '@@iterator'; + + var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL; + + var Iterator = function Iterator(next) { + this.next = next; + }; + + Iterator.prototype.toString = function toString () { + return '[Iterator]'; + }; + + Iterator.KEYS = ITERATE_KEYS; + Iterator.VALUES = ITERATE_VALUES; + Iterator.ENTRIES = ITERATE_ENTRIES; + + Iterator.prototype.inspect = Iterator.prototype.toSource = function () { + return this.toString(); + }; + Iterator.prototype[ITERATOR_SYMBOL] = function () { + return this; + }; + + function iteratorValue(type, k, v, iteratorResult) { + var value = + type === ITERATE_KEYS ? k : type === ITERATE_VALUES ? v : [k, v]; + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + iteratorResult + ? (iteratorResult.value = value) + : (iteratorResult = { + value: value, + done: false, + }); + return iteratorResult; + } + + function iteratorDone() { + return { value: undefined, done: true }; + } + + function hasIterator(maybeIterable) { + if (Array.isArray(maybeIterable)) { + // IE11 trick as it does not support `Symbol.iterator` + return true; + } + + return !!getIteratorFn(maybeIterable); + } + + function isIterator(maybeIterator) { + return maybeIterator && typeof maybeIterator.next === 'function'; + } + + function getIterator(iterable) { + var iteratorFn = getIteratorFn(iterable); + return iteratorFn && iteratorFn.call(iterable); + } + + function getIteratorFn(iterable) { + var iteratorFn = + iterable && + ((REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) || + iterable[FAUX_ITERATOR_SYMBOL]); + if (typeof iteratorFn === 'function') { + return iteratorFn; + } + } + + function isEntriesIterable(maybeIterable) { + var iteratorFn = getIteratorFn(maybeIterable); + return iteratorFn && iteratorFn === maybeIterable.entries; + } + + function isKeysIterable(maybeIterable) { + var iteratorFn = getIteratorFn(maybeIterable); + return iteratorFn && iteratorFn === maybeIterable.keys; + } + + var hasOwnProperty = Object.prototype.hasOwnProperty; + + function isArrayLike(value) { + if (Array.isArray(value) || typeof value === 'string') { + return true; + } + // @ts-expect-error "Type 'unknown' is not assignable to type 'boolean'" : convert to Boolean + return (value && + typeof value === 'object' && + // @ts-expect-error check that `'length' in value &&` + Number.isInteger(value.length) && + // @ts-expect-error check that `'length' in value &&` + value.length >= 0 && + // @ts-expect-error check that `'length' in value &&` + (value.length === 0 + ? // Only {length: 0} is considered Array-like. + Object.keys(value).length === 1 + : // An object is only Array-like if it has a property where the last value + // in the array-like may be found (which could be undefined). + // @ts-expect-error check that `'length' in value &&` + value.hasOwnProperty(value.length - 1))); + } + + var Seq = /*@__PURE__*/(function (Collection) { + function Seq(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptySequence() + : isImmutable(value) + ? value.toSeq() + : seqFromValue(value); + } + + if ( Collection ) Seq.__proto__ = Collection; + Seq.prototype = Object.create( Collection && Collection.prototype ); + Seq.prototype.constructor = Seq; + + Seq.prototype.toSeq = function toSeq () { + return this; + }; + + Seq.prototype.toString = function toString () { + return this.__toString('Seq {', '}'); + }; + + Seq.prototype.cacheResult = function cacheResult () { + if (!this._cache && this.__iterateUncached) { + this._cache = this.entrySeq().toArray(); + this.size = this._cache.length; + } + return this; + }; + + // abstract __iterateUncached(fn, reverse) + + Seq.prototype.__iterate = function __iterate (fn, reverse) { + var cache = this._cache; + if (cache) { + var size = cache.length; + var i = 0; + while (i !== size) { + var entry = cache[reverse ? size - ++i : i++]; + if (fn(entry[1], entry[0], this) === false) { + break; + } + } + return i; + } + return this.__iterateUncached(fn, reverse); + }; + + // abstract __iteratorUncached(type, reverse) + + Seq.prototype.__iterator = function __iterator (type, reverse) { + var cache = this._cache; + if (cache) { + var size = cache.length; + var i = 0; + return new Iterator(function () { + if (i === size) { + return iteratorDone(); + } + var entry = cache[reverse ? size - ++i : i++]; + return iteratorValue(type, entry[0], entry[1]); + }); + } + return this.__iteratorUncached(type, reverse); + }; + + return Seq; + }(Collection)); + + var KeyedSeq = /*@__PURE__*/(function (Seq) { + function KeyedSeq(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptySequence().toKeyedSeq() + : isCollection(value) + ? isKeyed(value) + ? value.toSeq() + : value.fromEntrySeq() + : isRecord(value) + ? value.toSeq() + : keyedSeqFromValue(value); + } + + if ( Seq ) KeyedSeq.__proto__ = Seq; + KeyedSeq.prototype = Object.create( Seq && Seq.prototype ); + KeyedSeq.prototype.constructor = KeyedSeq; + + KeyedSeq.prototype.toKeyedSeq = function toKeyedSeq () { + return this; + }; + + return KeyedSeq; + }(Seq)); + + var IndexedSeq = /*@__PURE__*/(function (Seq) { + function IndexedSeq(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptySequence() + : isCollection(value) + ? isKeyed(value) + ? value.entrySeq() + : value.toIndexedSeq() + : isRecord(value) + ? value.toSeq().entrySeq() + : indexedSeqFromValue(value); + } + + if ( Seq ) IndexedSeq.__proto__ = Seq; + IndexedSeq.prototype = Object.create( Seq && Seq.prototype ); + IndexedSeq.prototype.constructor = IndexedSeq; + + IndexedSeq.of = function of (/*...values*/) { + return IndexedSeq(arguments); + }; + + IndexedSeq.prototype.toIndexedSeq = function toIndexedSeq () { + return this; + }; + + IndexedSeq.prototype.toString = function toString () { + return this.__toString('Seq [', ']'); + }; + + return IndexedSeq; + }(Seq)); + + var SetSeq = /*@__PURE__*/(function (Seq) { + function SetSeq(value) { + // eslint-disable-next-line no-constructor-return + return ( + isCollection(value) && !isAssociative(value) ? value : IndexedSeq(value) + ).toSetSeq(); + } + + if ( Seq ) SetSeq.__proto__ = Seq; + SetSeq.prototype = Object.create( Seq && Seq.prototype ); + SetSeq.prototype.constructor = SetSeq; + + SetSeq.of = function of (/*...values*/) { + return SetSeq(arguments); + }; + + SetSeq.prototype.toSetSeq = function toSetSeq () { + return this; + }; + + return SetSeq; + }(Seq)); + + Seq.isSeq = isSeq; + Seq.Keyed = KeyedSeq; + Seq.Set = SetSeq; + Seq.Indexed = IndexedSeq; + + Seq.prototype[IS_SEQ_SYMBOL] = true; + + // #pragma Root Sequences + + var ArraySeq = /*@__PURE__*/(function (IndexedSeq) { + function ArraySeq(array) { + this._array = array; + this.size = array.length; + } + + if ( IndexedSeq ) ArraySeq.__proto__ = IndexedSeq; + ArraySeq.prototype = Object.create( IndexedSeq && IndexedSeq.prototype ); + ArraySeq.prototype.constructor = ArraySeq; + + ArraySeq.prototype.get = function get (index, notSetValue) { + return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue; + }; + + ArraySeq.prototype.__iterate = function __iterate (fn, reverse) { + var array = this._array; + var size = array.length; + var i = 0; + while (i !== size) { + var ii = reverse ? size - ++i : i++; + if (fn(array[ii], ii, this) === false) { + break; + } + } + return i; + }; + + ArraySeq.prototype.__iterator = function __iterator (type, reverse) { + var array = this._array; + var size = array.length; + var i = 0; + return new Iterator(function () { + if (i === size) { + return iteratorDone(); + } + var ii = reverse ? size - ++i : i++; + return iteratorValue(type, ii, array[ii]); + }); + }; + + return ArraySeq; + }(IndexedSeq)); + + var ObjectSeq = /*@__PURE__*/(function (KeyedSeq) { + function ObjectSeq(object) { + var keys = Object.keys(object).concat( + Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : [] + ); + this._object = object; + this._keys = keys; + this.size = keys.length; + } + + if ( KeyedSeq ) ObjectSeq.__proto__ = KeyedSeq; + ObjectSeq.prototype = Object.create( KeyedSeq && KeyedSeq.prototype ); + ObjectSeq.prototype.constructor = ObjectSeq; + + ObjectSeq.prototype.get = function get (key, notSetValue) { + if (notSetValue !== undefined && !this.has(key)) { + return notSetValue; + } + return this._object[key]; + }; + + ObjectSeq.prototype.has = function has (key) { + return hasOwnProperty.call(this._object, key); + }; + + ObjectSeq.prototype.__iterate = function __iterate (fn, reverse) { + var object = this._object; + var keys = this._keys; + var size = keys.length; + var i = 0; + while (i !== size) { + var key = keys[reverse ? size - ++i : i++]; + if (fn(object[key], key, this) === false) { + break; + } + } + return i; + }; + + ObjectSeq.prototype.__iterator = function __iterator (type, reverse) { + var object = this._object; + var keys = this._keys; + var size = keys.length; + var i = 0; + return new Iterator(function () { + if (i === size) { + return iteratorDone(); + } + var key = keys[reverse ? size - ++i : i++]; + return iteratorValue(type, key, object[key]); + }); + }; + + return ObjectSeq; + }(KeyedSeq)); + ObjectSeq.prototype[IS_ORDERED_SYMBOL] = true; + + var CollectionSeq = /*@__PURE__*/(function (IndexedSeq) { + function CollectionSeq(collection) { + this._collection = collection; + this.size = collection.length || collection.size; + } + + if ( IndexedSeq ) CollectionSeq.__proto__ = IndexedSeq; + CollectionSeq.prototype = Object.create( IndexedSeq && IndexedSeq.prototype ); + CollectionSeq.prototype.constructor = CollectionSeq; + + CollectionSeq.prototype.__iterateUncached = function __iterateUncached (fn, reverse) { + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var collection = this._collection; + var iterator = getIterator(collection); + var iterations = 0; + if (isIterator(iterator)) { + var step; + while (!(step = iterator.next()).done) { + if (fn(step.value, iterations++, this) === false) { + break; + } + } + } + return iterations; + }; + + CollectionSeq.prototype.__iteratorUncached = function __iteratorUncached (type, reverse) { + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + var collection = this._collection; + var iterator = getIterator(collection); + if (!isIterator(iterator)) { + return new Iterator(iteratorDone); + } + var iterations = 0; + return new Iterator(function () { + var step = iterator.next(); + return step.done ? step : iteratorValue(type, iterations++, step.value); + }); + }; + + return CollectionSeq; + }(IndexedSeq)); + + // # pragma Helper functions + + var EMPTY_SEQ; + + function emptySequence() { + return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([])); + } + + function keyedSeqFromValue(value) { + var seq = maybeIndexedSeqFromValue(value); + if (seq) { + return seq.fromEntrySeq(); + } + if (typeof value === 'object') { + return new ObjectSeq(value); + } + throw new TypeError( + 'Expected Array or collection object of [k, v] entries, or keyed object: ' + + value + ); + } + + function indexedSeqFromValue(value) { + var seq = maybeIndexedSeqFromValue(value); + if (seq) { + return seq; + } + throw new TypeError( + 'Expected Array or collection object of values: ' + value + ); + } + + function seqFromValue(value) { + var seq = maybeIndexedSeqFromValue(value); + if (seq) { + return isEntriesIterable(value) + ? seq.fromEntrySeq() + : isKeysIterable(value) + ? seq.toSetSeq() + : seq; + } + if (typeof value === 'object') { + return new ObjectSeq(value); + } + throw new TypeError( + 'Expected Array or collection object of values, or keyed object: ' + value + ); + } + + function maybeIndexedSeqFromValue(value) { + return isArrayLike(value) + ? new ArraySeq(value) + : hasIterator(value) + ? new CollectionSeq(value) + : undefined; + } + + var IS_MAP_SYMBOL = '@@__IMMUTABLE_MAP__@@'; + /** + * True if `maybeMap` is a Map. + * + * Also true for OrderedMaps. + */ + function isMap(maybeMap) { + return Boolean(maybeMap && + // @ts-expect-error: maybeMap is typed as `{}`, need to change in 6.0 to `maybeMap && typeof maybeMap === 'object' && IS_MAP_SYMBOL in maybeMap` + maybeMap[IS_MAP_SYMBOL]); + } + + /** + * True if `maybeOrderedMap` is an OrderedMap. + */ + function isOrderedMap(maybeOrderedMap) { + return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap); + } + + /** + * True if `maybeValue` is a JavaScript Object which has *both* `equals()` + * and `hashCode()` methods. + * + * Any two instances of *value objects* can be compared for value equality with + * `Immutable.is()` and can be used as keys in a `Map` or members in a `Set`. + */ + function isValueObject(maybeValue) { + return Boolean(maybeValue && + // @ts-expect-error: maybeValue is typed as `{}` + typeof maybeValue.equals === 'function' && + // @ts-expect-error: maybeValue is typed as `{}` + typeof maybeValue.hashCode === 'function'); + } + + /** + * An extension of the "same-value" algorithm as [described for use by ES6 Map + * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality) + * + * NaN is considered the same as NaN, however -0 and 0 are considered the same + * value, which is different from the algorithm described by + * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). + * + * This is extended further to allow Objects to describe the values they + * represent, by way of `valueOf` or `equals` (and `hashCode`). + * + * Note: because of this extension, the key equality of Immutable.Map and the + * value equality of Immutable.Set will differ from ES6 Map and Set. + * + * ### Defining custom values + * + * The easiest way to describe the value an object represents is by implementing + * `valueOf`. For example, `Date` represents a value by returning a unix + * timestamp for `valueOf`: + * + * var date1 = new Date(1234567890000); // Fri Feb 13 2009 ... + * var date2 = new Date(1234567890000); + * date1.valueOf(); // 1234567890000 + * assert( date1 !== date2 ); + * assert( Immutable.is( date1, date2 ) ); + * + * Note: overriding `valueOf` may have other implications if you use this object + * where JavaScript expects a primitive, such as implicit string coercion. + * + * For more complex types, especially collections, implementing `valueOf` may + * not be performant. An alternative is to implement `equals` and `hashCode`. + * + * `equals` takes another object, presumably of similar type, and returns true + * if it is equal. Equality is symmetrical, so the same result should be + * returned if this and the argument are flipped. + * + * assert( a.equals(b) === b.equals(a) ); + * + * `hashCode` returns a 32bit integer number representing the object which will + * be used to determine how to store the value object in a Map or Set. You must + * provide both or neither methods, one must not exist without the other. + * + * Also, an important relationship between these methods must be upheld: if two + * values are equal, they *must* return the same hashCode. If the values are not + * equal, they might have the same hashCode; this is called a hash collision, + * and while undesirable for performance reasons, it is acceptable. + * + * if (a.equals(b)) { + * assert( a.hashCode() === b.hashCode() ); + * } + * + * All Immutable collections are Value Objects: they implement `equals()` + * and `hashCode()`. + */ + function is(valueA, valueB) { + if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) { + return true; + } + if (!valueA || !valueB) { + return false; + } + if (typeof valueA.valueOf === 'function' && + typeof valueB.valueOf === 'function') { + valueA = valueA.valueOf(); + valueB = valueB.valueOf(); + if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) { + return true; + } + if (!valueA || !valueB) { + return false; + } + } + return !!(isValueObject(valueA) && + isValueObject(valueB) && + valueA.equals(valueB)); + } + + var imul = + typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2 + ? Math.imul + : function imul(a, b) { + a |= 0; // int + b |= 0; // int + var c = a & 0xffff; + var d = b & 0xffff; + // Shift by 0 fixes the sign on the high part. + return (c * d + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0)) | 0; // int + }; + + // v8 has an optimization for storing 31-bit signed numbers. + // Values which have either 00 or 11 as the high order bits qualify. + // This function drops the highest order bit in a signed number, maintaining + // the sign bit. + function smi(i32) { + return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff); + } + + var defaultValueOf = Object.prototype.valueOf; + + function hash(o) { + // eslint-disable-next-line eqeqeq + if (o == null) { + return hashNullish(o); + } + + if (typeof o.hashCode === 'function') { + // Drop any high bits from accidentally long hash codes. + return smi(o.hashCode(o)); + } + + var v = valueOf(o); + + // eslint-disable-next-line eqeqeq + if (v == null) { + return hashNullish(v); + } + + switch (typeof v) { + case 'boolean': + // The hash values for built-in constants are a 1 value for each 5-byte + // shift region expect for the first, which encodes the value. This + // reduces the odds of a hash collision for these common values. + return v ? 0x42108421 : 0x42108420; + case 'number': + return hashNumber(v); + case 'string': + return v.length > STRING_HASH_CACHE_MIN_STRLEN + ? cachedHashString(v) + : hashString(v); + case 'object': + case 'function': + return hashJSObj(v); + case 'symbol': + return hashSymbol(v); + default: + if (typeof v.toString === 'function') { + return hashString(v.toString()); + } + throw new Error('Value type ' + typeof v + ' cannot be hashed.'); + } + } + + function hashNullish(nullish) { + return nullish === null ? 0x42108422 : /* undefined */ 0x42108423; + } + + // Compress arbitrarily large numbers into smi hashes. + function hashNumber(n) { + if (n !== n || n === Infinity) { + return 0; + } + var hash = n | 0; + if (hash !== n) { + hash ^= n * 0xffffffff; + } + while (n > 0xffffffff) { + n /= 0xffffffff; + hash ^= n; + } + return smi(hash); + } + + function cachedHashString(string) { + var hashed = stringHashCache[string]; + if (hashed === undefined) { + hashed = hashString(string); + if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) { + STRING_HASH_CACHE_SIZE = 0; + stringHashCache = {}; + } + STRING_HASH_CACHE_SIZE++; + stringHashCache[string] = hashed; + } + return hashed; + } + + // http://jsperf.com/hashing-strings + function hashString(string) { + // This is the hash from JVM + // The hash code for a string is computed as + // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1], + // where s[i] is the ith character of the string and n is the length of + // the string. We "mod" the result to make it between 0 (inclusive) and 2^31 + // (exclusive) by dropping high bits. + var hashed = 0; + for (var ii = 0; ii < string.length; ii++) { + hashed = (31 * hashed + string.charCodeAt(ii)) | 0; + } + return smi(hashed); + } + + function hashSymbol(sym) { + var hashed = symbolMap[sym]; + if (hashed !== undefined) { + return hashed; + } + + hashed = nextHash(); + + symbolMap[sym] = hashed; + + return hashed; + } + + function hashJSObj(obj) { + var hashed; + if (usingWeakMap) { + hashed = weakMap.get(obj); + if (hashed !== undefined) { + return hashed; + } + } + + hashed = obj[UID_HASH_KEY]; + if (hashed !== undefined) { + return hashed; + } + + if (!canDefineProperty) { + hashed = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY]; + if (hashed !== undefined) { + return hashed; + } + + hashed = getIENodeHash(obj); + if (hashed !== undefined) { + return hashed; + } + } + + hashed = nextHash(); + + if (usingWeakMap) { + weakMap.set(obj, hashed); + } else if (isExtensible !== undefined && isExtensible(obj) === false) { + throw new Error('Non-extensible objects are not allowed as keys.'); + } else if (canDefineProperty) { + Object.defineProperty(obj, UID_HASH_KEY, { + enumerable: false, + configurable: false, + writable: false, + value: hashed, + }); + } else if ( + obj.propertyIsEnumerable !== undefined && + obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable + ) { + // Since we can't define a non-enumerable property on the object + // we'll hijack one of the less-used non-enumerable properties to + // save our hash on it. Since this is a function it will not show up in + // `JSON.stringify` which is what we want. + obj.propertyIsEnumerable = function () { + return this.constructor.prototype.propertyIsEnumerable.apply( + this, + arguments + ); + }; + obj.propertyIsEnumerable[UID_HASH_KEY] = hashed; + } else if (obj.nodeType !== undefined) { + // At this point we couldn't get the IE `uniqueID` to use as a hash + // and we couldn't use a non-enumerable property to exploit the + // dontEnum bug so we simply add the `UID_HASH_KEY` on the node + // itself. + obj[UID_HASH_KEY] = hashed; + } else { + throw new Error('Unable to set a non-enumerable property on object.'); + } + + return hashed; + } + + // Get references to ES5 object methods. + var isExtensible = Object.isExtensible; + + // True if Object.defineProperty works as expected. IE8 fails this test. + var canDefineProperty = (function () { + try { + Object.defineProperty({}, '@', {}); + return true; + // eslint-disable-next-line @typescript-eslint/no-unused-vars + } catch (e) { + return false; + } + })(); + + // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it + // and avoid memory leaks from the IE cloneNode bug. + function getIENodeHash(node) { + if (node && node.nodeType > 0) { + switch (node.nodeType) { + case 1: // Element + return node.uniqueID; + case 9: // Document + return node.documentElement && node.documentElement.uniqueID; + } + } + } + + function valueOf(obj) { + return obj.valueOf !== defaultValueOf && typeof obj.valueOf === 'function' + ? obj.valueOf(obj) + : obj; + } + + function nextHash() { + var nextHash = ++_objHashUID; + if (_objHashUID & 0x40000000) { + _objHashUID = 0; + } + return nextHash; + } + + // If possible, use a WeakMap. + var usingWeakMap = typeof WeakMap === 'function'; + var weakMap; + if (usingWeakMap) { + weakMap = new WeakMap(); + } + + var symbolMap = Object.create(null); + + var _objHashUID = 0; + + var UID_HASH_KEY = '__immutablehash__'; + if (typeof Symbol === 'function') { + UID_HASH_KEY = Symbol(UID_HASH_KEY); + } + + var STRING_HASH_CACHE_MIN_STRLEN = 16; + var STRING_HASH_CACHE_MAX_SIZE = 255; + var STRING_HASH_CACHE_SIZE = 0; + var stringHashCache = {}; + + var ToKeyedSequence = /*@__PURE__*/(function (KeyedSeq) { + function ToKeyedSequence(indexed, useKeys) { + this._iter = indexed; + this._useKeys = useKeys; + this.size = indexed.size; + } + + if ( KeyedSeq ) ToKeyedSequence.__proto__ = KeyedSeq; + ToKeyedSequence.prototype = Object.create( KeyedSeq && KeyedSeq.prototype ); + ToKeyedSequence.prototype.constructor = ToKeyedSequence; + + ToKeyedSequence.prototype.get = function get (key, notSetValue) { + return this._iter.get(key, notSetValue); + }; + + ToKeyedSequence.prototype.has = function has (key) { + return this._iter.has(key); + }; + + ToKeyedSequence.prototype.valueSeq = function valueSeq () { + return this._iter.valueSeq(); + }; + + ToKeyedSequence.prototype.reverse = function reverse () { + var this$1$1 = this; + + var reversedSequence = reverseFactory(this, true); + if (!this._useKeys) { + reversedSequence.valueSeq = function () { return this$1$1._iter.toSeq().reverse(); }; + } + return reversedSequence; + }; + + ToKeyedSequence.prototype.map = function map (mapper, context) { + var this$1$1 = this; + + var mappedSequence = mapFactory(this, mapper, context); + if (!this._useKeys) { + mappedSequence.valueSeq = function () { return this$1$1._iter.toSeq().map(mapper, context); }; + } + return mappedSequence; + }; + + ToKeyedSequence.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + return this._iter.__iterate(function (v, k) { return fn(v, k, this$1$1); }, reverse); + }; + + ToKeyedSequence.prototype.__iterator = function __iterator (type, reverse) { + return this._iter.__iterator(type, reverse); + }; + + return ToKeyedSequence; + }(KeyedSeq)); + ToKeyedSequence.prototype[IS_ORDERED_SYMBOL] = true; + + var ToIndexedSequence = /*@__PURE__*/(function (IndexedSeq) { + function ToIndexedSequence(iter) { + this._iter = iter; + this.size = iter.size; + } + + if ( IndexedSeq ) ToIndexedSequence.__proto__ = IndexedSeq; + ToIndexedSequence.prototype = Object.create( IndexedSeq && IndexedSeq.prototype ); + ToIndexedSequence.prototype.constructor = ToIndexedSequence; + + ToIndexedSequence.prototype.includes = function includes (value) { + return this._iter.includes(value); + }; + + ToIndexedSequence.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + var i = 0; + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + reverse && ensureSize(this); + return this._iter.__iterate( + function (v) { return fn(v, reverse ? this$1$1.size - ++i : i++, this$1$1); }, + reverse + ); + }; + + ToIndexedSequence.prototype.__iterator = function __iterator (type, reverse) { + var this$1$1 = this; + + var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); + var i = 0; + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + reverse && ensureSize(this); + return new Iterator(function () { + var step = iterator.next(); + return step.done + ? step + : iteratorValue( + type, + reverse ? this$1$1.size - ++i : i++, + step.value, + step + ); + }); + }; + + return ToIndexedSequence; + }(IndexedSeq)); + + var ToSetSequence = /*@__PURE__*/(function (SetSeq) { + function ToSetSequence(iter) { + this._iter = iter; + this.size = iter.size; + } + + if ( SetSeq ) ToSetSequence.__proto__ = SetSeq; + ToSetSequence.prototype = Object.create( SetSeq && SetSeq.prototype ); + ToSetSequence.prototype.constructor = ToSetSequence; + + ToSetSequence.prototype.has = function has (key) { + return this._iter.includes(key); + }; + + ToSetSequence.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + return this._iter.__iterate(function (v) { return fn(v, v, this$1$1); }, reverse); + }; + + ToSetSequence.prototype.__iterator = function __iterator (type, reverse) { + var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); + return new Iterator(function () { + var step = iterator.next(); + return step.done + ? step + : iteratorValue(type, step.value, step.value, step); + }); + }; + + return ToSetSequence; + }(SetSeq)); + + var FromEntriesSequence = /*@__PURE__*/(function (KeyedSeq) { + function FromEntriesSequence(entries) { + this._iter = entries; + this.size = entries.size; + } + + if ( KeyedSeq ) FromEntriesSequence.__proto__ = KeyedSeq; + FromEntriesSequence.prototype = Object.create( KeyedSeq && KeyedSeq.prototype ); + FromEntriesSequence.prototype.constructor = FromEntriesSequence; + + FromEntriesSequence.prototype.entrySeq = function entrySeq () { + return this._iter.toSeq(); + }; + + FromEntriesSequence.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + return this._iter.__iterate(function (entry) { + // Check if entry exists first so array access doesn't throw for holes + // in the parent iteration. + if (entry) { + validateEntry(entry); + var indexedCollection = isCollection(entry); + return fn( + indexedCollection ? entry.get(1) : entry[1], + indexedCollection ? entry.get(0) : entry[0], + this$1$1 + ); + } + }, reverse); + }; + + FromEntriesSequence.prototype.__iterator = function __iterator (type, reverse) { + var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); + return new Iterator(function () { + while (true) { + var step = iterator.next(); + if (step.done) { + return step; + } + var entry = step.value; + // Check if entry exists first so array access doesn't throw for holes + // in the parent iteration. + if (entry) { + validateEntry(entry); + var indexedCollection = isCollection(entry); + return iteratorValue( + type, + indexedCollection ? entry.get(0) : entry[0], + indexedCollection ? entry.get(1) : entry[1], + step + ); + } + } + }); + }; + + return FromEntriesSequence; + }(KeyedSeq)); + + ToIndexedSequence.prototype.cacheResult = + ToKeyedSequence.prototype.cacheResult = + ToSetSequence.prototype.cacheResult = + FromEntriesSequence.prototype.cacheResult = + cacheResultThrough; + + function flipFactory(collection) { + var flipSequence = makeSequence(collection); + flipSequence._iter = collection; + flipSequence.size = collection.size; + flipSequence.flip = function () { return collection; }; + flipSequence.reverse = function () { + var reversedSequence = collection.reverse.apply(this); // super.reverse() + reversedSequence.flip = function () { return collection.reverse(); }; + return reversedSequence; + }; + flipSequence.has = function (key) { return collection.includes(key); }; + flipSequence.includes = function (key) { return collection.has(key); }; + flipSequence.cacheResult = cacheResultThrough; + flipSequence.__iterateUncached = function (fn, reverse) { + var this$1$1 = this; + + return collection.__iterate(function (v, k) { return fn(k, v, this$1$1) !== false; }, reverse); + }; + flipSequence.__iteratorUncached = function (type, reverse) { + if (type === ITERATE_ENTRIES) { + var iterator = collection.__iterator(type, reverse); + return new Iterator(function () { + var step = iterator.next(); + if (!step.done) { + var k = step.value[0]; + step.value[0] = step.value[1]; + step.value[1] = k; + } + return step; + }); + } + return collection.__iterator( + type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES, + reverse + ); + }; + return flipSequence; + } + + function mapFactory(collection, mapper, context) { + var mappedSequence = makeSequence(collection); + mappedSequence.size = collection.size; + mappedSequence.has = function (key) { return collection.has(key); }; + mappedSequence.get = function (key, notSetValue) { + var v = collection.get(key, NOT_SET); + return v === NOT_SET + ? notSetValue + : mapper.call(context, v, key, collection); + }; + mappedSequence.__iterateUncached = function (fn, reverse) { + var this$1$1 = this; + + return collection.__iterate( + function (v, k, c) { return fn(mapper.call(context, v, k, c), k, this$1$1) !== false; }, + reverse + ); + }; + mappedSequence.__iteratorUncached = function (type, reverse) { + var iterator = collection.__iterator(ITERATE_ENTRIES, reverse); + return new Iterator(function () { + var step = iterator.next(); + if (step.done) { + return step; + } + var entry = step.value; + var key = entry[0]; + return iteratorValue( + type, + key, + mapper.call(context, entry[1], key, collection), + step + ); + }); + }; + return mappedSequence; + } + + function reverseFactory(collection, useKeys) { + var this$1$1 = this; + + var reversedSequence = makeSequence(collection); + reversedSequence._iter = collection; + reversedSequence.size = collection.size; + reversedSequence.reverse = function () { return collection; }; + if (collection.flip) { + reversedSequence.flip = function () { + var flipSequence = flipFactory(collection); + flipSequence.reverse = function () { return collection.flip(); }; + return flipSequence; + }; + } + reversedSequence.get = function (key, notSetValue) { return collection.get(useKeys ? key : -1 - key, notSetValue); }; + reversedSequence.has = function (key) { return collection.has(useKeys ? key : -1 - key); }; + reversedSequence.includes = function (value) { return collection.includes(value); }; + reversedSequence.cacheResult = cacheResultThrough; + reversedSequence.__iterate = function (fn, reverse) { + var this$1$1 = this; + + var i = 0; + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + reverse && ensureSize(collection); + return collection.__iterate( + function (v, k) { return fn(v, useKeys ? k : reverse ? this$1$1.size - ++i : i++, this$1$1); }, + !reverse + ); + }; + reversedSequence.__iterator = function (type, reverse) { + var i = 0; + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + reverse && ensureSize(collection); + var iterator = collection.__iterator(ITERATE_ENTRIES, !reverse); + return new Iterator(function () { + var step = iterator.next(); + if (step.done) { + return step; + } + var entry = step.value; + return iteratorValue( + type, + useKeys ? entry[0] : reverse ? this$1$1.size - ++i : i++, + entry[1], + step + ); + }); + }; + return reversedSequence; + } + + function filterFactory(collection, predicate, context, useKeys) { + var filterSequence = makeSequence(collection); + if (useKeys) { + filterSequence.has = function (key) { + var v = collection.get(key, NOT_SET); + return v !== NOT_SET && !!predicate.call(context, v, key, collection); + }; + filterSequence.get = function (key, notSetValue) { + var v = collection.get(key, NOT_SET); + return v !== NOT_SET && predicate.call(context, v, key, collection) + ? v + : notSetValue; + }; + } + filterSequence.__iterateUncached = function (fn, reverse) { + var this$1$1 = this; + + var iterations = 0; + collection.__iterate(function (v, k, c) { + if (predicate.call(context, v, k, c)) { + iterations++; + return fn(v, useKeys ? k : iterations - 1, this$1$1); + } + }, reverse); + return iterations; + }; + filterSequence.__iteratorUncached = function (type, reverse) { + var iterator = collection.__iterator(ITERATE_ENTRIES, reverse); + var iterations = 0; + return new Iterator(function () { + while (true) { + var step = iterator.next(); + if (step.done) { + return step; + } + var entry = step.value; + var key = entry[0]; + var value = entry[1]; + if (predicate.call(context, value, key, collection)) { + return iteratorValue(type, useKeys ? key : iterations++, value, step); + } + } + }); + }; + return filterSequence; + } + + function countByFactory(collection, grouper, context) { + var groups = Map().asMutable(); + collection.__iterate(function (v, k) { + groups.update(grouper.call(context, v, k, collection), 0, function (a) { return a + 1; }); + }); + return groups.asImmutable(); + } + + function groupByFactory(collection, grouper, context) { + var isKeyedIter = isKeyed(collection); + var groups = (isOrdered(collection) ? OrderedMap() : Map()).asMutable(); + collection.__iterate(function (v, k) { + groups.update( + grouper.call(context, v, k, collection), + function (a) { return ((a = a || []), a.push(isKeyedIter ? [k, v] : v), a); } + ); + }); + var coerce = collectionClass(collection); + return groups.map(function (arr) { return reify(collection, coerce(arr)); }).asImmutable(); + } + + function partitionFactory(collection, predicate, context) { + var isKeyedIter = isKeyed(collection); + var groups = [[], []]; + collection.__iterate(function (v, k) { + groups[predicate.call(context, v, k, collection) ? 1 : 0].push( + isKeyedIter ? [k, v] : v + ); + }); + var coerce = collectionClass(collection); + return groups.map(function (arr) { return reify(collection, coerce(arr)); }); + } + + function sliceFactory(collection, begin, end, useKeys) { + var originalSize = collection.size; + + if (wholeSlice(begin, end, originalSize)) { + return collection; + } + + // begin or end can not be resolved if they were provided as negative numbers and + // this collection's size is unknown. In that case, cache first so there is + // a known size and these do not resolve to NaN. + if (typeof originalSize === 'undefined' && (begin < 0 || end < 0)) { + return sliceFactory(collection.toSeq().cacheResult(), begin, end, useKeys); + } + + var resolvedBegin = resolveBegin(begin, originalSize); + var resolvedEnd = resolveEnd(end, originalSize); + + // Note: resolvedEnd is undefined when the original sequence's length is + // unknown and this slice did not supply an end and should contain all + // elements after resolvedBegin. + // In that case, resolvedSize will be NaN and sliceSize will remain undefined. + var resolvedSize = resolvedEnd - resolvedBegin; + var sliceSize; + if (resolvedSize === resolvedSize) { + sliceSize = resolvedSize < 0 ? 0 : resolvedSize; + } + + var sliceSeq = makeSequence(collection); + + // If collection.size is undefined, the size of the realized sliceSeq is + // unknown at this point unless the number of items to slice is 0 + sliceSeq.size = + sliceSize === 0 ? sliceSize : (collection.size && sliceSize) || undefined; + + if (!useKeys && isSeq(collection) && sliceSize >= 0) { + sliceSeq.get = function (index, notSetValue) { + index = wrapIndex(this, index); + return index >= 0 && index < sliceSize + ? collection.get(index + resolvedBegin, notSetValue) + : notSetValue; + }; + } + + sliceSeq.__iterateUncached = function (fn, reverse) { + var this$1$1 = this; + + if (sliceSize === 0) { + return 0; + } + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var skipped = 0; + var isSkipping = true; + var iterations = 0; + collection.__iterate(function (v, k) { + if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) { + iterations++; + return ( + fn(v, useKeys ? k : iterations - 1, this$1$1) !== false && + iterations !== sliceSize + ); + } + }); + return iterations; + }; + + sliceSeq.__iteratorUncached = function (type, reverse) { + if (sliceSize !== 0 && reverse) { + return this.cacheResult().__iterator(type, reverse); + } + // Don't bother instantiating parent iterator if taking 0. + if (sliceSize === 0) { + return new Iterator(iteratorDone); + } + var iterator = collection.__iterator(type, reverse); + var skipped = 0; + var iterations = 0; + return new Iterator(function () { + while (skipped++ < resolvedBegin) { + iterator.next(); + } + if (++iterations > sliceSize) { + return iteratorDone(); + } + var step = iterator.next(); + if (useKeys || type === ITERATE_VALUES || step.done) { + return step; + } + if (type === ITERATE_KEYS) { + return iteratorValue(type, iterations - 1, undefined, step); + } + return iteratorValue(type, iterations - 1, step.value[1], step); + }); + }; + + return sliceSeq; + } + + function takeWhileFactory(collection, predicate, context) { + var takeSequence = makeSequence(collection); + takeSequence.__iterateUncached = function (fn, reverse) { + var this$1$1 = this; + + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var iterations = 0; + collection.__iterate( + function (v, k, c) { return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$1$1); } + ); + return iterations; + }; + takeSequence.__iteratorUncached = function (type, reverse) { + var this$1$1 = this; + + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + var iterator = collection.__iterator(ITERATE_ENTRIES, reverse); + var iterating = true; + return new Iterator(function () { + if (!iterating) { + return iteratorDone(); + } + var step = iterator.next(); + if (step.done) { + return step; + } + var entry = step.value; + var k = entry[0]; + var v = entry[1]; + if (!predicate.call(context, v, k, this$1$1)) { + iterating = false; + return iteratorDone(); + } + return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step); + }); + }; + return takeSequence; + } + + function skipWhileFactory(collection, predicate, context, useKeys) { + var skipSequence = makeSequence(collection); + skipSequence.__iterateUncached = function (fn, reverse) { + var this$1$1 = this; + + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var isSkipping = true; + var iterations = 0; + collection.__iterate(function (v, k, c) { + if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) { + iterations++; + return fn(v, useKeys ? k : iterations - 1, this$1$1); + } + }); + return iterations; + }; + skipSequence.__iteratorUncached = function (type, reverse) { + var this$1$1 = this; + + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + var iterator = collection.__iterator(ITERATE_ENTRIES, reverse); + var skipping = true; + var iterations = 0; + return new Iterator(function () { + var step; + var k; + var v; + do { + step = iterator.next(); + if (step.done) { + if (useKeys || type === ITERATE_VALUES) { + return step; + } + if (type === ITERATE_KEYS) { + return iteratorValue(type, iterations++, undefined, step); + } + return iteratorValue(type, iterations++, step.value[1], step); + } + var entry = step.value; + k = entry[0]; + v = entry[1]; + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + skipping && (skipping = predicate.call(context, v, k, this$1$1)); + } while (skipping); + return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step); + }); + }; + return skipSequence; + } + + var ConcatSeq = /*@__PURE__*/(function (Seq) { + function ConcatSeq(iterables) { + this._wrappedIterables = iterables.flatMap(function (iterable) { + if (iterable._wrappedIterables) { + return iterable._wrappedIterables; + } + return [iterable]; + }); + this.size = this._wrappedIterables.reduce(function (sum, iterable) { + if (sum !== undefined) { + var size = iterable.size; + if (size !== undefined) { + return sum + size; + } + } + }, 0); + this[IS_KEYED_SYMBOL] = this._wrappedIterables[0][IS_KEYED_SYMBOL]; + this[IS_INDEXED_SYMBOL] = this._wrappedIterables[0][IS_INDEXED_SYMBOL]; + this[IS_ORDERED_SYMBOL] = this._wrappedIterables[0][IS_ORDERED_SYMBOL]; + } + + if ( Seq ) ConcatSeq.__proto__ = Seq; + ConcatSeq.prototype = Object.create( Seq && Seq.prototype ); + ConcatSeq.prototype.constructor = ConcatSeq; + + ConcatSeq.prototype.__iterateUncached = function __iterateUncached (fn, reverse) { + if (this._wrappedIterables.length === 0) { + return; + } + + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + + var iterableIndex = 0; + var useKeys = isKeyed(this); + var iteratorType = useKeys ? ITERATE_ENTRIES : ITERATE_VALUES; + var currentIterator = this._wrappedIterables[iterableIndex].__iterator( + iteratorType, + reverse + ); + + var keepGoing = true; + var index = 0; + while (keepGoing) { + var next = currentIterator.next(); + while (next.done) { + iterableIndex++; + if (iterableIndex === this._wrappedIterables.length) { + return index; + } + currentIterator = this._wrappedIterables[iterableIndex].__iterator( + iteratorType, + reverse + ); + next = currentIterator.next(); + } + var fnResult = useKeys + ? fn(next.value[1], next.value[0], this) + : fn(next.value, index, this); + keepGoing = fnResult !== false; + index++; + } + return index; + }; + + ConcatSeq.prototype.__iteratorUncached = function __iteratorUncached (type, reverse) { + var this$1$1 = this; + + if (this._wrappedIterables.length === 0) { + return new Iterator(iteratorDone); + } + + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + + var iterableIndex = 0; + var currentIterator = this._wrappedIterables[iterableIndex].__iterator( + type, + reverse + ); + return new Iterator(function () { + var next = currentIterator.next(); + while (next.done) { + iterableIndex++; + if (iterableIndex === this$1$1._wrappedIterables.length) { + return next; + } + currentIterator = this$1$1._wrappedIterables[iterableIndex].__iterator( + type, + reverse + ); + next = currentIterator.next(); + } + return next; + }); + }; + + return ConcatSeq; + }(Seq)); + + function concatFactory(collection, values) { + var isKeyedCollection = isKeyed(collection); + var iters = [collection] + .concat(values) + .map(function (v) { + if (!isCollection(v)) { + v = isKeyedCollection + ? keyedSeqFromValue(v) + : indexedSeqFromValue(Array.isArray(v) ? v : [v]); + } else if (isKeyedCollection) { + v = KeyedCollection(v); + } + return v; + }) + .filter(function (v) { return v.size !== 0; }); + + if (iters.length === 0) { + return collection; + } + + if (iters.length === 1) { + var singleton = iters[0]; + if ( + singleton === collection || + (isKeyedCollection && isKeyed(singleton)) || + (isIndexed(collection) && isIndexed(singleton)) + ) { + return singleton; + } + } + + return new ConcatSeq(iters); + } + + function flattenFactory(collection, depth, useKeys) { + var flatSequence = makeSequence(collection); + flatSequence.__iterateUncached = function (fn, reverse) { + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var iterations = 0; + var stopped = false; + function flatDeep(iter, currentDepth) { + iter.__iterate(function (v, k) { + if ((!depth || currentDepth < depth) && isCollection(v)) { + flatDeep(v, currentDepth + 1); + } else { + iterations++; + if (fn(v, useKeys ? k : iterations - 1, flatSequence) === false) { + stopped = true; + } + } + return !stopped; + }, reverse); + } + flatDeep(collection, 0); + return iterations; + }; + flatSequence.__iteratorUncached = function (type, reverse) { + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + var iterator = collection.__iterator(type, reverse); + var stack = []; + var iterations = 0; + return new Iterator(function () { + while (iterator) { + var step = iterator.next(); + if (step.done !== false) { + iterator = stack.pop(); + continue; + } + var v = step.value; + if (type === ITERATE_ENTRIES) { + v = v[1]; + } + if ((!depth || stack.length < depth) && isCollection(v)) { + stack.push(iterator); + iterator = v.__iterator(type, reverse); + } else { + return useKeys ? step : iteratorValue(type, iterations++, v, step); + } + } + return iteratorDone(); + }); + }; + return flatSequence; + } + + function flatMapFactory(collection, mapper, context) { + var coerce = collectionClass(collection); + return collection + .toSeq() + .map(function (v, k) { return coerce(mapper.call(context, v, k, collection)); }) + .flatten(true); + } + + function interposeFactory(collection, separator) { + var interposedSequence = makeSequence(collection); + interposedSequence.size = collection.size && collection.size * 2 - 1; + interposedSequence.__iterateUncached = function (fn, reverse) { + var this$1$1 = this; + + var iterations = 0; + collection.__iterate( + function (v) { return (!iterations || fn(separator, iterations++, this$1$1) !== false) && + fn(v, iterations++, this$1$1) !== false; }, + reverse + ); + return iterations; + }; + interposedSequence.__iteratorUncached = function (type, reverse) { + var iterator = collection.__iterator(ITERATE_VALUES, reverse); + var iterations = 0; + var step; + return new Iterator(function () { + if (!step || iterations % 2) { + step = iterator.next(); + if (step.done) { + return step; + } + } + return iterations % 2 + ? iteratorValue(type, iterations++, separator) + : iteratorValue(type, iterations++, step.value, step); + }); + }; + return interposedSequence; + } + + function sortFactory(collection, comparator, mapper) { + if (!comparator) { + comparator = defaultComparator; + } + var isKeyedCollection = isKeyed(collection); + var index = 0; + var entries = collection + .toSeq() + .map(function (v, k) { return [k, v, index++, mapper ? mapper(v, k, collection) : v]; }) + .valueSeq() + .toArray(); + entries + .sort(function (a, b) { return comparator(a[3], b[3]) || a[2] - b[2]; }) + .forEach( + isKeyedCollection + ? function (v, i) { + entries[i].length = 2; + } + : function (v, i) { + entries[i] = v[1]; + } + ); + return isKeyedCollection + ? KeyedSeq(entries) + : isIndexed(collection) + ? IndexedSeq(entries) + : SetSeq(entries); + } + + function maxFactory(collection, comparator, mapper) { + if (!comparator) { + comparator = defaultComparator; + } + if (mapper) { + var entry = collection + .toSeq() + .map(function (v, k) { return [v, mapper(v, k, collection)]; }) + .reduce(function (a, b) { return (maxCompare(comparator, a[1], b[1]) ? b : a); }); + return entry && entry[0]; + } + return collection.reduce(function (a, b) { return (maxCompare(comparator, a, b) ? b : a); }); + } + + function maxCompare(comparator, a, b) { + var comp = comparator(b, a); + // b is considered the new max if the comparator declares them equal, but + // they are not equal and b is in fact a nullish value. + return ( + (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) || + comp > 0 + ); + } + + function zipWithFactory(keyIter, zipper, iters, zipAll) { + var zipSequence = makeSequence(keyIter); + var sizes = new ArraySeq(iters).map(function (i) { return i.size; }); + zipSequence.size = zipAll ? sizes.max() : sizes.min(); + // Note: this a generic base implementation of __iterate in terms of + // __iterator which may be more generically useful in the future. + zipSequence.__iterate = function (fn, reverse) { + /* generic: + var iterator = this.__iterator(ITERATE_ENTRIES, reverse); + var step; + var iterations = 0; + while (!(step = iterator.next()).done) { + iterations++; + if (fn(step.value[1], step.value[0], this) === false) { + break; + } + } + return iterations; + */ + // indexed: + var iterator = this.__iterator(ITERATE_VALUES, reverse); + var step; + var iterations = 0; + while (!(step = iterator.next()).done) { + if (fn(step.value, iterations++, this) === false) { + break; + } + } + return iterations; + }; + zipSequence.__iteratorUncached = function (type, reverse) { + var iterators = iters.map( + function (i) { return ((i = Collection(i)), getIterator(reverse ? i.reverse() : i)); } + ); + var iterations = 0; + var isDone = false; + return new Iterator(function () { + var steps; + if (!isDone) { + steps = iterators.map(function (i) { return i.next(); }); + isDone = zipAll + ? steps.every(function (s) { return s.done; }) + : steps.some(function (s) { return s.done; }); + } + if (isDone) { + return iteratorDone(); + } + return iteratorValue( + type, + iterations++, + zipper.apply( + null, + steps.map(function (s) { return s.value; }) + ) + ); + }); + }; + return zipSequence; + } + + // #pragma Helper Functions + + function reify(iter, seq) { + return iter === seq ? iter : isSeq(iter) ? seq : iter.constructor(seq); + } + + function validateEntry(entry) { + if (entry !== Object(entry)) { + throw new TypeError('Expected [K, V] tuple: ' + entry); + } + } + + function collectionClass(collection) { + return isKeyed(collection) + ? KeyedCollection + : isIndexed(collection) + ? IndexedCollection + : SetCollection; + } + + function makeSequence(collection) { + return Object.create( + (isKeyed(collection) + ? KeyedSeq + : isIndexed(collection) + ? IndexedSeq + : SetSeq + ).prototype + ); + } + + function cacheResultThrough() { + if (this._iter.cacheResult) { + this._iter.cacheResult(); + this.size = this._iter.size; + return this; + } + return Seq.prototype.cacheResult.call(this); + } + + function defaultComparator(a, b) { + if (a === undefined && b === undefined) { + return 0; + } + + if (a === undefined) { + return 1; + } + + if (b === undefined) { + return -1; + } + + return a > b ? 1 : a < b ? -1 : 0; + } + + // http://jsperf.com/copy-array-inline + function arrCopy(arr, offset) { + offset = offset || 0; + var len = Math.max(0, arr.length - offset); + var newArr = new Array(len); + for (var ii = 0; ii < len; ii++) { + // @ts-expect-error We may want to guard for undefined values with `if (arr[ii + offset] !== undefined`, but ths should not happen by design + newArr[ii] = arr[ii + offset]; + } + return newArr; + } + + function invariant(condition, error) { + if (!condition) + { throw new Error(error); } + } + + function assertNotInfinite(size) { + invariant(size !== Infinity, 'Cannot perform this action with an infinite size.'); + } + + function coerceKeyPath(keyPath) { + if (isArrayLike(keyPath) && typeof keyPath !== 'string') { + return keyPath; + } + if (isOrdered(keyPath)) { + return keyPath.toArray(); + } + throw new TypeError('Invalid keyPath: expected Ordered Collection or Array: ' + keyPath); + } + + var toString = Object.prototype.toString; + function isPlainObject(value) { + // The base prototype's toString deals with Argument objects and native namespaces like Math + if (!value || + typeof value !== 'object' || + toString.call(value) !== '[object Object]') { + return false; + } + var proto = Object.getPrototypeOf(value); + if (proto === null) { + return true; + } + // Iteratively going up the prototype chain is needed for cross-realm environments (differing contexts, iframes, etc) + var parentProto = proto; + var nextProto = Object.getPrototypeOf(proto); + while (nextProto !== null) { + parentProto = nextProto; + nextProto = Object.getPrototypeOf(parentProto); + } + return parentProto === proto; + } + + /** + * Returns true if the value is a potentially-persistent data structure, either + * provided by Immutable.js or a plain Array or Object. + */ + function isDataStructure(value) { + return (typeof value === 'object' && + (isImmutable(value) || Array.isArray(value) || isPlainObject(value))); + } + + /** + * Converts a value to a string, adding quotes if a string was provided. + */ + function quoteString(value) { + try { + return typeof value === 'string' ? JSON.stringify(value) : String(value); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + } + catch (_ignoreError) { + return JSON.stringify(value); + } + } + + /** + * Returns true if the key is defined in the provided collection. + * + * A functional alternative to `collection.has(key)` which will also work with + * plain Objects and Arrays as an alternative for + * `collection.hasOwnProperty(key)`. + * + * + * ```js + * import { has } from 'immutable'; + * + * has([ 'dog', 'frog', 'cat' ], 2) // true + * has([ 'dog', 'frog', 'cat' ], 5) // false + * has({ x: 123, y: 456 }, 'x') // true + * has({ x: 123, y: 456 }, 'z') // false + * ``` + */ + function has(collection, key) { + return isImmutable(collection) + ? // @ts-expect-error key might be a number or symbol, which is not handled be Record key type + collection.has(key) + : // @ts-expect-error key might be anything else than PropertyKey, and will return false in that case but runtime is OK + isDataStructure(collection) && hasOwnProperty.call(collection, key); + } + + function get(collection, key, notSetValue) { + return isImmutable(collection) + ? collection.get(key, notSetValue) + : !has(collection, key) + ? notSetValue + : // @ts-expect-error weird "get" here, + typeof collection.get === 'function' + ? // @ts-expect-error weird "get" here, + collection.get(key) + : // @ts-expect-error key is unknown here, + collection[key]; + } + + function shallowCopy(from) { + if (Array.isArray(from)) { + return arrCopy(from); + } + var to = {}; + for (var key in from) { + if (hasOwnProperty.call(from, key)) { + to[key] = from[key]; + } + } + return to; + } + + function remove(collection, key) { + if (!isDataStructure(collection)) { + throw new TypeError('Cannot update non-data-structure value: ' + collection); + } + if (isImmutable(collection)) { + // @ts-expect-error weird "remove" here, + if (!collection.remove) { + throw new TypeError('Cannot update immutable value without .remove() method: ' + collection); + } + // @ts-expect-error weird "remove" here, + return collection.remove(key); + } + if (!hasOwnProperty.call(collection, key)) { + return collection; + } + var collectionCopy = shallowCopy(collection); + if (Array.isArray(collectionCopy)) { + // @ts-expect-error assert that key is a number here + collectionCopy.splice(key, 1); + } + else { + delete collectionCopy[key]; + } + return collectionCopy; + } + + function set(collection, key, value) { + if (!isDataStructure(collection)) { + throw new TypeError('Cannot update non-data-structure value: ' + collection); + } + if (isImmutable(collection)) { + // @ts-expect-error weird "set" here, + if (!collection.set) { + throw new TypeError('Cannot update immutable value without .set() method: ' + collection); + } + // @ts-expect-error weird "set" here, + return collection.set(key, value); + } + // @ts-expect-error mix of key and string here. Probably need a more fine type here + if (hasOwnProperty.call(collection, key) && value === collection[key]) { + return collection; + } + var collectionCopy = shallowCopy(collection); + // @ts-expect-error mix of key and string here. Probably need a more fine type here + collectionCopy[key] = value; + return collectionCopy; + } + + function updateIn$1(collection, keyPath, notSetValue, updater) { + if (!updater) { + // handle the fact that `notSetValue` is optional here, in that case `updater` is the updater function + // @ts-expect-error updater is a function here + updater = notSetValue; + notSetValue = undefined; + } + var updatedValue = updateInDeeply(isImmutable(collection), + // @ts-expect-error type issues with Record and mixed types + collection, coerceKeyPath(keyPath), 0, notSetValue, updater); + // @ts-expect-error mixed return type + return updatedValue === NOT_SET ? notSetValue : updatedValue; + } + function updateInDeeply(inImmutable, existing, keyPath, i, notSetValue, updater) { + var wasNotSet = existing === NOT_SET; + if (i === keyPath.length) { + var existingValue = wasNotSet ? notSetValue : existing; + // @ts-expect-error mixed type with optional value + var newValue = updater(existingValue); + // @ts-expect-error mixed type + return newValue === existingValue ? existing : newValue; + } + if (!wasNotSet && !isDataStructure(existing)) { + throw new TypeError('Cannot update within non-data-structure value in path [' + + Array.from(keyPath).slice(0, i).map(quoteString) + + ']: ' + + existing); + } + var key = keyPath[i]; + if (typeof key === 'undefined') { + throw new TypeError('Index can not be undefined in updateIn(). This should not happen'); + } + var nextExisting = wasNotSet ? NOT_SET : get(existing, key, NOT_SET); + var nextUpdated = updateInDeeply(nextExisting === NOT_SET ? inImmutable : isImmutable(nextExisting), + // @ts-expect-error mixed type + nextExisting, keyPath, i + 1, notSetValue, updater); + return nextUpdated === nextExisting + ? existing + : nextUpdated === NOT_SET + ? remove(existing, key) + : set(wasNotSet ? (inImmutable ? emptyMap() : {}) : existing, key, nextUpdated); + } + + /** + * Returns a copy of the collection with the value at the key path set to the + * provided value. + * + * A functional alternative to `collection.setIn(keypath)` which will also + * work with plain Objects and Arrays. + * + * + * ```js + * import { setIn } from 'immutable'; + * + * const original = { x: { y: { z: 123 }}} + * setIn(original, ['x', 'y', 'z'], 456) // { x: { y: { z: 456 }}} + * console.log(original) // { x: { y: { z: 123 }}} + * ``` + */ + function setIn$1(collection, keyPath, value) { + return updateIn$1(collection, keyPath, NOT_SET, function () { return value; }); + } + + function setIn(keyPath, v) { + return setIn$1(this, keyPath, v); + } + + /** + * Returns a copy of the collection with the value at the key path removed. + * + * A functional alternative to `collection.removeIn(keypath)` which will also + * work with plain Objects and Arrays. + * + * + * ```js + * import { removeIn } from 'immutable'; + * + * const original = { x: { y: { z: 123 }}} + * removeIn(original, ['x', 'y', 'z']) // { x: { y: {}}} + * console.log(original) // { x: { y: { z: 123 }}} + * ``` + */ + function removeIn(collection, keyPath) { + return updateIn$1(collection, keyPath, function () { return NOT_SET; }); + } + + function deleteIn(keyPath) { + return removeIn(this, keyPath); + } + + function update$1(collection, key, notSetValue, updater) { + return updateIn$1( + // @ts-expect-error Index signature for type string is missing in type V[] + collection, [key], notSetValue, updater); + } + + function update(key, notSetValue, updater) { + return arguments.length === 1 + ? key(this) + : update$1(this, key, notSetValue, updater); + } + + function updateIn(keyPath, notSetValue, updater) { + return updateIn$1(this, keyPath, notSetValue, updater); + } + + function merge$1() { + var iters = [], len = arguments.length; + while ( len-- ) iters[ len ] = arguments[ len ]; + + return mergeIntoKeyedWith(this, iters); + } + + function mergeWith$1(merger) { + var iters = [], len = arguments.length - 1; + while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ]; + + if (typeof merger !== 'function') { + throw new TypeError('Invalid merger function: ' + merger); + } + return mergeIntoKeyedWith(this, iters, merger); + } + + function mergeIntoKeyedWith(collection, collections, merger) { + var iters = []; + for (var ii = 0; ii < collections.length; ii++) { + var collection$1 = KeyedCollection(collections[ii]); + if (collection$1.size !== 0) { + iters.push(collection$1); + } + } + if (iters.length === 0) { + return collection; + } + if ( + collection.toSeq().size === 0 && + !collection.__ownerID && + iters.length === 1 + ) { + return collection.constructor(iters[0]); + } + return collection.withMutations(function (collection) { + var mergeIntoCollection = merger + ? function (value, key) { + update$1(collection, key, NOT_SET, function (oldVal) { return oldVal === NOT_SET ? value : merger(oldVal, value, key); } + ); + } + : function (value, key) { + collection.set(key, value); + }; + for (var ii = 0; ii < iters.length; ii++) { + iters[ii].forEach(mergeIntoCollection); + } + }); + } + + function merge(collection) { + var sources = [], len = arguments.length - 1; + while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ]; + + return mergeWithSources(collection, sources); + } + + function mergeWith(merger, collection) { + var sources = [], len = arguments.length - 2; + while ( len-- > 0 ) sources[ len ] = arguments[ len + 2 ]; + + return mergeWithSources(collection, sources, merger); + } + + function mergeDeep$1(collection) { + var sources = [], len = arguments.length - 1; + while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ]; + + return mergeDeepWithSources(collection, sources); + } + + function mergeDeepWith$1(merger, collection) { + var sources = [], len = arguments.length - 2; + while ( len-- > 0 ) sources[ len ] = arguments[ len + 2 ]; + + return mergeDeepWithSources(collection, sources, merger); + } + + function mergeDeepWithSources(collection, sources, merger) { + return mergeWithSources(collection, sources, deepMergerWith(merger)); + } + + function mergeWithSources(collection, sources, merger) { + if (!isDataStructure(collection)) { + throw new TypeError( + 'Cannot merge into non-data-structure value: ' + collection + ); + } + if (isImmutable(collection)) { + return typeof merger === 'function' && collection.mergeWith + ? collection.mergeWith.apply(collection, [ merger ].concat( sources )) + : collection.merge + ? collection.merge.apply(collection, sources) + : collection.concat.apply(collection, sources); + } + var isArray = Array.isArray(collection); + var merged = collection; + var Collection = isArray ? IndexedCollection : KeyedCollection; + var mergeItem = isArray + ? function (value) { + // Copy on write + if (merged === collection) { + merged = shallowCopy(merged); + } + merged.push(value); + } + : function (value, key) { + var hasVal = hasOwnProperty.call(merged, key); + var nextVal = + hasVal && merger ? merger(merged[key], value, key) : value; + if (!hasVal || nextVal !== merged[key]) { + // Copy on write + if (merged === collection) { + merged = shallowCopy(merged); + } + merged[key] = nextVal; + } + }; + for (var i = 0; i < sources.length; i++) { + Collection(sources[i]).forEach(mergeItem); + } + return merged; + } + + function deepMergerWith(merger) { + function deepMerger(oldValue, newValue, key) { + return isDataStructure(oldValue) && + isDataStructure(newValue) && + areMergeable(oldValue, newValue) + ? mergeWithSources(oldValue, [newValue], deepMerger) + : merger + ? merger(oldValue, newValue, key) + : newValue; + } + return deepMerger; + } + + /** + * It's unclear what the desired behavior is for merging two collections that + * fall into separate categories between keyed, indexed, or set-like, so we only + * consider them mergeable if they fall into the same category. + */ + function areMergeable(oldDataStructure, newDataStructure) { + var oldSeq = Seq(oldDataStructure); + var newSeq = Seq(newDataStructure); + // This logic assumes that a sequence can only fall into one of the three + // categories mentioned above (since there's no `isSetLike()` method). + return ( + isIndexed(oldSeq) === isIndexed(newSeq) && + isKeyed(oldSeq) === isKeyed(newSeq) + ); + } + + function mergeDeep() { + var iters = [], len = arguments.length; + while ( len-- ) iters[ len ] = arguments[ len ]; + + return mergeDeepWithSources(this, iters); + } + + function mergeDeepWith(merger) { + var iters = [], len = arguments.length - 1; + while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ]; + + return mergeDeepWithSources(this, iters, merger); + } + + function mergeIn(keyPath) { + var iters = [], len = arguments.length - 1; + while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ]; + + return updateIn$1(this, keyPath, emptyMap(), function (m) { return mergeWithSources(m, iters); }); + } + + function mergeDeepIn(keyPath) { + var iters = [], len = arguments.length - 1; + while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ]; + + return updateIn$1(this, keyPath, emptyMap(), function (m) { return mergeDeepWithSources(m, iters); } + ); + } + + function withMutations(fn) { + var mutable = this.asMutable(); + fn(mutable); + return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this; + } + + function asMutable() { + return this.__ownerID ? this : this.__ensureOwner(new OwnerID()); + } + + function asImmutable() { + return this.__ensureOwner(); + } + + function wasAltered() { + return this.__altered; + } + + var Map = /*@__PURE__*/(function (KeyedCollection) { + function Map(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptyMap() + : isMap(value) && !isOrdered(value) + ? value + : emptyMap().withMutations(function (map) { + var iter = KeyedCollection(value); + assertNotInfinite(iter.size); + iter.forEach(function (v, k) { return map.set(k, v); }); + }); + } + + if ( KeyedCollection ) Map.__proto__ = KeyedCollection; + Map.prototype = Object.create( KeyedCollection && KeyedCollection.prototype ); + Map.prototype.constructor = Map; + + Map.prototype.toString = function toString () { + return this.__toString('Map {', '}'); + }; + + // @pragma Access + + Map.prototype.get = function get (k, notSetValue) { + return this._root + ? this._root.get(0, undefined, k, notSetValue) + : notSetValue; + }; + + // @pragma Modification + + Map.prototype.set = function set (k, v) { + return updateMap(this, k, v); + }; + + Map.prototype.remove = function remove (k) { + return updateMap(this, k, NOT_SET); + }; + + Map.prototype.deleteAll = function deleteAll (keys) { + var collection = Collection(keys); + + if (collection.size === 0) { + return this; + } + + return this.withMutations(function (map) { + collection.forEach(function (key) { return map.remove(key); }); + }); + }; + + Map.prototype.clear = function clear () { + if (this.size === 0) { + return this; + } + if (this.__ownerID) { + this.size = 0; + this._root = null; + this.__hash = undefined; + this.__altered = true; + return this; + } + return emptyMap(); + }; + + // @pragma Composition + + Map.prototype.sort = function sort (comparator) { + // Late binding + return OrderedMap(sortFactory(this, comparator)); + }; + + Map.prototype.sortBy = function sortBy (mapper, comparator) { + // Late binding + return OrderedMap(sortFactory(this, comparator, mapper)); + }; + + Map.prototype.map = function map (mapper, context) { + var this$1$1 = this; + + return this.withMutations(function (map) { + map.forEach(function (value, key) { + map.set(key, mapper.call(context, value, key, this$1$1)); + }); + }); + }; + + // @pragma Mutability + + Map.prototype.__iterator = function __iterator (type, reverse) { + return new MapIterator(this, type, reverse); + }; + + Map.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + var iterations = 0; + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + this._root && + this._root.iterate(function (entry) { + iterations++; + return fn(entry[1], entry[0], this$1$1); + }, reverse); + return iterations; + }; + + Map.prototype.__ensureOwner = function __ensureOwner (ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + if (!ownerID) { + if (this.size === 0) { + return emptyMap(); + } + this.__ownerID = ownerID; + this.__altered = false; + return this; + } + return makeMap(this.size, this._root, ownerID, this.__hash); + }; + + return Map; + }(KeyedCollection)); + + Map.isMap = isMap; + + var MapPrototype = Map.prototype; + MapPrototype[IS_MAP_SYMBOL] = true; + MapPrototype[DELETE] = MapPrototype.remove; + MapPrototype.removeAll = MapPrototype.deleteAll; + MapPrototype.setIn = setIn; + MapPrototype.removeIn = MapPrototype.deleteIn = deleteIn; + MapPrototype.update = update; + MapPrototype.updateIn = updateIn; + MapPrototype.merge = MapPrototype.concat = merge$1; + MapPrototype.mergeWith = mergeWith$1; + MapPrototype.mergeDeep = mergeDeep; + MapPrototype.mergeDeepWith = mergeDeepWith; + MapPrototype.mergeIn = mergeIn; + MapPrototype.mergeDeepIn = mergeDeepIn; + MapPrototype.withMutations = withMutations; + MapPrototype.wasAltered = wasAltered; + MapPrototype.asImmutable = asImmutable; + MapPrototype['@@transducer/init'] = MapPrototype.asMutable = asMutable; + MapPrototype['@@transducer/step'] = function (result, arr) { + return result.set(arr[0], arr[1]); + }; + MapPrototype['@@transducer/result'] = function (obj) { + return obj.asImmutable(); + }; + + // #pragma Trie Nodes + + var ArrayMapNode = function ArrayMapNode(ownerID, entries) { + this.ownerID = ownerID; + this.entries = entries; + }; + + ArrayMapNode.prototype.get = function get (shift, keyHash, key, notSetValue) { + var entries = this.entries; + for (var ii = 0, len = entries.length; ii < len; ii++) { + if (is(key, entries[ii][0])) { + return entries[ii][1]; + } + } + return notSetValue; + }; + + ArrayMapNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + var removed = value === NOT_SET; + + var entries = this.entries; + var idx = 0; + var len = entries.length; + for (; idx < len; idx++) { + if (is(key, entries[idx][0])) { + break; + } + } + var exists = idx < len; + + if (exists ? entries[idx][1] === value : removed) { + return this; + } + + SetRef(didAlter); + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + (removed || !exists) && SetRef(didChangeSize); + + if (removed && entries.length === 1) { + return; // undefined + } + + if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) { + return createNodes(ownerID, entries, key, value); + } + + var isEditable = ownerID && ownerID === this.ownerID; + var newEntries = isEditable ? entries : arrCopy(entries); + + if (exists) { + if (removed) { + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + idx === len - 1 + ? newEntries.pop() + : (newEntries[idx] = newEntries.pop()); + } else { + newEntries[idx] = [key, value]; + } + } else { + newEntries.push([key, value]); + } + + if (isEditable) { + this.entries = newEntries; + return this; + } + + return new ArrayMapNode(ownerID, newEntries); + }; + + var BitmapIndexedNode = function BitmapIndexedNode(ownerID, bitmap, nodes) { + this.ownerID = ownerID; + this.bitmap = bitmap; + this.nodes = nodes; + }; + + BitmapIndexedNode.prototype.get = function get (shift, keyHash, key, notSetValue) { + if (keyHash === undefined) { + keyHash = hash(key); + } + var bit = 1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK); + var bitmap = this.bitmap; + return (bitmap & bit) === 0 + ? notSetValue + : this.nodes[popCount(bitmap & (bit - 1))].get( + shift + SHIFT, + keyHash, + key, + notSetValue + ); + }; + + BitmapIndexedNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + if (keyHash === undefined) { + keyHash = hash(key); + } + var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK; + var bit = 1 << keyHashFrag; + var bitmap = this.bitmap; + var exists = (bitmap & bit) !== 0; + + if (!exists && value === NOT_SET) { + return this; + } + + var idx = popCount(bitmap & (bit - 1)); + var nodes = this.nodes; + var node = exists ? nodes[idx] : undefined; + var newNode = updateNode( + node, + ownerID, + shift + SHIFT, + keyHash, + key, + value, + didChangeSize, + didAlter + ); + + if (newNode === node) { + return this; + } + + if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) { + return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode); + } + + if ( + exists && + !newNode && + nodes.length === 2 && + isLeafNode(nodes[idx ^ 1]) + ) { + return nodes[idx ^ 1]; + } + + if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) { + return newNode; + } + + var isEditable = ownerID && ownerID === this.ownerID; + var newBitmap = exists ? (newNode ? bitmap : bitmap ^ bit) : bitmap | bit; + var newNodes = exists + ? newNode + ? setAt(nodes, idx, newNode, isEditable) + : spliceOut(nodes, idx, isEditable) + : spliceIn(nodes, idx, newNode, isEditable); + + if (isEditable) { + this.bitmap = newBitmap; + this.nodes = newNodes; + return this; + } + + return new BitmapIndexedNode(ownerID, newBitmap, newNodes); + }; + + var HashArrayMapNode = function HashArrayMapNode(ownerID, count, nodes) { + this.ownerID = ownerID; + this.count = count; + this.nodes = nodes; + }; + + HashArrayMapNode.prototype.get = function get (shift, keyHash, key, notSetValue) { + if (keyHash === undefined) { + keyHash = hash(key); + } + var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK; + var node = this.nodes[idx]; + return node + ? node.get(shift + SHIFT, keyHash, key, notSetValue) + : notSetValue; + }; + + HashArrayMapNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + if (keyHash === undefined) { + keyHash = hash(key); + } + var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK; + var removed = value === NOT_SET; + var nodes = this.nodes; + var node = nodes[idx]; + + if (removed && !node) { + return this; + } + + var newNode = updateNode( + node, + ownerID, + shift + SHIFT, + keyHash, + key, + value, + didChangeSize, + didAlter + ); + if (newNode === node) { + return this; + } + + var newCount = this.count; + if (!node) { + newCount++; + } else if (!newNode) { + newCount--; + if (newCount < MIN_HASH_ARRAY_MAP_SIZE) { + return packNodes(ownerID, nodes, newCount, idx); + } + } + + var isEditable = ownerID && ownerID === this.ownerID; + var newNodes = setAt(nodes, idx, newNode, isEditable); + + if (isEditable) { + this.count = newCount; + this.nodes = newNodes; + return this; + } + + return new HashArrayMapNode(ownerID, newCount, newNodes); + }; + + var HashCollisionNode = function HashCollisionNode(ownerID, keyHash, entries) { + this.ownerID = ownerID; + this.keyHash = keyHash; + this.entries = entries; + }; + + HashCollisionNode.prototype.get = function get (shift, keyHash, key, notSetValue) { + var entries = this.entries; + for (var ii = 0, len = entries.length; ii < len; ii++) { + if (is(key, entries[ii][0])) { + return entries[ii][1]; + } + } + return notSetValue; + }; + + HashCollisionNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + if (keyHash === undefined) { + keyHash = hash(key); + } + + var removed = value === NOT_SET; + + if (keyHash !== this.keyHash) { + if (removed) { + return this; + } + SetRef(didAlter); + SetRef(didChangeSize); + return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]); + } + + var entries = this.entries; + var idx = 0; + var len = entries.length; + for (; idx < len; idx++) { + if (is(key, entries[idx][0])) { + break; + } + } + var exists = idx < len; + + if (exists ? entries[idx][1] === value : removed) { + return this; + } + + SetRef(didAlter); + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + (removed || !exists) && SetRef(didChangeSize); + + if (removed && len === 2) { + return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]); + } + + var isEditable = ownerID && ownerID === this.ownerID; + var newEntries = isEditable ? entries : arrCopy(entries); + + if (exists) { + if (removed) { + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + idx === len - 1 + ? newEntries.pop() + : (newEntries[idx] = newEntries.pop()); + } else { + newEntries[idx] = [key, value]; + } + } else { + newEntries.push([key, value]); + } + + if (isEditable) { + this.entries = newEntries; + return this; + } + + return new HashCollisionNode(ownerID, this.keyHash, newEntries); + }; + + var ValueNode = function ValueNode(ownerID, keyHash, entry) { + this.ownerID = ownerID; + this.keyHash = keyHash; + this.entry = entry; + }; + + ValueNode.prototype.get = function get (shift, keyHash, key, notSetValue) { + return is(key, this.entry[0]) ? this.entry[1] : notSetValue; + }; + + ValueNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + var removed = value === NOT_SET; + var keyMatch = is(key, this.entry[0]); + if (keyMatch ? value === this.entry[1] : removed) { + return this; + } + + SetRef(didAlter); + + if (removed) { + SetRef(didChangeSize); + return; // undefined + } + + if (keyMatch) { + if (ownerID && ownerID === this.ownerID) { + this.entry[1] = value; + return this; + } + return new ValueNode(ownerID, this.keyHash, [key, value]); + } + + SetRef(didChangeSize); + return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]); + }; + + // #pragma Iterators + + ArrayMapNode.prototype.iterate = HashCollisionNode.prototype.iterate = + function (fn, reverse) { + var entries = this.entries; + for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) { + if (fn(entries[reverse ? maxIndex - ii : ii]) === false) { + return false; + } + } + }; + + BitmapIndexedNode.prototype.iterate = HashArrayMapNode.prototype.iterate = + function (fn, reverse) { + var nodes = this.nodes; + for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) { + var node = nodes[reverse ? maxIndex - ii : ii]; + if (node && node.iterate(fn, reverse) === false) { + return false; + } + } + }; + + // eslint-disable-next-line @typescript-eslint/no-unused-vars + ValueNode.prototype.iterate = function (fn, reverse) { + return fn(this.entry); + }; + + var MapIterator = /*@__PURE__*/(function (Iterator) { + function MapIterator(map, type, reverse) { + this._type = type; + this._reverse = reverse; + this._stack = map._root && mapIteratorFrame(map._root); + } + + if ( Iterator ) MapIterator.__proto__ = Iterator; + MapIterator.prototype = Object.create( Iterator && Iterator.prototype ); + MapIterator.prototype.constructor = MapIterator; + + MapIterator.prototype.next = function next () { + var type = this._type; + var stack = this._stack; + while (stack) { + var node = stack.node; + var index = stack.index++; + var maxIndex = (void 0); + if (node.entry) { + if (index === 0) { + return mapIteratorValue(type, node.entry); + } + } else if (node.entries) { + maxIndex = node.entries.length - 1; + if (index <= maxIndex) { + return mapIteratorValue( + type, + node.entries[this._reverse ? maxIndex - index : index] + ); + } + } else { + maxIndex = node.nodes.length - 1; + if (index <= maxIndex) { + var subNode = node.nodes[this._reverse ? maxIndex - index : index]; + if (subNode) { + if (subNode.entry) { + return mapIteratorValue(type, subNode.entry); + } + stack = this._stack = mapIteratorFrame(subNode, stack); + } + continue; + } + } + stack = this._stack = this._stack.__prev; + } + return iteratorDone(); + }; + + return MapIterator; + }(Iterator)); + + function mapIteratorValue(type, entry) { + return iteratorValue(type, entry[0], entry[1]); + } + + function mapIteratorFrame(node, prev) { + return { + node: node, + index: 0, + __prev: prev, + }; + } + + function makeMap(size, root, ownerID, hash) { + var map = Object.create(MapPrototype); + map.size = size; + map._root = root; + map.__ownerID = ownerID; + map.__hash = hash; + map.__altered = false; + return map; + } + + var EMPTY_MAP; + function emptyMap() { + return EMPTY_MAP || (EMPTY_MAP = makeMap(0)); + } + + function updateMap(map, k, v) { + var newRoot; + var newSize; + if (!map._root) { + if (v === NOT_SET) { + return map; + } + newSize = 1; + newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]); + } else { + var didChangeSize = MakeRef(); + var didAlter = MakeRef(); + newRoot = updateNode( + map._root, + map.__ownerID, + 0, + undefined, + k, + v, + didChangeSize, + didAlter + ); + if (!didAlter.value) { + return map; + } + newSize = map.size + (didChangeSize.value ? (v === NOT_SET ? -1 : 1) : 0); + } + if (map.__ownerID) { + map.size = newSize; + map._root = newRoot; + map.__hash = undefined; + map.__altered = true; + return map; + } + return newRoot ? makeMap(newSize, newRoot) : emptyMap(); + } + + function updateNode( + node, + ownerID, + shift, + keyHash, + key, + value, + didChangeSize, + didAlter + ) { + if (!node) { + if (value === NOT_SET) { + return node; + } + SetRef(didAlter); + SetRef(didChangeSize); + return new ValueNode(ownerID, keyHash, [key, value]); + } + return node.update( + ownerID, + shift, + keyHash, + key, + value, + didChangeSize, + didAlter + ); + } + + function isLeafNode(node) { + return ( + node.constructor === ValueNode || node.constructor === HashCollisionNode + ); + } + + function mergeIntoNode(node, ownerID, shift, keyHash, entry) { + if (node.keyHash === keyHash) { + return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]); + } + + var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK; + var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK; + + var newNode; + var nodes = + idx1 === idx2 + ? [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)] + : ((newNode = new ValueNode(ownerID, keyHash, entry)), + idx1 < idx2 ? [node, newNode] : [newNode, node]); + + return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes); + } + + function createNodes(ownerID, entries, key, value) { + if (!ownerID) { + ownerID = new OwnerID(); + } + var node = new ValueNode(ownerID, hash(key), [key, value]); + for (var ii = 0; ii < entries.length; ii++) { + var entry = entries[ii]; + node = node.update(ownerID, 0, undefined, entry[0], entry[1]); + } + return node; + } + + function packNodes(ownerID, nodes, count, excluding) { + var bitmap = 0; + var packedII = 0; + var packedNodes = new Array(count); + for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) { + var node = nodes[ii]; + if (node !== undefined && ii !== excluding) { + bitmap |= bit; + packedNodes[packedII++] = node; + } + } + return new BitmapIndexedNode(ownerID, bitmap, packedNodes); + } + + function expandNodes(ownerID, nodes, bitmap, including, node) { + var count = 0; + var expandedNodes = new Array(SIZE); + for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) { + expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined; + } + expandedNodes[including] = node; + return new HashArrayMapNode(ownerID, count + 1, expandedNodes); + } + + function popCount(x) { + x -= (x >> 1) & 0x55555555; + x = (x & 0x33333333) + ((x >> 2) & 0x33333333); + x = (x + (x >> 4)) & 0x0f0f0f0f; + x += x >> 8; + x += x >> 16; + return x & 0x7f; + } + + function setAt(array, idx, val, canEdit) { + var newArray = canEdit ? array : arrCopy(array); + newArray[idx] = val; + return newArray; + } + + function spliceIn(array, idx, val, canEdit) { + var newLen = array.length + 1; + if (canEdit && idx + 1 === newLen) { + array[idx] = val; + return array; + } + var newArray = new Array(newLen); + var after = 0; + for (var ii = 0; ii < newLen; ii++) { + if (ii === idx) { + newArray[ii] = val; + after = -1; + } else { + newArray[ii] = array[ii + after]; + } + } + return newArray; + } + + function spliceOut(array, idx, canEdit) { + var newLen = array.length - 1; + if (canEdit && idx === newLen) { + array.pop(); + return array; + } + var newArray = new Array(newLen); + var after = 0; + for (var ii = 0; ii < newLen; ii++) { + if (ii === idx) { + after = 1; + } + newArray[ii] = array[ii + after]; + } + return newArray; + } + + var MAX_ARRAY_MAP_SIZE = SIZE / 4; + var MAX_BITMAP_INDEXED_SIZE = SIZE / 2; + var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4; + + var IS_LIST_SYMBOL = '@@__IMMUTABLE_LIST__@@'; + /** + * True if `maybeList` is a List. + */ + function isList(maybeList) { + return Boolean(maybeList && + // @ts-expect-error: maybeList is typed as `{}`, need to change in 6.0 to `maybeList && typeof maybeList === 'object' && IS_LIST_SYMBOL in maybeList` + maybeList[IS_LIST_SYMBOL]); + } + + var List = /*@__PURE__*/(function (IndexedCollection) { + function List(value) { + var empty = emptyList(); + if (value === undefined || value === null) { + // eslint-disable-next-line no-constructor-return + return empty; + } + if (isList(value)) { + // eslint-disable-next-line no-constructor-return + return value; + } + var iter = IndexedCollection(value); + var size = iter.size; + if (size === 0) { + // eslint-disable-next-line no-constructor-return + return empty; + } + assertNotInfinite(size); + if (size > 0 && size < SIZE) { + // eslint-disable-next-line no-constructor-return + return makeList(0, size, SHIFT, null, new VNode(iter.toArray())); + } + // eslint-disable-next-line no-constructor-return + return empty.withMutations(function (list) { + list.setSize(size); + iter.forEach(function (v, i) { return list.set(i, v); }); + }); + } + + if ( IndexedCollection ) List.__proto__ = IndexedCollection; + List.prototype = Object.create( IndexedCollection && IndexedCollection.prototype ); + List.prototype.constructor = List; + + List.of = function of (/*...values*/) { + return this(arguments); + }; + + List.prototype.toString = function toString () { + return this.__toString('List [', ']'); + }; + + // @pragma Access + + List.prototype.get = function get (index, notSetValue) { + index = wrapIndex(this, index); + if (index >= 0 && index < this.size) { + index += this._origin; + var node = listNodeFor(this, index); + return node && node.array[index & MASK]; + } + return notSetValue; + }; + + // @pragma Modification + + List.prototype.set = function set (index, value) { + return updateList(this, index, value); + }; + + List.prototype.remove = function remove (index) { + return !this.has(index) + ? this + : index === 0 + ? this.shift() + : index === this.size - 1 + ? this.pop() + : this.splice(index, 1); + }; + + List.prototype.insert = function insert (index, value) { + return this.splice(index, 0, value); + }; + + List.prototype.clear = function clear () { + if (this.size === 0) { + return this; + } + if (this.__ownerID) { + this.size = this._origin = this._capacity = 0; + this._level = SHIFT; + this._root = this._tail = this.__hash = undefined; + this.__altered = true; + return this; + } + return emptyList(); + }; + + List.prototype.push = function push (/*...values*/) { + var values = arguments; + var oldSize = this.size; + return this.withMutations(function (list) { + setListBounds(list, 0, oldSize + values.length); + for (var ii = 0; ii < values.length; ii++) { + list.set(oldSize + ii, values[ii]); + } + }); + }; + + List.prototype.pop = function pop () { + return setListBounds(this, 0, -1); + }; + + List.prototype.unshift = function unshift (/*...values*/) { + var values = arguments; + return this.withMutations(function (list) { + setListBounds(list, -values.length); + for (var ii = 0; ii < values.length; ii++) { + list.set(ii, values[ii]); + } + }); + }; + + List.prototype.shift = function shift () { + return setListBounds(this, 1); + }; + + List.prototype.shuffle = function shuffle (random) { + if ( random === void 0 ) random = Math.random; + + return this.withMutations(function (mutable) { + // implementation of the Fisher-Yates shuffle: https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle + var current = mutable.size; + var destination; + var tmp; + + while (current) { + destination = Math.floor(random() * current--); + + tmp = mutable.get(destination); + mutable.set(destination, mutable.get(current)); + mutable.set(current, tmp); + } + }); + }; + + // @pragma Composition + + List.prototype.concat = function concat (/*...collections*/) { + var arguments$1 = arguments; + + var seqs = []; + for (var i = 0; i < arguments.length; i++) { + var argument = arguments$1[i]; + var seq = IndexedCollection( + typeof argument !== 'string' && hasIterator(argument) + ? argument + : [argument] + ); + if (seq.size !== 0) { + seqs.push(seq); + } + } + if (seqs.length === 0) { + return this; + } + if (this.size === 0 && !this.__ownerID && seqs.length === 1) { + return this.constructor(seqs[0]); + } + return this.withMutations(function (list) { + seqs.forEach(function (seq) { return seq.forEach(function (value) { return list.push(value); }); }); + }); + }; + + List.prototype.setSize = function setSize (size) { + return setListBounds(this, 0, size); + }; + + List.prototype.map = function map (mapper, context) { + var this$1$1 = this; + + return this.withMutations(function (list) { + for (var i = 0; i < this$1$1.size; i++) { + list.set(i, mapper.call(context, list.get(i), i, this$1$1)); + } + }); + }; + + // @pragma Iteration + + List.prototype.slice = function slice (begin, end) { + var size = this.size; + if (wholeSlice(begin, end, size)) { + return this; + } + return setListBounds( + this, + resolveBegin(begin, size), + resolveEnd(end, size) + ); + }; + + List.prototype.__iterator = function __iterator (type, reverse) { + var index = reverse ? this.size : 0; + var values = iterateList(this, reverse); + return new Iterator(function () { + var value = values(); + return value === DONE + ? iteratorDone() + : iteratorValue(type, reverse ? --index : index++, value); + }); + }; + + List.prototype.__iterate = function __iterate (fn, reverse) { + var index = reverse ? this.size : 0; + var values = iterateList(this, reverse); + var value; + while ((value = values()) !== DONE) { + if (fn(value, reverse ? --index : index++, this) === false) { + break; + } + } + return index; + }; + + List.prototype.__ensureOwner = function __ensureOwner (ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + if (!ownerID) { + if (this.size === 0) { + return emptyList(); + } + this.__ownerID = ownerID; + this.__altered = false; + return this; + } + return makeList( + this._origin, + this._capacity, + this._level, + this._root, + this._tail, + ownerID, + this.__hash + ); + }; + + return List; + }(IndexedCollection)); + + List.isList = isList; + + var ListPrototype = List.prototype; + ListPrototype[IS_LIST_SYMBOL] = true; + ListPrototype[DELETE] = ListPrototype.remove; + ListPrototype.merge = ListPrototype.concat; + ListPrototype.setIn = setIn; + ListPrototype.deleteIn = ListPrototype.removeIn = deleteIn; + ListPrototype.update = update; + ListPrototype.updateIn = updateIn; + ListPrototype.mergeIn = mergeIn; + ListPrototype.mergeDeepIn = mergeDeepIn; + ListPrototype.withMutations = withMutations; + ListPrototype.wasAltered = wasAltered; + ListPrototype.asImmutable = asImmutable; + ListPrototype['@@transducer/init'] = ListPrototype.asMutable = asMutable; + ListPrototype['@@transducer/step'] = function (result, arr) { + return result.push(arr); + }; + ListPrototype['@@transducer/result'] = function (obj) { + return obj.asImmutable(); + }; + + var VNode = function VNode(array, ownerID) { + this.array = array; + this.ownerID = ownerID; + }; + + // TODO: seems like these methods are very similar + + VNode.prototype.removeBefore = function removeBefore (ownerID, level, index) { + if ( + (index & ((1 << (level + SHIFT)) - 1)) === 0 || + this.array.length === 0 + ) { + return this; + } + var originIndex = (index >>> level) & MASK; + if (originIndex >= this.array.length) { + return new VNode([], ownerID); + } + var removingFirst = originIndex === 0; + var newChild; + if (level > 0) { + var oldChild = this.array[originIndex]; + newChild = + oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index); + if (newChild === oldChild && removingFirst) { + return this; + } + } + if (removingFirst && !newChild) { + return this; + } + var editable = editableVNode(this, ownerID); + if (!removingFirst) { + for (var ii = 0; ii < originIndex; ii++) { + editable.array[ii] = undefined; + } + } + if (newChild) { + editable.array[originIndex] = newChild; + } + return editable; + }; + + VNode.prototype.removeAfter = function removeAfter (ownerID, level, index) { + if ( + index === (level ? 1 << (level + SHIFT) : SIZE) || + this.array.length === 0 + ) { + return this; + } + var sizeIndex = ((index - 1) >>> level) & MASK; + if (sizeIndex >= this.array.length) { + return this; + } + + var newChild; + if (level > 0) { + var oldChild = this.array[sizeIndex]; + newChild = + oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index); + if (newChild === oldChild && sizeIndex === this.array.length - 1) { + return this; + } + } + + var editable = editableVNode(this, ownerID); + editable.array.splice(sizeIndex + 1); + if (newChild) { + editable.array[sizeIndex] = newChild; + } + return editable; + }; + + var DONE = {}; + + function iterateList(list, reverse) { + var left = list._origin; + var right = list._capacity; + var tailPos = getTailOffset(right); + var tail = list._tail; + + return iterateNodeOrLeaf(list._root, list._level, 0); + + function iterateNodeOrLeaf(node, level, offset) { + return level === 0 + ? iterateLeaf(node, offset) + : iterateNode(node, level, offset); + } + + function iterateLeaf(node, offset) { + var array = offset === tailPos ? tail && tail.array : node && node.array; + var from = offset > left ? 0 : left - offset; + var to = right - offset; + if (to > SIZE) { + to = SIZE; + } + return function () { + if (from === to) { + return DONE; + } + var idx = reverse ? --to : from++; + return array && array[idx]; + }; + } + + function iterateNode(node, level, offset) { + var values; + var array = node && node.array; + var from = offset > left ? 0 : (left - offset) >> level; + var to = ((right - offset) >> level) + 1; + if (to > SIZE) { + to = SIZE; + } + return function () { + while (true) { + if (values) { + var value = values(); + if (value !== DONE) { + return value; + } + values = null; + } + if (from === to) { + return DONE; + } + var idx = reverse ? --to : from++; + values = iterateNodeOrLeaf( + array && array[idx], + level - SHIFT, + offset + (idx << level) + ); + } + }; + } + } + + function makeList(origin, capacity, level, root, tail, ownerID, hash) { + var list = Object.create(ListPrototype); + list.size = capacity - origin; + list._origin = origin; + list._capacity = capacity; + list._level = level; + list._root = root; + list._tail = tail; + list.__ownerID = ownerID; + list.__hash = hash; + list.__altered = false; + return list; + } + + function emptyList() { + return makeList(0, 0, SHIFT); + } + + function updateList(list, index, value) { + index = wrapIndex(list, index); + + if (index !== index) { + return list; + } + + if (index >= list.size || index < 0) { + return list.withMutations(function (list) { + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + index < 0 + ? setListBounds(list, index).set(0, value) + : setListBounds(list, 0, index + 1).set(index, value); + }); + } + + index += list._origin; + + var newTail = list._tail; + var newRoot = list._root; + var didAlter = MakeRef(); + if (index >= getTailOffset(list._capacity)) { + newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter); + } else { + newRoot = updateVNode( + newRoot, + list.__ownerID, + list._level, + index, + value, + didAlter + ); + } + + if (!didAlter.value) { + return list; + } + + if (list.__ownerID) { + list._root = newRoot; + list._tail = newTail; + list.__hash = undefined; + list.__altered = true; + return list; + } + return makeList(list._origin, list._capacity, list._level, newRoot, newTail); + } + + function updateVNode(node, ownerID, level, index, value, didAlter) { + var idx = (index >>> level) & MASK; + var nodeHas = node && idx < node.array.length; + if (!nodeHas && value === undefined) { + return node; + } + + var newNode; + + if (level > 0) { + var lowerNode = node && node.array[idx]; + var newLowerNode = updateVNode( + lowerNode, + ownerID, + level - SHIFT, + index, + value, + didAlter + ); + if (newLowerNode === lowerNode) { + return node; + } + newNode = editableVNode(node, ownerID); + newNode.array[idx] = newLowerNode; + return newNode; + } + + if (nodeHas && node.array[idx] === value) { + return node; + } + + if (didAlter) { + SetRef(didAlter); + } + + newNode = editableVNode(node, ownerID); + if (value === undefined && idx === newNode.array.length - 1) { + newNode.array.pop(); + } else { + newNode.array[idx] = value; + } + return newNode; + } + + function editableVNode(node, ownerID) { + if (ownerID && node && ownerID === node.ownerID) { + return node; + } + return new VNode(node ? node.array.slice() : [], ownerID); + } + + function listNodeFor(list, rawIndex) { + if (rawIndex >= getTailOffset(list._capacity)) { + return list._tail; + } + if (rawIndex < 1 << (list._level + SHIFT)) { + var node = list._root; + var level = list._level; + while (node && level > 0) { + node = node.array[(rawIndex >>> level) & MASK]; + level -= SHIFT; + } + return node; + } + } + + function setListBounds(list, begin, end) { + // Sanitize begin & end using this shorthand for ToInt32(argument) + // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32 + if (begin !== undefined) { + begin |= 0; + } + if (end !== undefined) { + end |= 0; + } + var owner = list.__ownerID || new OwnerID(); + var oldOrigin = list._origin; + var oldCapacity = list._capacity; + var newOrigin = oldOrigin + begin; + var newCapacity = + end === undefined + ? oldCapacity + : end < 0 + ? oldCapacity + end + : oldOrigin + end; + if (newOrigin === oldOrigin && newCapacity === oldCapacity) { + return list; + } + + // If it's going to end after it starts, it's empty. + if (newOrigin >= newCapacity) { + return list.clear(); + } + + var newLevel = list._level; + var newRoot = list._root; + + // New origin might need creating a higher root. + var offsetShift = 0; + while (newOrigin + offsetShift < 0) { + newRoot = new VNode( + newRoot && newRoot.array.length ? [undefined, newRoot] : [], + owner + ); + newLevel += SHIFT; + offsetShift += 1 << newLevel; + } + if (offsetShift) { + newOrigin += offsetShift; + oldOrigin += offsetShift; + newCapacity += offsetShift; + oldCapacity += offsetShift; + } + + var oldTailOffset = getTailOffset(oldCapacity); + var newTailOffset = getTailOffset(newCapacity); + + // New size might need creating a higher root. + while (newTailOffset >= 1 << (newLevel + SHIFT)) { + newRoot = new VNode( + newRoot && newRoot.array.length ? [newRoot] : [], + owner + ); + newLevel += SHIFT; + } + + // Locate or create the new tail. + var oldTail = list._tail; + var newTail = + newTailOffset < oldTailOffset + ? listNodeFor(list, newCapacity - 1) + : newTailOffset > oldTailOffset + ? new VNode([], owner) + : oldTail; + + // Merge Tail into tree. + if ( + oldTail && + newTailOffset > oldTailOffset && + newOrigin < oldCapacity && + oldTail.array.length + ) { + newRoot = editableVNode(newRoot, owner); + var node = newRoot; + for (var level = newLevel; level > SHIFT; level -= SHIFT) { + var idx = (oldTailOffset >>> level) & MASK; + node = node.array[idx] = editableVNode(node.array[idx], owner); + } + node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail; + } + + // If the size has been reduced, there's a chance the tail needs to be trimmed. + if (newCapacity < oldCapacity) { + newTail = newTail && newTail.removeAfter(owner, 0, newCapacity); + } + + // If the new origin is within the tail, then we do not need a root. + if (newOrigin >= newTailOffset) { + newOrigin -= newTailOffset; + newCapacity -= newTailOffset; + newLevel = SHIFT; + newRoot = null; + newTail = newTail && newTail.removeBefore(owner, 0, newOrigin); + + // Otherwise, if the root has been trimmed, garbage collect. + } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) { + offsetShift = 0; + + // Identify the new top root node of the subtree of the old root. + while (newRoot) { + var beginIndex = (newOrigin >>> newLevel) & MASK; + if ((beginIndex !== newTailOffset >>> newLevel) & MASK) { + break; + } + if (beginIndex) { + offsetShift += (1 << newLevel) * beginIndex; + } + newLevel -= SHIFT; + newRoot = newRoot.array[beginIndex]; + } + + // Trim the new sides of the new root. + if (newRoot && newOrigin > oldOrigin) { + newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift); + } + if (newRoot && newTailOffset < oldTailOffset) { + newRoot = newRoot.removeAfter( + owner, + newLevel, + newTailOffset - offsetShift + ); + } + if (offsetShift) { + newOrigin -= offsetShift; + newCapacity -= offsetShift; + } + } + + if (list.__ownerID) { + list.size = newCapacity - newOrigin; + list._origin = newOrigin; + list._capacity = newCapacity; + list._level = newLevel; + list._root = newRoot; + list._tail = newTail; + list.__hash = undefined; + list.__altered = true; + return list; + } + return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail); + } + + function getTailOffset(size) { + return size < SIZE ? 0 : ((size - 1) >>> SHIFT) << SHIFT; + } + + var OrderedMap = /*@__PURE__*/(function (Map) { + function OrderedMap(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptyOrderedMap() + : isOrderedMap(value) + ? value + : emptyOrderedMap().withMutations(function (map) { + var iter = KeyedCollection(value); + assertNotInfinite(iter.size); + iter.forEach(function (v, k) { return map.set(k, v); }); + }); + } + + if ( Map ) OrderedMap.__proto__ = Map; + OrderedMap.prototype = Object.create( Map && Map.prototype ); + OrderedMap.prototype.constructor = OrderedMap; + + OrderedMap.of = function of (/*...values*/) { + return this(arguments); + }; + + OrderedMap.prototype.toString = function toString () { + return this.__toString('OrderedMap {', '}'); + }; + + // @pragma Access + + OrderedMap.prototype.get = function get (k, notSetValue) { + var index = this._map.get(k); + return index !== undefined ? this._list.get(index)[1] : notSetValue; + }; + + // @pragma Modification + + OrderedMap.prototype.clear = function clear () { + if (this.size === 0) { + return this; + } + if (this.__ownerID) { + this.size = 0; + this._map.clear(); + this._list.clear(); + this.__altered = true; + return this; + } + return emptyOrderedMap(); + }; + + OrderedMap.prototype.set = function set (k, v) { + return updateOrderedMap(this, k, v); + }; + + OrderedMap.prototype.remove = function remove (k) { + return updateOrderedMap(this, k, NOT_SET); + }; + + OrderedMap.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + return this._list.__iterate( + function (entry) { return entry && fn(entry[1], entry[0], this$1$1); }, + reverse + ); + }; + + OrderedMap.prototype.__iterator = function __iterator (type, reverse) { + return this._list.fromEntrySeq().__iterator(type, reverse); + }; + + OrderedMap.prototype.__ensureOwner = function __ensureOwner (ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + var newMap = this._map.__ensureOwner(ownerID); + var newList = this._list.__ensureOwner(ownerID); + if (!ownerID) { + if (this.size === 0) { + return emptyOrderedMap(); + } + this.__ownerID = ownerID; + this.__altered = false; + this._map = newMap; + this._list = newList; + return this; + } + return makeOrderedMap(newMap, newList, ownerID, this.__hash); + }; + + return OrderedMap; + }(Map)); + + OrderedMap.isOrderedMap = isOrderedMap; + + OrderedMap.prototype[IS_ORDERED_SYMBOL] = true; + OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove; + + function makeOrderedMap(map, list, ownerID, hash) { + var omap = Object.create(OrderedMap.prototype); + omap.size = map ? map.size : 0; + omap._map = map; + omap._list = list; + omap.__ownerID = ownerID; + omap.__hash = hash; + omap.__altered = false; + return omap; + } + + var EMPTY_ORDERED_MAP; + function emptyOrderedMap() { + return ( + EMPTY_ORDERED_MAP || + (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList())) + ); + } + + function updateOrderedMap(omap, k, v) { + var map = omap._map; + var list = omap._list; + var i = map.get(k); + var has = i !== undefined; + var newMap; + var newList; + if (v === NOT_SET) { + // removed + if (!has) { + return omap; + } + if (list.size >= SIZE && list.size >= map.size * 2) { + newList = list.filter(function (entry, idx) { return entry !== undefined && i !== idx; }); + newMap = newList + .toKeyedSeq() + .map(function (entry) { return entry[0]; }) + .flip() + .toMap(); + if (omap.__ownerID) { + newMap.__ownerID = newList.__ownerID = omap.__ownerID; + } + } else { + newMap = map.remove(k); + newList = i === list.size - 1 ? list.pop() : list.set(i, undefined); + } + } else if (has) { + if (v === list.get(i)[1]) { + return omap; + } + newMap = map; + newList = list.set(i, [k, v]); + } else { + newMap = map.set(k, list.size); + newList = list.set(list.size, [k, v]); + } + if (omap.__ownerID) { + omap.size = newMap.size; + omap._map = newMap; + omap._list = newList; + omap.__hash = undefined; + omap.__altered = true; + return omap; + } + return makeOrderedMap(newMap, newList); + } + + var IS_STACK_SYMBOL = '@@__IMMUTABLE_STACK__@@'; + /** + * True if `maybeStack` is a Stack. + */ + function isStack(maybeStack) { + return Boolean(maybeStack && + // @ts-expect-error: maybeStack is typed as `{}`, need to change in 6.0 to `maybeStack && typeof maybeStack === 'object' && MAYBE_STACK_SYMBOL in maybeStack` + maybeStack[IS_STACK_SYMBOL]); + } + + var Stack = /*@__PURE__*/(function (IndexedCollection) { + function Stack(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptyStack() + : isStack(value) + ? value + : emptyStack().pushAll(value); + } + + if ( IndexedCollection ) Stack.__proto__ = IndexedCollection; + Stack.prototype = Object.create( IndexedCollection && IndexedCollection.prototype ); + Stack.prototype.constructor = Stack; + + Stack.of = function of (/*...values*/) { + return this(arguments); + }; + + Stack.prototype.toString = function toString () { + return this.__toString('Stack [', ']'); + }; + + // @pragma Access + + Stack.prototype.get = function get (index, notSetValue) { + var head = this._head; + index = wrapIndex(this, index); + while (head && index--) { + head = head.next; + } + return head ? head.value : notSetValue; + }; + + Stack.prototype.peek = function peek () { + return this._head && this._head.value; + }; + + // @pragma Modification + + Stack.prototype.push = function push (/*...values*/) { + var arguments$1 = arguments; + + if (arguments.length === 0) { + return this; + } + var newSize = this.size + arguments.length; + var head = this._head; + for (var ii = arguments.length - 1; ii >= 0; ii--) { + head = { + value: arguments$1[ii], + next: head, + }; + } + if (this.__ownerID) { + this.size = newSize; + this._head = head; + this.__hash = undefined; + this.__altered = true; + return this; + } + return makeStack(newSize, head); + }; + + Stack.prototype.pushAll = function pushAll (iter) { + iter = IndexedCollection(iter); + if (iter.size === 0) { + return this; + } + if (this.size === 0 && isStack(iter)) { + return iter; + } + assertNotInfinite(iter.size); + var newSize = this.size; + var head = this._head; + iter.__iterate(function (value) { + newSize++; + head = { + value: value, + next: head, + }; + }, /* reverse */ true); + if (this.__ownerID) { + this.size = newSize; + this._head = head; + this.__hash = undefined; + this.__altered = true; + return this; + } + return makeStack(newSize, head); + }; + + Stack.prototype.pop = function pop () { + return this.slice(1); + }; + + Stack.prototype.clear = function clear () { + if (this.size === 0) { + return this; + } + if (this.__ownerID) { + this.size = 0; + this._head = undefined; + this.__hash = undefined; + this.__altered = true; + return this; + } + return emptyStack(); + }; + + Stack.prototype.slice = function slice (begin, end) { + if (wholeSlice(begin, end, this.size)) { + return this; + } + var resolvedBegin = resolveBegin(begin, this.size); + var resolvedEnd = resolveEnd(end, this.size); + if (resolvedEnd !== this.size) { + // super.slice(begin, end); + return IndexedCollection.prototype.slice.call(this, begin, end); + } + var newSize = this.size - resolvedBegin; + var head = this._head; + while (resolvedBegin--) { + head = head.next; + } + if (this.__ownerID) { + this.size = newSize; + this._head = head; + this.__hash = undefined; + this.__altered = true; + return this; + } + return makeStack(newSize, head); + }; + + // @pragma Mutability + + Stack.prototype.__ensureOwner = function __ensureOwner (ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + if (!ownerID) { + if (this.size === 0) { + return emptyStack(); + } + this.__ownerID = ownerID; + this.__altered = false; + return this; + } + return makeStack(this.size, this._head, ownerID, this.__hash); + }; + + // @pragma Iteration + + Stack.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + if (reverse) { + return new ArraySeq(this.toArray()).__iterate( + function (v, k) { return fn(v, k, this$1$1); }, + reverse + ); + } + var iterations = 0; + var node = this._head; + while (node) { + if (fn(node.value, iterations++, this) === false) { + break; + } + node = node.next; + } + return iterations; + }; + + Stack.prototype.__iterator = function __iterator (type, reverse) { + if (reverse) { + return new ArraySeq(this.toArray()).__iterator(type, reverse); + } + var iterations = 0; + var node = this._head; + return new Iterator(function () { + if (node) { + var value = node.value; + node = node.next; + return iteratorValue(type, iterations++, value); + } + return iteratorDone(); + }); + }; + + return Stack; + }(IndexedCollection)); + + Stack.isStack = isStack; + + var StackPrototype = Stack.prototype; + StackPrototype[IS_STACK_SYMBOL] = true; + StackPrototype.shift = StackPrototype.pop; + StackPrototype.unshift = StackPrototype.push; + StackPrototype.unshiftAll = StackPrototype.pushAll; + StackPrototype.withMutations = withMutations; + StackPrototype.wasAltered = wasAltered; + StackPrototype.asImmutable = asImmutable; + StackPrototype['@@transducer/init'] = StackPrototype.asMutable = asMutable; + StackPrototype['@@transducer/step'] = function (result, arr) { + return result.unshift(arr); + }; + StackPrototype['@@transducer/result'] = function (obj) { + return obj.asImmutable(); + }; + + function makeStack(size, head, ownerID, hash) { + var map = Object.create(StackPrototype); + map.size = size; + map._head = head; + map.__ownerID = ownerID; + map.__hash = hash; + map.__altered = false; + return map; + } + + var EMPTY_STACK; + function emptyStack() { + return EMPTY_STACK || (EMPTY_STACK = makeStack(0)); + } + + var IS_SET_SYMBOL = '@@__IMMUTABLE_SET__@@'; + /** + * True if `maybeSet` is a Set. + * + * Also true for OrderedSets. + */ + function isSet(maybeSet) { + return Boolean(maybeSet && + // @ts-expect-error: maybeSet is typed as `{}`, need to change in 6.0 to `maybeSeq && typeof maybeSet === 'object' && MAYBE_SET_SYMBOL in maybeSet` + maybeSet[IS_SET_SYMBOL]); + } + + /** + * True if `maybeOrderedSet` is an OrderedSet. + */ + function isOrderedSet(maybeOrderedSet) { + return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet); + } + + function deepEqual(a, b) { + if (a === b) { + return true; + } + if (!isCollection(b) || + // @ts-expect-error size should exists on Collection + (a.size !== undefined && b.size !== undefined && a.size !== b.size) || + // @ts-expect-error __hash exists on Collection + (a.__hash !== undefined && + // @ts-expect-error __hash exists on Collection + b.__hash !== undefined && + // @ts-expect-error __hash exists on Collection + a.__hash !== b.__hash) || + isKeyed(a) !== isKeyed(b) || + isIndexed(a) !== isIndexed(b) || + // @ts-expect-error Range extends Collection, which implements [Symbol.iterator], so it is valid + isOrdered(a) !== isOrdered(b)) { + return false; + } + // @ts-expect-error size should exists on Collection + if (a.size === 0 && b.size === 0) { + return true; + } + var notAssociative = !isAssociative(a); + // @ts-expect-error Range extends Collection, which implements [Symbol.iterator], so it is valid + if (isOrdered(a)) { + var entries = a.entries(); + // @ts-expect-error need to cast as boolean + return (b.every(function (v, k) { + var entry = entries.next().value; + return entry && is(entry[1], v) && (notAssociative || is(entry[0], k)); + }) && entries.next().done); + } + var flipped = false; + if (a.size === undefined) { + // @ts-expect-error size should exists on Collection + if (b.size === undefined) { + if (typeof a.cacheResult === 'function') { + a.cacheResult(); + } + } + else { + flipped = true; + var _ = a; + a = b; + b = _; + } + } + var allEqual = true; + var bSize = + // @ts-expect-error b is Range | Repeat | Collection as it may have been flipped, and __iterate is valid + b.__iterate(function (v, k) { + if (notAssociative + ? // @ts-expect-error has exists on Collection + !a.has(v) + : flipped + ? // @ts-expect-error type of `get` does not "catch" the version with `notSetValue` + !is(v, a.get(k, NOT_SET)) + : // @ts-expect-error type of `get` does not "catch" the version with `notSetValue` + !is(a.get(k, NOT_SET), v)) { + allEqual = false; + return false; + } + }); + return (allEqual && + // @ts-expect-error size should exists on Collection + a.size === bSize); + } + + /** + * Contributes additional methods to a constructor + */ + function mixin(ctor, + // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type + methods) { + var keyCopier = function (key) { + // @ts-expect-error how to handle symbol ? + ctor.prototype[key] = methods[key]; + }; + Object.keys(methods).forEach(keyCopier); + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + Object.getOwnPropertySymbols && + Object.getOwnPropertySymbols(methods).forEach(keyCopier); + return ctor; + } + + function toJS(value) { + if (!value || typeof value !== 'object') { + return value; + } + if (!isCollection(value)) { + if (!isDataStructure(value)) { + return value; + } + value = Seq(value); + } + if (isKeyed(value)) { + var result$1 = {}; + value.__iterate(function (v, k) { + result$1[k] = toJS(v); + }); + return result$1; + } + var result = []; + value.__iterate(function (v) { + result.push(toJS(v)); + }); + return result; + } + + var Set = /*@__PURE__*/(function (SetCollection) { + function Set(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptySet() + : isSet(value) && !isOrdered(value) + ? value + : emptySet().withMutations(function (set) { + var iter = SetCollection(value); + assertNotInfinite(iter.size); + iter.forEach(function (v) { return set.add(v); }); + }); + } + + if ( SetCollection ) Set.__proto__ = SetCollection; + Set.prototype = Object.create( SetCollection && SetCollection.prototype ); + Set.prototype.constructor = Set; + + Set.of = function of (/*...values*/) { + return this(arguments); + }; + + Set.fromKeys = function fromKeys (value) { + return this(KeyedCollection(value).keySeq()); + }; + + Set.intersect = function intersect (sets) { + sets = Collection(sets).toArray(); + return sets.length + ? SetPrototype.intersect.apply(Set(sets.pop()), sets) + : emptySet(); + }; + + Set.union = function union (sets) { + sets = Collection(sets).toArray(); + return sets.length + ? SetPrototype.union.apply(Set(sets.pop()), sets) + : emptySet(); + }; + + Set.prototype.toString = function toString () { + return this.__toString('Set {', '}'); + }; + + // @pragma Access + + Set.prototype.has = function has (value) { + return this._map.has(value); + }; + + // @pragma Modification + + Set.prototype.add = function add (value) { + return updateSet(this, this._map.set(value, value)); + }; + + Set.prototype.remove = function remove (value) { + return updateSet(this, this._map.remove(value)); + }; + + Set.prototype.clear = function clear () { + return updateSet(this, this._map.clear()); + }; + + // @pragma Composition + + Set.prototype.map = function map (mapper, context) { + var this$1$1 = this; + + // keep track if the set is altered by the map function + var didChanges = false; + + var newMap = updateSet( + this, + this._map.mapEntries(function (ref) { + var v = ref[1]; + + var mapped = mapper.call(context, v, v, this$1$1); + + if (mapped !== v) { + didChanges = true; + } + + return [mapped, mapped]; + }, context) + ); + + return didChanges ? newMap : this; + }; + + Set.prototype.union = function union () { + var iters = [], len = arguments.length; + while ( len-- ) iters[ len ] = arguments[ len ]; + + iters = iters.filter(function (x) { return x.size !== 0; }); + if (iters.length === 0) { + return this; + } + if (this.size === 0 && !this.__ownerID && iters.length === 1) { + return this.constructor(iters[0]); + } + return this.withMutations(function (set) { + for (var ii = 0; ii < iters.length; ii++) { + if (typeof iters[ii] === 'string') { + set.add(iters[ii]); + } else { + SetCollection(iters[ii]).forEach(function (value) { return set.add(value); }); + } + } + }); + }; + + Set.prototype.intersect = function intersect () { + var iters = [], len = arguments.length; + while ( len-- ) iters[ len ] = arguments[ len ]; + + if (iters.length === 0) { + return this; + } + iters = iters.map(function (iter) { return SetCollection(iter); }); + var toRemove = []; + this.forEach(function (value) { + if (!iters.every(function (iter) { return iter.includes(value); })) { + toRemove.push(value); + } + }); + return this.withMutations(function (set) { + toRemove.forEach(function (value) { + set.remove(value); + }); + }); + }; + + Set.prototype.subtract = function subtract () { + var iters = [], len = arguments.length; + while ( len-- ) iters[ len ] = arguments[ len ]; + + if (iters.length === 0) { + return this; + } + iters = iters.map(function (iter) { return SetCollection(iter); }); + var toRemove = []; + this.forEach(function (value) { + if (iters.some(function (iter) { return iter.includes(value); })) { + toRemove.push(value); + } + }); + return this.withMutations(function (set) { + toRemove.forEach(function (value) { + set.remove(value); + }); + }); + }; + + Set.prototype.sort = function sort (comparator) { + // Late binding + return OrderedSet(sortFactory(this, comparator)); + }; + + Set.prototype.sortBy = function sortBy (mapper, comparator) { + // Late binding + return OrderedSet(sortFactory(this, comparator, mapper)); + }; + + Set.prototype.wasAltered = function wasAltered () { + return this._map.wasAltered(); + }; + + Set.prototype.__iterate = function __iterate (fn, reverse) { + var this$1$1 = this; + + return this._map.__iterate(function (k) { return fn(k, k, this$1$1); }, reverse); + }; + + Set.prototype.__iterator = function __iterator (type, reverse) { + return this._map.__iterator(type, reverse); + }; + + Set.prototype.__ensureOwner = function __ensureOwner (ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + var newMap = this._map.__ensureOwner(ownerID); + if (!ownerID) { + if (this.size === 0) { + return this.__empty(); + } + this.__ownerID = ownerID; + this._map = newMap; + return this; + } + return this.__make(newMap, ownerID); + }; + + return Set; + }(SetCollection)); + + Set.isSet = isSet; + + var SetPrototype = Set.prototype; + SetPrototype[IS_SET_SYMBOL] = true; + SetPrototype[DELETE] = SetPrototype.remove; + SetPrototype.merge = SetPrototype.concat = SetPrototype.union; + SetPrototype.withMutations = withMutations; + SetPrototype.asImmutable = asImmutable; + SetPrototype['@@transducer/init'] = SetPrototype.asMutable = asMutable; + SetPrototype['@@transducer/step'] = function (result, arr) { + return result.add(arr); + }; + SetPrototype['@@transducer/result'] = function (obj) { + return obj.asImmutable(); + }; + + SetPrototype.__empty = emptySet; + SetPrototype.__make = makeSet; + + function updateSet(set, newMap) { + if (set.__ownerID) { + set.size = newMap.size; + set._map = newMap; + return set; + } + return newMap === set._map + ? set + : newMap.size === 0 + ? set.__empty() + : set.__make(newMap); + } + + function makeSet(map, ownerID) { + var set = Object.create(SetPrototype); + set.size = map ? map.size : 0; + set._map = map; + set.__ownerID = ownerID; + return set; + } + + var EMPTY_SET; + function emptySet() { + return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap())); + } + + /** + * Returns a lazy seq of nums from start (inclusive) to end + * (exclusive), by step, where start defaults to 0, step to 1, and end to + * infinity. When start is equal to end, returns empty list. + */ + var Range = /*@__PURE__*/(function (IndexedSeq) { + function Range(start, end, step) { + if ( step === void 0 ) step = 1; + + if (!(this instanceof Range)) { + // eslint-disable-next-line no-constructor-return + return new Range(start, end, step); + } + invariant(step !== 0, 'Cannot step a Range by 0'); + invariant( + start !== undefined, + 'You must define a start value when using Range' + ); + invariant( + end !== undefined, + 'You must define an end value when using Range' + ); + + step = Math.abs(step); + if (end < start) { + step = -step; + } + this._start = start; + this._end = end; + this._step = step; + this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1); + if (this.size === 0) { + if (EMPTY_RANGE) { + // eslint-disable-next-line no-constructor-return + return EMPTY_RANGE; + } + // eslint-disable-next-line @typescript-eslint/no-this-alias + EMPTY_RANGE = this; + } + } + + if ( IndexedSeq ) Range.__proto__ = IndexedSeq; + Range.prototype = Object.create( IndexedSeq && IndexedSeq.prototype ); + Range.prototype.constructor = Range; + + Range.prototype.toString = function toString () { + return this.size === 0 + ? 'Range []' + : ("Range [ " + (this._start) + "..." + (this._end) + (this._step !== 1 ? ' by ' + this._step : '') + " ]"); + }; + + Range.prototype.get = function get (index, notSetValue) { + return this.has(index) + ? this._start + wrapIndex(this, index) * this._step + : notSetValue; + }; + + Range.prototype.includes = function includes (searchValue) { + var possibleIndex = (searchValue - this._start) / this._step; + return ( + possibleIndex >= 0 && + possibleIndex < this.size && + possibleIndex === Math.floor(possibleIndex) + ); + }; + + Range.prototype.slice = function slice (begin, end) { + if (wholeSlice(begin, end, this.size)) { + return this; + } + begin = resolveBegin(begin, this.size); + end = resolveEnd(end, this.size); + if (end <= begin) { + return new Range(0, 0); + } + return new Range( + this.get(begin, this._end), + this.get(end, this._end), + this._step + ); + }; + + Range.prototype.indexOf = function indexOf (searchValue) { + var offsetValue = searchValue - this._start; + if (offsetValue % this._step === 0) { + var index = offsetValue / this._step; + if (index >= 0 && index < this.size) { + return index; + } + } + return -1; + }; + + Range.prototype.lastIndexOf = function lastIndexOf (searchValue) { + return this.indexOf(searchValue); + }; + + Range.prototype.__iterate = function __iterate (fn, reverse) { + var size = this.size; + var step = this._step; + var value = reverse ? this._start + (size - 1) * step : this._start; + var i = 0; + while (i !== size) { + if (fn(value, reverse ? size - ++i : i++, this) === false) { + break; + } + value += reverse ? -step : step; + } + return i; + }; + + Range.prototype.__iterator = function __iterator (type, reverse) { + var size = this.size; + var step = this._step; + var value = reverse ? this._start + (size - 1) * step : this._start; + var i = 0; + return new Iterator(function () { + if (i === size) { + return iteratorDone(); + } + var v = value; + value += reverse ? -step : step; + return iteratorValue(type, reverse ? size - ++i : i++, v); + }); + }; + + Range.prototype.equals = function equals (other) { + return other instanceof Range + ? this._start === other._start && + this._end === other._end && + this._step === other._step + : deepEqual(this, other); + }; + + return Range; + }(IndexedSeq)); + + var EMPTY_RANGE; + + /** + * Returns the value at the provided key path starting at the provided + * collection, or notSetValue if the key path is not defined. + * + * A functional alternative to `collection.getIn(keypath)` which will also + * work with plain Objects and Arrays. + * + * + * ```js + * import { getIn } from 'immutable'; + * + * getIn({ x: { y: { z: 123 }}}, ['x', 'y', 'z']) // 123 + * getIn({ x: { y: { z: 123 }}}, ['x', 'q', 'p'], 'ifNotSet') // 'ifNotSet' + * ``` + */ + function getIn$1(collection, searchKeyPath, notSetValue) { + var keyPath = coerceKeyPath(searchKeyPath); + var i = 0; + while (i !== keyPath.length) { + // @ts-expect-error keyPath[i++] can not be undefined by design + collection = get(collection, keyPath[i++], NOT_SET); + if (collection === NOT_SET) { + return notSetValue; + } + } + return collection; + } + + function getIn(searchKeyPath, notSetValue) { + return getIn$1(this, searchKeyPath, notSetValue); + } + + /** + * Returns true if the key path is defined in the provided collection. + * + * A functional alternative to `collection.hasIn(keypath)` which will also + * work with plain Objects and Arrays. + * + * + * ```js + * import { hasIn } from 'immutable'; + * + * hasIn({ x: { y: { z: 123 }}}, ['x', 'y', 'z']) // true + * hasIn({ x: { y: { z: 123 }}}, ['x', 'q', 'p']) // false + * ``` + */ + function hasIn$1(collection, keyPath) { + return getIn$1(collection, keyPath, NOT_SET) !== NOT_SET; + } + + function hasIn(searchKeyPath) { + return hasIn$1(this, searchKeyPath); + } + + function toObject() { + assertNotInfinite(this.size); + var object = {}; + this.__iterate(function (v, k) { + object[k] = v; + }); + return object; + } + + Collection.Iterator = Iterator; + + mixin(Collection, { + // ### Conversion to other types + + toArray: function toArray() { + assertNotInfinite(this.size); + var array = new Array(this.size || 0); + var useTuples = isKeyed(this); + var i = 0; + this.__iterate(function (v, k) { + // Keyed collections produce an array of tuples. + array[i++] = useTuples ? [k, v] : v; + }); + return array; + }, + + toIndexedSeq: function toIndexedSeq() { + return new ToIndexedSequence(this); + }, + + toJS: function toJS$1() { + return toJS(this); + }, + + toKeyedSeq: function toKeyedSeq() { + return new ToKeyedSequence(this, true); + }, + + toMap: function toMap() { + // Use Late Binding here to solve the circular dependency. + return Map(this.toKeyedSeq()); + }, + + toObject: toObject, + + toOrderedMap: function toOrderedMap() { + // Use Late Binding here to solve the circular dependency. + return OrderedMap(this.toKeyedSeq()); + }, + + toOrderedSet: function toOrderedSet() { + // Use Late Binding here to solve the circular dependency. + return OrderedSet(isKeyed(this) ? this.valueSeq() : this); + }, + + toSet: function toSet() { + // Use Late Binding here to solve the circular dependency. + return Set(isKeyed(this) ? this.valueSeq() : this); + }, + + toSetSeq: function toSetSeq() { + return new ToSetSequence(this); + }, + + toSeq: function toSeq() { + return isIndexed(this) + ? this.toIndexedSeq() + : isKeyed(this) + ? this.toKeyedSeq() + : this.toSetSeq(); + }, + + toStack: function toStack() { + // Use Late Binding here to solve the circular dependency. + return Stack(isKeyed(this) ? this.valueSeq() : this); + }, + + toList: function toList() { + // Use Late Binding here to solve the circular dependency. + return List(isKeyed(this) ? this.valueSeq() : this); + }, + + // ### Common JavaScript methods and properties + + toString: function toString() { + return '[Collection]'; + }, + + __toString: function __toString(head, tail) { + if (this.size === 0) { + return head + tail; + } + return ( + head + + ' ' + + this.toSeq().map(this.__toStringMapper).join(', ') + + ' ' + + tail + ); + }, + + // ### ES6 Collection methods (ES6 Array and Map) + + concat: function concat() { + var values = [], len = arguments.length; + while ( len-- ) values[ len ] = arguments[ len ]; + + return reify(this, concatFactory(this, values)); + }, + + includes: function includes(searchValue) { + return this.some(function (value) { return is(value, searchValue); }); + }, + + entries: function entries() { + return this.__iterator(ITERATE_ENTRIES); + }, + + every: function every(predicate, context) { + assertNotInfinite(this.size); + var returnValue = true; + this.__iterate(function (v, k, c) { + if (!predicate.call(context, v, k, c)) { + returnValue = false; + return false; + } + }); + return returnValue; + }, + + filter: function filter(predicate, context) { + return reify(this, filterFactory(this, predicate, context, true)); + }, + + partition: function partition(predicate, context) { + return partitionFactory(this, predicate, context); + }, + + find: function find(predicate, context, notSetValue) { + var entry = this.findEntry(predicate, context); + return entry ? entry[1] : notSetValue; + }, + + forEach: function forEach(sideEffect, context) { + assertNotInfinite(this.size); + return this.__iterate(context ? sideEffect.bind(context) : sideEffect); + }, + + join: function join(separator) { + assertNotInfinite(this.size); + separator = separator !== undefined ? '' + separator : ','; + var joined = ''; + var isFirst = true; + this.__iterate(function (v) { + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + isFirst ? (isFirst = false) : (joined += separator); + joined += v !== null && v !== undefined ? v.toString() : ''; + }); + return joined; + }, + + keys: function keys() { + return this.__iterator(ITERATE_KEYS); + }, + + map: function map(mapper, context) { + return reify(this, mapFactory(this, mapper, context)); + }, + + reduce: function reduce$1(reducer, initialReduction, context) { + return reduce( + this, + reducer, + initialReduction, + context, + arguments.length < 2, + false + ); + }, + + reduceRight: function reduceRight(reducer, initialReduction, context) { + return reduce( + this, + reducer, + initialReduction, + context, + arguments.length < 2, + true + ); + }, + + reverse: function reverse() { + return reify(this, reverseFactory(this, true)); + }, + + slice: function slice(begin, end) { + return reify(this, sliceFactory(this, begin, end, true)); + }, + + some: function some(predicate, context) { + assertNotInfinite(this.size); + var returnValue = false; + this.__iterate(function (v, k, c) { + if (predicate.call(context, v, k, c)) { + returnValue = true; + return false; + } + }); + return returnValue; + }, + + sort: function sort(comparator) { + return reify(this, sortFactory(this, comparator)); + }, + + values: function values() { + return this.__iterator(ITERATE_VALUES); + }, + + // ### More sequential methods + + butLast: function butLast() { + return this.slice(0, -1); + }, + + isEmpty: function isEmpty() { + return this.size !== undefined ? this.size === 0 : !this.some(function () { return true; }); + }, + + count: function count(predicate, context) { + return ensureSize( + predicate ? this.toSeq().filter(predicate, context) : this + ); + }, + + countBy: function countBy(grouper, context) { + return countByFactory(this, grouper, context); + }, + + equals: function equals(other) { + return deepEqual(this, other); + }, + + entrySeq: function entrySeq() { + // eslint-disable-next-line @typescript-eslint/no-this-alias + var collection = this; + if (collection._cache) { + // We cache as an entries array, so we can just return the cache! + return new ArraySeq(collection._cache); + } + var entriesSequence = collection.toSeq().map(entryMapper).toIndexedSeq(); + entriesSequence.fromEntrySeq = function () { return collection.toSeq(); }; + return entriesSequence; + }, + + filterNot: function filterNot(predicate, context) { + return this.filter(not(predicate), context); + }, + + findEntry: function findEntry(predicate, context, notSetValue) { + var found = notSetValue; + this.__iterate(function (v, k, c) { + if (predicate.call(context, v, k, c)) { + found = [k, v]; + return false; + } + }); + return found; + }, + + findKey: function findKey(predicate, context) { + var entry = this.findEntry(predicate, context); + return entry && entry[0]; + }, + + findLast: function findLast(predicate, context, notSetValue) { + return this.toKeyedSeq().reverse().find(predicate, context, notSetValue); + }, + + findLastEntry: function findLastEntry(predicate, context, notSetValue) { + return this.toKeyedSeq() + .reverse() + .findEntry(predicate, context, notSetValue); + }, + + findLastKey: function findLastKey(predicate, context) { + return this.toKeyedSeq().reverse().findKey(predicate, context); + }, + + first: function first(notSetValue) { + return this.find(returnTrue, null, notSetValue); + }, + + flatMap: function flatMap(mapper, context) { + return reify(this, flatMapFactory(this, mapper, context)); + }, + + flatten: function flatten(depth) { + return reify(this, flattenFactory(this, depth, true)); + }, + + fromEntrySeq: function fromEntrySeq() { + return new FromEntriesSequence(this); + }, + + get: function get(searchKey, notSetValue) { + return this.find(function (_, key) { return is(key, searchKey); }, undefined, notSetValue); + }, + + getIn: getIn, + + groupBy: function groupBy(grouper, context) { + return groupByFactory(this, grouper, context); + }, + + has: function has(searchKey) { + return this.get(searchKey, NOT_SET) !== NOT_SET; + }, + + hasIn: hasIn, + + isSubset: function isSubset(iter) { + iter = typeof iter.includes === 'function' ? iter : Collection(iter); + return this.every(function (value) { return iter.includes(value); }); + }, + + isSuperset: function isSuperset(iter) { + iter = typeof iter.isSubset === 'function' ? iter : Collection(iter); + return iter.isSubset(this); + }, + + keyOf: function keyOf(searchValue) { + return this.findKey(function (value) { return is(value, searchValue); }); + }, + + keySeq: function keySeq() { + return this.toSeq().map(keyMapper).toIndexedSeq(); + }, + + last: function last(notSetValue) { + return this.toSeq().reverse().first(notSetValue); + }, + + lastKeyOf: function lastKeyOf(searchValue) { + return this.toKeyedSeq().reverse().keyOf(searchValue); + }, + + max: function max(comparator) { + return maxFactory(this, comparator); + }, + + maxBy: function maxBy(mapper, comparator) { + return maxFactory(this, comparator, mapper); + }, + + min: function min(comparator) { + return maxFactory( + this, + comparator ? neg(comparator) : defaultNegComparator + ); + }, + + minBy: function minBy(mapper, comparator) { + return maxFactory( + this, + comparator ? neg(comparator) : defaultNegComparator, + mapper + ); + }, + + rest: function rest() { + return this.slice(1); + }, + + skip: function skip(amount) { + return amount === 0 ? this : this.slice(Math.max(0, amount)); + }, + + skipLast: function skipLast(amount) { + return amount === 0 ? this : this.slice(0, -Math.max(0, amount)); + }, + + skipWhile: function skipWhile(predicate, context) { + return reify(this, skipWhileFactory(this, predicate, context, true)); + }, + + skipUntil: function skipUntil(predicate, context) { + return this.skipWhile(not(predicate), context); + }, + + sortBy: function sortBy(mapper, comparator) { + return reify(this, sortFactory(this, comparator, mapper)); + }, + + take: function take(amount) { + return this.slice(0, Math.max(0, amount)); + }, + + takeLast: function takeLast(amount) { + return this.slice(-Math.max(0, amount)); + }, + + takeWhile: function takeWhile(predicate, context) { + return reify(this, takeWhileFactory(this, predicate, context)); + }, + + takeUntil: function takeUntil(predicate, context) { + return this.takeWhile(not(predicate), context); + }, + + update: function update(fn) { + return fn(this); + }, + + valueSeq: function valueSeq() { + return this.toIndexedSeq(); + }, + + // ### Hashable Object + + hashCode: function hashCode() { + return this.__hash || (this.__hash = hashCollection(this)); + }, + + // ### Internal + + // abstract __iterate(fn, reverse) + + // abstract __iterator(type, reverse) + }); + + var CollectionPrototype = Collection.prototype; + CollectionPrototype[IS_COLLECTION_SYMBOL] = true; + CollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.values; + CollectionPrototype.toJSON = CollectionPrototype.toArray; + CollectionPrototype.__toStringMapper = quoteString; + CollectionPrototype.inspect = CollectionPrototype.toSource = function () { + return this.toString(); + }; + CollectionPrototype.chain = CollectionPrototype.flatMap; + CollectionPrototype.contains = CollectionPrototype.includes; + + mixin(KeyedCollection, { + // ### More sequential methods + + flip: function flip() { + return reify(this, flipFactory(this)); + }, + + mapEntries: function mapEntries(mapper, context) { + var this$1$1 = this; + + var iterations = 0; + return reify( + this, + this.toSeq() + .map(function (v, k) { return mapper.call(context, [k, v], iterations++, this$1$1); }) + .fromEntrySeq() + ); + }, + + mapKeys: function mapKeys(mapper, context) { + var this$1$1 = this; + + return reify( + this, + this.toSeq() + .flip() + .map(function (k, v) { return mapper.call(context, k, v, this$1$1); }) + .flip() + ); + }, + }); + + var KeyedCollectionPrototype = KeyedCollection.prototype; + KeyedCollectionPrototype[IS_KEYED_SYMBOL] = true; + KeyedCollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.entries; + KeyedCollectionPrototype.toJSON = toObject; + KeyedCollectionPrototype.__toStringMapper = function (v, k) { return quoteString(k) + ': ' + quoteString(v); }; + + mixin(IndexedCollection, { + // ### Conversion to other types + + toKeyedSeq: function toKeyedSeq() { + return new ToKeyedSequence(this, false); + }, + + // ### ES6 Collection methods (ES6 Array and Map) + + filter: function filter(predicate, context) { + return reify(this, filterFactory(this, predicate, context, false)); + }, + + findIndex: function findIndex(predicate, context) { + var entry = this.findEntry(predicate, context); + return entry ? entry[0] : -1; + }, + + indexOf: function indexOf(searchValue) { + var key = this.keyOf(searchValue); + return key === undefined ? -1 : key; + }, + + lastIndexOf: function lastIndexOf(searchValue) { + var key = this.lastKeyOf(searchValue); + return key === undefined ? -1 : key; + }, + + reverse: function reverse() { + return reify(this, reverseFactory(this, false)); + }, + + slice: function slice(begin, end) { + return reify(this, sliceFactory(this, begin, end, false)); + }, + + splice: function splice(index, removeNum /*, ...values*/) { + var numArgs = arguments.length; + removeNum = Math.max(removeNum || 0, 0); + if (numArgs === 0 || (numArgs === 2 && !removeNum)) { + return this; + } + // If index is negative, it should resolve relative to the size of the + // collection. However size may be expensive to compute if not cached, so + // only call count() if the number is in fact negative. + index = resolveBegin(index, index < 0 ? this.count() : this.size); + var spliced = this.slice(0, index); + return reify( + this, + numArgs === 1 + ? spliced + : spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum)) + ); + }, + + // ### More collection methods + + findLastIndex: function findLastIndex(predicate, context) { + var entry = this.findLastEntry(predicate, context); + return entry ? entry[0] : -1; + }, + + first: function first(notSetValue) { + return this.get(0, notSetValue); + }, + + flatten: function flatten(depth) { + return reify(this, flattenFactory(this, depth, false)); + }, + + get: function get(index, notSetValue) { + index = wrapIndex(this, index); + return index < 0 || + this.size === Infinity || + (this.size !== undefined && index > this.size) + ? notSetValue + : this.find(function (_, key) { return key === index; }, undefined, notSetValue); + }, + + has: function has(index) { + index = wrapIndex(this, index); + return ( + index >= 0 && + (this.size !== undefined + ? this.size === Infinity || index < this.size + : this.indexOf(index) !== -1) + ); + }, + + interpose: function interpose(separator) { + return reify(this, interposeFactory(this, separator)); + }, + + interleave: function interleave(/*...collections*/) { + var collections = [this].concat(arrCopy(arguments)); + var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, collections); + var interleaved = zipped.flatten(true); + if (zipped.size) { + interleaved.size = zipped.size * collections.length; + } + return reify(this, interleaved); + }, + + keySeq: function keySeq() { + return Range(0, this.size); + }, + + last: function last(notSetValue) { + return this.get(-1, notSetValue); + }, + + skipWhile: function skipWhile(predicate, context) { + return reify(this, skipWhileFactory(this, predicate, context, false)); + }, + + zip: function zip(/*, ...collections */) { + var collections = [this].concat(arrCopy(arguments)); + return reify(this, zipWithFactory(this, defaultZipper, collections)); + }, + + zipAll: function zipAll(/*, ...collections */) { + var collections = [this].concat(arrCopy(arguments)); + return reify(this, zipWithFactory(this, defaultZipper, collections, true)); + }, + + zipWith: function zipWith(zipper /*, ...collections */) { + var collections = arrCopy(arguments); + collections[0] = this; + return reify(this, zipWithFactory(this, zipper, collections)); + }, + }); + + var IndexedCollectionPrototype = IndexedCollection.prototype; + IndexedCollectionPrototype[IS_INDEXED_SYMBOL] = true; + IndexedCollectionPrototype[IS_ORDERED_SYMBOL] = true; + + mixin(SetCollection, { + // ### ES6 Collection methods (ES6 Array and Map) + + get: function get(value, notSetValue) { + return this.has(value) ? value : notSetValue; + }, + + includes: function includes(value) { + return this.has(value); + }, + + // ### More sequential methods + + keySeq: function keySeq() { + return this.valueSeq(); + }, + }); + + var SetCollectionPrototype = SetCollection.prototype; + SetCollectionPrototype.has = CollectionPrototype.includes; + SetCollectionPrototype.contains = SetCollectionPrototype.includes; + SetCollectionPrototype.keys = SetCollectionPrototype.values; + + // Mixin subclasses + + mixin(KeyedSeq, KeyedCollectionPrototype); + mixin(IndexedSeq, IndexedCollectionPrototype); + mixin(SetSeq, SetCollectionPrototype); + + // #pragma Helper functions + + function reduce(collection, reducer, reduction, context, useFirst, reverse) { + assertNotInfinite(collection.size); + collection.__iterate(function (v, k, c) { + if (useFirst) { + useFirst = false; + reduction = v; + } else { + reduction = reducer.call(context, reduction, v, k, c); + } + }, reverse); + return reduction; + } + + function keyMapper(v, k) { + return k; + } + + function entryMapper(v, k) { + return [k, v]; + } + + function not(predicate) { + return function () { + return !predicate.apply(this, arguments); + }; + } + + function neg(predicate) { + return function () { + return -predicate.apply(this, arguments); + }; + } + + function defaultZipper() { + return arrCopy(arguments); + } + + function defaultNegComparator(a, b) { + return a < b ? 1 : a > b ? -1 : 0; + } + + function hashCollection(collection) { + if (collection.size === Infinity) { + return 0; + } + var ordered = isOrdered(collection); + var keyed = isKeyed(collection); + var h = ordered ? 1 : 0; + + collection.__iterate( + keyed + ? ordered + ? function (v, k) { + h = (31 * h + hashMerge(hash(v), hash(k))) | 0; + } + : function (v, k) { + h = (h + hashMerge(hash(v), hash(k))) | 0; + } + : ordered + ? function (v) { + h = (31 * h + hash(v)) | 0; + } + : function (v) { + h = (h + hash(v)) | 0; + } + ); + + return murmurHashOfSize(collection.size, h); + } + + function murmurHashOfSize(size, h) { + h = imul(h, 0xcc9e2d51); + h = imul((h << 15) | (h >>> -15), 0x1b873593); + h = imul((h << 13) | (h >>> -13), 5); + h = ((h + 0xe6546b64) | 0) ^ size; + h = imul(h ^ (h >>> 16), 0x85ebca6b); + h = imul(h ^ (h >>> 13), 0xc2b2ae35); + h = smi(h ^ (h >>> 16)); + return h; + } + + function hashMerge(a, b) { + return (a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2))) | 0; // int + } + + var OrderedSet = /*@__PURE__*/(function (Set) { + function OrderedSet(value) { + // eslint-disable-next-line no-constructor-return + return value === undefined || value === null + ? emptyOrderedSet() + : isOrderedSet(value) + ? value + : emptyOrderedSet().withMutations(function (set) { + var iter = SetCollection(value); + assertNotInfinite(iter.size); + iter.forEach(function (v) { return set.add(v); }); + }); + } + + if ( Set ) OrderedSet.__proto__ = Set; + OrderedSet.prototype = Object.create( Set && Set.prototype ); + OrderedSet.prototype.constructor = OrderedSet; + + OrderedSet.of = function of (/*...values*/) { + return this(arguments); + }; + + OrderedSet.fromKeys = function fromKeys (value) { + return this(KeyedCollection(value).keySeq()); + }; + + OrderedSet.prototype.toString = function toString () { + return this.__toString('OrderedSet {', '}'); + }; + + return OrderedSet; + }(Set)); + + OrderedSet.isOrderedSet = isOrderedSet; + + var OrderedSetPrototype = OrderedSet.prototype; + OrderedSetPrototype[IS_ORDERED_SYMBOL] = true; + OrderedSetPrototype.zip = IndexedCollectionPrototype.zip; + OrderedSetPrototype.zipWith = IndexedCollectionPrototype.zipWith; + OrderedSetPrototype.zipAll = IndexedCollectionPrototype.zipAll; + + OrderedSetPrototype.__empty = emptyOrderedSet; + OrderedSetPrototype.__make = makeOrderedSet; + + function makeOrderedSet(map, ownerID) { + var set = Object.create(OrderedSetPrototype); + set.size = map ? map.size : 0; + set._map = map; + set.__ownerID = ownerID; + return set; + } + + var EMPTY_ORDERED_SET; + function emptyOrderedSet() { + return ( + EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap())) + ); + } + + var PairSorting = { + LeftThenRight: -1, + RightThenLeft: 1, + }; + + function throwOnInvalidDefaultValues(defaultValues) { + if (isRecord(defaultValues)) { + throw new Error( + 'Can not call `Record` with an immutable Record as default values. Use a plain javascript object instead.' + ); + } + + if (isImmutable(defaultValues)) { + throw new Error( + 'Can not call `Record` with an immutable Collection as default values. Use a plain javascript object instead.' + ); + } + + if (defaultValues === null || typeof defaultValues !== 'object') { + throw new Error( + 'Can not call `Record` with a non-object as default values. Use a plain javascript object instead.' + ); + } + } + + var Record = function Record(defaultValues, name) { + var hasInitialized; + + throwOnInvalidDefaultValues(defaultValues); + + var RecordType = function Record(values) { + var this$1$1 = this; + + if (values instanceof RecordType) { + return values; + } + if (!(this instanceof RecordType)) { + return new RecordType(values); + } + if (!hasInitialized) { + hasInitialized = true; + var keys = Object.keys(defaultValues); + var indices = (RecordTypePrototype._indices = {}); + // Deprecated: left to attempt not to break any external code which + // relies on a ._name property existing on record instances. + // Use Record.getDescriptiveName() instead + RecordTypePrototype._name = name; + RecordTypePrototype._keys = keys; + RecordTypePrototype._defaultValues = defaultValues; + for (var i = 0; i < keys.length; i++) { + var propName = keys[i]; + indices[propName] = i; + if (RecordTypePrototype[propName]) { + /* eslint-disable no-console */ + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + typeof console === 'object' && + console.warn && + console.warn( + 'Cannot define ' + + recordName(this) + + ' with property "' + + propName + + '" since that property name is part of the Record API.' + ); + /* eslint-enable no-console */ + } else { + setProp(RecordTypePrototype, propName); + } + } + } + this.__ownerID = undefined; + this._values = List().withMutations(function (l) { + l.setSize(this$1$1._keys.length); + KeyedCollection(values).forEach(function (v, k) { + l.set(this$1$1._indices[k], v === this$1$1._defaultValues[k] ? undefined : v); + }); + }); + return this; + }; + + var RecordTypePrototype = (RecordType.prototype = + Object.create(RecordPrototype)); + RecordTypePrototype.constructor = RecordType; + + if (name) { + RecordType.displayName = name; + } + + // eslint-disable-next-line no-constructor-return + return RecordType; + }; + + Record.prototype.toString = function toString () { + var str = recordName(this) + ' { '; + var keys = this._keys; + var k; + for (var i = 0, l = keys.length; i !== l; i++) { + k = keys[i]; + str += (i ? ', ' : '') + k + ': ' + quoteString(this.get(k)); + } + return str + ' }'; + }; + + Record.prototype.equals = function equals (other) { + return ( + this === other || + (isRecord(other) && recordSeq(this).equals(recordSeq(other))) + ); + }; + + Record.prototype.hashCode = function hashCode () { + return recordSeq(this).hashCode(); + }; + + // @pragma Access + + Record.prototype.has = function has (k) { + return this._indices.hasOwnProperty(k); + }; + + Record.prototype.get = function get (k, notSetValue) { + if (!this.has(k)) { + return notSetValue; + } + var index = this._indices[k]; + var value = this._values.get(index); + return value === undefined ? this._defaultValues[k] : value; + }; + + // @pragma Modification + + Record.prototype.set = function set (k, v) { + if (this.has(k)) { + var newValues = this._values.set( + this._indices[k], + v === this._defaultValues[k] ? undefined : v + ); + if (newValues !== this._values && !this.__ownerID) { + return makeRecord(this, newValues); + } + } + return this; + }; + + Record.prototype.remove = function remove (k) { + return this.set(k); + }; + + Record.prototype.clear = function clear () { + var newValues = this._values.clear().setSize(this._keys.length); + + return this.__ownerID ? this : makeRecord(this, newValues); + }; + + Record.prototype.wasAltered = function wasAltered () { + return this._values.wasAltered(); + }; + + Record.prototype.toSeq = function toSeq () { + return recordSeq(this); + }; + + Record.prototype.toJS = function toJS$1 () { + return toJS(this); + }; + + Record.prototype.entries = function entries () { + return this.__iterator(ITERATE_ENTRIES); + }; + + Record.prototype.__iterator = function __iterator (type, reverse) { + return recordSeq(this).__iterator(type, reverse); + }; + + Record.prototype.__iterate = function __iterate (fn, reverse) { + return recordSeq(this).__iterate(fn, reverse); + }; + + Record.prototype.__ensureOwner = function __ensureOwner (ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + var newValues = this._values.__ensureOwner(ownerID); + if (!ownerID) { + this.__ownerID = ownerID; + this._values = newValues; + return this; + } + return makeRecord(this, newValues, ownerID); + }; + + Record.isRecord = isRecord; + Record.getDescriptiveName = recordName; + var RecordPrototype = Record.prototype; + RecordPrototype[IS_RECORD_SYMBOL] = true; + RecordPrototype[DELETE] = RecordPrototype.remove; + RecordPrototype.deleteIn = RecordPrototype.removeIn = deleteIn; + RecordPrototype.getIn = getIn; + RecordPrototype.hasIn = CollectionPrototype.hasIn; + RecordPrototype.merge = merge$1; + RecordPrototype.mergeWith = mergeWith$1; + RecordPrototype.mergeIn = mergeIn; + RecordPrototype.mergeDeep = mergeDeep; + RecordPrototype.mergeDeepWith = mergeDeepWith; + RecordPrototype.mergeDeepIn = mergeDeepIn; + RecordPrototype.setIn = setIn; + RecordPrototype.update = update; + RecordPrototype.updateIn = updateIn; + RecordPrototype.withMutations = withMutations; + RecordPrototype.asMutable = asMutable; + RecordPrototype.asImmutable = asImmutable; + RecordPrototype[ITERATOR_SYMBOL] = RecordPrototype.entries; + RecordPrototype.toJSON = RecordPrototype.toObject = + CollectionPrototype.toObject; + RecordPrototype.inspect = RecordPrototype.toSource = function () { + return this.toString(); + }; + + function makeRecord(likeRecord, values, ownerID) { + var record = Object.create(Object.getPrototypeOf(likeRecord)); + record._values = values; + record.__ownerID = ownerID; + return record; + } + + function recordName(record) { + return record.constructor.displayName || record.constructor.name || 'Record'; + } + + function recordSeq(record) { + return keyedSeqFromValue(record._keys.map(function (k) { return [k, record.get(k)]; })); + } + + function setProp(prototype, name) { + try { + Object.defineProperty(prototype, name, { + get: function () { + return this.get(name); + }, + set: function (value) { + invariant(this.__ownerID, 'Cannot set on an immutable record.'); + this.set(name, value); + }, + }); + // eslint-disable-next-line @typescript-eslint/no-unused-vars -- TODO enable eslint here + } catch (error) { + // Object.defineProperty failed. Probably IE8. + } + } + + /** + * Returns a lazy Seq of `value` repeated `times` times. When `times` is + * undefined, returns an infinite sequence of `value`. + */ + var Repeat = /*@__PURE__*/(function (IndexedSeq) { + function Repeat(value, times) { + if (!(this instanceof Repeat)) { + // eslint-disable-next-line no-constructor-return + return new Repeat(value, times); + } + this._value = value; + this.size = times === undefined ? Infinity : Math.max(0, times); + if (this.size === 0) { + if (EMPTY_REPEAT) { + // eslint-disable-next-line no-constructor-return + return EMPTY_REPEAT; + } + // eslint-disable-next-line @typescript-eslint/no-this-alias + EMPTY_REPEAT = this; + } + } + + if ( IndexedSeq ) Repeat.__proto__ = IndexedSeq; + Repeat.prototype = Object.create( IndexedSeq && IndexedSeq.prototype ); + Repeat.prototype.constructor = Repeat; + + Repeat.prototype.toString = function toString () { + if (this.size === 0) { + return 'Repeat []'; + } + return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]'; + }; + + Repeat.prototype.get = function get (index, notSetValue) { + return this.has(index) ? this._value : notSetValue; + }; + + Repeat.prototype.includes = function includes (searchValue) { + return is(this._value, searchValue); + }; + + Repeat.prototype.slice = function slice (begin, end) { + var size = this.size; + return wholeSlice(begin, end, size) + ? this + : new Repeat( + this._value, + resolveEnd(end, size) - resolveBegin(begin, size) + ); + }; + + Repeat.prototype.reverse = function reverse () { + return this; + }; + + Repeat.prototype.indexOf = function indexOf (searchValue) { + if (is(this._value, searchValue)) { + return 0; + } + return -1; + }; + + Repeat.prototype.lastIndexOf = function lastIndexOf (searchValue) { + if (is(this._value, searchValue)) { + return this.size; + } + return -1; + }; + + Repeat.prototype.__iterate = function __iterate (fn, reverse) { + var size = this.size; + var i = 0; + while (i !== size) { + if (fn(this._value, reverse ? size - ++i : i++, this) === false) { + break; + } + } + return i; + }; + + Repeat.prototype.__iterator = function __iterator (type, reverse) { + var this$1$1 = this; + + var size = this.size; + var i = 0; + return new Iterator(function () { return i === size + ? iteratorDone() + : iteratorValue(type, reverse ? size - ++i : i++, this$1$1._value); } + ); + }; + + Repeat.prototype.equals = function equals (other) { + return other instanceof Repeat + ? is(this._value, other._value) + : deepEqual(this, other); + }; + + return Repeat; + }(IndexedSeq)); + + var EMPTY_REPEAT; + + function fromJS(value, converter) { + return fromJSWith( + [], + converter || defaultConverter, + value, + '', + converter && converter.length > 2 ? [] : undefined, + { '': value } + ); + } + + function fromJSWith(stack, converter, value, key, keyPath, parentValue) { + if ( + typeof value !== 'string' && + !isImmutable(value) && + (isArrayLike(value) || hasIterator(value) || isPlainObject(value)) + ) { + if (~stack.indexOf(value)) { + throw new TypeError('Cannot convert circular structure to Immutable'); + } + stack.push(value); + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + keyPath && key !== '' && keyPath.push(key); + var converted = converter.call( + parentValue, + key, + Seq(value).map(function (v, k) { return fromJSWith(stack, converter, v, k, keyPath, value); } + ), + keyPath && keyPath.slice() + ); + stack.pop(); + // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here + keyPath && keyPath.pop(); + return converted; + } + return value; + } + + function defaultConverter(k, v) { + // Effectively the opposite of "Collection.toSeq()" + return isIndexed(v) ? v.toList() : isKeyed(v) ? v.toMap() : v.toSet(); + } + + var version = "5.1.1"; + + // Note: Iterable is deprecated + var Iterable = Collection; + + exports.Collection = Collection; + exports.Iterable = Iterable; + exports.List = List; + exports.Map = Map; + exports.OrderedMap = OrderedMap; + exports.OrderedSet = OrderedSet; + exports.PairSorting = PairSorting; + exports.Range = Range; + exports.Record = Record; + exports.Repeat = Repeat; + exports.Seq = Seq; + exports.Set = Set; + exports.Stack = Stack; + exports.fromJS = fromJS; + exports.get = get; + exports.getIn = getIn$1; + exports.has = has; + exports.hasIn = hasIn$1; + exports.hash = hash; + exports.is = is; + exports.isAssociative = isAssociative; + exports.isCollection = isCollection; + exports.isImmutable = isImmutable; + exports.isIndexed = isIndexed; + exports.isKeyed = isKeyed; + exports.isList = isList; + exports.isMap = isMap; + exports.isOrdered = isOrdered; + exports.isOrderedMap = isOrderedMap; + exports.isOrderedSet = isOrderedSet; + exports.isPlainObject = isPlainObject; + exports.isRecord = isRecord; + exports.isSeq = isSeq; + exports.isSet = isSet; + exports.isStack = isStack; + exports.isValueObject = isValueObject; + exports.merge = merge; + exports.mergeDeep = mergeDeep$1; + exports.mergeDeepWith = mergeDeepWith$1; + exports.mergeWith = mergeWith; + exports.remove = remove; + exports.removeIn = removeIn; + exports.set = set; + exports.setIn = setIn$1; + exports.update = update$1; + exports.updateIn = updateIn$1; + exports.version = version; + +})); diff --git a/node_modules/immutable/dist/immutable.js.flow b/node_modules/immutable/dist/immutable.js.flow new file mode 100644 index 0000000..9ab444d --- /dev/null +++ b/node_modules/immutable/dist/immutable.js.flow @@ -0,0 +1,2414 @@ +/** + * This file provides type definitions for use with the Flow type checker. + * + * An important caveat when using these definitions is that the types for + * `Collection.Keyed`, `Collection.Indexed`, `Seq.Keyed`, and so on are stubs. + * When referring to those types, you can get the proper definitions by + * importing the types `KeyedCollection`, `IndexedCollection`, `KeyedSeq`, etc. + * For example, + * + * import { Seq } from 'immutable' + * import type { IndexedCollection, IndexedSeq } from 'immutable' + * + * const someSeq: IndexedSeq = Seq.Indexed.of(1, 2, 3) + * + * function takesASeq>(iter: TS): TS { + * return iter.butLast() + * } + * + * takesASeq(someSeq) + * + * @flow strict + */ + +// Helper type that represents plain objects allowed as arguments to +// some constructors and functions. +type PlainObjInput = { +[key: K]: V, __proto__: null }; + +type K = $Keys; + +// Helper types to extract the "keys" and "values" use by the *In() methods. +type $KeyOf = $Call< + ((?_Collection) => K) & + ((?$ReadOnlyArray) => number) & + ((?RecordInstance | T) => $Keys) & + ((T) => $Keys), + C, +>; + +type $ValOf> = $Call< + ((?_Collection) => V) & + ((?$ReadOnlyArray) => T) & + (>(?RecordInstance | T, K) => $ElementType) & + ((T) => $Values), + C, + K, +>; + +type $IterableOf = $Call< + ( | IndexedCollection | SetCollection>( + V + ) => Iterable<$ValOf>) & + (< + V: + | KeyedCollection + | RecordInstance + | PlainObjInput, + >( + V + ) => Iterable<[$KeyOf, $ValOf]>), + C, +>; + +const PairSorting: $ReadOnly<{ LeftThenRight: number, RightThenLeft: number }> = + { + LeftThenRight: -1, + RightThenLeft: +1, + }; + +type Comparator = (left: T, right: T) => number; + +declare class _Collection implements ValueObject { + equals(other: mixed): boolean; + hashCode(): number; + get(key: K, ..._: []): V | void; + get(key: K, notSetValue: NSV): V | NSV; + has(key: K): boolean; + includes(value: V): boolean; + contains(value: V): boolean; + first(): V | void; + first(notSetValue: NSV): V | NSV; + last(): V | void; + last(notSetValue: NSV): V | NSV; + + hasIn(keyPath: Iterable): boolean; + + getIn(keyPath: [], notSetValue?: mixed): this; + getIn(keyPath: [K], notSetValue: NSV): V | NSV; + getIn>( + keyPath: [K, K2], + notSetValue: NSV + ): $ValOf | NSV; + getIn, K3: $KeyOf<$ValOf>>( + keyPath: [K, K2, K3], + notSetValue: NSV + ): $ValOf<$ValOf, K3> | NSV; + getIn< + NSV, + K2: $KeyOf, + K3: $KeyOf<$ValOf>, + K4: $KeyOf<$ValOf<$ValOf, K3>>, + >( + keyPath: [K, K2, K3, K4], + notSetValue: NSV + ): $ValOf<$ValOf<$ValOf, K3>, K4> | NSV; + getIn< + NSV, + K2: $KeyOf, + K3: $KeyOf<$ValOf>, + K4: $KeyOf<$ValOf<$ValOf, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf, K3>, K4>>, + >( + keyPath: [K, K2, K3, K4, K5], + notSetValue: NSV + ): $ValOf<$ValOf<$ValOf<$ValOf, K3>, K4>, K5> | NSV; + + update(updater: (value: this) => U): U; + + toJS(): Array | { [key: string]: mixed }; + toJSON(): Array | { [key: string]: V }; + toArray(): Array | Array<[K, V]>; + toObject(): { [key: string]: V }; + toMap(): Map; + toOrderedMap(): OrderedMap; + toSet(): Set; + toOrderedSet(): OrderedSet; + toList(): List; + toStack(): Stack; + toSeq(): Seq; + toKeyedSeq(): KeyedSeq; + toIndexedSeq(): IndexedSeq; + toSetSeq(): SetSeq; + + keys(): Iterator; + values(): Iterator; + entries(): Iterator<[K, V]>; + + keySeq(): IndexedSeq; + valueSeq(): IndexedSeq; + entrySeq(): IndexedSeq<[K, V]>; + + reverse(): this; + sort(comparator?: Comparator): this; + + sortBy( + comparatorValueMapper: (value: V, key: K, iter: this) => C, + comparator?: Comparator + ): this; + + groupBy( + grouper: (value: V, key: K, iter: this) => G, + context?: mixed + ): KeyedSeq; + + forEach( + sideEffect: (value: V, key: K, iter: this) => any, + context?: mixed + ): number; + + slice(begin?: number, end?: number): this; + rest(): this; + butLast(): this; + skip(amount: number): this; + skipLast(amount: number): this; + skipWhile( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): this; + skipUntil( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): this; + take(amount: number): this; + takeLast(amount: number): this; + takeWhile( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): this; + takeUntil( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): this; + + filterNot( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): this; + + reduce( + reducer: (reduction: R, value: V, key: K, iter: this) => R, + initialReduction: R, + context?: mixed + ): R; + reduce(reducer: (reduction: V | R, value: V, key: K, iter: this) => R): R; + + reduceRight( + reducer: (reduction: R, value: V, key: K, iter: this) => R, + initialReduction: R, + context?: mixed + ): R; + reduceRight( + reducer: (reduction: V | R, value: V, key: K, iter: this) => R + ): R; + + every( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): boolean; + some( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): boolean; + join(separator?: string): string; + isEmpty(): boolean; + count( + predicate?: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): number; + countBy( + grouper: (value: V, key: K, iter: this) => G, + context?: mixed + ): Map; + + find( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed, + notSetValue?: V + ): V | void; + findLast( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed, + notSetValue?: V + ): V | void; + + findEntry(predicate: (value: V, key: K, iter: this) => mixed): [K, V] | void; + findLastEntry( + predicate: (value: V, key: K, iter: this) => mixed + ): [K, V] | void; + + findKey( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): K | void; + findLastKey( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): K | void; + + keyOf(searchValue: V): K | void; + lastKeyOf(searchValue: V): K | void; + + max(comparator?: Comparator): V; + maxBy( + comparatorValueMapper: (value: V, key: K, iter: this) => C, + comparator?: Comparator + ): V; + min(comparator?: Comparator): V; + minBy( + comparatorValueMapper: (value: V, key: K, iter: this) => C, + comparator?: Comparator + ): V; + + isSubset(iter: Iterable): boolean; + isSuperset(iter: Iterable): boolean; +} + +declare function isImmutable( + maybeImmutable: mixed +): boolean %checks(maybeImmutable instanceof Collection); +declare function isCollection( + maybeCollection: mixed +): boolean %checks(maybeCollection instanceof Collection); +declare function isKeyed( + maybeKeyed: mixed +): boolean %checks(maybeKeyed instanceof KeyedCollection); +declare function isIndexed( + maybeIndexed: mixed +): boolean %checks(maybeIndexed instanceof IndexedCollection); +declare function isAssociative( + maybeAssociative: mixed +): boolean %checks(maybeAssociative instanceof KeyedCollection || + maybeAssociative instanceof IndexedCollection); +declare function isOrdered( + maybeOrdered: mixed +): boolean %checks(maybeOrdered instanceof IndexedCollection || + maybeOrdered instanceof OrderedMap || + maybeOrdered instanceof OrderedSet); +declare function isValueObject(maybeValue: mixed): boolean; + +declare function isSeq(maybeSeq: any): boolean %checks(maybeSeq instanceof Seq); +declare function isList(maybeList: any): boolean %checks(maybeList instanceof + List); +declare function isMap(maybeMap: any): boolean %checks(maybeMap instanceof Map); +declare function isOrderedMap( + maybeOrderedMap: any +): boolean %checks(maybeOrderedMap instanceof OrderedMap); +declare function isStack(maybeStack: any): boolean %checks(maybeStack instanceof + Stack); +declare function isSet(maybeSet: any): boolean %checks(maybeSet instanceof Set); +declare function isOrderedSet( + maybeOrderedSet: any +): boolean %checks(maybeOrderedSet instanceof OrderedSet); +declare function isRecord( + maybeRecord: any +): boolean %checks(maybeRecord instanceof Record); + +declare interface ValueObject { + equals(other: mixed): boolean; + hashCode(): number; +} + +declare class Collection extends _Collection { + static Keyed: typeof KeyedCollection; + static Indexed: typeof IndexedCollection; + static Set: typeof SetCollection; + + static isCollection: typeof isCollection; + static isKeyed: typeof isKeyed; + static isIndexed: typeof isIndexed; + static isAssociative: typeof isAssociative; + static isOrdered: typeof isOrdered; +} + +declare class KeyedCollection extends Collection { + static ( + values?: Iterable<[K, V]> | PlainObjInput + ): KeyedCollection; + + toJS(): { [key: string]: mixed }; + toJSON(): { [key: string]: V }; + toArray(): Array<[K, V]>; + @@iterator(): Iterator<[K, V]>; + toSeq(): KeyedSeq; + flip(): KeyedCollection; + + concat( + ...iters: Array | PlainObjInput> + ): KeyedCollection; + + filter(predicate: typeof Boolean): KeyedCollection>; + filter( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): KeyedCollection; + + partition( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): [this, this]; + + map( + mapper: (value: V, key: K, iter: this) => M, + context?: mixed + ): KeyedCollection; + + mapKeys( + mapper: (key: K, value: V, iter: this) => M, + context?: mixed + ): KeyedCollection; + + mapEntries( + mapper: (entry: [K, V], index: number, iter: this) => [KM, VM], + context?: mixed + ): KeyedCollection; + + flatMap( + mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>, + context?: mixed + ): KeyedCollection; + + flatten(depth?: number): KeyedCollection; + flatten(shallow?: boolean): KeyedCollection; +} + +Collection.Keyed = KeyedCollection; + +declare class IndexedCollection<+T> extends Collection { + static (iter?: Iterable): IndexedCollection; + + toJS(): Array; + toJSON(): Array; + toArray(): Array; + @@iterator(): Iterator; + toSeq(): IndexedSeq; + fromEntrySeq(): KeyedSeq; + interpose(separator: T): this; + interleave(...collections: Iterable[]): this; + splice(index: number, removeNum: number, ...values: T[]): this; + + zip(a: Iterable, ..._: []): IndexedCollection<[T, A]>; + zip( + a: Iterable, + b: Iterable, + ..._: [] + ): IndexedCollection<[T, A, B]>; + zip( + a: Iterable, + b: Iterable, + c: Iterable, + ..._: [] + ): IndexedCollection<[T, A, B, C]>; + zip( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + ..._: [] + ): IndexedCollection<[T, A, B, C, D]>; + zip( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + e: Iterable, + ..._: [] + ): IndexedCollection<[T, A, B, C, D, E]>; + + zipAll(a: Iterable, ..._: []): IndexedCollection<[T | void, A | void]>; + zipAll( + a: Iterable, + b: Iterable, + ..._: [] + ): IndexedCollection<[T | void, A | void, B | void]>; + zipAll( + a: Iterable, + b: Iterable, + c: Iterable, + ..._: [] + ): IndexedCollection<[T | void, A | void, B | void, C | void]>; + zipAll( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + ..._: [] + ): IndexedCollection<[T | void, A | void, B | void, C | void, D | void]>; + zipAll( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + e: Iterable, + ..._: [] + ): IndexedCollection< + [T | void, A | void, B | void, C | void, D | void, E | void], + >; + + zipWith( + zipper: (value: T, a: A) => R, + a: Iterable, + ..._: [] + ): IndexedCollection; + zipWith( + zipper: (value: T, a: A, b: B) => R, + a: Iterable, + b: Iterable, + ..._: [] + ): IndexedCollection; + zipWith( + zipper: (value: T, a: A, b: B, c: C) => R, + a: Iterable, + b: Iterable, + c: Iterable, + ..._: [] + ): IndexedCollection; + zipWith( + zipper: (value: T, a: A, b: B, c: C, d: D) => R, + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + ..._: [] + ): IndexedCollection; + zipWith( + zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R, + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + e: Iterable, + ..._: [] + ): IndexedCollection; + + indexOf(searchValue: T): number; + lastIndexOf(searchValue: T): number; + findIndex( + predicate: (value: T, index: number, iter: this) => mixed, + context?: mixed + ): number; + findLastIndex( + predicate: (value: T, index: number, iter: this) => mixed, + context?: mixed + ): number; + + concat(...iters: Array | C>): IndexedCollection; + + filter(predicate: typeof Boolean): IndexedCollection<$NonMaybeType>; + filter( + predicate: (value: T, index: number, iter: this) => mixed, + context?: mixed + ): IndexedCollection; + + partition( + predicate: (value: T, index: number, iter: this) => mixed, + context?: mixed + ): [this, this]; + + map( + mapper: (value: T, index: number, iter: this) => M, + context?: mixed + ): IndexedCollection; + + flatMap( + mapper: (value: T, index: number, iter: this) => Iterable, + context?: mixed + ): IndexedCollection; + + flatten(depth?: number): IndexedCollection; + flatten(shallow?: boolean): IndexedCollection; +} + +declare class SetCollection<+T> extends Collection { + static (iter?: Iterable): SetCollection; + + toJS(): Array; + toJSON(): Array; + toArray(): Array; + @@iterator(): Iterator; + toSeq(): SetSeq; + + concat(...collections: Iterable[]): SetCollection; + + // `filter`, `map` and `flatMap` cannot be defined further up the hierarchy, + // because the implementation for `KeyedCollection` allows the value type to + // change without constraining the key type. That does not work for + // `SetCollection` - the value and key types *must* match. + filter(predicate: typeof Boolean): SetCollection<$NonMaybeType>; + filter( + predicate: (value: T, value: T, iter: this) => mixed, + context?: mixed + ): SetCollection; + + partition( + predicate: (value: T, value: T, iter: this) => mixed, + context?: mixed + ): [this, this]; + + map( + mapper: (value: T, value: T, iter: this) => M, + context?: mixed + ): SetCollection; + + flatMap( + mapper: (value: T, value: T, iter: this) => Iterable, + context?: mixed + ): SetCollection; + + flatten(depth?: number): SetCollection; + flatten(shallow?: boolean): SetCollection; +} + +declare function isSeq(maybeSeq: mixed): boolean %checks(maybeSeq instanceof + Seq); +declare class Seq extends _Collection { + static Keyed: typeof KeyedSeq; + static Indexed: typeof IndexedSeq; + static Set: typeof SetSeq; + + static (values: KeyedSeq): KeyedSeq; + static (values: SetSeq): SetSeq; + static (values: Iterable): IndexedSeq; + static (values?: PlainObjInput): KeyedSeq; + + static isSeq: typeof isSeq; + + size: number | void; + cacheResult(): this; + toSeq(): this; +} + +declare class KeyedSeq extends Seq mixins KeyedCollection { + static ( + values?: Iterable<[K, V]> | PlainObjInput + ): KeyedSeq; + + // Override specialized return types + flip(): KeyedSeq; + + concat( + ...iters: Array | PlainObjInput> + ): KeyedSeq; + + filter(predicate: typeof Boolean): KeyedSeq>; + filter( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): KeyedSeq; + + partition( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): [this, this]; + + map( + mapper: (value: V, key: K, iter: this) => M, + context?: mixed + ): KeyedSeq; + + mapKeys( + mapper: (key: K, value: V, iter: this) => M, + context?: mixed + ): KeyedSeq; + + mapEntries( + mapper: (entry: [K, V], index: number, iter: this) => [KM, VM], + context?: mixed + ): KeyedSeq; + + flatMap( + mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>, + context?: mixed + ): KeyedSeq; + + flatten(depth?: number): KeyedSeq; + flatten(shallow?: boolean): KeyedSeq; +} + +declare class IndexedSeq<+T> + extends Seq + mixins IndexedCollection +{ + static (values?: Iterable): IndexedSeq; + + static of(...values: T[]): IndexedSeq; + + // Override specialized return types + + concat(...iters: Array | C>): IndexedSeq; + + filter(predicate: typeof Boolean): IndexedSeq<$NonMaybeType>; + filter( + predicate: (value: T, index: number, iter: this) => mixed, + context?: mixed + ): IndexedSeq; + + partition( + predicate: (value: T, index: number, iter: this) => mixed, + context?: mixed + ): [this, this]; + + map( + mapper: (value: T, index: number, iter: this) => M, + context?: mixed + ): IndexedSeq; + + flatMap( + mapper: (value: T, index: number, iter: this) => Iterable, + context?: mixed + ): IndexedSeq; + + flatten(depth?: number): IndexedSeq; + flatten(shallow?: boolean): IndexedSeq; + + zip(a: Iterable, ..._: []): IndexedSeq<[T, A]>; + zip(a: Iterable, b: Iterable, ..._: []): IndexedSeq<[T, A, B]>; + zip( + a: Iterable, + b: Iterable, + c: Iterable, + ..._: [] + ): IndexedSeq<[T, A, B, C]>; + zip( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + ..._: [] + ): IndexedSeq<[T, A, B, C, D]>; + zip( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + e: Iterable, + ..._: [] + ): IndexedSeq<[T, A, B, C, D, E]>; + + zipAll(a: Iterable, ..._: []): IndexedSeq<[T | void, A | void]>; + zipAll( + a: Iterable, + b: Iterable, + ..._: [] + ): IndexedSeq<[T | void, A | void, B | void]>; + zipAll( + a: Iterable, + b: Iterable, + c: Iterable, + ..._: [] + ): IndexedSeq<[T | void, A | void, B | void, C | void]>; + zipAll( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + ..._: [] + ): IndexedSeq<[T | void, A | void, B | void, C | void, D | void]>; + zipAll( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + e: Iterable, + ..._: [] + ): IndexedSeq<[T | void, A | void, B | void, C | void, D | void, E | void]>; + + zipWith( + zipper: (value: T, a: A) => R, + a: Iterable, + ..._: [] + ): IndexedSeq; + zipWith( + zipper: (value: T, a: A, b: B) => R, + a: Iterable, + b: Iterable, + ..._: [] + ): IndexedSeq; + zipWith( + zipper: (value: T, a: A, b: B, c: C) => R, + a: Iterable, + b: Iterable, + c: Iterable, + ..._: [] + ): IndexedSeq; + zipWith( + zipper: (value: T, a: A, b: B, c: C, d: D) => R, + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + ..._: [] + ): IndexedSeq; + zipWith( + zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R, + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + e: Iterable, + ..._: [] + ): IndexedSeq; +} + +declare class SetSeq<+T> extends Seq mixins SetCollection { + static (values?: Iterable): SetSeq; + + static of(...values: T[]): SetSeq; + + // Override specialized return types + + concat(...collections: Iterable[]): SetSeq; + + filter(predicate: typeof Boolean): SetSeq<$NonMaybeType>; + filter( + predicate: (value: T, value: T, iter: this) => mixed, + context?: mixed + ): SetSeq; + + partition( + predicate: (value: T, value: T, iter: this) => mixed, + context?: mixed + ): [this, this]; + + map( + mapper: (value: T, value: T, iter: this) => M, + context?: mixed + ): SetSeq; + + flatMap( + mapper: (value: T, value: T, iter: this) => Iterable, + context?: mixed + ): SetSeq; + + flatten(depth?: number): SetSeq; + flatten(shallow?: boolean): SetSeq; +} + +declare class UpdatableInCollection { + setIn(keyPath: [], value: S): S; + setIn(keyPath: [K], value: V): this; + setIn, S: $ValOf>(keyPath: [K, K2], value: S): this; + setIn, K3: $KeyOf<$ValOf>, S: $ValOf<$ValOf, K3>>( + keyPath: [K, K2, K3], + value: S + ): this; + setIn< + K2: $KeyOf, + K3: $KeyOf<$ValOf>, + K4: $KeyOf<$ValOf<$ValOf, K3>>, + S: $ValOf<$ValOf<$ValOf, K3>, K4>, + >( + keyPath: [K, K2, K3, K4], + value: S + ): this; + setIn< + K2: $KeyOf, + K3: $KeyOf<$ValOf>, + K4: $KeyOf<$ValOf<$ValOf, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf, K3>, K4>>, + S: $ValOf<$ValOf<$ValOf<$ValOf, K3>, K4>, K5>, + >( + keyPath: [K, K2, K3, K4, K5], + value: S + ): this; + + deleteIn(keyPath: []): void; + deleteIn(keyPath: [K]): this; + deleteIn>(keyPath: [K, K2]): this; + deleteIn, K3: $KeyOf<$ValOf>>( + keyPath: [K, K2, K3] + ): this; + deleteIn< + K2: $KeyOf, + K3: $KeyOf<$ValOf>, + K4: $KeyOf<$ValOf<$ValOf, K3>>, + >( + keyPath: [K, K2, K3, K4] + ): this; + deleteIn< + K2: $KeyOf, + K3: $KeyOf<$ValOf>, + K4: $KeyOf<$ValOf<$ValOf, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf, K3>, K4>>, + >( + keyPath: [K, K2, K3, K4, K5] + ): this; + + removeIn(keyPath: []): void; + removeIn(keyPath: [K]): this; + removeIn>(keyPath: [K, K2]): this; + removeIn, K3: $KeyOf<$ValOf>>( + keyPath: [K, K2, K3] + ): this; + removeIn< + K2: $KeyOf, + K3: $KeyOf<$ValOf>, + K4: $KeyOf<$ValOf<$ValOf, K3>>, + >( + keyPath: [K, K2, K3, K4] + ): this; + removeIn< + K2: $KeyOf, + K3: $KeyOf<$ValOf>, + K4: $KeyOf<$ValOf<$ValOf, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf, K3>, K4>>, + >( + keyPath: [K, K2, K3, K4, K5] + ): this; + + updateIn(keyPath: [], notSetValue: mixed, updater: (value: this) => U): U; + updateIn(keyPath: [], updater: (value: this) => U): U; + updateIn(keyPath: [K], notSetValue: NSV, updater: (value: V) => V): this; + updateIn(keyPath: [K], updater: (value: V) => V): this; + updateIn, S: $ValOf>( + keyPath: [K, K2], + notSetValue: NSV, + updater: (value: $ValOf | NSV) => S + ): this; + updateIn, S: $ValOf>( + keyPath: [K, K2], + updater: (value: $ValOf) => S + ): this; + updateIn< + NSV, + K2: $KeyOf, + K3: $KeyOf<$ValOf>, + S: $ValOf<$ValOf, K3>, + >( + keyPath: [K, K2, K3], + notSetValue: NSV, + updater: (value: $ValOf<$ValOf, K3> | NSV) => S + ): this; + updateIn< + K2: $KeyOf, + K3: $KeyOf<$ValOf>, + S: $ValOf<$ValOf, K3>, + >( + keyPath: [K, K2, K3], + updater: (value: $ValOf<$ValOf, K3>) => S + ): this; + updateIn< + NSV, + K2: $KeyOf, + K3: $KeyOf<$ValOf>, + K4: $KeyOf<$ValOf<$ValOf, K3>>, + S: $ValOf<$ValOf<$ValOf, K3>, K4>, + >( + keyPath: [K, K2, K3, K4], + notSetValue: NSV, + updater: (value: $ValOf<$ValOf<$ValOf, K3>, K4> | NSV) => S + ): this; + updateIn< + K2: $KeyOf, + K3: $KeyOf<$ValOf>, + K4: $KeyOf<$ValOf<$ValOf, K3>>, + S: $ValOf<$ValOf<$ValOf, K3>, K4>, + >( + keyPath: [K, K2, K3, K4], + updater: (value: $ValOf<$ValOf<$ValOf, K3>, K4>) => S + ): this; + updateIn< + NSV, + K2: $KeyOf, + K3: $KeyOf<$ValOf>, + K4: $KeyOf<$ValOf<$ValOf, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf, K3>, K4>>, + S: $ValOf<$ValOf<$ValOf<$ValOf, K3>, K4>, K5>, + >( + keyPath: [K, K2, K3, K4, K5], + notSetValue: NSV, + updater: ( + value: $ValOf<$ValOf<$ValOf<$ValOf, K3>, K4>, K5> | NSV + ) => S + ): this; + updateIn< + K2: $KeyOf, + K3: $KeyOf<$ValOf>, + K4: $KeyOf<$ValOf<$ValOf, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf, K3>, K4>>, + S: $ValOf<$ValOf<$ValOf<$ValOf, K3>, K4>, K5>, + >( + keyPath: [K, K2, K3, K4, K5], + updater: (value: $ValOf<$ValOf<$ValOf<$ValOf, K3>, K4>, K5>) => S + ): this; +} + +declare function isList(maybeList: mixed): boolean %checks(maybeList instanceof + List); +declare class List<+T> + extends IndexedCollection + mixins UpdatableInCollection +{ + static (collection?: Iterable): List; + + static of(...values: T[]): List; + + static isList: typeof isList; + + size: number; + + set(index: number, value: U): List; + delete(index: number): this; + remove(index: number): this; + insert(index: number, value: U): List; + clear(): this; + push(...values: U[]): List; + pop(): this; + unshift(...values: U[]): List; + shift(): this; + + update(updater: (value: this) => U): U; + update(index: number, updater: (value: T) => U): List; + update( + index: number, + notSetValue: U, + updater: (value: T) => U + ): List; + + merge(...collections: Iterable[]): List; + + setSize(size: number): this; + + mergeIn(keyPath: Iterable, ...collections: Iterable[]): this; + mergeDeepIn( + keyPath: Iterable, + ...collections: Iterable[] + ): this; + + withMutations(mutator: (mutable: this) => mixed): this; + asMutable(): this; + wasAltered(): boolean; + asImmutable(): this; + + // Override specialized return types + + concat(...iters: Array | C>): List; + + filter(predicate: typeof Boolean): List<$NonMaybeType>; + filter( + predicate: (value: T, index: number, iter: this) => mixed, + context?: mixed + ): List; + + partition( + predicate: (value: T, index: number, iter: this) => mixed, + context?: mixed + ): [this, this]; + + map( + mapper: (value: T, index: number, iter: this) => M, + context?: mixed + ): List; + + flatMap( + mapper: (value: T, index: number, iter: this) => Iterable, + context?: mixed + ): List; + + flatten(depth?: number): List; + flatten(shallow?: boolean): List; + + zip(a: Iterable, ..._: []): List<[T, A]>; + zip(a: Iterable, b: Iterable, ..._: []): List<[T, A, B]>; + zip( + a: Iterable, + b: Iterable, + c: Iterable, + ..._: [] + ): List<[T, A, B, C]>; + zip( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + ..._: [] + ): List<[T, A, B, C, D]>; + zip( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + e: Iterable, + ..._: [] + ): List<[T, A, B, C, D, E]>; + + zipAll(a: Iterable, ..._: []): List<[T | void, A | void]>; + zipAll( + a: Iterable, + b: Iterable, + ..._: [] + ): List<[T | void, A | void, B | void]>; + zipAll( + a: Iterable, + b: Iterable, + c: Iterable, + ..._: [] + ): List<[T | void, A | void, B | void, C | void]>; + zipAll( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + ..._: [] + ): List<[T | void, A | void, B | void, C | void, D | void]>; + zipAll( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + e: Iterable, + ..._: [] + ): List<[T | void, A | void, B | void, C | void, D | void, E | void]>; + + zipWith( + zipper: (value: T, a: A) => R, + a: Iterable, + ..._: [] + ): List; + zipWith( + zipper: (value: T, a: A, b: B) => R, + a: Iterable, + b: Iterable, + ..._: [] + ): List; + zipWith( + zipper: (value: T, a: A, b: B, c: C) => R, + a: Iterable, + b: Iterable, + c: Iterable, + ..._: [] + ): List; + zipWith( + zipper: (value: T, a: A, b: B, c: C, d: D) => R, + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + ..._: [] + ): List; + zipWith( + zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R, + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + e: Iterable, + ..._: [] + ): List; +} + +declare function isMap(maybeMap: mixed): boolean %checks(maybeMap instanceof + Map); +declare class Map + extends KeyedCollection + mixins UpdatableInCollection +{ + static (values?: Iterable<[K, V]> | PlainObjInput): Map; + + static isMap: typeof isMap; + + size: number; + + set(key: K_, value: V_): Map; + delete(key: K): this; + remove(key: K): this; + clear(): this; + + deleteAll(keys: Iterable): Map; + removeAll(keys: Iterable): Map; + + update(updater: (value: this) => U): U; + update(key: K, updater: (value: V) => V_): Map; + update( + key: K, + notSetValue: V_, + updater: (value: V) => V_ + ): Map; + + merge( + ...collections: (Iterable<[K_, V_]> | PlainObjInput)[] + ): Map; + concat( + ...collections: (Iterable<[K_, V_]> | PlainObjInput)[] + ): Map; + + mergeWith( + merger: (oldVal: V, newVal: W, key: K) => X, + ...collections: (Iterable<[K_, W]> | PlainObjInput)[] + ): Map; + + mergeDeep( + ...collections: (Iterable<[K_, V_]> | PlainObjInput)[] + ): Map; + + mergeDeepWith( + merger: (oldVal: any, newVal: any, key: any) => mixed, + ...collections: (Iterable<[K_, V_]> | PlainObjInput)[] + ): Map; + + mergeIn( + keyPath: Iterable, + ...collections: (Iterable | PlainObjInput)[] + ): this; + mergeDeepIn( + keyPath: Iterable, + ...collections: (Iterable | PlainObjInput)[] + ): this; + + withMutations(mutator: (mutable: this) => mixed): this; + asMutable(): this; + wasAltered(): boolean; + asImmutable(): this; + + // Override specialized return types + + flip(): Map; + + filter(predicate: typeof Boolean): Map>; + filter( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): Map; + + partition( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): [this, this]; + + map( + mapper: (value: V, key: K, iter: this) => M, + context?: mixed + ): Map; + + mapKeys( + mapper: (key: K, value: V, iter: this) => M, + context?: mixed + ): Map; + + mapEntries( + mapper: (entry: [K, V], index: number, iter: this) => [KM, VM], + context?: mixed + ): Map; + + flatMap( + mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>, + context?: mixed + ): Map; + + flatten(depth?: number): Map; + flatten(shallow?: boolean): Map; +} + +declare function isOrderedMap( + maybeOrderedMap: mixed +): boolean %checks(maybeOrderedMap instanceof OrderedMap); +declare class OrderedMap + extends Map + mixins UpdatableInCollection +{ + static ( + values?: Iterable<[K, V]> | PlainObjInput + ): OrderedMap; + + static isOrderedMap: typeof isOrderedMap; + + size: number; + + set(key: K_, value: V_): OrderedMap; + delete(key: K): this; + remove(key: K): this; + clear(): this; + + update(updater: (value: this) => U): U; + update(key: K, updater: (value: V) => V_): OrderedMap; + update( + key: K, + notSetValue: V_, + updater: (value: V) => V_ + ): OrderedMap; + + merge( + ...collections: (Iterable<[K_, V_]> | PlainObjInput)[] + ): OrderedMap; + concat( + ...collections: (Iterable<[K_, V_]> | PlainObjInput)[] + ): OrderedMap; + + mergeWith( + merger: (oldVal: V, newVal: W, key: K) => X, + ...collections: (Iterable<[K_, W]> | PlainObjInput)[] + ): OrderedMap; + + mergeDeep( + ...collections: (Iterable<[K_, V_]> | PlainObjInput)[] + ): OrderedMap; + + mergeDeepWith( + merger: (oldVal: any, newVal: any, key: any) => mixed, + ...collections: (Iterable<[K_, V_]> | PlainObjInput)[] + ): OrderedMap; + + mergeIn( + keyPath: Iterable, + ...collections: (Iterable | PlainObjInput)[] + ): this; + mergeDeepIn( + keyPath: Iterable, + ...collections: (Iterable | PlainObjInput)[] + ): this; + + withMutations(mutator: (mutable: this) => mixed): this; + asMutable(): this; + wasAltered(): boolean; + asImmutable(): this; + + // Override specialized return types + + flip(): OrderedMap; + + filter(predicate: typeof Boolean): OrderedMap>; + filter( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): OrderedMap; + + partition( + predicate: (value: V, key: K, iter: this) => mixed, + context?: mixed + ): [this, this]; + + map( + mapper: (value: V, key: K, iter: this) => M, + context?: mixed + ): OrderedMap; + + mapKeys( + mapper: (key: K, value: V, iter: this) => M, + context?: mixed + ): OrderedMap; + + mapEntries( + mapper: (entry: [K, V], index: number, iter: this) => [KM, VM], + context?: mixed + ): OrderedMap; + + flatMap( + mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>, + context?: mixed + ): OrderedMap; + + flatten(depth?: number): OrderedMap; + flatten(shallow?: boolean): OrderedMap; +} + +declare function isSet(maybeSet: mixed): boolean %checks(maybeSet instanceof + Set); +declare class Set<+T> extends SetCollection { + static (values?: Iterable): Set; + + static of(...values: T[]): Set; + static fromKeys( + values: Iterable<[T, mixed]> | PlainObjInput + ): Set; + + static intersect(sets: Iterable>): Set; + static union(sets: Iterable>): Set; + + static isSet: typeof isSet; + + size: number; + + add(value: U): Set; + delete(value: T): this; + remove(value: T): this; + clear(): this; + union(...collections: Iterable[]): Set; + merge(...collections: Iterable[]): Set; + concat(...collections: Iterable[]): Set; + intersect(...collections: Iterable[]): Set; + subtract(...collections: Iterable[]): this; + + withMutations(mutator: (mutable: this) => mixed): this; + asMutable(): this; + wasAltered(): boolean; + asImmutable(): this; + + // Override specialized return types + + filter(predicate: typeof Boolean): Set<$NonMaybeType>; + filter( + predicate: (value: T, value: T, iter: this) => mixed, + context?: mixed + ): Set; + + partition( + predicate: (value: T, value: T, iter: this) => mixed, + context?: mixed + ): [this, this]; + + map( + mapper: (value: T, value: T, iter: this) => M, + context?: mixed + ): Set; + + flatMap( + mapper: (value: T, value: T, iter: this) => Iterable, + context?: mixed + ): Set; + + flatten(depth?: number): Set; + flatten(shallow?: boolean): Set; +} + +// Overrides except for `isOrderedSet` are for specialized return types +declare function isOrderedSet( + maybeOrderedSet: mixed +): boolean %checks(maybeOrderedSet instanceof OrderedSet); +declare class OrderedSet<+T> extends Set { + static (values?: Iterable): OrderedSet; + + static of(...values: T[]): OrderedSet; + static fromKeys( + values: Iterable<[T, mixed]> | PlainObjInput + ): OrderedSet; + + static isOrderedSet: typeof isOrderedSet; + + size: number; + + add(value: U): OrderedSet; + union(...collections: Iterable[]): OrderedSet; + merge(...collections: Iterable[]): OrderedSet; + concat(...collections: Iterable[]): OrderedSet; + intersect(...collections: Iterable[]): OrderedSet; + + filter(predicate: typeof Boolean): OrderedSet<$NonMaybeType>; + filter( + predicate: (value: T, value: T, iter: this) => mixed, + context?: mixed + ): OrderedSet; + + partition( + predicate: (value: T, value: T, iter: this) => mixed, + context?: mixed + ): [this, this]; + + map( + mapper: (value: T, value: T, iter: this) => M, + context?: mixed + ): OrderedSet; + + flatMap( + mapper: (value: T, value: T, iter: this) => Iterable, + context?: mixed + ): OrderedSet; + + flatten(depth?: number): OrderedSet; + flatten(shallow?: boolean): OrderedSet; + + zip(a: Iterable, ..._: []): OrderedSet<[T, A]>; + zip(a: Iterable, b: Iterable, ..._: []): OrderedSet<[T, A, B]>; + zip( + a: Iterable, + b: Iterable, + c: Iterable, + ..._: [] + ): OrderedSet<[T, A, B, C]>; + zip( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + ..._: [] + ): OrderedSet<[T, A, B, C, D]>; + zip( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + e: Iterable, + ..._: [] + ): OrderedSet<[T, A, B, C, D, E]>; + + zipAll(a: Iterable, ..._: []): OrderedSet<[T | void, A | void]>; + zipAll( + a: Iterable, + b: Iterable, + ..._: [] + ): OrderedSet<[T | void, A | void, B | void]>; + zipAll( + a: Iterable, + b: Iterable, + c: Iterable, + ..._: [] + ): OrderedSet<[T | void, A | void, B | void, C | void]>; + zipAll( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + ..._: [] + ): OrderedSet<[T | void, A | void, B | void, C | void, D | void]>; + zipAll( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + e: Iterable, + ..._: [] + ): OrderedSet<[T | void, A | void, B | void, C | void, D | void, E | void]>; + + zipWith( + zipper: (value: T, a: A) => R, + a: Iterable, + ..._: [] + ): OrderedSet; + zipWith( + zipper: (value: T, a: A, b: B) => R, + a: Iterable, + b: Iterable, + ..._: [] + ): OrderedSet; + zipWith( + zipper: (value: T, a: A, b: B, c: C) => R, + a: Iterable, + b: Iterable, + c: Iterable, + ..._: [] + ): OrderedSet; + zipWith( + zipper: (value: T, a: A, b: B, c: C, d: D) => R, + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + ..._: [] + ): OrderedSet; + zipWith( + zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R, + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + e: Iterable, + ..._: [] + ): OrderedSet; +} + +declare function isStack( + maybeStack: mixed +): boolean %checks(maybeStack instanceof Stack); +declare class Stack<+T> extends IndexedCollection { + static (collection?: Iterable): Stack; + + static isStack(maybeStack: mixed): boolean; + static of(...values: T[]): Stack; + + static isStack: typeof isStack; + + size: number; + + peek(): T; + clear(): this; + unshift(...values: U[]): Stack; + unshiftAll(iter: Iterable): Stack; + shift(): this; + push(...values: U[]): Stack; + pushAll(iter: Iterable): Stack; + pop(): this; + + withMutations(mutator: (mutable: this) => mixed): this; + asMutable(): this; + wasAltered(): boolean; + asImmutable(): this; + + // Override specialized return types + + concat(...iters: Array | C>): Stack; + + filter(predicate: typeof Boolean): Stack<$NonMaybeType>; + filter( + predicate: (value: T, index: number, iter: this) => mixed, + context?: mixed + ): Stack; + + map( + mapper: (value: T, index: number, iter: this) => M, + context?: mixed + ): Stack; + + flatMap( + mapper: (value: T, index: number, iter: this) => Iterable, + context?: mixed + ): Stack; + + flatten(depth?: number): Stack; + flatten(shallow?: boolean): Stack; + + zip(a: Iterable, ..._: []): Stack<[T, A]>; + zip(a: Iterable, b: Iterable, ..._: []): Stack<[T, A, B]>; + zip( + a: Iterable, + b: Iterable, + c: Iterable, + ..._: [] + ): Stack<[T, A, B, C]>; + zip( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + ..._: [] + ): Stack<[T, A, B, C, D]>; + zip( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + e: Iterable, + ..._: [] + ): Stack<[T, A, B, C, D, E]>; + + zipAll(a: Iterable, ..._: []): Stack<[T | void, A | void]>; + zipAll( + a: Iterable, + b: Iterable, + ..._: [] + ): Stack<[T | void, A | void, B | void]>; + zipAll( + a: Iterable, + b: Iterable, + c: Iterable, + ..._: [] + ): Stack<[T | void, A | void, B | void, C | void]>; + zipAll( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + ..._: [] + ): Stack<[T | void, A | void, B | void, C | void, D | void]>; + zipAll( + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + e: Iterable, + ..._: [] + ): Stack<[T | void, A | void, B | void, C | void, D | void, E | void]>; + + zipWith( + zipper: (value: T, a: A) => R, + a: Iterable, + ..._: [] + ): Stack; + zipWith( + zipper: (value: T, a: A, b: B) => R, + a: Iterable, + b: Iterable, + ..._: [] + ): Stack; + zipWith( + zipper: (value: T, a: A, b: B, c: C) => R, + a: Iterable, + b: Iterable, + c: Iterable, + ..._: [] + ): Stack; + zipWith( + zipper: (value: T, a: A, b: B, c: C, d: D) => R, + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + ..._: [] + ): Stack; + zipWith( + zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R, + a: Iterable, + b: Iterable, + c: Iterable, + d: Iterable, + e: Iterable, + ..._: [] + ): Stack; +} + +declare function Range( + start?: number, + end?: number, + step?: number +): IndexedSeq; +declare function Repeat(value: T, times?: number): IndexedSeq; + +// The type of a Record factory function. +type RecordFactory = Class>; + +// The type of runtime Record instances. +type RecordOf = RecordInstance & $ReadOnly; + +// The values of a Record instance. +type _RecordValues | T> = R; +type RecordValues = _RecordValues<*, R>; + +declare function isRecord( + maybeRecord: any +): boolean %checks(maybeRecord instanceof RecordInstance); +declare class Record { + static (spec: Values, name?: string): typeof RecordInstance; + constructor( + spec: Values, + name?: string + ): typeof RecordInstance; + + static isRecord: typeof isRecord; + + static getDescriptiveName(record: RecordInstance): string; +} + +declare class RecordInstance { + static (values?: Iterable<[$Keys, $ValOf]> | $Shape): RecordOf; + // Note: a constructor can only create an instance of RecordInstance, + // it's encouraged to not use `new` when creating Records. + constructor(values?: Iterable<[$Keys, $ValOf]> | $Shape): void; + + size: number; + + has(key: string): boolean; + + get>(key: K, ..._: []): $ElementType; + get, NSV>(key: K, notSetValue: NSV): $ElementType | NSV; + + hasIn(keyPath: Iterable): boolean; + + getIn(keyPath: [], notSetValue?: mixed): this & $ReadOnly; + getIn>(keyPath: [K], notSetValue?: mixed): $ElementType; + getIn, K2: $KeyOf<$ValOf>>( + keyPath: [K, K2], + notSetValue: NSV + ): $ValOf<$ValOf, K2> | NSV; + getIn< + NSV, + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + >( + keyPath: [K, K2, K3], + notSetValue: NSV + ): $ValOf<$ValOf<$ValOf, K2>, K3> | NSV; + getIn< + NSV, + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + >( + keyPath: [K, K2, K3, K4], + notSetValue: NSV + ): $ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4> | NSV; + getIn< + NSV, + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>>, + >( + keyPath: [K, K2, K3, K4, K5], + notSetValue: NSV + ): $ValOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, K5> | NSV; + + equals(other: any): boolean; + hashCode(): number; + + set>(key: K, value: $ElementType): this & $ReadOnly; + update>( + key: K, + updater: (value: $ElementType) => $ElementType + ): this & $ReadOnly; + merge( + ...collections: Array, $ValOf]> | $Shape> + ): this & $ReadOnly; + mergeDeep( + ...collections: Array, $ValOf]> | $Shape> + ): this & $ReadOnly; + + mergeWith( + merger: (oldVal: $ValOf, newVal: $ValOf, key: $Keys) => $ValOf, + ...collections: Array, $ValOf]> | $Shape> + ): this & $ReadOnly; + mergeDeepWith( + merger: (oldVal: any, newVal: any, key: any) => any, + ...collections: Array, $ValOf]> | $Shape> + ): this & $ReadOnly; + + delete>(key: K): this & $ReadOnly; + remove>(key: K): this & $ReadOnly; + clear(): this & $ReadOnly; + + setIn(keyPath: [], value: S): S; + setIn, S: $ValOf>( + keyPath: [K], + value: S + ): this & $ReadOnly; + setIn, K2: $KeyOf<$ValOf>, S: $ValOf<$ValOf, K2>>( + keyPath: [K, K2], + value: S + ): this & $ReadOnly; + setIn< + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + S: $ValOf<$ValOf<$ValOf, K2>, K3>, + >( + keyPath: [K, K2, K3], + value: S + ): this & $ReadOnly; + setIn< + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + S: $ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, + >( + keyPath: [K, K2, K3, K4], + value: S + ): this & $ReadOnly; + setIn< + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>>, + S: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, K5>, + >( + keyPath: [K, K2, K3, K4, K5], + value: S + ): this & $ReadOnly; + + deleteIn(keyPath: []): void; + deleteIn>(keyPath: [K]): this & $ReadOnly; + deleteIn, K2: $KeyOf<$ValOf>>( + keyPath: [K, K2] + ): this & $ReadOnly; + deleteIn< + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + >( + keyPath: [K, K2, K3] + ): this & $ReadOnly; + deleteIn< + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + >( + keyPath: [K, K2, K3, K4] + ): this & $ReadOnly; + deleteIn< + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>>, + >( + keyPath: [K, K2, K3, K4, K5] + ): this & $ReadOnly; + + removeIn(keyPath: []): void; + removeIn>(keyPath: [K]): this & $ReadOnly; + removeIn, K2: $KeyOf<$ValOf>>( + keyPath: [K, K2] + ): this & $ReadOnly; + removeIn< + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + >( + keyPath: [K, K2, K3] + ): this & $ReadOnly; + removeIn< + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + >( + keyPath: [K, K2, K3, K4] + ): this & $ReadOnly; + removeIn< + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>>, + >( + keyPath: [K, K2, K3, K4, K5] + ): this & $ReadOnly; + + updateIn( + keyPath: [], + notSetValue: mixed, + updater: (value: this & T) => U + ): U; + updateIn(keyPath: [], updater: (value: this & T) => U): U; + updateIn, S: $ValOf>( + keyPath: [K], + notSetValue: NSV, + updater: (value: $ValOf) => S + ): this & $ReadOnly; + updateIn, S: $ValOf>( + keyPath: [K], + updater: (value: $ValOf) => S + ): this & $ReadOnly; + updateIn< + NSV, + K: $Keys, + K2: $KeyOf<$ValOf>, + S: $ValOf<$ValOf, K2>, + >( + keyPath: [K, K2], + notSetValue: NSV, + updater: (value: $ValOf<$ValOf, K2> | NSV) => S + ): this & $ReadOnly; + updateIn, K2: $KeyOf<$ValOf>, S: $ValOf<$ValOf, K2>>( + keyPath: [K, K2], + updater: (value: $ValOf<$ValOf, K2>) => S + ): this & $ReadOnly; + updateIn< + NSV, + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + S: $ValOf<$ValOf<$ValOf, K2>, K3>, + >( + keyPath: [K, K2, K3], + notSetValue: NSV, + updater: (value: $ValOf<$ValOf<$ValOf, K2>, K3> | NSV) => S + ): this & $ReadOnly; + updateIn< + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + S: $ValOf<$ValOf<$ValOf, K2>, K3>, + >( + keyPath: [K, K2, K3], + updater: (value: $ValOf<$ValOf<$ValOf, K2>, K3>) => S + ): this & $ReadOnly; + updateIn< + NSV, + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + S: $ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, + >( + keyPath: [K, K2, K3, K4], + notSetValue: NSV, + updater: ( + value: $ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4> | NSV + ) => S + ): this & $ReadOnly; + updateIn< + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + S: $ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, + >( + keyPath: [K, K2, K3, K4], + updater: (value: $ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>) => S + ): this & $ReadOnly; + updateIn< + NSV, + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>>, + S: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, K5>, + >( + keyPath: [K, K2, K3, K4, K5], + notSetValue: NSV, + updater: ( + value: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, K5> | NSV + ) => S + ): this & $ReadOnly; + updateIn< + K: $Keys, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>>, + S: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, K5>, + >( + keyPath: [K, K2, K3, K4, K5], + updater: ( + value: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, K5> + ) => S + ): this & $ReadOnly; + + mergeIn( + keyPath: Iterable, + ...collections: Array + ): this & $ReadOnly; + mergeDeepIn( + keyPath: Iterable, + ...collections: Array + ): this & $ReadOnly; + + toSeq(): KeyedSeq<$Keys, any>; + + toJS(): { [key: $Keys]: mixed }; + toJSON(): T; + toObject(): T; + + withMutations(mutator: (mutable: this & T) => mixed): this & $ReadOnly; + asMutable(): this & $ReadOnly; + wasAltered(): boolean; + asImmutable(): this & $ReadOnly; + + @@iterator(): Iterator<[$Keys, $ValOf]>; +} + +declare function fromJS( + jsValue: mixed, + reviver?: ( + key: string | number, + sequence: KeyedCollection | IndexedCollection, + path?: Array + ) => mixed +): Collection; + +declare function is(first: mixed, second: mixed): boolean; +declare function hash(value: mixed): number; + +declare function get>( + collection: C, + key: K, + notSetValue: mixed +): $ValOf; +declare function get, NSV>( + collection: C, + key: K, + notSetValue: NSV +): $ValOf | NSV; + +declare function has(collection: Object, key: mixed): boolean; +declare function remove(collection: C, key: $KeyOf): C; +declare function set, V: $ValOf>( + collection: C, + key: K, + value: V +): C; +declare function update, V: $ValOf, NSV>( + collection: C, + key: K, + notSetValue: NSV, + updater: ($ValOf | NSV) => V +): C; +declare function update, V: $ValOf>( + collection: C, + key: K, + updater: ($ValOf) => V +): C; + +declare function getIn(collection: C, keyPath: [], notSetValue?: mixed): C; +declare function getIn, NSV>( + collection: C, + keyPath: [K], + notSetValue: NSV +): $ValOf | NSV; +declare function getIn, K2: $KeyOf<$ValOf>, NSV>( + collection: C, + keyPath: [K, K2], + notSetValue: NSV +): $ValOf<$ValOf, K2> | NSV; +declare function getIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + NSV, +>( + collection: C, + keyPath: [K, K2, K3], + notSetValue: NSV +): $ValOf<$ValOf<$ValOf, K2>, K3> | NSV; +declare function getIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + NSV, +>( + collection: C, + keyPath: [K, K2, K3, K4], + notSetValue: NSV +): $ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4> | NSV; +declare function getIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>>, + NSV, +>( + collection: C, + keyPath: [K, K2, K3, K4, K5], + notSetValue: NSV +): $ValOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, K5> | NSV; + +declare function hasIn(collection: Object, keyPath: Iterable): boolean; + +declare function removeIn(collection: C, keyPath: []): void; +declare function removeIn>(collection: C, keyPath: [K]): C; +declare function removeIn, K2: $KeyOf<$ValOf>>( + collection: C, + keyPath: [K, K2] +): C; +declare function removeIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, +>( + collection: C, + keyPath: [K, K2, K3] +): C; +declare function removeIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, +>( + collection: C, + keyPath: [K, K2, K3, K4] +): C; +declare function removeIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>>, +>( + collection: C, + keyPath: [K, K2, K3, K4, K5] +): C; + +declare function setIn(collection: Object, keyPath: [], value: S): S; +declare function setIn, S: $ValOf>( + collection: C, + keyPath: [K], + value: S +): C; +declare function setIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + S: $ValOf<$ValOf, K2>, +>( + collection: C, + keyPath: [K, K2], + value: S +): C; +declare function setIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + S: $ValOf<$ValOf<$ValOf, K2>, K3>, +>( + collection: C, + keyPath: [K, K2, K3], + value: S +): C; +declare function setIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + S: $ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, +>( + collection: C, + keyPath: [K, K2, K3, K4], + value: S +): C; +declare function setIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>>, + S: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, K5>, +>( + collection: C, + keyPath: [K, K2, K3, K4, K5], + value: S +): C; + +declare function updateIn( + collection: C, + keyPath: [], + notSetValue: mixed, + updater: (value: C) => S +): S; +declare function updateIn( + collection: C, + keyPath: [], + updater: (value: C) => S +): S; +declare function updateIn, S: $ValOf, NSV>( + collection: C, + keyPath: [K], + notSetValue: NSV, + updater: (value: $ValOf | NSV) => S +): C; +declare function updateIn, S: $ValOf>( + collection: C, + keyPath: [K], + updater: (value: $ValOf) => S +): C; +declare function updateIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + S: $ValOf<$ValOf, K2>, + NSV, +>( + collection: C, + keyPath: [K, K2], + notSetValue: NSV, + updater: (value: $ValOf<$ValOf, K2> | NSV) => S +): C; +declare function updateIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + S: $ValOf<$ValOf, K2>, +>( + collection: C, + keyPath: [K, K2], + updater: (value: $ValOf<$ValOf, K2>) => S +): C; +declare function updateIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + S: $ValOf<$ValOf<$ValOf, K2>, K3>, + NSV, +>( + collection: C, + keyPath: [K, K2, K3], + notSetValue: NSV, + updater: (value: $ValOf<$ValOf<$ValOf, K2>, K3> | NSV) => S +): C; +declare function updateIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + S: $ValOf<$ValOf<$ValOf, K2>, K3>, +>( + collection: C, + keyPath: [K, K2, K3], + updater: (value: $ValOf<$ValOf<$ValOf, K2>, K3>) => S +): C; +declare function updateIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + S: $ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, + NSV, +>( + collection: C, + keyPath: [K, K2, K3, K4], + notSetValue: NSV, + updater: (value: $ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4> | NSV) => S +): C; +declare function updateIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + S: $ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, +>( + collection: C, + keyPath: [K, K2, K3, K4], + updater: (value: $ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>) => S +): C; +declare function updateIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>>, + S: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, K5>, + NSV, +>( + collection: C, + keyPath: [K, K2, K3, K4, K5], + notSetValue: NSV, + updater: ( + value: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, K5> | NSV + ) => S +): C; +declare function updateIn< + C, + K: $KeyOf, + K2: $KeyOf<$ValOf>, + K3: $KeyOf<$ValOf<$ValOf, K2>>, + K4: $KeyOf<$ValOf<$ValOf<$ValOf, K2>, K3>>, + K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>>, + S: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, K5>, +>( + collection: C, + keyPath: [K, K2, K3, K4, K5], + updater: ( + value: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf, K2>, K3>, K4>, K5> + ) => S +): C; + +declare function merge( + collection: C, + ...collections: Array< + | $IterableOf + | $Shape> + | PlainObjInput<$KeyOf, $ValOf>, + > +): C; +declare function mergeWith( + merger: (oldVal: $ValOf, newVal: $ValOf, key: $KeyOf) => $ValOf, + collection: C, + ...collections: Array< + | $IterableOf + | $Shape> + | PlainObjInput<$KeyOf, $ValOf>, + > +): C; +declare function mergeDeep( + collection: C, + ...collections: Array< + | $IterableOf + | $Shape> + | PlainObjInput<$KeyOf, $ValOf>, + > +): C; +declare function mergeDeepWith( + merger: (oldVal: any, newVal: any, key: any) => mixed, + collection: C, + ...collections: Array< + | $IterableOf + | $Shape> + | PlainObjInput<$KeyOf, $ValOf>, + > +): C; + +export { + Collection, + Seq, + List, + Map, + OrderedMap, + OrderedSet, + Range, + Repeat, + Record, + Set, + Stack, + fromJS, + is, + hash, + isImmutable, + isCollection, + isKeyed, + isIndexed, + isAssociative, + isOrdered, + isRecord, + isValueObject, + get, + has, + remove, + set, + update, + getIn, + hasIn, + removeIn, + setIn, + updateIn, + merge, + mergeWith, + mergeDeep, + mergeDeepWith, +}; + +export default { + Collection, + Seq, + + List, + Map, + OrderedMap, + OrderedSet, + PairSorting, + Range, + Repeat, + Record, + Set, + Stack, + + fromJS, + is, + hash, + + isImmutable, + isCollection, + isKeyed, + isIndexed, + isAssociative, + isOrdered, + isRecord, + isValueObject, + + get, + has, + remove, + set, + update, + getIn, + hasIn, + removeIn, + setIn, + updateIn, + merge, + mergeWith, + mergeDeep, + mergeDeepWith, +}; + +export type { + Comparator, + KeyedCollection, + IndexedCollection, + SetCollection, + KeyedSeq, + IndexedSeq, + SetSeq, + RecordFactory, + RecordOf, + RecordInstance, + ValueObject, + $KeyOf, + $ValOf, +}; diff --git a/node_modules/immutable/dist/immutable.min.js b/node_modules/immutable/dist/immutable.min.js new file mode 100644 index 0000000..91c0b31 --- /dev/null +++ b/node_modules/immutable/dist/immutable.min.js @@ -0,0 +1,25 @@ +/** + * @license + * MIT License + * + * Copyright (c) 2014-present, Lee Byron and other contributors. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).Immutable={})}(this,(function(t){"use strict";var e="delete",r=5,n=1<>>0;if(""+r!==e||4294967295===r)return NaN;e=r}return e<0?a(t)+e:e}function f(){return!0}function h(t,e,r){return(0===t&&!v(t)||void 0!==r&&t<=-r)&&(void 0===e||void 0!==r&&e>=r)}function p(t,e){return l(t,e,0)}function _(t,e){return l(t,e,e)}function l(t,e,r){return void 0===t?r:v(t)?e===1/0?e:0|Math.max(0,e+t):void 0===e||e===t?t:0|Math.min(e,t)}function v(t){return t<0||0===t&&1/t==-1/0}var y="@@__IMMUTABLE_ITERABLE__@@";function d(t){return Boolean(t&&t[y])}var g="@@__IMMUTABLE_KEYED__@@";function w(t){return Boolean(t&&t[g])}var m="@@__IMMUTABLE_INDEXED__@@";function b(t){return Boolean(t&&t[m])}function z(t){return w(t)||b(t)}var S=function(t){return d(t)?t:X(t)},I=function(t){function e(t){return w(t)?t:F(t)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e}(S),O=function(t){function e(t){return b(t)?t:G(t)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e}(S),E=function(t){function e(t){return d(t)&&!z(t)?t:Z(t)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e}(S);S.Keyed=I,S.Indexed=O,S.Set=E;var j="@@__IMMUTABLE_SEQ__@@";function q(t){return Boolean(t&&t[j])}var M="@@__IMMUTABLE_RECORD__@@";function D(t){return Boolean(t&&t[M])}function x(t){return d(t)||D(t)}var A="@@__IMMUTABLE_ORDERED__@@";function k(t){return Boolean(t&&t[A])}var R=0,U=1,T=2,B="function"==typeof Symbol&&Symbol.iterator,K="@@iterator",L=B||K,C=function(t){this.next=t};function P(t,e,r,n){var i=t===R?e:t===U?r:[e,r];return n?n.value=i:n={value:i,done:!1},n}function W(){return{value:void 0,done:!0}}function N(t){return!!Array.isArray(t)||!!V(t)}function H(t){return t&&"function"==typeof t.next}function J(t){var e=V(t);return e&&e.call(t)}function V(t){var e=t&&(B&&t[B]||t[K]);if("function"==typeof e)return e}C.prototype.toString=function(){return"[Iterator]"},C.KEYS=R,C.VALUES=U,C.ENTRIES=T,C.prototype.inspect=C.prototype.toSource=function(){return this.toString()},C.prototype[L]=function(){return this};var Y=Object.prototype.hasOwnProperty;function Q(t){return!(!Array.isArray(t)&&"string"!=typeof t)||t&&"object"==typeof t&&Number.isInteger(t.length)&&t.length>=0&&(0===t.length?1===Object.keys(t).length:t.hasOwnProperty(t.length-1))}var X=function(t){function e(t){return null==t?nt():x(t)?t.toSeq():function(t){var e=ut(t);if(e)return(n=V(r=t))&&n===r.entries?e.fromEntrySeq():function(t){var e=V(t);return e&&e===t.keys}(t)?e.toSetSeq():e;var r,n;if("object"==typeof t)return new tt(t);throw new TypeError("Expected Array or collection object of values, or keyed object: "+t)}(t)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.toSeq=function(){return this},e.prototype.toString=function(){return this.__toString("Seq {","}")},e.prototype.cacheResult=function(){return!this._cache&&this.__iterateUncached&&(this._cache=this.entrySeq().toArray(),this.size=this._cache.length),this},e.prototype.__iterate=function(t,e){var r=this._cache;if(r){for(var n=r.length,i=0;i!==n;){var o=r[e?n-++i:i++];if(!1===t(o[1],o[0],this))break}return i}return this.__iterateUncached(t,e)},e.prototype.__iterator=function(t,e){var r=this._cache;if(r){var n=r.length,i=0;return new C((function(){if(i===n)return{value:void 0,done:!0};var o=r[e?n-++i:i++];return P(t,o[0],o[1])}))}return this.__iteratorUncached(t,e)},e}(S),F=function(t){function e(t){return null==t?nt().toKeyedSeq():d(t)?w(t)?t.toSeq():t.fromEntrySeq():D(t)?t.toSeq():it(t)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.toKeyedSeq=function(){return this},e}(X),G=function(t){function e(t){return null==t?nt():d(t)?w(t)?t.entrySeq():t.toIndexedSeq():D(t)?t.toSeq().entrySeq():ot(t)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.of=function(){return e(arguments)},e.prototype.toIndexedSeq=function(){return this},e.prototype.toString=function(){return this.__toString("Seq [","]")},e}(X),Z=function(t){function e(t){return(d(t)&&!z(t)?t:G(t)).toSetSeq()}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.of=function(){return e(arguments)},e.prototype.toSetSeq=function(){return this},e}(X);X.isSeq=q,X.Keyed=F,X.Set=Z,X.Indexed=G,X.prototype[j]=!0;var $=function(t){function e(t){this._array=t,this.size=t.length}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.get=function(t,e){return this.has(t)?this._array[c(this,t)]:e},e.prototype.__iterate=function(t,e){for(var r=this._array,n=r.length,i=0;i!==n;){var o=e?n-++i:i++;if(!1===t(r[o],o,this))break}return i},e.prototype.__iterator=function(t,e){var r=this._array,n=r.length,i=0;return new C((function(){if(i===n)return{value:void 0,done:!0};var o=e?n-++i:i++;return P(t,o,r[o])}))},e}(G),tt=function(t){function e(t){var e=Object.keys(t).concat(Object.getOwnPropertySymbols?Object.getOwnPropertySymbols(t):[]);this._object=t,this._keys=e,this.size=e.length}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.get=function(t,e){return void 0===e||this.has(t)?this._object[t]:e},e.prototype.has=function(t){return Y.call(this._object,t)},e.prototype.__iterate=function(t,e){for(var r=this._object,n=this._keys,i=n.length,o=0;o!==i;){var u=n[e?i-++o:o++];if(!1===t(r[u],u,this))break}return o},e.prototype.__iterator=function(t,e){var r=this._object,n=this._keys,i=n.length,o=0;return new C((function(){if(o===i)return{value:void 0,done:!0};var u=n[e?i-++o:o++];return P(t,u,r[u])}))},e}(F);tt.prototype[A]=!0;var et,rt=function(t){function e(t){this._collection=t,this.size=t.length||t.size}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.__iterateUncached=function(t,e){if(e)return this.cacheResult().__iterate(t,e);var r=J(this._collection),n=0;if(H(r))for(var i;!(i=r.next()).done&&!1!==t(i.value,n++,this););return n},e.prototype.__iteratorUncached=function(t,e){if(e)return this.cacheResult().__iterator(t,e);var r=J(this._collection);if(!H(r))return new C(W);var n=0;return new C((function(){var e=r.next();return e.done?e:P(t,n++,e.value)}))},e}(G);function nt(){return et||(et=new $([]))}function it(t){var e=ut(t);if(e)return e.fromEntrySeq();if("object"==typeof t)return new tt(t);throw new TypeError("Expected Array or collection object of [k, v] entries, or keyed object: "+t)}function ot(t){var e=ut(t);if(e)return e;throw new TypeError("Expected Array or collection object of values: "+t)}function ut(t){return Q(t)?new $(t):N(t)?new rt(t):void 0}var st="@@__IMMUTABLE_MAP__@@";function at(t){return Boolean(t&&t[st])}function ct(t){return at(t)&&k(t)}function ft(t){return Boolean(t&&"function"==typeof t.equals&&"function"==typeof t.hashCode)}function ht(t,e){if(t===e||t!=t&&e!=e)return!0;if(!t||!e)return!1;if("function"==typeof t.valueOf&&"function"==typeof e.valueOf){if((t=t.valueOf())===(e=e.valueOf())||t!=t&&e!=e)return!0;if(!t||!e)return!1}return!!(ft(t)&&ft(e)&&t.equals(e))}var pt="function"==typeof Math.imul&&-2===Math.imul(4294967295,2)?Math.imul:function(t,e){var r=65535&(t|=0),n=65535&(e|=0);return r*n+((t>>>16)*n+r*(e>>>16)<<16>>>0)|0};function _t(t){return t>>>1&1073741824|3221225471&t}var lt=Object.prototype.valueOf;function vt(t){if(null==t)return yt(t);if("function"==typeof t.hashCode)return _t(t.hashCode(t));var e,r=(e=t).valueOf!==lt&&"function"==typeof e.valueOf?e.valueOf(e):e;if(null==r)return yt(r);switch(typeof r){case"boolean":return r?1108378657:1108378656;case"number":return function(t){if(t!=t||t===1/0)return 0;var e=0|t;e!==t&&(e^=4294967295*t);for(;t>4294967295;)e^=t/=4294967295;return _t(e)}(r);case"string":return r.length>Et?function(t){var e=Mt[t];void 0===e&&(e=dt(t),qt===jt&&(qt=0,Mt={}),qt++,Mt[t]=e);return e}(r):dt(r);case"object":case"function":return function(t){var e;if(zt&&void 0!==(e=bt.get(t)))return e;if(e=t[Ot],void 0!==e)return e;if(!wt){if(void 0!==(e=t.propertyIsEnumerable&&t.propertyIsEnumerable[Ot]))return e;if(void 0!==(e=function(t){if(t&&t.nodeType>0)switch(t.nodeType){case 1:return t.uniqueID;case 9:return t.documentElement&&t.documentElement.uniqueID}}(t)))return e}if(e=mt(),zt)bt.set(t,e);else{if(void 0!==gt&&!1===gt(t))throw new Error("Non-extensible objects are not allowed as keys.");if(wt)Object.defineProperty(t,Ot,{enumerable:!1,configurable:!1,writable:!1,value:e});else if(void 0!==t.propertyIsEnumerable&&t.propertyIsEnumerable===t.constructor.prototype.propertyIsEnumerable)t.propertyIsEnumerable=function(){return this.constructor.prototype.propertyIsEnumerable.apply(this,arguments)},t.propertyIsEnumerable[Ot]=e;else{if(void 0===t.nodeType)throw new Error("Unable to set a non-enumerable property on object.");t[Ot]=e}}return e}(r);case"symbol":return function(t){var e=St[t];if(void 0!==e)return e;return e=mt(),St[t]=e,e}(r);default:if("function"==typeof r.toString)return dt(r.toString());throw new Error("Value type "+typeof r+" cannot be hashed.")}}function yt(t){return null===t?1108378658:1108378659}function dt(t){for(var e=0,r=0;r=0&&(a.get=function(e,r){return(e=c(this,e))>=0&&eo)return{value:void 0,done:!0};var t=i.next();return n||e===U||t.done?t:P(e,a-1,e===R?void 0:t.value[1],t)}))},a}function Lt(t,e,r,n){var i=Xt(t);return i.__iterateUncached=function(i,o){var u=this;if(o)return this.cacheResult().__iterate(i,o);var s=!0,a=0;return t.__iterate((function(t,o,c){if(!s||!(s=e.call(r,t,o,c)))return a++,i(t,n?o:a-1,u)})),a},i.__iteratorUncached=function(i,o){var u=this;if(o)return this.cacheResult().__iterator(i,o);var s=t.__iterator(T,o),a=!0,c=0;return new C((function(){var t,o,f;do{if((t=s.next()).done)return n||i===U?t:P(i,c++,i===R?void 0:t.value[1],t);var h=t.value;o=h[0],f=h[1],a&&(a=e.call(r,f,o,u))}while(a);return i===T?t:P(i,o,f,t)}))},i}xt.prototype.cacheResult=Dt.prototype.cacheResult=At.prototype.cacheResult=kt.prototype.cacheResult=Ft;var Ct=function(t){function e(t){this._wrappedIterables=t.flatMap((function(t){return t._wrappedIterables?t._wrappedIterables:[t]})),this.size=this._wrappedIterables.reduce((function(t,e){if(void 0!==t){var r=e.size;if(void 0!==r)return t+r}}),0),this[g]=this._wrappedIterables[0][g],this[m]=this._wrappedIterables[0][m],this[A]=this._wrappedIterables[0][A]}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.__iterateUncached=function(t,e){if(0!==this._wrappedIterables.length){if(e)return this.cacheResult().__iterate(t,e);for(var r=0,n=w(this),i=n?T:U,o=this._wrappedIterables[r].__iterator(i,e),u=!0,s=0;u;){for(var a=o.next();a.done;){if(++r===this._wrappedIterables.length)return s;a=(o=this._wrappedIterables[r].__iterator(i,e)).next()}u=!1!==(n?t(a.value[1],a.value[0],this):t(a.value,s,this)),s++}return s}},e.prototype.__iteratorUncached=function(t,e){var r=this;if(0===this._wrappedIterables.length)return new C(W);if(e)return this.cacheResult().__iterator(t,e);var n=0,i=this._wrappedIterables[n].__iterator(t,e);return new C((function(){for(var o=i.next();o.done;){if(++n===r._wrappedIterables.length)return o;o=(i=r._wrappedIterables[n].__iterator(t,e)).next()}return o}))},e}(X);function Pt(t,e,r){var n=Xt(t);return n.__iterateUncached=function(i,o){if(o)return this.cacheResult().__iterate(i,o);var u=0,s=!1;return function t(a,c){a.__iterate((function(o,a){return(!e||c0}function Jt(t,e,r,n){var i=Xt(t),o=new $(r).map((function(t){return t.size}));return i.size=n?o.max():o.min(),i.__iterate=function(t,e){for(var r,n=this.__iterator(U,e),i=0;!(r=n.next()).done&&!1!==t(r.value,i++,this););return i},i.__iteratorUncached=function(t,i){var o=r.map((function(t){return t=S(t),J(i?t.reverse():t)})),u=0,s=!1;return new C((function(){var r;return s||(r=o.map((function(t){return t.next()})),s=n?r.every((function(t){return t.done})):r.some((function(t){return t.done}))),s?{value:void 0,done:!0}:P(t,u++,e.apply(null,r.map((function(t){return t.value}))))}))},i}function Vt(t,e){return t===e?t:q(t)?e:t.constructor(e)}function Yt(t){if(t!==Object(t))throw new TypeError("Expected [K, V] tuple: "+t)}function Qt(t){return w(t)?I:b(t)?O:E}function Xt(t){return Object.create((w(t)?F:b(t)?G:Z).prototype)}function Ft(){return this._iter.cacheResult?(this._iter.cacheResult(),this.size=this._iter.size,this):X.prototype.cacheResult.call(this)}function Gt(t,e){return void 0===t&&void 0===e?0:void 0===t?1:void 0===e?-1:t>e?1:t0;)e[r]=arguments[r+1];if("function"!=typeof t)throw new TypeError("Invalid merger function: "+t);return ze(this,e,t)}function ze(t,e,r){for(var n=[],i=0;i0;)e[r]=arguments[r+1];return Se(this,e,t)}function je(t){for(var e=[],r=arguments.length-1;r-- >0;)e[r]=arguments[r+1];return he(this,t,Je(),(function(t){return Ie(t,e)}))}function qe(t){for(var e=[],r=arguments.length-1;r-- >0;)e[r]=arguments[r+1];return he(this,t,Je(),(function(t){return Se(t,e)}))}function Me(t){var e=this.asMutable();return t(e),e.wasAltered()?e.__ensureOwner(this.__ownerID):this}function De(){return this.__ownerID?this:this.__ensureOwner(new s)}function xe(){return this.__ensureOwner()}function Ae(){return this.__altered}var ke=function(t){function e(e){return null==e?Je():at(e)&&!k(e)?e:Je().withMutations((function(r){var n=t(e);te(n.size),n.forEach((function(t,e){return r.set(e,t)}))}))}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.toString=function(){return this.__toString("Map {","}")},e.prototype.get=function(t,e){return this._root?this._root.get(0,void 0,t,e):e},e.prototype.set=function(t,e){return Ve(this,t,e)},e.prototype.remove=function(t){return Ve(this,t,o)},e.prototype.deleteAll=function(t){var e=S(t);return 0===e.size?this:this.withMutations((function(t){e.forEach((function(e){return t.remove(e)}))}))},e.prototype.clear=function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._root=null,this.__hash=void 0,this.__altered=!0,this):Je()},e.prototype.sort=function(t){return yr(Wt(this,t))},e.prototype.sortBy=function(t,e){return yr(Wt(this,e,t))},e.prototype.map=function(t,e){var r=this;return this.withMutations((function(n){n.forEach((function(i,o){n.set(o,t.call(e,i,o,r))}))}))},e.prototype.__iterator=function(t,e){return new Pe(this,t,e)},e.prototype.__iterate=function(t,e){var r=this,n=0;return this._root&&this._root.iterate((function(e){return n++,t(e[1],e[0],r)}),e),n},e.prototype.__ensureOwner=function(t){return t===this.__ownerID?this:t?He(this.size,this._root,t,this.__hash):0===this.size?Je():(this.__ownerID=t,this.__altered=!1,this)},e}(I);ke.isMap=at;var Re=ke.prototype;Re[st]=!0,Re[e]=Re.remove,Re.removeAll=Re.deleteAll,Re.setIn=le,Re.removeIn=Re.deleteIn=ye,Re.update=ge,Re.updateIn=we,Re.merge=Re.concat=me,Re.mergeWith=be,Re.mergeDeep=Oe,Re.mergeDeepWith=Ee,Re.mergeIn=je,Re.mergeDeepIn=qe,Re.withMutations=Me,Re.wasAltered=Ae,Re.asImmutable=xe,Re["@@transducer/init"]=Re.asMutable=De,Re["@@transducer/step"]=function(t,e){return t.set(e[0],e[1])},Re["@@transducer/result"]=function(t){return t.asImmutable()};var Ue=function(t,e){this.ownerID=t,this.entries=e};Ue.prototype.get=function(t,e,r,n){for(var i=this.entries,o=0,u=i.length;o=Ze)return function(t,e,r,n){t||(t=new s);for(var i=new Le(t,vt(r),[r,n]),o=0;o>>t)&i),s=this.bitmap;return 0==(s&u)?o:this.nodes[Fe(s&u-1)].get(t+r,e,n,o)},Te.prototype.update=function(t,e,u,s,a,c,f){void 0===u&&(u=vt(s));var h=(0===e?u:u>>>e)&i,p=1<=$e)return function(t,e,r,i,o){for(var u=0,s=new Array(n),a=0;0!==r;a++,r>>>=1)s[a]=1&r?e[u++]:void 0;return s[i]=o,new Be(t,u+1,s)}(t,y,_,h,g);if(l&&!g&&2===y.length&&Qe(y[1^v]))return y[1^v];if(l&&g&&1===y.length&&Qe(g))return g;var w=t&&t===this.ownerID,m=l?g?_:_^p:_|p,b=l?g?Ge(y,v,g,w):function(t,e,r){var n=t.length-1;if(r&&e===n)return t.pop(),t;for(var i=new Array(n),o=0,u=0;u>>t)&i,s=this.nodes[u];return s?s.get(t+r,e,n,o):o},Be.prototype.update=function(t,e,n,u,s,a,c){void 0===n&&(n=vt(u));var f=(0===e?n:n>>>e)&i,h=s===o,p=this.nodes,_=p[f];if(h&&!_)return this;var l=Ye(_,t,e+r,n,u,s,a,c);if(l===_)return this;var v=this.count;if(_){if(!l&&--v>>n)&i,c=(0===n?o:o>>>n)&i,f=a===c?[Xe(t,e,n+r,o,u)]:(s=new Le(e,o,u),a>1&1431655765))+(t>>2&858993459))+(t>>4)&252645135,t+=t>>8,127&(t+=t>>16)}function Ge(t,e,r,n){var i=n?t:Zt(t);return i[e]=r,i}var Ze=n/4,$e=n/2,tr=n/4,er="@@__IMMUTABLE_LIST__@@";function rr(t){return Boolean(t&&t[er])}var nr=function(t){function e(e){var i=cr();if(null==e)return i;if(rr(e))return e;var o=t(e),u=o.size;return 0===u?i:(te(u),u>0&&u=0&&t=t.size||e<0)return t.withMutations((function(t){e<0?_r(t,e).set(0,r):_r(t,0,e+1).set(e,r)}));e+=t._origin;var n=t._tail,i=t._root,o={value:!1};e>=lr(t._capacity)?n=fr(n,t.__ownerID,0,e,r,o):i=fr(i,t.__ownerID,t._level,e,r,o);if(!o.value)return t;if(t.__ownerID)return t._root=i,t._tail=n,t.__hash=void 0,t.__altered=!0,t;return ar(t._origin,t._capacity,t._level,i,n)}(this,t,e)},e.prototype.remove=function(t){return this.has(t)?0===t?this.shift():t===this.size-1?this.pop():this.splice(t,1):this},e.prototype.insert=function(t,e){return this.splice(t,0,e)},e.prototype.clear=function(){return 0===this.size?this:this.__ownerID?(this.size=this._origin=this._capacity=0,this._level=r,this._root=this._tail=this.__hash=void 0,this.__altered=!0,this):cr()},e.prototype.push=function(){var t=arguments,e=this.size;return this.withMutations((function(r){_r(r,0,e+t.length);for(var n=0;n>>e&i;if(o>=this.array.length)return new or([],t);var u,s=0===o;if(e>0){var a=this.array[o];if((u=a&&a.removeBefore(t,e-r,n))===a&&s)return this}if(s&&!u)return this;var c=hr(this,t);if(!s)for(var f=0;f>>e&i;if(s>=this.array.length)return this;if(e>0){var a=this.array[s];if((u=a&&a.removeAfter(t,e-r,o))===a&&s===this.array.length-1)return this}var c=hr(this,t);return c.array.splice(s+1),u&&(c.array[s]=u),c};var ur={};function sr(t,e){var i=t._origin,o=t._capacity,u=lr(o),s=t._tail;return a(t._root,t._level,0);function a(t,c,f){return 0===c?function(t,r){var a=r===u?s&&s.array:t&&t.array,c=r>i?0:i-r,f=o-r;f>n&&(f=n);return function(){if(c===f)return ur;var t=e?--f:c++;return a&&a[t]}}(t,f):function(t,u,s){var c,f=t&&t.array,h=s>i?0:i-s>>u,p=1+(o-s>>u);p>n&&(p=n);return function(){for(;;){if(c){var t=c();if(t!==ur)return t;c=null}if(h===p)return ur;var n=e?--p:h++;c=a(f&&f[n],u-r,s+(n<>>n&i,h=t&&f0){var p=t&&t.array[f],_=fr(p,e,n-r,o,s,a);return _===p?t:((c=hr(t,e)).array[f]=_,c)}return h&&t.array[f]===s?t:(a&&u(a),c=hr(t,e),void 0===s&&f===c.array.length-1?c.array.pop():c.array[f]=s,c)}function hr(t,e){return e&&t&&e===t.ownerID?t:new or(t?t.array.slice():[],e)}function pr(t,e){if(e>=lr(t._capacity))return t._tail;if(e<1<0;)n=n.array[e>>>o&i],o-=r;return n}}function _r(t,e,n){void 0!==e&&(e|=0),void 0!==n&&(n|=0);var o=t.__ownerID||new s,u=t._origin,a=t._capacity,c=u+e,f=void 0===n?a:n<0?a+n:u+n;if(c===u&&f===a)return t;if(c>=f)return t.clear();for(var h=t._level,p=t._root,_=0;c+_<0;)p=new or(p&&p.array.length?[void 0,p]:[],o),_+=1<<(h+=r);_&&(c+=_,u+=_,f+=_,a+=_);for(var l=lr(a),v=lr(f);v>=1<l?new or([],o):y;if(y&&v>l&&cr;w-=r){var m=l>>>w&i;g=g.array[m]=hr(g.array[m],o)}g.array[l>>>r&i]=y}if(f=v)c-=v,f-=v,h=r,p=null,d=d&&d.removeBefore(o,0,c);else if(c>u||v>>h&i;if(b!==v>>>h&i)break;b&&(_+=(1<u&&(p=p.removeBefore(o,h,c-_)),p&&v>>r<=n&&a.size>=2*s.size?(i=(u=a.filter((function(t,e){return void 0!==t&&c!==e}))).toKeyedSeq().map((function(t){return t[0]})).flip().toMap(),t.__ownerID&&(i.__ownerID=u.__ownerID=t.__ownerID)):(i=s.remove(e),u=c===a.size-1?a.pop():a.set(c,void 0))}else if(f){if(r===a.get(c)[1])return t;i=s,u=a.set(c,[e,r])}else i=s.set(e,a.size),u=a.set(a.size,[e,r]);return t.__ownerID?(t.size=i.size,t._map=i,t._list=u,t.__hash=void 0,t.__altered=!0,t):dr(i,u)}yr.isOrderedMap=ct,yr.prototype[A]=!0,yr.prototype[e]=yr.prototype.remove;var mr="@@__IMMUTABLE_STACK__@@";function br(t){return Boolean(t&&t[mr])}var zr=function(t){function e(t){return null==t?Er():br(t)?t:Er().pushAll(t)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.of=function(){return this(arguments)},e.prototype.toString=function(){return this.__toString("Stack [","]")},e.prototype.get=function(t,e){var r=this._head;for(t=c(this,t);r&&t--;)r=r.next;return r?r.value:e},e.prototype.peek=function(){return this._head&&this._head.value},e.prototype.push=function(){var t=arguments;if(0===arguments.length)return this;for(var e=this.size+arguments.length,r=this._head,n=arguments.length-1;n>=0;n--)r={value:t[n],next:r};return this.__ownerID?(this.size=e,this._head=r,this.__hash=void 0,this.__altered=!0,this):Or(e,r)},e.prototype.pushAll=function(e){if(0===(e=t(e)).size)return this;if(0===this.size&&br(e))return e;te(e.size);var r=this.size,n=this._head;return e.__iterate((function(t){r++,n={value:t,next:n}}),!0),this.__ownerID?(this.size=r,this._head=n,this.__hash=void 0,this.__altered=!0,this):Or(r,n)},e.prototype.pop=function(){return this.slice(1)},e.prototype.clear=function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._head=void 0,this.__hash=void 0,this.__altered=!0,this):Er()},e.prototype.slice=function(e,r){if(h(e,r,this.size))return this;var n=p(e,this.size);if(_(r,this.size)!==this.size)return t.prototype.slice.call(this,e,r);for(var i=this.size-n,o=this._head;n--;)o=o.next;return this.__ownerID?(this.size=i,this._head=o,this.__hash=void 0,this.__altered=!0,this):Or(i,o)},e.prototype.__ensureOwner=function(t){return t===this.__ownerID?this:t?Or(this.size,this._head,t,this.__hash):0===this.size?Er():(this.__ownerID=t,this.__altered=!1,this)},e.prototype.__iterate=function(t,e){var r=this;if(e)return new $(this.toArray()).__iterate((function(e,n){return t(e,n,r)}),e);for(var n=0,i=this._head;i&&!1!==t(i.value,n++,this);)i=i.next;return n},e.prototype.__iterator=function(t,e){if(e)return new $(this.toArray()).__iterator(t,e);var r=0,n=this._head;return new C((function(){if(n){var e=n.value;return n=n.next,P(t,r++,e)}return{value:void 0,done:!0}}))},e}(O);zr.isStack=br;var Sr,Ir=zr.prototype;function Or(t,e,r,n){var i=Object.create(Ir);return i.size=t,i._head=e,i.__ownerID=r,i.__hash=n,i.__altered=!1,i}function Er(){return Sr||(Sr=Or(0))}Ir[mr]=!0,Ir.shift=Ir.pop,Ir.unshift=Ir.push,Ir.unshiftAll=Ir.pushAll,Ir.withMutations=Me,Ir.wasAltered=Ae,Ir.asImmutable=xe,Ir["@@transducer/init"]=Ir.asMutable=De,Ir["@@transducer/step"]=function(t,e){return t.unshift(e)},Ir["@@transducer/result"]=function(t){return t.asImmutable()};var jr="@@__IMMUTABLE_SET__@@";function qr(t){return Boolean(t&&t[jr])}function Mr(t){return qr(t)&&k(t)}function Dr(t,e){if(t===e)return!0;if(!d(e)||void 0!==t.size&&void 0!==e.size&&t.size!==e.size||void 0!==t.__hash&&void 0!==e.__hash&&t.__hash!==e.__hash||w(t)!==w(e)||b(t)!==b(e)||k(t)!==k(e))return!1;if(0===t.size&&0===e.size)return!0;var r=!z(t);if(k(t)){var n=t.entries();return e.every((function(t,e){var i=n.next().value;return i&&ht(i[1],t)&&(r||ht(i[0],e))}))&&n.next().done}var i=!1;if(void 0===t.size)if(void 0===e.size)"function"==typeof t.cacheResult&&t.cacheResult();else{i=!0;var u=t;t=e,e=u}var s=!0,a=e.__iterate((function(e,n){if(r?!t.has(e):i?!ht(e,t.get(n,o)):!ht(t.get(n,o),e))return s=!1,!1}));return s&&t.size===a}function xr(t,e){var r=function(r){t.prototype[r]=e[r]};return Object.keys(e).forEach(r),Object.getOwnPropertySymbols&&Object.getOwnPropertySymbols(e).forEach(r),t}function Ar(t){if(!t||"object"!=typeof t)return t;if(!d(t)){if(!ie(t))return t;t=X(t)}if(w(t)){var e={};return t.__iterate((function(t,r){e[r]=Ar(t)})),e}var r=[];return t.__iterate((function(t){r.push(Ar(t))})),r}var kr=function(t){function e(e){return null==e?Kr():qr(e)&&!k(e)?e:Kr().withMutations((function(r){var n=t(e);te(n.size),n.forEach((function(t){return r.add(t)}))}))}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.of=function(){return this(arguments)},e.fromKeys=function(t){return this(I(t).keySeq())},e.intersect=function(t){return(t=S(t).toArray()).length?Ur.intersect.apply(e(t.pop()),t):Kr()},e.union=function(t){return(t=S(t).toArray()).length?Ur.union.apply(e(t.pop()),t):Kr()},e.prototype.toString=function(){return this.__toString("Set {","}")},e.prototype.has=function(t){return this._map.has(t)},e.prototype.add=function(t){return Tr(this,this._map.set(t,t))},e.prototype.remove=function(t){return Tr(this,this._map.remove(t))},e.prototype.clear=function(){return Tr(this,this._map.clear())},e.prototype.map=function(t,e){var r=this,n=!1,i=Tr(this,this._map.mapEntries((function(i){var o=i[1],u=t.call(e,o,o,r);return u!==o&&(n=!0),[u,u]}),e));return n?i:this},e.prototype.union=function(){for(var e=[],r=arguments.length;r--;)e[r]=arguments[r];return 0===(e=e.filter((function(t){return 0!==t.size}))).length?this:0!==this.size||this.__ownerID||1!==e.length?this.withMutations((function(r){for(var n=0;n=0&&e=0&&r>>-15,461845907),e=pt(e<<13|e>>>-13,5),e=pt((e=(e+3864292196|0)^t)^e>>>16,2246822507),e=_t((e=pt(e^e>>>13,3266489909))^e>>>16)}(t.size,n)}(this))}});var Jr=S.prototype;Jr[y]=!0,Jr[L]=Jr.values,Jr.toJSON=Jr.toArray,Jr.__toStringMapper=oe,Jr.inspect=Jr.toSource=function(){return this.toString()},Jr.chain=Jr.flatMap,Jr.contains=Jr.includes,xr(I,{flip:function(){return Vt(this,Rt(this))},mapEntries:function(t,e){var r=this,n=0;return Vt(this,this.toSeq().map((function(i,o){return t.call(e,[o,i],n++,r)})).fromEntrySeq())},mapKeys:function(t,e){var r=this;return Vt(this,this.toSeq().flip().map((function(n,i){return t.call(e,n,i,r)})).flip())}});var Vr=I.prototype;Vr[g]=!0,Vr[L]=Jr.entries,Vr.toJSON=Hr,Vr.__toStringMapper=function(t,e){return oe(e)+": "+oe(t)},xr(O,{toKeyedSeq:function(){return new Dt(this,!1)},filter:function(t,e){return Vt(this,Bt(this,t,e,!1))},findIndex:function(t,e){var r=this.findEntry(t,e);return r?r[0]:-1},indexOf:function(t){var e=this.keyOf(t);return void 0===e?-1:e},lastIndexOf:function(t){var e=this.lastKeyOf(t);return void 0===e?-1:e},reverse:function(){return Vt(this,Tt(this,!1))},slice:function(t,e){return Vt(this,Kt(this,t,e,!1))},splice:function(t,e){var r=arguments.length;if(e=Math.max(e||0,0),0===r||2===r&&!e)return this;t=p(t,t<0?this.count():this.size);var n=this.slice(0,t);return Vt(this,1===r?n:n.concat(Zt(arguments,2),this.slice(t+e)))},findLastIndex:function(t,e){var r=this.findLastEntry(t,e);return r?r[0]:-1},first:function(t){return this.get(0,t)},flatten:function(t){return Vt(this,Pt(this,t,!1))},get:function(t,e){return(t=c(this,t))<0||this.size===1/0||void 0!==this.size&&t>this.size?e:this.find((function(e,r){return r===t}),void 0,e)},has:function(t){return(t=c(this,t))>=0&&(void 0!==this.size?this.size===1/0||te?-1:0}function rn(t,e){return t^e+2654435769+(t<<6)+(t>>2)|0}Qr.has=Jr.includes,Qr.contains=Qr.includes,Qr.keys=Qr.values,xr(F,Vr),xr(G,Yr),xr(Z,Qr);var nn=function(t){function e(t){return null==t?an():Mr(t)?t:an().withMutations((function(e){var r=E(t);te(r.size),r.forEach((function(t){return e.add(t)}))}))}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.of=function(){return this(arguments)},e.fromKeys=function(t){return this(I(t).keySeq())},e.prototype.toString=function(){return this.__toString("OrderedSet {","}")},e}(kr);nn.isOrderedSet=Mr;var on,un=nn.prototype;function sn(t,e){var r=Object.create(un);return r.size=t?t.size:0,r._map=t,r.__ownerID=e,r}function an(){return on||(on=sn(gr()))}un[A]=!0,un.zip=Yr.zip,un.zipWith=Yr.zipWith,un.zipAll=Yr.zipAll,un.__empty=an,un.__make=sn;var cn=function(t,e){var r;!function(t){if(D(t))throw new Error("Can not call `Record` with an immutable Record as default values. Use a plain javascript object instead.");if(x(t))throw new Error("Can not call `Record` with an immutable Collection as default values. Use a plain javascript object instead.");if(null===t||"object"!=typeof t)throw new Error("Can not call `Record` with a non-object as default values. Use a plain javascript object instead.")}(t);var n=function(o){var u=this;if(o instanceof n)return o;if(!(this instanceof n))return new n(o);if(!r){r=!0;var s=Object.keys(t),a=i._indices={};i._name=e,i._keys=s,i._defaultValues=t;for(var c=0;c2?[]:void 0,{"":t})},t.get=se,t.getIn=Pr,t.has=ue,t.hasIn=Nr,t.hash=vt,t.is=ht,t.isAssociative=z,t.isCollection=d,t.isImmutable=x,t.isIndexed=b,t.isKeyed=w,t.isList=rr,t.isMap=at,t.isOrdered=k,t.isOrderedMap=ct,t.isOrderedSet=Mr,t.isPlainObject=ne,t.isRecord=D,t.isSeq=q,t.isSet=qr,t.isStack=br,t.isValueObject=ft,t.merge=function(t){for(var e=[],r=arguments.length-1;r-- >0;)e[r]=arguments[r+1];return Ie(t,e)},t.mergeDeep=function(t){for(var e=[],r=arguments.length-1;r-- >0;)e[r]=arguments[r+1];return Se(t,e)},t.mergeDeepWith=function(t,e){for(var r=[],n=arguments.length-2;n-- >0;)r[n]=arguments[n+2];return Se(e,r,t)},t.mergeWith=function(t,e){for(var r=[],n=arguments.length-2;n-- >0;)r[n]=arguments[n+2];return Ie(e,r,t)},t.remove=ce,t.removeIn=ve,t.set=fe,t.setIn=_e,t.update=de,t.updateIn=he,t.version="5.1.1"})); diff --git a/node_modules/immutable/package.json b/node_modules/immutable/package.json new file mode 100644 index 0000000..b43c22a --- /dev/null +++ b/node_modules/immutable/package.json @@ -0,0 +1,38 @@ +{ + "name": "immutable", + "version": "5.1.1", + "description": "Immutable Data Collections", + "license": "MIT", + "homepage": "https://immutable-js.com", + "author": { + "name": "Lee Byron", + "url": "https://github.com/leebyron" + }, + "repository": { + "type": "git", + "url": "git://github.com/immutable-js/immutable-js.git" + }, + "bugs": { + "url": "https://github.com/immutable-js/immutable-js/issues" + }, + "main": "dist/immutable.js", + "module": "dist/immutable.es.js", + "types": "dist/immutable.d.ts", + "files": [ + "dist", + "README.md", + "LICENSE" + ], + "keywords": [ + "immutable", + "persistent", + "lazy", + "data", + "datastructure", + "functional", + "collection", + "stateless", + "sequence", + "iteration" + ] +} \ No newline at end of file diff --git a/node_modules/is-extglob/LICENSE b/node_modules/is-extglob/LICENSE new file mode 100644 index 0000000..842218c --- /dev/null +++ b/node_modules/is-extglob/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014-2016, Jon Schlinkert + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/is-extglob/README.md b/node_modules/is-extglob/README.md new file mode 100644 index 0000000..0416af5 --- /dev/null +++ b/node_modules/is-extglob/README.md @@ -0,0 +1,107 @@ +# is-extglob [![NPM version](https://img.shields.io/npm/v/is-extglob.svg?style=flat)](https://www.npmjs.com/package/is-extglob) [![NPM downloads](https://img.shields.io/npm/dm/is-extglob.svg?style=flat)](https://npmjs.org/package/is-extglob) [![Build Status](https://img.shields.io/travis/jonschlinkert/is-extglob.svg?style=flat)](https://travis-ci.org/jonschlinkert/is-extglob) + +> Returns true if a string has an extglob. + +## Install + +Install with [npm](https://www.npmjs.com/): + +```sh +$ npm install --save is-extglob +``` + +## Usage + +```js +var isExtglob = require('is-extglob'); +``` + +**True** + +```js +isExtglob('?(abc)'); +isExtglob('@(abc)'); +isExtglob('!(abc)'); +isExtglob('*(abc)'); +isExtglob('+(abc)'); +``` + +**False** + +Escaped extglobs: + +```js +isExtglob('\\?(abc)'); +isExtglob('\\@(abc)'); +isExtglob('\\!(abc)'); +isExtglob('\\*(abc)'); +isExtglob('\\+(abc)'); +``` + +Everything else... + +```js +isExtglob('foo.js'); +isExtglob('!foo.js'); +isExtglob('*.js'); +isExtglob('**/abc.js'); +isExtglob('abc/*.js'); +isExtglob('abc/(aaa|bbb).js'); +isExtglob('abc/[a-z].js'); +isExtglob('abc/{a,b}.js'); +isExtglob('abc/?.js'); +isExtglob('abc.js'); +isExtglob('abc/def/ghi.js'); +``` + +## History + +**v2.0** + +Adds support for escaping. Escaped exglobs no longer return true. + +## About + +### Related projects + +* [has-glob](https://www.npmjs.com/package/has-glob): Returns `true` if an array has a glob pattern. | [homepage](https://github.com/jonschlinkert/has-glob "Returns `true` if an array has a glob pattern.") +* [is-glob](https://www.npmjs.com/package/is-glob): Returns `true` if the given string looks like a glob pattern or an extglob pattern… [more](https://github.com/jonschlinkert/is-glob) | [homepage](https://github.com/jonschlinkert/is-glob "Returns `true` if the given string looks like a glob pattern or an extglob pattern. This makes it easy to create code that only uses external modules like node-glob when necessary, resulting in much faster code execution and initialization time, and a bet") +* [micromatch](https://www.npmjs.com/package/micromatch): Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. | [homepage](https://github.com/jonschlinkert/micromatch "Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch.") + +### Contributing + +Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new). + +### Building docs + +_(This document was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme) (a [verb](https://github.com/verbose/verb) generator), please don't edit the readme directly. Any changes to the readme must be made in [.verb.md](.verb.md).)_ + +To generate the readme and API documentation with [verb](https://github.com/verbose/verb): + +```sh +$ npm install -g verb verb-generate-readme && verb +``` + +### Running tests + +Install dev dependencies: + +```sh +$ npm install -d && npm test +``` + +### Author + +**Jon Schlinkert** + +* [github/jonschlinkert](https://github.com/jonschlinkert) +* [twitter/jonschlinkert](http://twitter.com/jonschlinkert) + +### License + +Copyright © 2016, [Jon Schlinkert](https://github.com/jonschlinkert). +Released under the [MIT license](https://github.com/jonschlinkert/is-extglob/blob/master/LICENSE). + +*** + +_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.1.31, on October 12, 2016._ \ No newline at end of file diff --git a/node_modules/is-extglob/index.js b/node_modules/is-extglob/index.js new file mode 100644 index 0000000..c1d986f --- /dev/null +++ b/node_modules/is-extglob/index.js @@ -0,0 +1,20 @@ +/*! + * is-extglob + * + * Copyright (c) 2014-2016, Jon Schlinkert. + * Licensed under the MIT License. + */ + +module.exports = function isExtglob(str) { + if (typeof str !== 'string' || str === '') { + return false; + } + + var match; + while ((match = /(\\).|([@?!+*]\(.*\))/g.exec(str))) { + if (match[2]) return true; + str = str.slice(match.index + match[0].length); + } + + return false; +}; diff --git a/node_modules/is-extglob/package.json b/node_modules/is-extglob/package.json new file mode 100644 index 0000000..7a90836 --- /dev/null +++ b/node_modules/is-extglob/package.json @@ -0,0 +1,69 @@ +{ + "name": "is-extglob", + "description": "Returns true if a string has an extglob.", + "version": "2.1.1", + "homepage": "https://github.com/jonschlinkert/is-extglob", + "author": "Jon Schlinkert (https://github.com/jonschlinkert)", + "repository": "jonschlinkert/is-extglob", + "bugs": { + "url": "https://github.com/jonschlinkert/is-extglob/issues" + }, + "license": "MIT", + "files": [ + "index.js" + ], + "main": "index.js", + "engines": { + "node": ">=0.10.0" + }, + "scripts": { + "test": "mocha" + }, + "devDependencies": { + "gulp-format-md": "^0.1.10", + "mocha": "^3.0.2" + }, + "keywords": [ + "bash", + "braces", + "check", + "exec", + "expression", + "extglob", + "glob", + "globbing", + "globstar", + "is", + "match", + "matches", + "pattern", + "regex", + "regular", + "string", + "test" + ], + "verb": { + "toc": false, + "layout": "default", + "tasks": [ + "readme" + ], + "plugins": [ + "gulp-format-md" + ], + "related": { + "list": [ + "has-glob", + "is-glob", + "micromatch" + ] + }, + "reflinks": [ + "verb", + "verb-generate-readme" + ], + "lint": { + "reflinks": true + } + } +} diff --git a/node_modules/is-glob/LICENSE b/node_modules/is-glob/LICENSE new file mode 100644 index 0000000..3f2eca1 --- /dev/null +++ b/node_modules/is-glob/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014-2017, Jon Schlinkert. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/is-glob/README.md b/node_modules/is-glob/README.md new file mode 100644 index 0000000..740724b --- /dev/null +++ b/node_modules/is-glob/README.md @@ -0,0 +1,206 @@ +# is-glob [![NPM version](https://img.shields.io/npm/v/is-glob.svg?style=flat)](https://www.npmjs.com/package/is-glob) [![NPM monthly downloads](https://img.shields.io/npm/dm/is-glob.svg?style=flat)](https://npmjs.org/package/is-glob) [![NPM total downloads](https://img.shields.io/npm/dt/is-glob.svg?style=flat)](https://npmjs.org/package/is-glob) [![Build Status](https://img.shields.io/github/workflow/status/micromatch/is-glob/dev)](https://github.com/micromatch/is-glob/actions) + +> Returns `true` if the given string looks like a glob pattern or an extglob pattern. This makes it easy to create code that only uses external modules like node-glob when necessary, resulting in much faster code execution and initialization time, and a better user experience. + +Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support. + +## Install + +Install with [npm](https://www.npmjs.com/): + +```sh +$ npm install --save is-glob +``` + +You might also be interested in [is-valid-glob](https://github.com/jonschlinkert/is-valid-glob) and [has-glob](https://github.com/jonschlinkert/has-glob). + +## Usage + +```js +var isGlob = require('is-glob'); +``` + +### Default behavior + +**True** + +Patterns that have glob characters or regex patterns will return `true`: + +```js +isGlob('!foo.js'); +isGlob('*.js'); +isGlob('**/abc.js'); +isGlob('abc/*.js'); +isGlob('abc/(aaa|bbb).js'); +isGlob('abc/[a-z].js'); +isGlob('abc/{a,b}.js'); +//=> true +``` + +Extglobs + +```js +isGlob('abc/@(a).js'); +isGlob('abc/!(a).js'); +isGlob('abc/+(a).js'); +isGlob('abc/*(a).js'); +isGlob('abc/?(a).js'); +//=> true +``` + +**False** + +Escaped globs or extglobs return `false`: + +```js +isGlob('abc/\\@(a).js'); +isGlob('abc/\\!(a).js'); +isGlob('abc/\\+(a).js'); +isGlob('abc/\\*(a).js'); +isGlob('abc/\\?(a).js'); +isGlob('\\!foo.js'); +isGlob('\\*.js'); +isGlob('\\*\\*/abc.js'); +isGlob('abc/\\*.js'); +isGlob('abc/\\(aaa|bbb).js'); +isGlob('abc/\\[a-z].js'); +isGlob('abc/\\{a,b}.js'); +//=> false +``` + +Patterns that do not have glob patterns return `false`: + +```js +isGlob('abc.js'); +isGlob('abc/def/ghi.js'); +isGlob('foo.js'); +isGlob('abc/@.js'); +isGlob('abc/+.js'); +isGlob('abc/?.js'); +isGlob(); +isGlob(null); +//=> false +``` + +Arrays are also `false` (If you want to check if an array has a glob pattern, use [has-glob](https://github.com/jonschlinkert/has-glob)): + +```js +isGlob(['**/*.js']); +isGlob(['foo.js']); +//=> false +``` + +### Option strict + +When `options.strict === false` the behavior is less strict in determining if a pattern is a glob. Meaning that +some patterns that would return `false` may return `true`. This is done so that matching libraries like [micromatch](https://github.com/micromatch/micromatch) have a chance at determining if the pattern is a glob or not. + +**True** + +Patterns that have glob characters or regex patterns will return `true`: + +```js +isGlob('!foo.js', {strict: false}); +isGlob('*.js', {strict: false}); +isGlob('**/abc.js', {strict: false}); +isGlob('abc/*.js', {strict: false}); +isGlob('abc/(aaa|bbb).js', {strict: false}); +isGlob('abc/[a-z].js', {strict: false}); +isGlob('abc/{a,b}.js', {strict: false}); +//=> true +``` + +Extglobs + +```js +isGlob('abc/@(a).js', {strict: false}); +isGlob('abc/!(a).js', {strict: false}); +isGlob('abc/+(a).js', {strict: false}); +isGlob('abc/*(a).js', {strict: false}); +isGlob('abc/?(a).js', {strict: false}); +//=> true +``` + +**False** + +Escaped globs or extglobs return `false`: + +```js +isGlob('\\!foo.js', {strict: false}); +isGlob('\\*.js', {strict: false}); +isGlob('\\*\\*/abc.js', {strict: false}); +isGlob('abc/\\*.js', {strict: false}); +isGlob('abc/\\(aaa|bbb).js', {strict: false}); +isGlob('abc/\\[a-z].js', {strict: false}); +isGlob('abc/\\{a,b}.js', {strict: false}); +//=> false +``` + +## About + +
+Contributing + +Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new). + +
+ +
+Running Tests + +Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command: + +```sh +$ npm install && npm test +``` + +
+ +
+Building docs + +_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_ + +To generate the readme, run the following command: + +```sh +$ npm install -g verbose/verb#dev verb-generate-readme && verb +``` + +
+ +### Related projects + +You might also be interested in these projects: + +* [assemble](https://www.npmjs.com/package/assemble): Get the rocks out of your socks! Assemble makes you fast at creating web projects… [more](https://github.com/assemble/assemble) | [homepage](https://github.com/assemble/assemble "Get the rocks out of your socks! Assemble makes you fast at creating web projects. Assemble is used by thousands of projects for rapid prototyping, creating themes, scaffolds, boilerplates, e-books, UI components, API documentation, blogs, building websit") +* [base](https://www.npmjs.com/package/base): Framework for rapidly creating high quality, server-side node.js applications, using plugins like building blocks | [homepage](https://github.com/node-base/base "Framework for rapidly creating high quality, server-side node.js applications, using plugins like building blocks") +* [update](https://www.npmjs.com/package/update): Be scalable! Update is a new, open source developer framework and CLI for automating updates… [more](https://github.com/update/update) | [homepage](https://github.com/update/update "Be scalable! Update is a new, open source developer framework and CLI for automating updates of any kind in code projects.") +* [verb](https://www.npmjs.com/package/verb): Documentation generator for GitHub projects. Verb is extremely powerful, easy to use, and is used… [more](https://github.com/verbose/verb) | [homepage](https://github.com/verbose/verb "Documentation generator for GitHub projects. Verb is extremely powerful, easy to use, and is used on hundreds of projects of all sizes to generate everything from API docs to readmes.") + +### Contributors + +| **Commits** | **Contributor** | +| --- | --- | +| 47 | [jonschlinkert](https://github.com/jonschlinkert) | +| 5 | [doowb](https://github.com/doowb) | +| 1 | [phated](https://github.com/phated) | +| 1 | [danhper](https://github.com/danhper) | +| 1 | [paulmillr](https://github.com/paulmillr) | + +### Author + +**Jon Schlinkert** + +* [GitHub Profile](https://github.com/jonschlinkert) +* [Twitter Profile](https://twitter.com/jonschlinkert) +* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert) + +### License + +Copyright © 2019, [Jon Schlinkert](https://github.com/jonschlinkert). +Released under the [MIT License](LICENSE). + +*** + +_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on March 27, 2019._ \ No newline at end of file diff --git a/node_modules/is-glob/index.js b/node_modules/is-glob/index.js new file mode 100644 index 0000000..620f563 --- /dev/null +++ b/node_modules/is-glob/index.js @@ -0,0 +1,150 @@ +/*! + * is-glob + * + * Copyright (c) 2014-2017, Jon Schlinkert. + * Released under the MIT License. + */ + +var isExtglob = require('is-extglob'); +var chars = { '{': '}', '(': ')', '[': ']'}; +var strictCheck = function(str) { + if (str[0] === '!') { + return true; + } + var index = 0; + var pipeIndex = -2; + var closeSquareIndex = -2; + var closeCurlyIndex = -2; + var closeParenIndex = -2; + var backSlashIndex = -2; + while (index < str.length) { + if (str[index] === '*') { + return true; + } + + if (str[index + 1] === '?' && /[\].+)]/.test(str[index])) { + return true; + } + + if (closeSquareIndex !== -1 && str[index] === '[' && str[index + 1] !== ']') { + if (closeSquareIndex < index) { + closeSquareIndex = str.indexOf(']', index); + } + if (closeSquareIndex > index) { + if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) { + return true; + } + backSlashIndex = str.indexOf('\\', index); + if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) { + return true; + } + } + } + + if (closeCurlyIndex !== -1 && str[index] === '{' && str[index + 1] !== '}') { + closeCurlyIndex = str.indexOf('}', index); + if (closeCurlyIndex > index) { + backSlashIndex = str.indexOf('\\', index); + if (backSlashIndex === -1 || backSlashIndex > closeCurlyIndex) { + return true; + } + } + } + + if (closeParenIndex !== -1 && str[index] === '(' && str[index + 1] === '?' && /[:!=]/.test(str[index + 2]) && str[index + 3] !== ')') { + closeParenIndex = str.indexOf(')', index); + if (closeParenIndex > index) { + backSlashIndex = str.indexOf('\\', index); + if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) { + return true; + } + } + } + + if (pipeIndex !== -1 && str[index] === '(' && str[index + 1] !== '|') { + if (pipeIndex < index) { + pipeIndex = str.indexOf('|', index); + } + if (pipeIndex !== -1 && str[pipeIndex + 1] !== ')') { + closeParenIndex = str.indexOf(')', pipeIndex); + if (closeParenIndex > pipeIndex) { + backSlashIndex = str.indexOf('\\', pipeIndex); + if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) { + return true; + } + } + } + } + + if (str[index] === '\\') { + var open = str[index + 1]; + index += 2; + var close = chars[open]; + + if (close) { + var n = str.indexOf(close, index); + if (n !== -1) { + index = n + 1; + } + } + + if (str[index] === '!') { + return true; + } + } else { + index++; + } + } + return false; +}; + +var relaxedCheck = function(str) { + if (str[0] === '!') { + return true; + } + var index = 0; + while (index < str.length) { + if (/[*?{}()[\]]/.test(str[index])) { + return true; + } + + if (str[index] === '\\') { + var open = str[index + 1]; + index += 2; + var close = chars[open]; + + if (close) { + var n = str.indexOf(close, index); + if (n !== -1) { + index = n + 1; + } + } + + if (str[index] === '!') { + return true; + } + } else { + index++; + } + } + return false; +}; + +module.exports = function isGlob(str, options) { + if (typeof str !== 'string' || str === '') { + return false; + } + + if (isExtglob(str)) { + return true; + } + + var check = strictCheck; + + // optionally relax check + if (options && options.strict === false) { + check = relaxedCheck; + } + + return check(str); +}; diff --git a/node_modules/is-glob/package.json b/node_modules/is-glob/package.json new file mode 100644 index 0000000..858af03 --- /dev/null +++ b/node_modules/is-glob/package.json @@ -0,0 +1,81 @@ +{ + "name": "is-glob", + "description": "Returns `true` if the given string looks like a glob pattern or an extglob pattern. This makes it easy to create code that only uses external modules like node-glob when necessary, resulting in much faster code execution and initialization time, and a better user experience.", + "version": "4.0.3", + "homepage": "https://github.com/micromatch/is-glob", + "author": "Jon Schlinkert (https://github.com/jonschlinkert)", + "contributors": [ + "Brian Woodward (https://twitter.com/doowb)", + "Daniel Perez (https://tuvistavie.com)", + "Jon Schlinkert (http://twitter.com/jonschlinkert)" + ], + "repository": "micromatch/is-glob", + "bugs": { + "url": "https://github.com/micromatch/is-glob/issues" + }, + "license": "MIT", + "files": [ + "index.js" + ], + "main": "index.js", + "engines": { + "node": ">=0.10.0" + }, + "scripts": { + "test": "mocha && node benchmark.js" + }, + "dependencies": { + "is-extglob": "^2.1.1" + }, + "devDependencies": { + "gulp-format-md": "^0.1.10", + "mocha": "^3.0.2" + }, + "keywords": [ + "bash", + "braces", + "check", + "exec", + "expression", + "extglob", + "glob", + "globbing", + "globstar", + "is", + "match", + "matches", + "pattern", + "regex", + "regular", + "string", + "test" + ], + "verb": { + "layout": "default", + "plugins": [ + "gulp-format-md" + ], + "related": { + "list": [ + "assemble", + "base", + "update", + "verb" + ] + }, + "reflinks": [ + "assemble", + "bach", + "base", + "composer", + "gulp", + "has-glob", + "is-valid-glob", + "micromatch", + "npm", + "scaffold", + "verb", + "vinyl" + ] + } +} diff --git a/node_modules/is-number/LICENSE b/node_modules/is-number/LICENSE new file mode 100644 index 0000000..9af4a67 --- /dev/null +++ b/node_modules/is-number/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014-present, Jon Schlinkert. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/is-number/README.md b/node_modules/is-number/README.md new file mode 100644 index 0000000..eb8149e --- /dev/null +++ b/node_modules/is-number/README.md @@ -0,0 +1,187 @@ +# is-number [![NPM version](https://img.shields.io/npm/v/is-number.svg?style=flat)](https://www.npmjs.com/package/is-number) [![NPM monthly downloads](https://img.shields.io/npm/dm/is-number.svg?style=flat)](https://npmjs.org/package/is-number) [![NPM total downloads](https://img.shields.io/npm/dt/is-number.svg?style=flat)](https://npmjs.org/package/is-number) [![Linux Build Status](https://img.shields.io/travis/jonschlinkert/is-number.svg?style=flat&label=Travis)](https://travis-ci.org/jonschlinkert/is-number) + +> Returns true if the value is a finite number. + +Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support. + +## Install + +Install with [npm](https://www.npmjs.com/): + +```sh +$ npm install --save is-number +``` + +## Why is this needed? + +In JavaScript, it's not always as straightforward as it should be to reliably check if a value is a number. It's common for devs to use `+`, `-`, or `Number()` to cast a string value to a number (for example, when values are returned from user input, regex matches, parsers, etc). But there are many non-intuitive edge cases that yield unexpected results: + +```js +console.log(+[]); //=> 0 +console.log(+''); //=> 0 +console.log(+' '); //=> 0 +console.log(typeof NaN); //=> 'number' +``` + +This library offers a performant way to smooth out edge cases like these. + +## Usage + +```js +const isNumber = require('is-number'); +``` + +See the [tests](./test.js) for more examples. + +### true + +```js +isNumber(5e3); // true +isNumber(0xff); // true +isNumber(-1.1); // true +isNumber(0); // true +isNumber(1); // true +isNumber(1.1); // true +isNumber(10); // true +isNumber(10.10); // true +isNumber(100); // true +isNumber('-1.1'); // true +isNumber('0'); // true +isNumber('012'); // true +isNumber('0xff'); // true +isNumber('1'); // true +isNumber('1.1'); // true +isNumber('10'); // true +isNumber('10.10'); // true +isNumber('100'); // true +isNumber('5e3'); // true +isNumber(parseInt('012')); // true +isNumber(parseFloat('012')); // true +``` + +### False + +Everything else is false, as you would expect: + +```js +isNumber(Infinity); // false +isNumber(NaN); // false +isNumber(null); // false +isNumber(undefined); // false +isNumber(''); // false +isNumber(' '); // false +isNumber('foo'); // false +isNumber([1]); // false +isNumber([]); // false +isNumber(function () {}); // false +isNumber({}); // false +``` + +## Release history + +### 7.0.0 + +* Refactor. Now uses `.isFinite` if it exists. +* Performance is about the same as v6.0 when the value is a string or number. But it's now 3x-4x faster when the value is not a string or number. + +### 6.0.0 + +* Optimizations, thanks to @benaadams. + +### 5.0.0 + +**Breaking changes** + +* removed support for `instanceof Number` and `instanceof String` + +## Benchmarks + +As with all benchmarks, take these with a grain of salt. See the [benchmarks](./benchmark/index.js) for more detail. + +``` +# all +v7.0 x 413,222 ops/sec ±2.02% (86 runs sampled) +v6.0 x 111,061 ops/sec ±1.29% (85 runs sampled) +parseFloat x 317,596 ops/sec ±1.36% (86 runs sampled) +fastest is 'v7.0' + +# string +v7.0 x 3,054,496 ops/sec ±1.05% (89 runs sampled) +v6.0 x 2,957,781 ops/sec ±0.98% (88 runs sampled) +parseFloat x 3,071,060 ops/sec ±1.13% (88 runs sampled) +fastest is 'parseFloat,v7.0' + +# number +v7.0 x 3,146,895 ops/sec ±0.89% (89 runs sampled) +v6.0 x 3,214,038 ops/sec ±1.07% (89 runs sampled) +parseFloat x 3,077,588 ops/sec ±1.07% (87 runs sampled) +fastest is 'v6.0' +``` + +## About + +
+Contributing + +Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new). + +
+ +
+Running Tests + +Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command: + +```sh +$ npm install && npm test +``` + +
+ +
+Building docs + +_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_ + +To generate the readme, run the following command: + +```sh +$ npm install -g verbose/verb#dev verb-generate-readme && verb +``` + +
+ +### Related projects + +You might also be interested in these projects: + +* [is-plain-object](https://www.npmjs.com/package/is-plain-object): Returns true if an object was created by the `Object` constructor. | [homepage](https://github.com/jonschlinkert/is-plain-object "Returns true if an object was created by the `Object` constructor.") +* [is-primitive](https://www.npmjs.com/package/is-primitive): Returns `true` if the value is a primitive. | [homepage](https://github.com/jonschlinkert/is-primitive "Returns `true` if the value is a primitive. ") +* [isobject](https://www.npmjs.com/package/isobject): Returns true if the value is an object and not an array or null. | [homepage](https://github.com/jonschlinkert/isobject "Returns true if the value is an object and not an array or null.") +* [kind-of](https://www.npmjs.com/package/kind-of): Get the native type of a value. | [homepage](https://github.com/jonschlinkert/kind-of "Get the native type of a value.") + +### Contributors + +| **Commits** | **Contributor** | +| --- | --- | +| 49 | [jonschlinkert](https://github.com/jonschlinkert) | +| 5 | [charlike-old](https://github.com/charlike-old) | +| 1 | [benaadams](https://github.com/benaadams) | +| 1 | [realityking](https://github.com/realityking) | + +### Author + +**Jon Schlinkert** + +* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert) +* [GitHub Profile](https://github.com/jonschlinkert) +* [Twitter Profile](https://twitter.com/jonschlinkert) + +### License + +Copyright © 2018, [Jon Schlinkert](https://github.com/jonschlinkert). +Released under the [MIT License](LICENSE). + +*** + +_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.6.0, on June 15, 2018._ \ No newline at end of file diff --git a/node_modules/is-number/index.js b/node_modules/is-number/index.js new file mode 100644 index 0000000..27f19b7 --- /dev/null +++ b/node_modules/is-number/index.js @@ -0,0 +1,18 @@ +/*! + * is-number + * + * Copyright (c) 2014-present, Jon Schlinkert. + * Released under the MIT License. + */ + +'use strict'; + +module.exports = function(num) { + if (typeof num === 'number') { + return num - num === 0; + } + if (typeof num === 'string' && num.trim() !== '') { + return Number.isFinite ? Number.isFinite(+num) : isFinite(+num); + } + return false; +}; diff --git a/node_modules/is-number/package.json b/node_modules/is-number/package.json new file mode 100644 index 0000000..3715072 --- /dev/null +++ b/node_modules/is-number/package.json @@ -0,0 +1,82 @@ +{ + "name": "is-number", + "description": "Returns true if a number or string value is a finite number. Useful for regex matches, parsing, user input, etc.", + "version": "7.0.0", + "homepage": "https://github.com/jonschlinkert/is-number", + "author": "Jon Schlinkert (https://github.com/jonschlinkert)", + "contributors": [ + "Jon Schlinkert (http://twitter.com/jonschlinkert)", + "Olsten Larck (https://i.am.charlike.online)", + "Rouven Weßling (www.rouvenwessling.de)" + ], + "repository": "jonschlinkert/is-number", + "bugs": { + "url": "https://github.com/jonschlinkert/is-number/issues" + }, + "license": "MIT", + "files": [ + "index.js" + ], + "main": "index.js", + "engines": { + "node": ">=0.12.0" + }, + "scripts": { + "test": "mocha" + }, + "devDependencies": { + "ansi": "^0.3.1", + "benchmark": "^2.1.4", + "gulp-format-md": "^1.0.0", + "mocha": "^3.5.3" + }, + "keywords": [ + "cast", + "check", + "coerce", + "coercion", + "finite", + "integer", + "is", + "isnan", + "is-nan", + "is-num", + "is-number", + "isnumber", + "isfinite", + "istype", + "kind", + "math", + "nan", + "num", + "number", + "numeric", + "parseFloat", + "parseInt", + "test", + "type", + "typeof", + "value" + ], + "verb": { + "toc": false, + "layout": "default", + "tasks": [ + "readme" + ], + "related": { + "list": [ + "is-plain-object", + "is-primitive", + "isobject", + "kind-of" + ] + }, + "plugins": [ + "gulp-format-md" + ], + "lint": { + "reflinks": true + } + } +} diff --git a/node_modules/micromatch/LICENSE b/node_modules/micromatch/LICENSE new file mode 100644 index 0000000..9af4a67 --- /dev/null +++ b/node_modules/micromatch/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014-present, Jon Schlinkert. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/micromatch/README.md b/node_modules/micromatch/README.md new file mode 100644 index 0000000..d72a059 --- /dev/null +++ b/node_modules/micromatch/README.md @@ -0,0 +1,1024 @@ +# micromatch [![NPM version](https://img.shields.io/npm/v/micromatch.svg?style=flat)](https://www.npmjs.com/package/micromatch) [![NPM monthly downloads](https://img.shields.io/npm/dm/micromatch.svg?style=flat)](https://npmjs.org/package/micromatch) [![NPM total downloads](https://img.shields.io/npm/dt/micromatch.svg?style=flat)](https://npmjs.org/package/micromatch) [![Tests](https://github.com/micromatch/micromatch/actions/workflows/test.yml/badge.svg)](https://github.com/micromatch/micromatch/actions/workflows/test.yml) + +> Glob matching for javascript/node.js. A replacement and faster alternative to minimatch and multimatch. + +Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support. + +## Table of Contents + +
+Details + + * [Install](#install) +- [Sponsors](#sponsors) + * [Gold Sponsors](#gold-sponsors) + * [Quickstart](#quickstart) + * [Why use micromatch?](#why-use-micromatch) + + [Matching features](#matching-features) + * [Switching to micromatch](#switching-to-micromatch) + + [From minimatch](#from-minimatch) + + [From multimatch](#from-multimatch) + * [API](#api) + * [Options](#options) + * [Options Examples](#options-examples) + + [options.basename](#optionsbasename) + + [options.bash](#optionsbash) + + [options.expandRange](#optionsexpandrange) + + [options.format](#optionsformat) + + [options.ignore](#optionsignore) + + [options.matchBase](#optionsmatchbase) + + [options.noextglob](#optionsnoextglob) + + [options.nonegate](#optionsnonegate) + + [options.noglobstar](#optionsnoglobstar) + + [options.nonull](#optionsnonull) + + [options.nullglob](#optionsnullglob) + + [options.onIgnore](#optionsonignore) + + [options.onMatch](#optionsonmatch) + + [options.onResult](#optionsonresult) + + [options.posixSlashes](#optionsposixslashes) + + [options.unescape](#optionsunescape) + * [Extended globbing](#extended-globbing) + + [Extglobs](#extglobs) + + [Braces](#braces) + + [Regex character classes](#regex-character-classes) + + [Regex groups](#regex-groups) + + [POSIX bracket expressions](#posix-bracket-expressions) + * [Notes](#notes) + + [Bash 4.3 parity](#bash-43-parity) + + [Backslashes](#backslashes) + * [Benchmarks](#benchmarks) + + [Running benchmarks](#running-benchmarks) + + [Latest results](#latest-results) + * [Contributing](#contributing) + * [About](#about) + +
+ +## Install + +Install with [npm](https://www.npmjs.com/): + +```sh +$ npm install --save micromatch +``` + +
+ +# Sponsors + +[Become a Sponsor](https://github.com/sponsors/jonschlinkert) to add your logo to this README, or any of [my other projects](https://github.com/jonschlinkert?tab=repositories&q=&type=&language=&sort=stargazers) + +
+ +## Quickstart + +```js +const micromatch = require('micromatch'); +// micromatch(list, patterns[, options]); +``` + +The [main export](#micromatch) takes a list of strings and one or more glob patterns: + +```js +console.log(micromatch(['foo', 'bar', 'baz', 'qux'], ['f*', 'b*'])) //=> ['foo', 'bar', 'baz'] +console.log(micromatch(['foo', 'bar', 'baz', 'qux'], ['*', '!b*'])) //=> ['foo', 'qux'] +``` + +Use [.isMatch()](#ismatch) to for boolean matching: + +```js +console.log(micromatch.isMatch('foo', 'f*')) //=> true +console.log(micromatch.isMatch('foo', ['b*', 'f*'])) //=> true +``` + +[Switching](#switching-to-micromatch) from minimatch and multimatch is easy! + +
+ +## Why use micromatch? + +> micromatch is a [replacement](#switching-to-micromatch) for minimatch and multimatch + +* Supports all of the same matching features as [minimatch](https://github.com/isaacs/minimatch) and [multimatch](https://github.com/sindresorhus/multimatch) +* More complete support for the Bash 4.3 specification than minimatch and multimatch. Micromatch passes _all of the spec tests_ from bash, including some that bash still fails. +* **Fast & Performant** - Loads in about 5ms and performs [fast matches](#benchmarks). +* **Glob matching** - Using wildcards (`*` and `?`), globstars (`**`) for nested directories +* **[Advanced globbing](#extended-globbing)** - Supports [extglobs](#extglobs), [braces](#braces-1), and [POSIX brackets](#posix-bracket-expressions), and support for escaping special characters with `\` or quotes. +* **Accurate** - Covers more scenarios [than minimatch](https://github.com/yarnpkg/yarn/pull/3339) +* **Well tested** - More than 5,000 [test assertions](./test) +* **Windows support** - More reliable windows support than minimatch and multimatch. +* **[Safe](https://github.com/micromatch/braces#braces-is-safe)** - Micromatch is not subject to DoS with brace patterns like minimatch and multimatch. + +### Matching features + +* Support for multiple glob patterns (no need for wrappers like multimatch) +* Wildcards (`**`, `*.js`) +* Negation (`'!a/*.js'`, `'*!(b).js'`) +* [extglobs](#extglobs) (`+(x|y)`, `!(a|b)`) +* [POSIX character classes](#posix-bracket-expressions) (`[[:alpha:][:digit:]]`) +* [brace expansion](https://github.com/micromatch/braces) (`foo/{1..5}.md`, `bar/{a,b,c}.js`) +* regex character classes (`foo-[1-5].js`) +* regex logical "or" (`foo/(abc|xyz).js`) + +You can mix and match these features to create whatever patterns you need! + +## Switching to micromatch + +_(There is one notable difference between micromatch and minimatch in regards to how backslashes are handled. See [the notes about backslashes](#backslashes) for more information.)_ + +### From minimatch + +Use [micromatch.isMatch()](#ismatch) instead of `minimatch()`: + +```js +console.log(micromatch.isMatch('foo', 'b*')); //=> false +``` + +Use [micromatch.match()](#match) instead of `minimatch.match()`: + +```js +console.log(micromatch.match(['foo', 'bar'], 'b*')); //=> 'bar' +``` + +### From multimatch + +Same signature: + +```js +console.log(micromatch(['foo', 'bar', 'baz'], ['f*', '*z'])); //=> ['foo', 'baz'] +``` + +## API + +**Params** + +* `list` **{String|Array}**: List of strings to match. +* `patterns` **{String|Array}**: One or more glob patterns to use for matching. +* `options` **{Object}**: See available [options](#options) +* `returns` **{Array}**: Returns an array of matches + +**Example** + +```js +const mm = require('micromatch'); +// mm(list, patterns[, options]); + +console.log(mm(['a.js', 'a.txt'], ['*.js'])); +//=> [ 'a.js' ] +``` + +### [.matcher](index.js#L109) + +Returns a matcher function from the given glob `pattern` and `options`. The returned function takes a string to match as its only argument and returns true if the string is a match. + +**Params** + +* `pattern` **{String}**: Glob pattern +* `options` **{Object}** +* `returns` **{Function}**: Returns a matcher function. + +**Example** + +```js +const mm = require('micromatch'); +// mm.matcher(pattern[, options]); + +const isMatch = mm.matcher('*.!(*a)'); +console.log(isMatch('a.a')); //=> false +console.log(isMatch('a.b')); //=> true +``` + +### [.isMatch](index.js#L128) + +Returns true if **any** of the given glob `patterns` match the specified `string`. + +**Params** + +* `str` **{String}**: The string to test. +* `patterns` **{String|Array}**: One or more glob patterns to use for matching. +* `[options]` **{Object}**: See available [options](#options). +* `returns` **{Boolean}**: Returns true if any patterns match `str` + +**Example** + +```js +const mm = require('micromatch'); +// mm.isMatch(string, patterns[, options]); + +console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true +console.log(mm.isMatch('a.a', 'b.*')); //=> false +``` + +### [.not](index.js#L153) + +Returns a list of strings that _**do not match any**_ of the given `patterns`. + +**Params** + +* `list` **{Array}**: Array of strings to match. +* `patterns` **{String|Array}**: One or more glob pattern to use for matching. +* `options` **{Object}**: See available [options](#options) for changing how matches are performed +* `returns` **{Array}**: Returns an array of strings that **do not match** the given patterns. + +**Example** + +```js +const mm = require('micromatch'); +// mm.not(list, patterns[, options]); + +console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a')); +//=> ['b.b', 'c.c'] +``` + +### [.contains](index.js#L193) + +Returns true if the given `string` contains the given pattern. Similar to [.isMatch](#isMatch) but the pattern can match any part of the string. + +**Params** + +* `str` **{String}**: The string to match. +* `patterns` **{String|Array}**: Glob pattern to use for matching. +* `options` **{Object}**: See available [options](#options) for changing how matches are performed +* `returns` **{Boolean}**: Returns true if any of the patterns matches any part of `str`. + +**Example** + +```js +var mm = require('micromatch'); +// mm.contains(string, pattern[, options]); + +console.log(mm.contains('aa/bb/cc', '*b')); +//=> true +console.log(mm.contains('aa/bb/cc', '*d')); +//=> false +``` + +### [.matchKeys](index.js#L235) + +Filter the keys of the given object with the given `glob` pattern and `options`. Does not attempt to match nested keys. If you need this feature, use [glob-object](https://github.com/jonschlinkert/glob-object) instead. + +**Params** + +* `object` **{Object}**: The object with keys to filter. +* `patterns` **{String|Array}**: One or more glob patterns to use for matching. +* `options` **{Object}**: See available [options](#options) for changing how matches are performed +* `returns` **{Object}**: Returns an object with only keys that match the given patterns. + +**Example** + +```js +const mm = require('micromatch'); +// mm.matchKeys(object, patterns[, options]); + +const obj = { aa: 'a', ab: 'b', ac: 'c' }; +console.log(mm.matchKeys(obj, '*b')); +//=> { ab: 'b' } +``` + +### [.some](index.js#L264) + +Returns true if some of the strings in the given `list` match any of the given glob `patterns`. + +**Params** + +* `list` **{String|Array}**: The string or array of strings to test. Returns as soon as the first match is found. +* `patterns` **{String|Array}**: One or more glob patterns to use for matching. +* `options` **{Object}**: See available [options](#options) for changing how matches are performed +* `returns` **{Boolean}**: Returns true if any `patterns` matches any of the strings in `list` + +**Example** + +```js +const mm = require('micromatch'); +// mm.some(list, patterns[, options]); + +console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js'])); +// true +console.log(mm.some(['foo.js'], ['*.js', '!foo.js'])); +// false +``` + +### [.every](index.js#L300) + +Returns true if every string in the given `list` matches any of the given glob `patterns`. + +**Params** + +* `list` **{String|Array}**: The string or array of strings to test. +* `patterns` **{String|Array}**: One or more glob patterns to use for matching. +* `options` **{Object}**: See available [options](#options) for changing how matches are performed +* `returns` **{Boolean}**: Returns true if all `patterns` matches all of the strings in `list` + +**Example** + +```js +const mm = require('micromatch'); +// mm.every(list, patterns[, options]); + +console.log(mm.every('foo.js', ['foo.js'])); +// true +console.log(mm.every(['foo.js', 'bar.js'], ['*.js'])); +// true +console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js'])); +// false +console.log(mm.every(['foo.js'], ['*.js', '!foo.js'])); +// false +``` + +### [.all](index.js#L339) + +Returns true if **all** of the given `patterns` match the specified string. + +**Params** + +* `str` **{String|Array}**: The string to test. +* `patterns` **{String|Array}**: One or more glob patterns to use for matching. +* `options` **{Object}**: See available [options](#options) for changing how matches are performed +* `returns` **{Boolean}**: Returns true if any patterns match `str` + +**Example** + +```js +const mm = require('micromatch'); +// mm.all(string, patterns[, options]); + +console.log(mm.all('foo.js', ['foo.js'])); +// true + +console.log(mm.all('foo.js', ['*.js', '!foo.js'])); +// false + +console.log(mm.all('foo.js', ['*.js', 'foo.js'])); +// true + +console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js'])); +// true +``` + +### [.capture](index.js#L366) + +Returns an array of matches captured by `pattern` in `string, or`null` if the pattern did not match. + +**Params** + +* `glob` **{String}**: Glob pattern to use for matching. +* `input` **{String}**: String to match +* `options` **{Object}**: See available [options](#options) for changing how matches are performed +* `returns` **{Array|null}**: Returns an array of captures if the input matches the glob pattern, otherwise `null`. + +**Example** + +```js +const mm = require('micromatch'); +// mm.capture(pattern, string[, options]); + +console.log(mm.capture('test/*.js', 'test/foo.js')); +//=> ['foo'] +console.log(mm.capture('test/*.js', 'foo/bar.css')); +//=> null +``` + +### [.makeRe](index.js#L392) + +Create a regular expression from the given glob `pattern`. + +**Params** + +* `pattern` **{String}**: A glob pattern to convert to regex. +* `options` **{Object}** +* `returns` **{RegExp}**: Returns a regex created from the given pattern. + +**Example** + +```js +const mm = require('micromatch'); +// mm.makeRe(pattern[, options]); + +console.log(mm.makeRe('*.js')); +//=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/ +``` + +### [.scan](index.js#L408) + +Scan a glob pattern to separate the pattern into segments. Used by the [split](#split) method. + +**Params** + +* `pattern` **{String}** +* `options` **{Object}** +* `returns` **{Object}**: Returns an object with + +**Example** + +```js +const mm = require('micromatch'); +const state = mm.scan(pattern[, options]); +``` + +### [.parse](index.js#L424) + +Parse a glob pattern to create the source string for a regular expression. + +**Params** + +* `glob` **{String}** +* `options` **{Object}** +* `returns` **{Object}**: Returns an object with useful properties and output to be used as regex source string. + +**Example** + +```js +const mm = require('micromatch'); +const state = mm.parse(pattern[, options]); +``` + +### [.braces](index.js#L451) + +Process the given brace `pattern`. + +**Params** + +* `pattern` **{String}**: String with brace pattern to process. +* `options` **{Object}**: Any [options](#options) to change how expansion is performed. See the [braces](https://github.com/micromatch/braces) library for all available options. +* `returns` **{Array}** + +**Example** + +```js +const { braces } = require('micromatch'); +console.log(braces('foo/{a,b,c}/bar')); +//=> [ 'foo/(a|b|c)/bar' ] + +console.log(braces('foo/{a,b,c}/bar', { expand: true })); +//=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ] +``` + +## Options + +| **Option** | **Type** | **Default value** | **Description** | +| --- | --- | --- | --- | +| `basename` | `boolean` | `false` | If set, then patterns without slashes will be matched against the basename of the path if it contains slashes. For example, `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`. | +| `bash` | `boolean` | `false` | Follow bash matching rules more strictly - disallows backslashes as escape characters, and treats single stars as globstars (`**`). | +| `capture` | `boolean` | `undefined` | Return regex matches in supporting methods. | +| `contains` | `boolean` | `undefined` | Allows glob to match any part of the given string(s). | +| `cwd` | `string` | `process.cwd()` | Current working directory. Used by `picomatch.split()` | +| `debug` | `boolean` | `undefined` | Debug regular expressions when an error is thrown. | +| `dot` | `boolean` | `false` | Match dotfiles. Otherwise dotfiles are ignored unless a `.` is explicitly defined in the pattern. | +| `expandRange` | `function` | `undefined` | Custom function for expanding ranges in brace patterns, such as `{a..z}`. The function receives the range values as two arguments, and it must return a string to be used in the generated regex. It's recommended that returned strings be wrapped in parentheses. This option is overridden by the `expandBrace` option. | +| `failglob` | `boolean` | `false` | Similar to the `failglob` behavior in Bash, throws an error when no matches are found. Based on the bash option of the same name. | +| `fastpaths` | `boolean` | `true` | To speed up processing, full parsing is skipped for a handful common glob patterns. Disable this behavior by setting this option to `false`. | +| `flags` | `boolean` | `undefined` | Regex flags to use in the generated regex. If defined, the `nocase` option will be overridden. | +| [format](#optionsformat) | `function` | `undefined` | Custom function for formatting the returned string. This is useful for removing leading slashes, converting Windows paths to Posix paths, etc. | +| `ignore` | `array\|string` | `undefined` | One or more glob patterns for excluding strings that should not be matched from the result. | +| `keepQuotes` | `boolean` | `false` | Retain quotes in the generated regex, since quotes may also be used as an alternative to backslashes. | +| `literalBrackets` | `boolean` | `undefined` | When `true`, brackets in the glob pattern will be escaped so that only literal brackets will be matched. | +| `lookbehinds` | `boolean` | `true` | Support regex positive and negative lookbehinds. Note that you must be using Node 8.1.10 or higher to enable regex lookbehinds. | +| `matchBase` | `boolean` | `false` | Alias for `basename` | +| `maxLength` | `boolean` | `65536` | Limit the max length of the input string. An error is thrown if the input string is longer than this value. | +| `nobrace` | `boolean` | `false` | Disable brace matching, so that `{a,b}` and `{1..3}` would be treated as literal characters. | +| `nobracket` | `boolean` | `undefined` | Disable matching with regex brackets. | +| `nocase` | `boolean` | `false` | Perform case-insensitive matching. Equivalent to the regex `i` flag. Note that this option is ignored when the `flags` option is defined. | +| `nodupes` | `boolean` | `true` | Deprecated, use `nounique` instead. This option will be removed in a future major release. By default duplicates are removed. Disable uniquification by setting this option to false. | +| `noext` | `boolean` | `false` | Alias for `noextglob` | +| `noextglob` | `boolean` | `false` | Disable support for matching with [extglobs](#extglobs) (like `+(a\|b)`) | +| `noglobstar` | `boolean` | `false` | Disable support for matching nested directories with globstars (`**`) | +| `nonegate` | `boolean` | `false` | Disable support for negating with leading `!` | +| `noquantifiers` | `boolean` | `false` | Disable support for regex quantifiers (like `a{1,2}`) and treat them as brace patterns to be expanded. | +| [onIgnore](#optionsonIgnore) | `function` | `undefined` | Function to be called on ignored items. | +| [onMatch](#optionsonMatch) | `function` | `undefined` | Function to be called on matched items. | +| [onResult](#optionsonResult) | `function` | `undefined` | Function to be called on all items, regardless of whether or not they are matched or ignored. | +| `posix` | `boolean` | `false` | Support [POSIX character classes](#posix-bracket-expressions) ("posix brackets"). | +| `posixSlashes` | `boolean` | `undefined` | Convert all slashes in file paths to forward slashes. This does not convert slashes in the glob pattern itself | +| `prepend` | `string` | `undefined` | String to prepend to the generated regex used for matching. | +| `regex` | `boolean` | `false` | Use regular expression rules for `+` (instead of matching literal `+`), and for stars that follow closing parentheses or brackets (as in `)*` and `]*`). | +| `strictBrackets` | `boolean` | `undefined` | Throw an error if brackets, braces, or parens are imbalanced. | +| `strictSlashes` | `boolean` | `undefined` | When true, picomatch won't match trailing slashes with single stars. | +| `unescape` | `boolean` | `undefined` | Remove preceding backslashes from escaped glob characters before creating the regular expression to perform matches. | +| `unixify` | `boolean` | `undefined` | Alias for `posixSlashes`, for backwards compatitibility. | + +## Options Examples + +### options.basename + +Allow glob patterns without slashes to match a file path based on its basename. Same behavior as [minimatch](https://github.com/isaacs/minimatch) option `matchBase`. + +**Type**: `Boolean` + +**Default**: `false` + +**Example** + +```js +micromatch(['a/b.js', 'a/c.md'], '*.js'); +//=> [] + +micromatch(['a/b.js', 'a/c.md'], '*.js', { basename: true }); +//=> ['a/b.js'] +``` + +### options.bash + +Enabled by default, this option enforces bash-like behavior with stars immediately following a bracket expression. Bash bracket expressions are similar to regex character classes, but unlike regex, a star following a bracket expression **does not repeat the bracketed characters**. Instead, the star is treated the same as any other star. + +**Type**: `Boolean` + +**Default**: `true` + +**Example** + +```js +const files = ['abc', 'ajz']; +console.log(micromatch(files, '[a-c]*')); +//=> ['abc', 'ajz'] + +console.log(micromatch(files, '[a-c]*', { bash: false })); +``` + +### options.expandRange + +**Type**: `function` + +**Default**: `undefined` + +Custom function for expanding ranges in brace patterns. The [fill-range](https://github.com/jonschlinkert/fill-range) library is ideal for this purpose, or you can use custom code to do whatever you need. + +**Example** + +The following example shows how to create a glob that matches a numeric folder name between `01` and `25`, with leading zeros. + +```js +const fill = require('fill-range'); +const regex = micromatch.makeRe('foo/{01..25}/bar', { + expandRange(a, b) { + return `(${fill(a, b, { toRegex: true })})`; + } +}); + +console.log(regex) +//=> /^(?:foo\/((?:0[1-9]|1[0-9]|2[0-5]))\/bar)$/ + +console.log(regex.test('foo/00/bar')) // false +console.log(regex.test('foo/01/bar')) // true +console.log(regex.test('foo/10/bar')) // true +console.log(regex.test('foo/22/bar')) // true +console.log(regex.test('foo/25/bar')) // true +console.log(regex.test('foo/26/bar')) // false +``` + +### options.format + +**Type**: `function` + +**Default**: `undefined` + +Custom function for formatting strings before they're matched. + +**Example** + +```js +// strip leading './' from strings +const format = str => str.replace(/^\.\//, ''); +const isMatch = picomatch('foo/*.js', { format }); +console.log(isMatch('./foo/bar.js')) //=> true +``` + +### options.ignore + +String or array of glob patterns to match files to ignore. + +**Type**: `String|Array` + +**Default**: `undefined` + +```js +const isMatch = micromatch.matcher('*', { ignore: 'f*' }); +console.log(isMatch('foo')) //=> false +console.log(isMatch('bar')) //=> true +console.log(isMatch('baz')) //=> true +``` + +### options.matchBase + +Alias for [options.basename](#options-basename). + +### options.noextglob + +Disable extglob support, so that [extglobs](#extglobs) are regarded as literal characters. + +**Type**: `Boolean` + +**Default**: `undefined` + +**Examples** + +```js +console.log(micromatch(['a/z', 'a/b', 'a/!(z)'], 'a/!(z)')); +//=> ['a/b', 'a/!(z)'] + +console.log(micromatch(['a/z', 'a/b', 'a/!(z)'], 'a/!(z)', { noextglob: true })); +//=> ['a/!(z)'] (matches only as literal characters) +``` + +### options.nonegate + +Disallow negation (`!`) patterns, and treat leading `!` as a literal character to match. + +**Type**: `Boolean` + +**Default**: `undefined` + +### options.noglobstar + +Disable matching with globstars (`**`). + +**Type**: `Boolean` + +**Default**: `undefined` + +```js +micromatch(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**'); +//=> ['a/b', 'a/b/c', 'a/b/c/d'] + +micromatch(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**', {noglobstar: true}); +//=> ['a/b'] +``` + +### options.nonull + +Alias for [options.nullglob](#options-nullglob). + +### options.nullglob + +If `true`, when no matches are found the actual (arrayified) glob pattern is returned instead of an empty array. Same behavior as [minimatch](https://github.com/isaacs/minimatch) option `nonull`. + +**Type**: `Boolean` + +**Default**: `undefined` + +### options.onIgnore + +```js +const onIgnore = ({ glob, regex, input, output }) => { + console.log({ glob, regex, input, output }); + // { glob: '*', regex: /^(?:(?!\.)(?=.)[^\/]*?\/?)$/, input: 'foo', output: 'foo' } +}; + +const isMatch = micromatch.matcher('*', { onIgnore, ignore: 'f*' }); +isMatch('foo'); +isMatch('bar'); +isMatch('baz'); +``` + +### options.onMatch + +```js +const onMatch = ({ glob, regex, input, output }) => { + console.log({ input, output }); + // { input: 'some\\path', output: 'some/path' } + // { input: 'some\\path', output: 'some/path' } + // { input: 'some\\path', output: 'some/path' } +}; + +const isMatch = micromatch.matcher('**', { onMatch, posixSlashes: true }); +isMatch('some\\path'); +isMatch('some\\path'); +isMatch('some\\path'); +``` + +### options.onResult + +```js +const onResult = ({ glob, regex, input, output }) => { + console.log({ glob, regex, input, output }); +}; + +const isMatch = micromatch('*', { onResult, ignore: 'f*' }); +isMatch('foo'); +isMatch('bar'); +isMatch('baz'); +``` + +### options.posixSlashes + +Convert path separators on returned files to posix/unix-style forward slashes. Aliased as `unixify` for backwards compatibility. + +**Type**: `Boolean` + +**Default**: `true` on windows, `false` everywhere else. + +**Example** + +```js +console.log(micromatch.match(['a\\b\\c'], 'a/**')); +//=> ['a/b/c'] + +console.log(micromatch.match(['a\\b\\c'], { posixSlashes: false })); +//=> ['a\\b\\c'] +``` + +### options.unescape + +Remove backslashes from escaped glob characters before creating the regular expression to perform matches. + +**Type**: `Boolean` + +**Default**: `undefined` + +**Example** + +In this example we want to match a literal `*`: + +```js +console.log(micromatch.match(['abc', 'a\\*c'], 'a\\*c')); +//=> ['a\\*c'] + +console.log(micromatch.match(['abc', 'a\\*c'], 'a\\*c', { unescape: true })); +//=> ['a*c'] +``` + +
+
+ +## Extended globbing + +Micromatch supports the following extended globbing features. + +### Extglobs + +Extended globbing, as described by the bash man page: + +| **pattern** | **regex equivalent** | **description** | +| --- | --- | --- | +| `?(pattern)` | `(pattern)?` | Matches zero or one occurrence of the given patterns | +| `*(pattern)` | `(pattern)*` | Matches zero or more occurrences of the given patterns | +| `+(pattern)` | `(pattern)+` | Matches one or more occurrences of the given patterns | +| `@(pattern)` | `(pattern)` * | Matches one of the given patterns | +| `!(pattern)` | N/A (equivalent regex is much more complicated) | Matches anything except one of the given patterns | + +* Note that `@` isn't a regex character. + +### Braces + +Brace patterns can be used to match specific ranges or sets of characters. + +**Example** + +The pattern `{f,b}*/{1..3}/{b,q}*` would match any of following strings: + +``` +foo/1/bar +foo/2/bar +foo/3/bar +baz/1/qux +baz/2/qux +baz/3/qux +``` + +Visit [braces](https://github.com/micromatch/braces) to see the full range of features and options related to brace expansion, or to create brace matching or expansion related issues. + +### Regex character classes + +Given the list: `['a.js', 'b.js', 'c.js', 'd.js', 'E.js']`: + +* `[ac].js`: matches both `a` and `c`, returning `['a.js', 'c.js']` +* `[b-d].js`: matches from `b` to `d`, returning `['b.js', 'c.js', 'd.js']` +* `a/[A-Z].js`: matches and uppercase letter, returning `['a/E.md']` + +Learn about [regex character classes](http://www.regular-expressions.info/charclass.html). + +### Regex groups + +Given `['a.js', 'b.js', 'c.js', 'd.js', 'E.js']`: + +* `(a|c).js`: would match either `a` or `c`, returning `['a.js', 'c.js']` +* `(b|d).js`: would match either `b` or `d`, returning `['b.js', 'd.js']` +* `(b|[A-Z]).js`: would match either `b` or an uppercase letter, returning `['b.js', 'E.js']` + +As with regex, parens can be nested, so patterns like `((a|b)|c)/b` will work. Although brace expansion might be friendlier to use, depending on preference. + +### POSIX bracket expressions + +POSIX brackets are intended to be more user-friendly than regex character classes. This of course is in the eye of the beholder. + +**Example** + +```js +console.log(micromatch.isMatch('a1', '[[:alpha:][:digit:]]')) //=> true +console.log(micromatch.isMatch('a1', '[[:alpha:][:alpha:]]')) //=> false +``` + +*** + +## Notes + +### Bash 4.3 parity + +Whenever possible matching behavior is based on behavior Bash 4.3, which is mostly consistent with minimatch. + +However, it's suprising how many edge cases and rabbit holes there are with glob matching, and since there is no real glob specification, and micromatch is more accurate than both Bash and minimatch, there are cases where best-guesses were made for behavior. In a few cases where Bash had no answers, we used wildmatch (used by git) as a fallback. + +### Backslashes + +There is an important, notable difference between minimatch and micromatch _in regards to how backslashes are handled_ in glob patterns. + +* Micromatch exclusively and explicitly reserves backslashes for escaping characters in a glob pattern, even on windows, which is consistent with bash behavior. _More importantly, unescaping globs can result in unsafe regular expressions_. +* Minimatch converts all backslashes to forward slashes, which means you can't use backslashes to escape any characters in your glob patterns. + +We made this decision for micromatch for a couple of reasons: + +* Consistency with bash conventions. +* Glob patterns are not filepaths. They are a type of [regular language](https://en.wikipedia.org/wiki/Regular_language) that is converted to a JavaScript regular expression. Thus, when forward slashes are defined in a glob pattern, the resulting regular expression will match windows or POSIX path separators just fine. + +**A note about joining paths to globs** + +Note that when you pass something like `path.join('foo', '*')` to micromatch, you are creating a filepath and expecting it to still work as a glob pattern. This causes problems on windows, since the `path.sep` is `\\`. + +In other words, since `\\` is reserved as an escape character in globs, on windows `path.join('foo', '*')` would result in `foo\\*`, which tells micromatch to match `*` as a literal character. This is the same behavior as bash. + +To solve this, you might be inspired to do something like `'foo\\*'.replace(/\\/g, '/')`, but this causes another, potentially much more serious, problem. + +## Benchmarks + +### Running benchmarks + +Install dependencies for running benchmarks: + +```sh +$ cd bench && npm install +``` + +Run the benchmarks: + +```sh +$ npm run bench +``` + +### Latest results + +As of August 23, 2024 (longer bars are better): + +```sh +# .makeRe star + micromatch x 2,232,802 ops/sec ±2.34% (89 runs sampled)) + minimatch x 781,018 ops/sec ±6.74% (92 runs sampled)) + +# .makeRe star; dot=true + micromatch x 1,863,453 ops/sec ±0.74% (93 runs sampled) + minimatch x 723,105 ops/sec ±0.75% (93 runs sampled) + +# .makeRe globstar + micromatch x 1,624,179 ops/sec ±2.22% (91 runs sampled) + minimatch x 1,117,230 ops/sec ±2.78% (86 runs sampled)) + +# .makeRe globstars + micromatch x 1,658,642 ops/sec ±0.86% (92 runs sampled) + minimatch x 741,224 ops/sec ±1.24% (89 runs sampled)) + +# .makeRe with leading star + micromatch x 1,525,014 ops/sec ±1.63% (90 runs sampled) + minimatch x 561,074 ops/sec ±3.07% (89 runs sampled) + +# .makeRe - braces + micromatch x 172,478 ops/sec ±2.37% (78 runs sampled) + minimatch x 96,087 ops/sec ±2.34% (88 runs sampled))) + +# .makeRe braces - range (expanded) + micromatch x 26,973 ops/sec ±0.84% (89 runs sampled) + minimatch x 3,023 ops/sec ±0.99% (90 runs sampled)) + +# .makeRe braces - range (compiled) + micromatch x 152,892 ops/sec ±1.67% (83 runs sampled) + minimatch x 992 ops/sec ±3.50% (89 runs sampled)d)) + +# .makeRe braces - nested ranges (expanded) + micromatch x 15,816 ops/sec ±13.05% (80 runs sampled) + minimatch x 2,953 ops/sec ±1.64% (91 runs sampled) + +# .makeRe braces - nested ranges (compiled) + micromatch x 110,881 ops/sec ±1.85% (82 runs sampled) + minimatch x 1,008 ops/sec ±1.51% (91 runs sampled) + +# .makeRe braces - set (compiled) + micromatch x 134,930 ops/sec ±3.54% (63 runs sampled)) + minimatch x 43,242 ops/sec ±0.60% (93 runs sampled) + +# .makeRe braces - nested sets (compiled) + micromatch x 94,455 ops/sec ±1.74% (69 runs sampled)) + minimatch x 27,720 ops/sec ±1.84% (93 runs sampled)) +``` + +## Contributing + +All contributions are welcome! Please read [the contributing guide](.github/contributing.md) to get started. + +**Bug reports** + +Please create an issue if you encounter a bug or matching behavior that doesn't seem correct. If you find a matching-related issue, please: + +* [research existing issues first](../../issues) (open and closed) +* visit the [GNU Bash documentation](https://www.gnu.org/software/bash/manual/) to see how Bash deals with the pattern +* visit the [minimatch](https://github.com/isaacs/minimatch) documentation to cross-check expected behavior in node.js +* if all else fails, since there is no real specification for globs we will probably need to discuss expected behavior and decide how to resolve it. which means any detail you can provide to help with this discussion would be greatly appreciated. + +**Platform issues** + +It's important to us that micromatch work consistently on all platforms. If you encounter any platform-specific matching or path related issues, please let us know (pull requests are also greatly appreciated). + +## About + +
+Contributing + +Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new). + +Please read the [contributing guide](.github/contributing.md) for advice on opening issues, pull requests, and coding standards. + +
+ +
+Running Tests + +Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command: + +```sh +$ npm install && npm test +``` + +
+ +
+Building docs + +_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_ + +To generate the readme, run the following command: + +```sh +$ npm install -g verbose/verb#dev verb-generate-readme && verb +``` + +
+ +### Related projects + +You might also be interested in these projects: + +* [braces](https://www.npmjs.com/package/braces): Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support… [more](https://github.com/micromatch/braces) | [homepage](https://github.com/micromatch/braces "Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support for the Bash 4.3 braces specification, without sacrificing speed.") +* [expand-brackets](https://www.npmjs.com/package/expand-brackets): Expand POSIX bracket expressions (character classes) in glob patterns. | [homepage](https://github.com/micromatch/expand-brackets "Expand POSIX bracket expressions (character classes) in glob patterns.") +* [extglob](https://www.npmjs.com/package/extglob): Extended glob support for JavaScript. Adds (almost) the expressive power of regular expressions to glob… [more](https://github.com/micromatch/extglob) | [homepage](https://github.com/micromatch/extglob "Extended glob support for JavaScript. Adds (almost) the expressive power of regular expressions to glob patterns.") +* [fill-range](https://www.npmjs.com/package/fill-range): Fill in a range of numbers or letters, optionally passing an increment or `step` to… [more](https://github.com/jonschlinkert/fill-range) | [homepage](https://github.com/jonschlinkert/fill-range "Fill in a range of numbers or letters, optionally passing an increment or `step` to use, or create a regex-compatible range with `options.toRegex`") +* [nanomatch](https://www.npmjs.com/package/nanomatch): Fast, minimal glob matcher for node.js. Similar to micromatch, minimatch and multimatch, but complete Bash… [more](https://github.com/micromatch/nanomatch) | [homepage](https://github.com/micromatch/nanomatch "Fast, minimal glob matcher for node.js. Similar to micromatch, minimatch and multimatch, but complete Bash 4.3 wildcard support only (no support for exglobs, posix brackets or braces)") + +### Contributors + +| **Commits** | **Contributor** | +| --- | --- | +| 523 | [jonschlinkert](https://github.com/jonschlinkert) | +| 12 | [es128](https://github.com/es128) | +| 9 | [danez](https://github.com/danez) | +| 8 | [doowb](https://github.com/doowb) | +| 6 | [paulmillr](https://github.com/paulmillr) | +| 5 | [mrmlnc](https://github.com/mrmlnc) | +| 3 | [DrPizza](https://github.com/DrPizza) | +| 2 | [Tvrqvoise](https://github.com/Tvrqvoise) | +| 2 | [antonyk](https://github.com/antonyk) | +| 2 | [MartinKolarik](https://github.com/MartinKolarik) | +| 2 | [Glazy](https://github.com/Glazy) | +| 2 | [mceIdo](https://github.com/mceIdo) | +| 2 | [TrySound](https://github.com/TrySound) | +| 1 | [yvele](https://github.com/yvele) | +| 1 | [wtgtybhertgeghgtwtg](https://github.com/wtgtybhertgeghgtwtg) | +| 1 | [simlu](https://github.com/simlu) | +| 1 | [curbengh](https://github.com/curbengh) | +| 1 | [fidian](https://github.com/fidian) | +| 1 | [tomByrer](https://github.com/tomByrer) | +| 1 | [ZoomerTedJackson](https://github.com/ZoomerTedJackson) | +| 1 | [styfle](https://github.com/styfle) | +| 1 | [sebdeckers](https://github.com/sebdeckers) | +| 1 | [muescha](https://github.com/muescha) | +| 1 | [juszczykjakub](https://github.com/juszczykjakub) | +| 1 | [joyceerhl](https://github.com/joyceerhl) | +| 1 | [donatj](https://github.com/donatj) | +| 1 | [frangio](https://github.com/frangio) | +| 1 | [UltCombo](https://github.com/UltCombo) | +| 1 | [DianeLooney](https://github.com/DianeLooney) | +| 1 | [devongovett](https://github.com/devongovett) | +| 1 | [Cslove](https://github.com/Cslove) | +| 1 | [amilajack](https://github.com/amilajack) | + +### Author + +**Jon Schlinkert** + +* [GitHub Profile](https://github.com/jonschlinkert) +* [Twitter Profile](https://twitter.com/jonschlinkert) +* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert) + +### License + +Copyright © 2024, [Jon Schlinkert](https://github.com/jonschlinkert). +Released under the [MIT License](LICENSE). + +*** + +_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on August 23, 2024._ \ No newline at end of file diff --git a/node_modules/micromatch/index.js b/node_modules/micromatch/index.js new file mode 100644 index 0000000..cb9d9ef --- /dev/null +++ b/node_modules/micromatch/index.js @@ -0,0 +1,474 @@ +'use strict'; + +const util = require('util'); +const braces = require('braces'); +const picomatch = require('picomatch'); +const utils = require('picomatch/lib/utils'); + +const isEmptyString = v => v === '' || v === './'; +const hasBraces = v => { + const index = v.indexOf('{'); + return index > -1 && v.indexOf('}', index) > -1; +}; + +/** + * Returns an array of strings that match one or more glob patterns. + * + * ```js + * const mm = require('micromatch'); + * // mm(list, patterns[, options]); + * + * console.log(mm(['a.js', 'a.txt'], ['*.js'])); + * //=> [ 'a.js' ] + * ``` + * @param {String|Array} `list` List of strings to match. + * @param {String|Array} `patterns` One or more glob patterns to use for matching. + * @param {Object} `options` See available [options](#options) + * @return {Array} Returns an array of matches + * @summary false + * @api public + */ + +const micromatch = (list, patterns, options) => { + patterns = [].concat(patterns); + list = [].concat(list); + + let omit = new Set(); + let keep = new Set(); + let items = new Set(); + let negatives = 0; + + let onResult = state => { + items.add(state.output); + if (options && options.onResult) { + options.onResult(state); + } + }; + + for (let i = 0; i < patterns.length; i++) { + let isMatch = picomatch(String(patterns[i]), { ...options, onResult }, true); + let negated = isMatch.state.negated || isMatch.state.negatedExtglob; + if (negated) negatives++; + + for (let item of list) { + let matched = isMatch(item, true); + + let match = negated ? !matched.isMatch : matched.isMatch; + if (!match) continue; + + if (negated) { + omit.add(matched.output); + } else { + omit.delete(matched.output); + keep.add(matched.output); + } + } + } + + let result = negatives === patterns.length ? [...items] : [...keep]; + let matches = result.filter(item => !omit.has(item)); + + if (options && matches.length === 0) { + if (options.failglob === true) { + throw new Error(`No matches found for "${patterns.join(', ')}"`); + } + + if (options.nonull === true || options.nullglob === true) { + return options.unescape ? patterns.map(p => p.replace(/\\/g, '')) : patterns; + } + } + + return matches; +}; + +/** + * Backwards compatibility + */ + +micromatch.match = micromatch; + +/** + * Returns a matcher function from the given glob `pattern` and `options`. + * The returned function takes a string to match as its only argument and returns + * true if the string is a match. + * + * ```js + * const mm = require('micromatch'); + * // mm.matcher(pattern[, options]); + * + * const isMatch = mm.matcher('*.!(*a)'); + * console.log(isMatch('a.a')); //=> false + * console.log(isMatch('a.b')); //=> true + * ``` + * @param {String} `pattern` Glob pattern + * @param {Object} `options` + * @return {Function} Returns a matcher function. + * @api public + */ + +micromatch.matcher = (pattern, options) => picomatch(pattern, options); + +/** + * Returns true if **any** of the given glob `patterns` match the specified `string`. + * + * ```js + * const mm = require('micromatch'); + * // mm.isMatch(string, patterns[, options]); + * + * console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true + * console.log(mm.isMatch('a.a', 'b.*')); //=> false + * ``` + * @param {String} `str` The string to test. + * @param {String|Array} `patterns` One or more glob patterns to use for matching. + * @param {Object} `[options]` See available [options](#options). + * @return {Boolean} Returns true if any patterns match `str` + * @api public + */ + +micromatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str); + +/** + * Backwards compatibility + */ + +micromatch.any = micromatch.isMatch; + +/** + * Returns a list of strings that _**do not match any**_ of the given `patterns`. + * + * ```js + * const mm = require('micromatch'); + * // mm.not(list, patterns[, options]); + * + * console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a')); + * //=> ['b.b', 'c.c'] + * ``` + * @param {Array} `list` Array of strings to match. + * @param {String|Array} `patterns` One or more glob pattern to use for matching. + * @param {Object} `options` See available [options](#options) for changing how matches are performed + * @return {Array} Returns an array of strings that **do not match** the given patterns. + * @api public + */ + +micromatch.not = (list, patterns, options = {}) => { + patterns = [].concat(patterns).map(String); + let result = new Set(); + let items = []; + + let onResult = state => { + if (options.onResult) options.onResult(state); + items.push(state.output); + }; + + let matches = new Set(micromatch(list, patterns, { ...options, onResult })); + + for (let item of items) { + if (!matches.has(item)) { + result.add(item); + } + } + return [...result]; +}; + +/** + * Returns true if the given `string` contains the given pattern. Similar + * to [.isMatch](#isMatch) but the pattern can match any part of the string. + * + * ```js + * var mm = require('micromatch'); + * // mm.contains(string, pattern[, options]); + * + * console.log(mm.contains('aa/bb/cc', '*b')); + * //=> true + * console.log(mm.contains('aa/bb/cc', '*d')); + * //=> false + * ``` + * @param {String} `str` The string to match. + * @param {String|Array} `patterns` Glob pattern to use for matching. + * @param {Object} `options` See available [options](#options) for changing how matches are performed + * @return {Boolean} Returns true if any of the patterns matches any part of `str`. + * @api public + */ + +micromatch.contains = (str, pattern, options) => { + if (typeof str !== 'string') { + throw new TypeError(`Expected a string: "${util.inspect(str)}"`); + } + + if (Array.isArray(pattern)) { + return pattern.some(p => micromatch.contains(str, p, options)); + } + + if (typeof pattern === 'string') { + if (isEmptyString(str) || isEmptyString(pattern)) { + return false; + } + + if (str.includes(pattern) || (str.startsWith('./') && str.slice(2).includes(pattern))) { + return true; + } + } + + return micromatch.isMatch(str, pattern, { ...options, contains: true }); +}; + +/** + * Filter the keys of the given object with the given `glob` pattern + * and `options`. Does not attempt to match nested keys. If you need this feature, + * use [glob-object][] instead. + * + * ```js + * const mm = require('micromatch'); + * // mm.matchKeys(object, patterns[, options]); + * + * const obj = { aa: 'a', ab: 'b', ac: 'c' }; + * console.log(mm.matchKeys(obj, '*b')); + * //=> { ab: 'b' } + * ``` + * @param {Object} `object` The object with keys to filter. + * @param {String|Array} `patterns` One or more glob patterns to use for matching. + * @param {Object} `options` See available [options](#options) for changing how matches are performed + * @return {Object} Returns an object with only keys that match the given patterns. + * @api public + */ + +micromatch.matchKeys = (obj, patterns, options) => { + if (!utils.isObject(obj)) { + throw new TypeError('Expected the first argument to be an object'); + } + let keys = micromatch(Object.keys(obj), patterns, options); + let res = {}; + for (let key of keys) res[key] = obj[key]; + return res; +}; + +/** + * Returns true if some of the strings in the given `list` match any of the given glob `patterns`. + * + * ```js + * const mm = require('micromatch'); + * // mm.some(list, patterns[, options]); + * + * console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js'])); + * // true + * console.log(mm.some(['foo.js'], ['*.js', '!foo.js'])); + * // false + * ``` + * @param {String|Array} `list` The string or array of strings to test. Returns as soon as the first match is found. + * @param {String|Array} `patterns` One or more glob patterns to use for matching. + * @param {Object} `options` See available [options](#options) for changing how matches are performed + * @return {Boolean} Returns true if any `patterns` matches any of the strings in `list` + * @api public + */ + +micromatch.some = (list, patterns, options) => { + let items = [].concat(list); + + for (let pattern of [].concat(patterns)) { + let isMatch = picomatch(String(pattern), options); + if (items.some(item => isMatch(item))) { + return true; + } + } + return false; +}; + +/** + * Returns true if every string in the given `list` matches + * any of the given glob `patterns`. + * + * ```js + * const mm = require('micromatch'); + * // mm.every(list, patterns[, options]); + * + * console.log(mm.every('foo.js', ['foo.js'])); + * // true + * console.log(mm.every(['foo.js', 'bar.js'], ['*.js'])); + * // true + * console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js'])); + * // false + * console.log(mm.every(['foo.js'], ['*.js', '!foo.js'])); + * // false + * ``` + * @param {String|Array} `list` The string or array of strings to test. + * @param {String|Array} `patterns` One or more glob patterns to use for matching. + * @param {Object} `options` See available [options](#options) for changing how matches are performed + * @return {Boolean} Returns true if all `patterns` matches all of the strings in `list` + * @api public + */ + +micromatch.every = (list, patterns, options) => { + let items = [].concat(list); + + for (let pattern of [].concat(patterns)) { + let isMatch = picomatch(String(pattern), options); + if (!items.every(item => isMatch(item))) { + return false; + } + } + return true; +}; + +/** + * Returns true if **all** of the given `patterns` match + * the specified string. + * + * ```js + * const mm = require('micromatch'); + * // mm.all(string, patterns[, options]); + * + * console.log(mm.all('foo.js', ['foo.js'])); + * // true + * + * console.log(mm.all('foo.js', ['*.js', '!foo.js'])); + * // false + * + * console.log(mm.all('foo.js', ['*.js', 'foo.js'])); + * // true + * + * console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js'])); + * // true + * ``` + * @param {String|Array} `str` The string to test. + * @param {String|Array} `patterns` One or more glob patterns to use for matching. + * @param {Object} `options` See available [options](#options) for changing how matches are performed + * @return {Boolean} Returns true if any patterns match `str` + * @api public + */ + +micromatch.all = (str, patterns, options) => { + if (typeof str !== 'string') { + throw new TypeError(`Expected a string: "${util.inspect(str)}"`); + } + + return [].concat(patterns).every(p => picomatch(p, options)(str)); +}; + +/** + * Returns an array of matches captured by `pattern` in `string, or `null` if the pattern did not match. + * + * ```js + * const mm = require('micromatch'); + * // mm.capture(pattern, string[, options]); + * + * console.log(mm.capture('test/*.js', 'test/foo.js')); + * //=> ['foo'] + * console.log(mm.capture('test/*.js', 'foo/bar.css')); + * //=> null + * ``` + * @param {String} `glob` Glob pattern to use for matching. + * @param {String} `input` String to match + * @param {Object} `options` See available [options](#options) for changing how matches are performed + * @return {Array|null} Returns an array of captures if the input matches the glob pattern, otherwise `null`. + * @api public + */ + +micromatch.capture = (glob, input, options) => { + let posix = utils.isWindows(options); + let regex = picomatch.makeRe(String(glob), { ...options, capture: true }); + let match = regex.exec(posix ? utils.toPosixSlashes(input) : input); + + if (match) { + return match.slice(1).map(v => v === void 0 ? '' : v); + } +}; + +/** + * Create a regular expression from the given glob `pattern`. + * + * ```js + * const mm = require('micromatch'); + * // mm.makeRe(pattern[, options]); + * + * console.log(mm.makeRe('*.js')); + * //=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/ + * ``` + * @param {String} `pattern` A glob pattern to convert to regex. + * @param {Object} `options` + * @return {RegExp} Returns a regex created from the given pattern. + * @api public + */ + +micromatch.makeRe = (...args) => picomatch.makeRe(...args); + +/** + * Scan a glob pattern to separate the pattern into segments. Used + * by the [split](#split) method. + * + * ```js + * const mm = require('micromatch'); + * const state = mm.scan(pattern[, options]); + * ``` + * @param {String} `pattern` + * @param {Object} `options` + * @return {Object} Returns an object with + * @api public + */ + +micromatch.scan = (...args) => picomatch.scan(...args); + +/** + * Parse a glob pattern to create the source string for a regular + * expression. + * + * ```js + * const mm = require('micromatch'); + * const state = mm.parse(pattern[, options]); + * ``` + * @param {String} `glob` + * @param {Object} `options` + * @return {Object} Returns an object with useful properties and output to be used as regex source string. + * @api public + */ + +micromatch.parse = (patterns, options) => { + let res = []; + for (let pattern of [].concat(patterns || [])) { + for (let str of braces(String(pattern), options)) { + res.push(picomatch.parse(str, options)); + } + } + return res; +}; + +/** + * Process the given brace `pattern`. + * + * ```js + * const { braces } = require('micromatch'); + * console.log(braces('foo/{a,b,c}/bar')); + * //=> [ 'foo/(a|b|c)/bar' ] + * + * console.log(braces('foo/{a,b,c}/bar', { expand: true })); + * //=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ] + * ``` + * @param {String} `pattern` String with brace pattern to process. + * @param {Object} `options` Any [options](#options) to change how expansion is performed. See the [braces][] library for all available options. + * @return {Array} + * @api public + */ + +micromatch.braces = (pattern, options) => { + if (typeof pattern !== 'string') throw new TypeError('Expected a string'); + if ((options && options.nobrace === true) || !hasBraces(pattern)) { + return [pattern]; + } + return braces(pattern, options); +}; + +/** + * Expand braces + */ + +micromatch.braceExpand = (pattern, options) => { + if (typeof pattern !== 'string') throw new TypeError('Expected a string'); + return micromatch.braces(pattern, { ...options, expand: true }); +}; + +/** + * Expose micromatch + */ + +// exposed for tests +micromatch.hasBraces = hasBraces; +module.exports = micromatch; diff --git a/node_modules/micromatch/package.json b/node_modules/micromatch/package.json new file mode 100644 index 0000000..d5558bb --- /dev/null +++ b/node_modules/micromatch/package.json @@ -0,0 +1,119 @@ +{ + "name": "micromatch", + "description": "Glob matching for javascript/node.js. A replacement and faster alternative to minimatch and multimatch.", + "version": "4.0.8", + "homepage": "https://github.com/micromatch/micromatch", + "author": "Jon Schlinkert (https://github.com/jonschlinkert)", + "contributors": [ + "(https://github.com/DianeLooney)", + "Amila Welihinda (amilajack.com)", + "Bogdan Chadkin (https://github.com/TrySound)", + "Brian Woodward (https://twitter.com/doowb)", + "Devon Govett (http://badassjs.com)", + "Elan Shanker (https://github.com/es128)", + "Fabrício Matté (https://ultcombo.js.org)", + "Jon Schlinkert (http://twitter.com/jonschlinkert)", + "Martin Kolárik (https://kolarik.sk)", + "Olsten Larck (https://i.am.charlike.online)", + "Paul Miller (paulmillr.com)", + "Tom Byrer (https://github.com/tomByrer)", + "Tyler Akins (http://rumkin.com)", + "Peter Bright (https://github.com/drpizza)", + "Kuba Juszczyk (https://github.com/ku8ar)" + ], + "repository": "micromatch/micromatch", + "bugs": { + "url": "https://github.com/micromatch/micromatch/issues" + }, + "license": "MIT", + "files": [ + "index.js" + ], + "main": "index.js", + "engines": { + "node": ">=8.6" + }, + "scripts": { + "test": "mocha" + }, + "dependencies": { + "braces": "^3.0.3", + "picomatch": "^2.3.1" + }, + "devDependencies": { + "fill-range": "^7.0.1", + "gulp-format-md": "^2.0.0", + "minimatch": "^5.0.1", + "mocha": "^9.2.2", + "time-require": "github:jonschlinkert/time-require" + }, + "keywords": [ + "bash", + "bracket", + "character-class", + "expand", + "expansion", + "expression", + "extglob", + "extglobs", + "file", + "files", + "filter", + "find", + "glob", + "globbing", + "globs", + "globstar", + "lookahead", + "lookaround", + "lookbehind", + "match", + "matcher", + "matches", + "matching", + "micromatch", + "minimatch", + "multimatch", + "negate", + "negation", + "path", + "pattern", + "patterns", + "posix", + "regex", + "regexp", + "regular", + "shell", + "star", + "wildcard" + ], + "verb": { + "toc": "collapsible", + "layout": "default", + "tasks": [ + "readme" + ], + "plugins": [ + "gulp-format-md" + ], + "lint": { + "reflinks": true + }, + "related": { + "list": [ + "braces", + "expand-brackets", + "extglob", + "fill-range", + "nanomatch" + ] + }, + "reflinks": [ + "extglob", + "fill-range", + "glob-object", + "minimatch", + "multimatch" + ] + } +} diff --git a/node_modules/node-addon-api/LICENSE.md b/node_modules/node-addon-api/LICENSE.md new file mode 100644 index 0000000..819d91a --- /dev/null +++ b/node_modules/node-addon-api/LICENSE.md @@ -0,0 +1,9 @@ +The MIT License (MIT) + +Copyright (c) 2017 [Node.js API collaborators](https://github.com/nodejs/node-addon-api#collaborators) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/node_modules/node-addon-api/README.md b/node_modules/node-addon-api/README.md new file mode 100644 index 0000000..e90eb7c --- /dev/null +++ b/node_modules/node-addon-api/README.md @@ -0,0 +1,319 @@ +NOTE: The default branch has been renamed! +master is now named main + +If you have a local clone, you can update it by running: + +```shell +git branch -m master main +git fetch origin +git branch -u origin/main main +``` + +# **node-addon-api module** +This module contains **header-only C++ wrapper classes** which simplify +the use of the C based [Node-API](https://nodejs.org/dist/latest/docs/api/n-api.html) +provided by Node.js when using C++. It provides a C++ object model +and exception handling semantics with low overhead. + +There are three options for implementing addons: Node-API, nan, or direct +use of internal V8, libuv, and Node.js libraries. Unless there is a need for +direct access to functionality that is not exposed by Node-API as outlined +in [C/C++ addons](https://nodejs.org/dist/latest/docs/api/addons.html) +in Node.js core, use Node-API. Refer to +[C/C++ addons with Node-API](https://nodejs.org/dist/latest/docs/api/n-api.html) +for more information on Node-API. + +Node-API is an ABI stable C interface provided by Node.js for building native +addons. It is independent of the underlying JavaScript runtime (e.g. V8 or ChakraCore) +and is maintained as part of Node.js itself. It is intended to insulate +native addons from changes in the underlying JavaScript engine and allow +modules compiled for one version to run on later versions of Node.js without +recompilation. + +The `node-addon-api` module, which is not part of Node.js, preserves the benefits +of the Node-API as it consists only of inline code that depends only on the stable API +provided by Node-API. As such, modules built against one version of Node.js +using node-addon-api should run without having to be rebuilt with newer versions +of Node.js. + +It is important to remember that *other* Node.js interfaces such as +`libuv` (included in a project via `#include `) are not ABI-stable across +Node.js major versions. Thus, an addon must use Node-API and/or `node-addon-api` +exclusively and build against a version of Node.js that includes an +implementation of Node-API (meaning an active LTS version of Node.js) in +order to benefit from ABI stability across Node.js major versions. Node.js +provides an [ABI stability guide][] containing a detailed explanation of ABI +stability in general, and the Node-API ABI stability guarantee in particular. + +As new APIs are added to Node-API, node-addon-api must be updated to provide +wrappers for those new APIs. For this reason, node-addon-api provides +methods that allow callers to obtain the underlying Node-API handles so +direct calls to Node-API and the use of the objects/methods provided by +node-addon-api can be used together. For example, in order to be able +to use an API for which the node-addon-api does not yet provide a wrapper. + +APIs exposed by node-addon-api are generally used to create and +manipulate JavaScript values. Concepts and operations generally map +to ideas specified in the **ECMA262 Language Specification**. + +The [Node-API Resource](https://nodejs.github.io/node-addon-examples/) offers an +excellent orientation and tips for developers just getting started with Node-API +and node-addon-api. + +- **[Setup](#setup)** +- **[API Documentation](#api)** +- **[Examples](#examples)** +- **[Tests](#tests)** +- **[More resource and info about native Addons](#resources)** +- **[Badges](#badges)** +- **[Code of Conduct](CODE_OF_CONDUCT.md)** +- **[Contributors](#contributors)** +- **[License](#license)** + +## **Current version: 7.1.1** + +(See [CHANGELOG.md](CHANGELOG.md) for complete Changelog) + +[![NPM](https://nodei.co/npm/node-addon-api.png?downloads=true&downloadRank=true)](https://nodei.co/npm/node-addon-api/) [![NPM](https://nodei.co/npm-dl/node-addon-api.png?months=6&height=1)](https://nodei.co/npm/node-addon-api/) + + + +node-addon-api is based on [Node-API](https://nodejs.org/api/n-api.html) and supports using different Node-API versions. +This allows addons built with it to run with Node.js versions which support the targeted Node-API version. +**However** the node-addon-api support model is to support only the active LTS Node.js versions. This means that +every year there will be a new major which drops support for the Node.js LTS version which has gone out of service. + +The oldest Node.js version supported by the current version of node-addon-api is Node.js 16.x. + +## Setup + - [Installation and usage](doc/setup.md) + - [node-gyp](doc/node-gyp.md) + - [cmake-js](doc/cmake-js.md) + - [Conversion tool](doc/conversion-tool.md) + - [Checker tool](doc/checker-tool.md) + - [Generator](doc/generator.md) + - [Prebuild tools](doc/prebuild_tools.md) + + + +### **API Documentation** + +The following is the documentation for node-addon-api. + + - [Full Class Hierarchy](doc/hierarchy.md) + - [Addon Structure](doc/addon.md) + - Data Types: + - [Env](doc/env.md) + - [CallbackInfo](doc/callbackinfo.md) + - [Reference](doc/reference.md) + - [Value](doc/value.md) + - [Name](doc/name.md) + - [Symbol](doc/symbol.md) + - [String](doc/string.md) + - [Number](doc/number.md) + - [Date](doc/date.md) + - [BigInt](doc/bigint.md) + - [Boolean](doc/boolean.md) + - [External](doc/external.md) + - [Object](doc/object.md) + - [Array](doc/array.md) + - [ObjectReference](doc/object_reference.md) + - [PropertyDescriptor](doc/property_descriptor.md) + - [Function](doc/function.md) + - [FunctionReference](doc/function_reference.md) + - [ObjectWrap](doc/object_wrap.md) + - [ClassPropertyDescriptor](doc/class_property_descriptor.md) + - [Buffer](doc/buffer.md) + - [ArrayBuffer](doc/array_buffer.md) + - [TypedArray](doc/typed_array.md) + - [TypedArrayOf](doc/typed_array_of.md) + - [DataView](doc/dataview.md) + - [Error Handling](doc/error_handling.md) + - [Error](doc/error.md) + - [TypeError](doc/type_error.md) + - [RangeError](doc/range_error.md) + - [SyntaxError](doc/syntax_error.md) + - [Object Lifetime Management](doc/object_lifetime_management.md) + - [HandleScope](doc/handle_scope.md) + - [EscapableHandleScope](doc/escapable_handle_scope.md) + - [Memory Management](doc/memory_management.md) + - [Async Operations](doc/async_operations.md) + - [AsyncWorker](doc/async_worker.md) + - [AsyncContext](doc/async_context.md) + - [AsyncWorker Variants](doc/async_worker_variants.md) + - [Thread-safe Functions](doc/threadsafe.md) + - [ThreadSafeFunction](doc/threadsafe_function.md) + - [TypedThreadSafeFunction](doc/typed_threadsafe_function.md) + - [Promises](doc/promises.md) + - [Version management](doc/version_management.md) + + + +### **Examples** + +Are you new to **node-addon-api**? Take a look at our **[examples](https://github.com/nodejs/node-addon-examples)** + +- **[Hello World](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/1_hello_world)** +- **[Pass arguments to a function](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/2_function_arguments/node-addon-api)** +- **[Callbacks](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/3_callbacks/node-addon-api)** +- **[Object factory](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/4_object_factory/node-addon-api)** +- **[Function factory](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/5_function_factory/node-addon-api)** +- **[Wrapping C++ Object](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/6_object_wrap/node-addon-api)** +- **[Factory of wrapped object](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/7_factory_wrap/node-addon-api)** +- **[Passing wrapped object around](https://github.com/nodejs/node-addon-examples/tree/main/src/2-js-to-native-conversion/8_passing_wrapped/node-addon-api)** + + + +### **Tests** + +To run the **node-addon-api** tests do: + +``` +npm install +npm test +``` + +To avoid testing the deprecated portions of the API run +``` +npm install +npm test --disable-deprecated +``` + +To run the tests targeting a specific version of Node-API run +``` +npm install +export NAPI_VERSION=X +npm test --NAPI_VERSION=X +``` + +where X is the version of Node-API you want to target. + +To run a specific unit test, filter conditions are available + +**Example:** + compile and run only tests on objectwrap.cc and objectwrap.js + ``` + npm run unit --filter=objectwrap + ``` + +Multiple unit tests cane be selected with wildcards + +**Example:** +compile and run all test files ending with "reference" -> function_reference.cc, object_reference.cc, reference.cc + ``` + npm run unit --filter=*reference + ``` + +Multiple filter conditions can be joined to broaden the test selection + +**Example:** + compile and run all tests under folders threadsafe_function and typed_threadsafe_function and also the objectwrap.cc file + npm run unit --filter='*function objectwrap' + +### **Debug** + +To run the **node-addon-api** tests with `--debug` option: + +``` +npm run-script dev +``` + +If you want a faster build, you might use the following option: + +``` +npm run-script dev:incremental +``` + +Take a look and get inspired by our **[test suite](https://github.com/nodejs/node-addon-api/tree/HEAD/test)** + +### **Benchmarks** + +You can run the available benchmarks using the following command: + +``` +npm run-script benchmark +``` + +See [benchmark/README.md](benchmark/README.md) for more details about running and adding benchmarks. + + + +### **More resource and info about native Addons** +- **[C++ Addons](https://nodejs.org/dist/latest/docs/api/addons.html)** +- **[Node-API](https://nodejs.org/dist/latest/docs/api/n-api.html)** +- **[Node-API - Next Generation Node API for Native Modules](https://youtu.be/-Oniup60Afs)** +- **[How We Migrated Realm JavaScript From NAN to Node-API](https://developer.mongodb.com/article/realm-javascript-nan-to-n-api)** + +As node-addon-api's core mission is to expose the plain C Node-API as C++ +wrappers, tools that facilitate n-api/node-addon-api providing more +convenient patterns for developing a Node.js add-on with n-api/node-addon-api +can be published to NPM as standalone packages. It is also recommended to tag +such packages with `node-addon-api` to provide more visibility to the community. + +Quick links to NPM searches: [keywords:node-addon-api](https://www.npmjs.com/search?q=keywords%3Anode-addon-api). + + + +### **Other bindings** + +- **[napi-rs](https://napi.rs)** - (`Rust`) + + + +### **Badges** + +The use of badges is recommended to indicate the minimum version of Node-API +required for the module. This helps to determine which Node.js major versions are +supported. Addon maintainers can consult the [Node-API support matrix][] to determine +which Node.js versions provide a given Node-API version. The following badges are +available: + +![Node-API v1 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v1%20Badge.svg) +![Node-API v2 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v2%20Badge.svg) +![Node-API v3 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v3%20Badge.svg) +![Node-API v4 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v4%20Badge.svg) +![Node-API v5 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v5%20Badge.svg) +![Node-API v6 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v6%20Badge.svg) +![Node-API v7 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v7%20Badge.svg) +![Node-API v8 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v8%20Badge.svg) +![Node-API v9 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v9%20Badge.svg) +![Node-API Experimental Version Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20Experimental%20Version%20Badge.svg) + +## **Contributing** + +We love contributions from the community to **node-addon-api**! +See [CONTRIBUTING.md](CONTRIBUTING.md) for more details on our philosophy around extending this module. + + + +## Team members + +### Active +| Name | GitHub Link | +| ------------------- | ----------------------------------------------------- | +| Anna Henningsen | [addaleax](https://github.com/addaleax) | +| Chengzhong Wu | [legendecas](https://github.com/legendecas) | +| Jack Xia | [JckXia](https://github.com/JckXia) | +| Kevin Eady | [KevinEady](https://github.com/KevinEady) | +| Michael Dawson | [mhdawson](https://github.com/mhdawson) | +| Nicola Del Gobbo | [NickNaso](https://github.com/NickNaso) | +| Vladimir Morozov | [vmoroz](https://github.com/vmoroz) | + +### Emeritus +| Name | GitHub Link | +| ------------------- | ----------------------------------------------------- | +| Arunesh Chandra | [aruneshchandra](https://github.com/aruneshchandra) | +| Benjamin Byholm | [kkoopa](https://github.com/kkoopa) | +| Gabriel Schulhof | [gabrielschulhof](https://github.com/gabrielschulhof) | +| Hitesh Kanwathirtha | [digitalinfinity](https://github.com/digitalinfinity) | +| Jason Ginchereau | [jasongin](https://github.com/jasongin) | +| Jim Schlight | [jschlight](https://github.com/jschlight) | +| Sampson Gao | [sampsongao](https://github.com/sampsongao) | +| Taylor Woll | [boingoing](https://github.com/boingoing) | + + + +Licensed under [MIT](./LICENSE.md) + +[ABI stability guide]: https://nodejs.org/en/docs/guides/abi-stability/ +[Node-API support matrix]: https://nodejs.org/dist/latest/docs/api/n-api.html#n_api_n_api_version_matrix diff --git a/node_modules/node-addon-api/common.gypi b/node_modules/node-addon-api/common.gypi new file mode 100644 index 0000000..06c0176 --- /dev/null +++ b/node_modules/node-addon-api/common.gypi @@ -0,0 +1,20 @@ +{ + 'variables': { + 'NAPI_VERSION%': " +inline PropertyDescriptor PropertyDescriptor::Accessor( + const char* utf8name, + Getter getter, + napi_property_attributes attributes, + void* /*data*/) { + using CbData = details::CallbackData; + // TODO: Delete when the function is destroyed + auto callbackData = new CbData({getter, nullptr}); + + return PropertyDescriptor({utf8name, + nullptr, + nullptr, + CbData::Wrapper, + nullptr, + nullptr, + attributes, + callbackData}); +} + +template +inline PropertyDescriptor PropertyDescriptor::Accessor( + const std::string& utf8name, + Getter getter, + napi_property_attributes attributes, + void* data) { + return Accessor(utf8name.c_str(), getter, attributes, data); +} + +template +inline PropertyDescriptor PropertyDescriptor::Accessor( + napi_value name, + Getter getter, + napi_property_attributes attributes, + void* /*data*/) { + using CbData = details::CallbackData; + // TODO: Delete when the function is destroyed + auto callbackData = new CbData({getter, nullptr}); + + return PropertyDescriptor({nullptr, + name, + nullptr, + CbData::Wrapper, + nullptr, + nullptr, + attributes, + callbackData}); +} + +template +inline PropertyDescriptor PropertyDescriptor::Accessor( + Name name, Getter getter, napi_property_attributes attributes, void* data) { + napi_value nameValue = name; + return PropertyDescriptor::Accessor(nameValue, getter, attributes, data); +} + +template +inline PropertyDescriptor PropertyDescriptor::Accessor( + const char* utf8name, + Getter getter, + Setter setter, + napi_property_attributes attributes, + void* /*data*/) { + using CbData = details::AccessorCallbackData; + // TODO: Delete when the function is destroyed + auto callbackData = new CbData({getter, setter, nullptr}); + + return PropertyDescriptor({utf8name, + nullptr, + nullptr, + CbData::GetterWrapper, + CbData::SetterWrapper, + nullptr, + attributes, + callbackData}); +} + +template +inline PropertyDescriptor PropertyDescriptor::Accessor( + const std::string& utf8name, + Getter getter, + Setter setter, + napi_property_attributes attributes, + void* data) { + return Accessor(utf8name.c_str(), getter, setter, attributes, data); +} + +template +inline PropertyDescriptor PropertyDescriptor::Accessor( + napi_value name, + Getter getter, + Setter setter, + napi_property_attributes attributes, + void* /*data*/) { + using CbData = details::AccessorCallbackData; + // TODO: Delete when the function is destroyed + auto callbackData = new CbData({getter, setter, nullptr}); + + return PropertyDescriptor({nullptr, + name, + nullptr, + CbData::GetterWrapper, + CbData::SetterWrapper, + nullptr, + attributes, + callbackData}); +} + +template +inline PropertyDescriptor PropertyDescriptor::Accessor( + Name name, + Getter getter, + Setter setter, + napi_property_attributes attributes, + void* data) { + napi_value nameValue = name; + return PropertyDescriptor::Accessor( + nameValue, getter, setter, attributes, data); +} + +template +inline PropertyDescriptor PropertyDescriptor::Function( + const char* utf8name, + Callable cb, + napi_property_attributes attributes, + void* /*data*/) { + using ReturnType = decltype(cb(CallbackInfo(nullptr, nullptr))); + using CbData = details::CallbackData; + // TODO: Delete when the function is destroyed + auto callbackData = new CbData({cb, nullptr}); + + return PropertyDescriptor({utf8name, + nullptr, + CbData::Wrapper, + nullptr, + nullptr, + nullptr, + attributes, + callbackData}); +} + +template +inline PropertyDescriptor PropertyDescriptor::Function( + const std::string& utf8name, + Callable cb, + napi_property_attributes attributes, + void* data) { + return Function(utf8name.c_str(), cb, attributes, data); +} + +template +inline PropertyDescriptor PropertyDescriptor::Function( + napi_value name, + Callable cb, + napi_property_attributes attributes, + void* /*data*/) { + using ReturnType = decltype(cb(CallbackInfo(nullptr, nullptr))); + using CbData = details::CallbackData; + // TODO: Delete when the function is destroyed + auto callbackData = new CbData({cb, nullptr}); + + return PropertyDescriptor({nullptr, + name, + CbData::Wrapper, + nullptr, + nullptr, + nullptr, + attributes, + callbackData}); +} + +template +inline PropertyDescriptor PropertyDescriptor::Function( + Name name, Callable cb, napi_property_attributes attributes, void* data) { + napi_value nameValue = name; + return PropertyDescriptor::Function(nameValue, cb, attributes, data); +} + +#endif // !SRC_NAPI_INL_DEPRECATED_H_ diff --git a/node_modules/node-addon-api/napi-inl.h b/node_modules/node-addon-api/napi-inl.h new file mode 100644 index 0000000..a5ae7af --- /dev/null +++ b/node_modules/node-addon-api/napi-inl.h @@ -0,0 +1,6607 @@ +#ifndef SRC_NAPI_INL_H_ +#define SRC_NAPI_INL_H_ + +//////////////////////////////////////////////////////////////////////////////// +// Node-API C++ Wrapper Classes +// +// Inline header-only implementations for "Node-API" ABI-stable C APIs for +// Node.js. +//////////////////////////////////////////////////////////////////////////////// + +// Note: Do not include this file directly! Include "napi.h" instead. + +#include +#include +#if NAPI_HAS_THREADS +#include +#endif // NAPI_HAS_THREADS +#include +#include + +namespace Napi { + +#ifdef NAPI_CPP_CUSTOM_NAMESPACE +namespace NAPI_CPP_CUSTOM_NAMESPACE { +#endif + +// Helpers to handle functions exposed from C++ and internal constants. +namespace details { + +// New napi_status constants not yet available in all supported versions of +// Node.js releases. Only necessary when they are used in napi.h and napi-inl.h. +constexpr int napi_no_external_buffers_allowed = 22; + +template +inline void default_finalizer(napi_env /*env*/, void* data, void* /*hint*/) { + delete static_cast(data); +} + +// Attach a data item to an object and delete it when the object gets +// garbage-collected. +// TODO: Replace this code with `napi_add_finalizer()` whenever it becomes +// available on all supported versions of Node.js. +template > +inline napi_status AttachData(napi_env env, + napi_value obj, + FreeType* data, + void* hint = nullptr) { + napi_status status; +#if (NAPI_VERSION < 5) + napi_value symbol, external; + status = napi_create_symbol(env, nullptr, &symbol); + if (status == napi_ok) { + status = napi_create_external(env, data, finalizer, hint, &external); + if (status == napi_ok) { + napi_property_descriptor desc = {nullptr, + symbol, + nullptr, + nullptr, + nullptr, + external, + napi_default, + nullptr}; + status = napi_define_properties(env, obj, 1, &desc); + } + } +#else // NAPI_VERSION >= 5 + status = napi_add_finalizer(env, obj, data, finalizer, hint, nullptr); +#endif + return status; +} + +// For use in JS to C++ callback wrappers to catch any Napi::Error exceptions +// and rethrow them as JavaScript exceptions before returning from the callback. +template +inline napi_value WrapCallback(Callable callback) { +#ifdef NAPI_CPP_EXCEPTIONS + try { + return callback(); + } catch (const Error& e) { + e.ThrowAsJavaScriptException(); + return nullptr; + } +#else // NAPI_CPP_EXCEPTIONS + // When C++ exceptions are disabled, errors are immediately thrown as JS + // exceptions, so there is no need to catch and rethrow them here. + return callback(); +#endif // NAPI_CPP_EXCEPTIONS +} + +// For use in JS to C++ void callback wrappers to catch any Napi::Error +// exceptions and rethrow them as JavaScript exceptions before returning from +// the callback. +template +inline void WrapVoidCallback(Callable callback) { +#ifdef NAPI_CPP_EXCEPTIONS + try { + callback(); + } catch (const Error& e) { + e.ThrowAsJavaScriptException(); + } +#else // NAPI_CPP_EXCEPTIONS + // When C++ exceptions are disabled, errors are immediately thrown as JS + // exceptions, so there is no need to catch and rethrow them here. + callback(); +#endif // NAPI_CPP_EXCEPTIONS +} + +template +struct CallbackData { + static inline napi_value Wrapper(napi_env env, napi_callback_info info) { + return details::WrapCallback([&] { + CallbackInfo callbackInfo(env, info); + CallbackData* callbackData = + static_cast(callbackInfo.Data()); + callbackInfo.SetData(callbackData->data); + return callbackData->callback(callbackInfo); + }); + } + + Callable callback; + void* data; +}; + +template +struct CallbackData { + static inline napi_value Wrapper(napi_env env, napi_callback_info info) { + return details::WrapCallback([&] { + CallbackInfo callbackInfo(env, info); + CallbackData* callbackData = + static_cast(callbackInfo.Data()); + callbackInfo.SetData(callbackData->data); + callbackData->callback(callbackInfo); + return nullptr; + }); + } + + Callable callback; + void* data; +}; + +template +napi_value TemplatedVoidCallback(napi_env env, + napi_callback_info info) NAPI_NOEXCEPT { + return details::WrapCallback([&] { + CallbackInfo cbInfo(env, info); + Callback(cbInfo); + return nullptr; + }); +} + +template +napi_value TemplatedCallback(napi_env env, + napi_callback_info info) NAPI_NOEXCEPT { + return details::WrapCallback([&] { + CallbackInfo cbInfo(env, info); + return Callback(cbInfo); + }); +} + +template +napi_value TemplatedInstanceCallback(napi_env env, + napi_callback_info info) NAPI_NOEXCEPT { + return details::WrapCallback([&] { + CallbackInfo cbInfo(env, info); + T* instance = T::Unwrap(cbInfo.This().As()); + return instance ? (instance->*UnwrapCallback)(cbInfo) : Napi::Value(); + }); +} + +template +napi_value TemplatedInstanceVoidCallback(napi_env env, napi_callback_info info) + NAPI_NOEXCEPT { + return details::WrapCallback([&] { + CallbackInfo cbInfo(env, info); + T* instance = T::Unwrap(cbInfo.This().As()); + if (instance) (instance->*UnwrapCallback)(cbInfo); + return nullptr; + }); +} + +template +struct FinalizeData { + static inline void Wrapper(napi_env env, + void* data, + void* finalizeHint) NAPI_NOEXCEPT { + WrapVoidCallback([&] { + FinalizeData* finalizeData = static_cast(finalizeHint); + finalizeData->callback(Env(env), static_cast(data)); + delete finalizeData; + }); + } + + static inline void WrapperWithHint(napi_env env, + void* data, + void* finalizeHint) NAPI_NOEXCEPT { + WrapVoidCallback([&] { + FinalizeData* finalizeData = static_cast(finalizeHint); + finalizeData->callback( + Env(env), static_cast(data), finalizeData->hint); + delete finalizeData; + }); + } + + Finalizer callback; + Hint* hint; +}; + +#if (NAPI_VERSION > 3 && NAPI_HAS_THREADS) +template , + typename FinalizerDataType = void> +struct ThreadSafeFinalize { + static inline void Wrapper(napi_env env, + void* rawFinalizeData, + void* /* rawContext */) { + if (rawFinalizeData == nullptr) return; + + ThreadSafeFinalize* finalizeData = + static_cast(rawFinalizeData); + finalizeData->callback(Env(env)); + delete finalizeData; + } + + static inline void FinalizeWrapperWithData(napi_env env, + void* rawFinalizeData, + void* /* rawContext */) { + if (rawFinalizeData == nullptr) return; + + ThreadSafeFinalize* finalizeData = + static_cast(rawFinalizeData); + finalizeData->callback(Env(env), finalizeData->data); + delete finalizeData; + } + + static inline void FinalizeWrapperWithContext(napi_env env, + void* rawFinalizeData, + void* rawContext) { + if (rawFinalizeData == nullptr) return; + + ThreadSafeFinalize* finalizeData = + static_cast(rawFinalizeData); + finalizeData->callback(Env(env), static_cast(rawContext)); + delete finalizeData; + } + + static inline void FinalizeFinalizeWrapperWithDataAndContext( + napi_env env, void* rawFinalizeData, void* rawContext) { + if (rawFinalizeData == nullptr) return; + + ThreadSafeFinalize* finalizeData = + static_cast(rawFinalizeData); + finalizeData->callback( + Env(env), finalizeData->data, static_cast(rawContext)); + delete finalizeData; + } + + FinalizerDataType* data; + Finalizer callback; +}; + +template +inline typename std::enable_if(nullptr)>::type +CallJsWrapper(napi_env env, napi_value jsCallback, void* context, void* data) { + details::WrapVoidCallback([&]() { + call(env, + Function(env, jsCallback), + static_cast(context), + static_cast(data)); + }); +} + +template +inline typename std::enable_if(nullptr)>::type +CallJsWrapper(napi_env env, + napi_value jsCallback, + void* /*context*/, + void* /*data*/) { + details::WrapVoidCallback([&]() { + if (jsCallback != nullptr) { + Function(env, jsCallback).Call(0, nullptr); + } + }); +} + +#if NAPI_VERSION > 4 + +template +napi_value DefaultCallbackWrapper(napi_env /*env*/, std::nullptr_t /*cb*/) { + return nullptr; +} + +template +napi_value DefaultCallbackWrapper(napi_env /*env*/, Napi::Function cb) { + return cb; +} + +#else +template +napi_value DefaultCallbackWrapper(napi_env env, Napi::Function cb) { + if (cb.IsEmpty()) { + return TSFN::EmptyFunctionFactory(env); + } + return cb; +} +#endif // NAPI_VERSION > 4 +#endif // NAPI_VERSION > 3 && NAPI_HAS_THREADS + +template +struct AccessorCallbackData { + static inline napi_value GetterWrapper(napi_env env, + napi_callback_info info) { + return details::WrapCallback([&] { + CallbackInfo callbackInfo(env, info); + AccessorCallbackData* callbackData = + static_cast(callbackInfo.Data()); + callbackInfo.SetData(callbackData->data); + return callbackData->getterCallback(callbackInfo); + }); + } + + static inline napi_value SetterWrapper(napi_env env, + napi_callback_info info) { + return details::WrapCallback([&] { + CallbackInfo callbackInfo(env, info); + AccessorCallbackData* callbackData = + static_cast(callbackInfo.Data()); + callbackInfo.SetData(callbackData->data); + callbackData->setterCallback(callbackInfo); + return nullptr; + }); + } + + Getter getterCallback; + Setter setterCallback; + void* data; +}; + +} // namespace details + +#ifndef NODE_ADDON_API_DISABLE_DEPRECATED +#include "napi-inl.deprecated.h" +#endif // !NODE_ADDON_API_DISABLE_DEPRECATED + +//////////////////////////////////////////////////////////////////////////////// +// Module registration +//////////////////////////////////////////////////////////////////////////////// + +// Register an add-on based on an initializer function. +#define NODE_API_MODULE(modname, regfunc) \ + static napi_value __napi_##regfunc(napi_env env, napi_value exports) { \ + return Napi::RegisterModule(env, exports, regfunc); \ + } \ + NAPI_MODULE(modname, __napi_##regfunc) + +// Register an add-on based on a subclass of `Addon` with a custom Node.js +// module name. +#define NODE_API_NAMED_ADDON(modname, classname) \ + static napi_value __napi_##classname(napi_env env, napi_value exports) { \ + return Napi::RegisterModule(env, exports, &classname::Init); \ + } \ + NAPI_MODULE(modname, __napi_##classname) + +// Register an add-on based on a subclass of `Addon` with the Node.js module +// name given by node-gyp from the `target_name` in binding.gyp. +#define NODE_API_ADDON(classname) \ + NODE_API_NAMED_ADDON(NODE_GYP_MODULE_NAME, classname) + +// Adapt the NAPI_MODULE registration function: +// - Wrap the arguments in NAPI wrappers. +// - Catch any NAPI errors and rethrow as JS exceptions. +inline napi_value RegisterModule(napi_env env, + napi_value exports, + ModuleRegisterCallback registerCallback) { + return details::WrapCallback([&] { + return napi_value( + registerCallback(Napi::Env(env), Napi::Object(env, exports))); + }); +} + +//////////////////////////////////////////////////////////////////////////////// +// Maybe class +//////////////////////////////////////////////////////////////////////////////// + +template +bool Maybe::IsNothing() const { + return !_has_value; +} + +template +bool Maybe::IsJust() const { + return _has_value; +} + +template +void Maybe::Check() const { + NAPI_CHECK(IsJust(), "Napi::Maybe::Check", "Maybe value is Nothing."); +} + +template +T Maybe::Unwrap() const { + NAPI_CHECK(IsJust(), "Napi::Maybe::Unwrap", "Maybe value is Nothing."); + return _value; +} + +template +T Maybe::UnwrapOr(const T& default_value) const { + return _has_value ? _value : default_value; +} + +template +bool Maybe::UnwrapTo(T* out) const { + if (IsJust()) { + *out = _value; + return true; + }; + return false; +} + +template +bool Maybe::operator==(const Maybe& other) const { + return (IsJust() == other.IsJust()) && + (!IsJust() || Unwrap() == other.Unwrap()); +} + +template +bool Maybe::operator!=(const Maybe& other) const { + return !operator==(other); +} + +template +Maybe::Maybe() : _has_value(false) {} + +template +Maybe::Maybe(const T& t) : _has_value(true), _value(t) {} + +template +inline Maybe Nothing() { + return Maybe(); +} + +template +inline Maybe Just(const T& t) { + return Maybe(t); +} + +//////////////////////////////////////////////////////////////////////////////// +// Env class +//////////////////////////////////////////////////////////////////////////////// + +inline Env::Env(napi_env env) : _env(env) {} + +inline Env::operator napi_env() const { + return _env; +} + +inline Object Env::Global() const { + napi_value value; + napi_status status = napi_get_global(*this, &value); + NAPI_THROW_IF_FAILED(*this, status, Object()); + return Object(*this, value); +} + +inline Value Env::Undefined() const { + napi_value value; + napi_status status = napi_get_undefined(*this, &value); + NAPI_THROW_IF_FAILED(*this, status, Value()); + return Value(*this, value); +} + +inline Value Env::Null() const { + napi_value value; + napi_status status = napi_get_null(*this, &value); + NAPI_THROW_IF_FAILED(*this, status, Value()); + return Value(*this, value); +} + +inline bool Env::IsExceptionPending() const { + bool result; + napi_status status = napi_is_exception_pending(_env, &result); + if (status != napi_ok) + result = false; // Checking for a pending exception shouldn't throw. + return result; +} + +inline Error Env::GetAndClearPendingException() const { + napi_value value; + napi_status status = napi_get_and_clear_last_exception(_env, &value); + if (status != napi_ok) { + // Don't throw another exception when failing to get the exception! + return Error(); + } + return Error(_env, value); +} + +inline MaybeOrValue Env::RunScript(const char* utf8script) const { + String script = String::New(_env, utf8script); + return RunScript(script); +} + +inline MaybeOrValue Env::RunScript(const std::string& utf8script) const { + return RunScript(utf8script.c_str()); +} + +inline MaybeOrValue Env::RunScript(String script) const { + napi_value result; + napi_status status = napi_run_script(_env, script, &result); + NAPI_RETURN_OR_THROW_IF_FAILED( + _env, status, Napi::Value(_env, result), Napi::Value); +} + +#if NAPI_VERSION > 2 +template +void Env::CleanupHook::Wrapper(void* data) NAPI_NOEXCEPT { + auto* cleanupData = + static_cast::CleanupData*>( + data); + cleanupData->hook(); + delete cleanupData; +} + +template +void Env::CleanupHook::WrapperWithArg(void* data) NAPI_NOEXCEPT { + auto* cleanupData = + static_cast::CleanupData*>( + data); + cleanupData->hook(static_cast(cleanupData->arg)); + delete cleanupData; +} +#endif // NAPI_VERSION > 2 + +#if NAPI_VERSION > 5 +template fini> +inline void Env::SetInstanceData(T* data) const { + napi_status status = napi_set_instance_data( + _env, + data, + [](napi_env env, void* data, void*) { fini(env, static_cast(data)); }, + nullptr); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +template fini> +inline void Env::SetInstanceData(DataType* data, HintType* hint) const { + napi_status status = napi_set_instance_data( + _env, + data, + [](napi_env env, void* data, void* hint) { + fini(env, static_cast(data), static_cast(hint)); + }, + hint); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +template +inline T* Env::GetInstanceData() const { + void* data = nullptr; + + napi_status status = napi_get_instance_data(_env, &data); + NAPI_THROW_IF_FAILED(_env, status, nullptr); + + return static_cast(data); +} + +template +void Env::DefaultFini(Env, T* data) { + delete data; +} + +template +void Env::DefaultFiniWithHint(Env, DataType* data, HintType*) { + delete data; +} +#endif // NAPI_VERSION > 5 + +#if NAPI_VERSION > 8 +inline const char* Env::GetModuleFileName() const { + const char* result; + napi_status status = node_api_get_module_file_name(_env, &result); + NAPI_THROW_IF_FAILED(*this, status, nullptr); + return result; +} +#endif // NAPI_VERSION > 8 +//////////////////////////////////////////////////////////////////////////////// +// Value class +//////////////////////////////////////////////////////////////////////////////// + +inline Value::Value() : _env(nullptr), _value(nullptr) {} + +inline Value::Value(napi_env env, napi_value value) + : _env(env), _value(value) {} + +inline Value::operator napi_value() const { + return _value; +} + +inline bool Value::operator==(const Value& other) const { + return StrictEquals(other); +} + +inline bool Value::operator!=(const Value& other) const { + return !this->operator==(other); +} + +inline bool Value::StrictEquals(const Value& other) const { + bool result; + napi_status status = napi_strict_equals(_env, *this, other, &result); + NAPI_THROW_IF_FAILED(_env, status, false); + return result; +} + +inline Napi::Env Value::Env() const { + return Napi::Env(_env); +} + +inline bool Value::IsEmpty() const { + return _value == nullptr; +} + +inline napi_valuetype Value::Type() const { + if (IsEmpty()) { + return napi_undefined; + } + + napi_valuetype type; + napi_status status = napi_typeof(_env, _value, &type); + NAPI_THROW_IF_FAILED(_env, status, napi_undefined); + return type; +} + +inline bool Value::IsUndefined() const { + return Type() == napi_undefined; +} + +inline bool Value::IsNull() const { + return Type() == napi_null; +} + +inline bool Value::IsBoolean() const { + return Type() == napi_boolean; +} + +inline bool Value::IsNumber() const { + return Type() == napi_number; +} + +#if NAPI_VERSION > 5 +inline bool Value::IsBigInt() const { + return Type() == napi_bigint; +} +#endif // NAPI_VERSION > 5 + +#if (NAPI_VERSION > 4) +inline bool Value::IsDate() const { + if (IsEmpty()) { + return false; + } + + bool result; + napi_status status = napi_is_date(_env, _value, &result); + NAPI_THROW_IF_FAILED(_env, status, false); + return result; +} +#endif + +inline bool Value::IsString() const { + return Type() == napi_string; +} + +inline bool Value::IsSymbol() const { + return Type() == napi_symbol; +} + +inline bool Value::IsArray() const { + if (IsEmpty()) { + return false; + } + + bool result; + napi_status status = napi_is_array(_env, _value, &result); + NAPI_THROW_IF_FAILED(_env, status, false); + return result; +} + +inline bool Value::IsArrayBuffer() const { + if (IsEmpty()) { + return false; + } + + bool result; + napi_status status = napi_is_arraybuffer(_env, _value, &result); + NAPI_THROW_IF_FAILED(_env, status, false); + return result; +} + +inline bool Value::IsTypedArray() const { + if (IsEmpty()) { + return false; + } + + bool result; + napi_status status = napi_is_typedarray(_env, _value, &result); + NAPI_THROW_IF_FAILED(_env, status, false); + return result; +} + +inline bool Value::IsObject() const { + return Type() == napi_object || IsFunction(); +} + +inline bool Value::IsFunction() const { + return Type() == napi_function; +} + +inline bool Value::IsPromise() const { + if (IsEmpty()) { + return false; + } + + bool result; + napi_status status = napi_is_promise(_env, _value, &result); + NAPI_THROW_IF_FAILED(_env, status, false); + return result; +} + +inline bool Value::IsDataView() const { + if (IsEmpty()) { + return false; + } + + bool result; + napi_status status = napi_is_dataview(_env, _value, &result); + NAPI_THROW_IF_FAILED(_env, status, false); + return result; +} + +inline bool Value::IsBuffer() const { + if (IsEmpty()) { + return false; + } + + bool result; + napi_status status = napi_is_buffer(_env, _value, &result); + NAPI_THROW_IF_FAILED(_env, status, false); + return result; +} + +inline bool Value::IsExternal() const { + return Type() == napi_external; +} + +template +inline T Value::As() const { +#ifdef NODE_ADDON_API_ENABLE_TYPE_CHECK_ON_AS + T::CheckCast(_env, _value); +#endif + return T(_env, _value); +} + +inline MaybeOrValue Value::ToBoolean() const { + napi_value result; + napi_status status = napi_coerce_to_bool(_env, _value, &result); + NAPI_RETURN_OR_THROW_IF_FAILED( + _env, status, Napi::Boolean(_env, result), Napi::Boolean); +} + +inline MaybeOrValue Value::ToNumber() const { + napi_value result; + napi_status status = napi_coerce_to_number(_env, _value, &result); + NAPI_RETURN_OR_THROW_IF_FAILED( + _env, status, Napi::Number(_env, result), Napi::Number); +} + +inline MaybeOrValue Value::ToString() const { + napi_value result; + napi_status status = napi_coerce_to_string(_env, _value, &result); + NAPI_RETURN_OR_THROW_IF_FAILED( + _env, status, Napi::String(_env, result), Napi::String); +} + +inline MaybeOrValue Value::ToObject() const { + napi_value result; + napi_status status = napi_coerce_to_object(_env, _value, &result); + NAPI_RETURN_OR_THROW_IF_FAILED( + _env, status, Napi::Object(_env, result), Napi::Object); +} + +//////////////////////////////////////////////////////////////////////////////// +// Boolean class +//////////////////////////////////////////////////////////////////////////////// + +inline Boolean Boolean::New(napi_env env, bool val) { + napi_value value; + napi_status status = napi_get_boolean(env, val, &value); + NAPI_THROW_IF_FAILED(env, status, Boolean()); + return Boolean(env, value); +} + +inline void Boolean::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "Boolean::CheckCast", "empty value"); + + napi_valuetype type; + napi_status status = napi_typeof(env, value, &type); + NAPI_CHECK(status == napi_ok, "Boolean::CheckCast", "napi_typeof failed"); + NAPI_CHECK( + type == napi_boolean, "Boolean::CheckCast", "value is not napi_boolean"); +} + +inline Boolean::Boolean() : Napi::Value() {} + +inline Boolean::Boolean(napi_env env, napi_value value) + : Napi::Value(env, value) {} + +inline Boolean::operator bool() const { + return Value(); +} + +inline bool Boolean::Value() const { + bool result; + napi_status status = napi_get_value_bool(_env, _value, &result); + NAPI_THROW_IF_FAILED(_env, status, false); + return result; +} + +//////////////////////////////////////////////////////////////////////////////// +// Number class +//////////////////////////////////////////////////////////////////////////////// + +inline Number Number::New(napi_env env, double val) { + napi_value value; + napi_status status = napi_create_double(env, val, &value); + NAPI_THROW_IF_FAILED(env, status, Number()); + return Number(env, value); +} + +inline void Number::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "Number::CheckCast", "empty value"); + + napi_valuetype type; + napi_status status = napi_typeof(env, value, &type); + NAPI_CHECK(status == napi_ok, "Number::CheckCast", "napi_typeof failed"); + NAPI_CHECK( + type == napi_number, "Number::CheckCast", "value is not napi_number"); +} + +inline Number::Number() : Value() {} + +inline Number::Number(napi_env env, napi_value value) : Value(env, value) {} + +inline Number::operator int32_t() const { + return Int32Value(); +} + +inline Number::operator uint32_t() const { + return Uint32Value(); +} + +inline Number::operator int64_t() const { + return Int64Value(); +} + +inline Number::operator float() const { + return FloatValue(); +} + +inline Number::operator double() const { + return DoubleValue(); +} + +inline int32_t Number::Int32Value() const { + int32_t result; + napi_status status = napi_get_value_int32(_env, _value, &result); + NAPI_THROW_IF_FAILED(_env, status, 0); + return result; +} + +inline uint32_t Number::Uint32Value() const { + uint32_t result; + napi_status status = napi_get_value_uint32(_env, _value, &result); + NAPI_THROW_IF_FAILED(_env, status, 0); + return result; +} + +inline int64_t Number::Int64Value() const { + int64_t result; + napi_status status = napi_get_value_int64(_env, _value, &result); + NAPI_THROW_IF_FAILED(_env, status, 0); + return result; +} + +inline float Number::FloatValue() const { + return static_cast(DoubleValue()); +} + +inline double Number::DoubleValue() const { + double result; + napi_status status = napi_get_value_double(_env, _value, &result); + NAPI_THROW_IF_FAILED(_env, status, 0); + return result; +} + +#if NAPI_VERSION > 5 +//////////////////////////////////////////////////////////////////////////////// +// BigInt Class +//////////////////////////////////////////////////////////////////////////////// + +inline BigInt BigInt::New(napi_env env, int64_t val) { + napi_value value; + napi_status status = napi_create_bigint_int64(env, val, &value); + NAPI_THROW_IF_FAILED(env, status, BigInt()); + return BigInt(env, value); +} + +inline BigInt BigInt::New(napi_env env, uint64_t val) { + napi_value value; + napi_status status = napi_create_bigint_uint64(env, val, &value); + NAPI_THROW_IF_FAILED(env, status, BigInt()); + return BigInt(env, value); +} + +inline BigInt BigInt::New(napi_env env, + int sign_bit, + size_t word_count, + const uint64_t* words) { + napi_value value; + napi_status status = + napi_create_bigint_words(env, sign_bit, word_count, words, &value); + NAPI_THROW_IF_FAILED(env, status, BigInt()); + return BigInt(env, value); +} + +inline void BigInt::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "BigInt::CheckCast", "empty value"); + + napi_valuetype type; + napi_status status = napi_typeof(env, value, &type); + NAPI_CHECK(status == napi_ok, "BigInt::CheckCast", "napi_typeof failed"); + NAPI_CHECK( + type == napi_bigint, "BigInt::CheckCast", "value is not napi_bigint"); +} + +inline BigInt::BigInt() : Value() {} + +inline BigInt::BigInt(napi_env env, napi_value value) : Value(env, value) {} + +inline int64_t BigInt::Int64Value(bool* lossless) const { + int64_t result; + napi_status status = + napi_get_value_bigint_int64(_env, _value, &result, lossless); + NAPI_THROW_IF_FAILED(_env, status, 0); + return result; +} + +inline uint64_t BigInt::Uint64Value(bool* lossless) const { + uint64_t result; + napi_status status = + napi_get_value_bigint_uint64(_env, _value, &result, lossless); + NAPI_THROW_IF_FAILED(_env, status, 0); + return result; +} + +inline size_t BigInt::WordCount() const { + size_t word_count; + napi_status status = + napi_get_value_bigint_words(_env, _value, nullptr, &word_count, nullptr); + NAPI_THROW_IF_FAILED(_env, status, 0); + return word_count; +} + +inline void BigInt::ToWords(int* sign_bit, + size_t* word_count, + uint64_t* words) { + napi_status status = + napi_get_value_bigint_words(_env, _value, sign_bit, word_count, words); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} +#endif // NAPI_VERSION > 5 + +#if (NAPI_VERSION > 4) +//////////////////////////////////////////////////////////////////////////////// +// Date Class +//////////////////////////////////////////////////////////////////////////////// + +inline Date Date::New(napi_env env, double val) { + napi_value value; + napi_status status = napi_create_date(env, val, &value); + NAPI_THROW_IF_FAILED(env, status, Date()); + return Date(env, value); +} + +inline void Date::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "Date::CheckCast", "empty value"); + + bool result; + napi_status status = napi_is_date(env, value, &result); + NAPI_CHECK(status == napi_ok, "Date::CheckCast", "napi_is_date failed"); + NAPI_CHECK(result, "Date::CheckCast", "value is not date"); +} + +inline Date::Date() : Value() {} + +inline Date::Date(napi_env env, napi_value value) : Value(env, value) {} + +inline Date::operator double() const { + return ValueOf(); +} + +inline double Date::ValueOf() const { + double result; + napi_status status = napi_get_date_value(_env, _value, &result); + NAPI_THROW_IF_FAILED(_env, status, 0); + return result; +} +#endif + +//////////////////////////////////////////////////////////////////////////////// +// Name class +//////////////////////////////////////////////////////////////////////////////// +inline void Name::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "Name::CheckCast", "empty value"); + + napi_valuetype type; + napi_status status = napi_typeof(env, value, &type); + NAPI_CHECK(status == napi_ok, "Name::CheckCast", "napi_typeof failed"); + NAPI_CHECK(type == napi_string || type == napi_symbol, + "Name::CheckCast", + "value is not napi_string or napi_symbol"); +} + +inline Name::Name() : Value() {} + +inline Name::Name(napi_env env, napi_value value) : Value(env, value) {} + +//////////////////////////////////////////////////////////////////////////////// +// String class +//////////////////////////////////////////////////////////////////////////////// + +inline String String::New(napi_env env, const std::string& val) { + return String::New(env, val.c_str(), val.size()); +} + +inline String String::New(napi_env env, const std::u16string& val) { + return String::New(env, val.c_str(), val.size()); +} + +inline String String::New(napi_env env, const char* val) { + // TODO(@gabrielschulhof) Remove if-statement when core's error handling is + // available in all supported versions. + if (val == nullptr) { + // Throw an error that looks like it came from core. + NAPI_THROW_IF_FAILED(env, napi_invalid_arg, String()); + } + napi_value value; + napi_status status = + napi_create_string_utf8(env, val, std::strlen(val), &value); + NAPI_THROW_IF_FAILED(env, status, String()); + return String(env, value); +} + +inline String String::New(napi_env env, const char16_t* val) { + napi_value value; + // TODO(@gabrielschulhof) Remove if-statement when core's error handling is + // available in all supported versions. + if (val == nullptr) { + // Throw an error that looks like it came from core. + NAPI_THROW_IF_FAILED(env, napi_invalid_arg, String()); + } + napi_status status = + napi_create_string_utf16(env, val, std::u16string(val).size(), &value); + NAPI_THROW_IF_FAILED(env, status, String()); + return String(env, value); +} + +inline String String::New(napi_env env, const char* val, size_t length) { + napi_value value; + napi_status status = napi_create_string_utf8(env, val, length, &value); + NAPI_THROW_IF_FAILED(env, status, String()); + return String(env, value); +} + +inline String String::New(napi_env env, const char16_t* val, size_t length) { + napi_value value; + napi_status status = napi_create_string_utf16(env, val, length, &value); + NAPI_THROW_IF_FAILED(env, status, String()); + return String(env, value); +} + +inline void String::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "String::CheckCast", "empty value"); + + napi_valuetype type; + napi_status status = napi_typeof(env, value, &type); + NAPI_CHECK(status == napi_ok, "String::CheckCast", "napi_typeof failed"); + NAPI_CHECK( + type == napi_string, "String::CheckCast", "value is not napi_string"); +} + +inline String::String() : Name() {} + +inline String::String(napi_env env, napi_value value) : Name(env, value) {} + +inline String::operator std::string() const { + return Utf8Value(); +} + +inline String::operator std::u16string() const { + return Utf16Value(); +} + +inline std::string String::Utf8Value() const { + size_t length; + napi_status status = + napi_get_value_string_utf8(_env, _value, nullptr, 0, &length); + NAPI_THROW_IF_FAILED(_env, status, ""); + + std::string value; + value.reserve(length + 1); + value.resize(length); + status = napi_get_value_string_utf8( + _env, _value, &value[0], value.capacity(), nullptr); + NAPI_THROW_IF_FAILED(_env, status, ""); + return value; +} + +inline std::u16string String::Utf16Value() const { + size_t length; + napi_status status = + napi_get_value_string_utf16(_env, _value, nullptr, 0, &length); + NAPI_THROW_IF_FAILED(_env, status, NAPI_WIDE_TEXT("")); + + std::u16string value; + value.reserve(length + 1); + value.resize(length); + status = napi_get_value_string_utf16( + _env, _value, &value[0], value.capacity(), nullptr); + NAPI_THROW_IF_FAILED(_env, status, NAPI_WIDE_TEXT("")); + return value; +} + +//////////////////////////////////////////////////////////////////////////////// +// Symbol class +//////////////////////////////////////////////////////////////////////////////// + +inline Symbol Symbol::New(napi_env env, const char* description) { + napi_value descriptionValue = description != nullptr + ? String::New(env, description) + : static_cast(nullptr); + return Symbol::New(env, descriptionValue); +} + +inline Symbol Symbol::New(napi_env env, const std::string& description) { + napi_value descriptionValue = String::New(env, description); + return Symbol::New(env, descriptionValue); +} + +inline Symbol Symbol::New(napi_env env, String description) { + napi_value descriptionValue = description; + return Symbol::New(env, descriptionValue); +} + +inline Symbol Symbol::New(napi_env env, napi_value description) { + napi_value value; + napi_status status = napi_create_symbol(env, description, &value); + NAPI_THROW_IF_FAILED(env, status, Symbol()); + return Symbol(env, value); +} + +inline MaybeOrValue Symbol::WellKnown(napi_env env, + const std::string& name) { +#if defined(NODE_ADDON_API_ENABLE_MAYBE) + Value symbol_obj; + Value symbol_value; + if (Napi::Env(env).Global().Get("Symbol").UnwrapTo(&symbol_obj) && + symbol_obj.As().Get(name).UnwrapTo(&symbol_value)) { + return Just(symbol_value.As()); + } + return Nothing(); +#else + return Napi::Env(env) + .Global() + .Get("Symbol") + .As() + .Get(name) + .As(); +#endif +} + +inline MaybeOrValue Symbol::For(napi_env env, + const std::string& description) { + napi_value descriptionValue = String::New(env, description); + return Symbol::For(env, descriptionValue); +} + +inline MaybeOrValue Symbol::For(napi_env env, const char* description) { + napi_value descriptionValue = String::New(env, description); + return Symbol::For(env, descriptionValue); +} + +inline MaybeOrValue Symbol::For(napi_env env, String description) { + return Symbol::For(env, static_cast(description)); +} + +inline MaybeOrValue Symbol::For(napi_env env, napi_value description) { +#if defined(NODE_ADDON_API_ENABLE_MAYBE) + Value symbol_obj; + Value symbol_for_value; + Value symbol_value; + if (Napi::Env(env).Global().Get("Symbol").UnwrapTo(&symbol_obj) && + symbol_obj.As().Get("for").UnwrapTo(&symbol_for_value) && + symbol_for_value.As() + .Call(symbol_obj, {description}) + .UnwrapTo(&symbol_value)) { + return Just(symbol_value.As()); + } + return Nothing(); +#else + Object symbol_obj = Napi::Env(env).Global().Get("Symbol").As(); + return symbol_obj.Get("for") + .As() + .Call(symbol_obj, {description}) + .As(); +#endif +} + +inline void Symbol::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "Symbol::CheckCast", "empty value"); + + napi_valuetype type; + napi_status status = napi_typeof(env, value, &type); + NAPI_CHECK(status == napi_ok, "Symbol::CheckCast", "napi_typeof failed"); + NAPI_CHECK( + type == napi_symbol, "Symbol::CheckCast", "value is not napi_symbol"); +} + +inline Symbol::Symbol() : Name() {} + +inline Symbol::Symbol(napi_env env, napi_value value) : Name(env, value) {} + +//////////////////////////////////////////////////////////////////////////////// +// Automagic value creation +//////////////////////////////////////////////////////////////////////////////// + +namespace details { +template +struct vf_number { + static Number From(napi_env env, T value) { + return Number::New(env, static_cast(value)); + } +}; + +template <> +struct vf_number { + static Boolean From(napi_env env, bool value) { + return Boolean::New(env, value); + } +}; + +struct vf_utf8_charp { + static String From(napi_env env, const char* value) { + return String::New(env, value); + } +}; + +struct vf_utf16_charp { + static String From(napi_env env, const char16_t* value) { + return String::New(env, value); + } +}; +struct vf_utf8_string { + static String From(napi_env env, const std::string& value) { + return String::New(env, value); + } +}; + +struct vf_utf16_string { + static String From(napi_env env, const std::u16string& value) { + return String::New(env, value); + } +}; + +template +struct vf_fallback { + static Value From(napi_env env, const T& value) { return Value(env, value); } +}; + +template +struct disjunction : std::false_type {}; +template +struct disjunction : B {}; +template +struct disjunction + : std::conditional>::type {}; + +template +struct can_make_string + : disjunction::type, + typename std::is_convertible::type, + typename std::is_convertible::type, + typename std::is_convertible::type> {}; +} // namespace details + +template +Value Value::From(napi_env env, const T& value) { + using Helper = typename std::conditional< + std::is_integral::value || std::is_floating_point::value, + details::vf_number, + typename std::conditional::value, + String, + details::vf_fallback>::type>::type; + return Helper::From(env, value); +} + +template +String String::From(napi_env env, const T& value) { + struct Dummy {}; + using Helper = typename std::conditional< + std::is_convertible::value, + details::vf_utf8_charp, + typename std::conditional< + std::is_convertible::value, + details::vf_utf16_charp, + typename std::conditional< + std::is_convertible::value, + details::vf_utf8_string, + typename std::conditional< + std::is_convertible::value, + details::vf_utf16_string, + Dummy>::type>::type>::type>::type; + return Helper::From(env, value); +} + +//////////////////////////////////////////////////////////////////////////////// +// TypeTaggable class +//////////////////////////////////////////////////////////////////////////////// + +inline TypeTaggable::TypeTaggable() : Value() {} + +inline TypeTaggable::TypeTaggable(napi_env _env, napi_value _value) + : Value(_env, _value) {} + +#if NAPI_VERSION >= 8 + +inline void TypeTaggable::TypeTag(const napi_type_tag* type_tag) const { + napi_status status = napi_type_tag_object(_env, _value, type_tag); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +inline bool TypeTaggable::CheckTypeTag(const napi_type_tag* type_tag) const { + bool result; + napi_status status = + napi_check_object_type_tag(_env, _value, type_tag, &result); + NAPI_THROW_IF_FAILED(_env, status, false); + return result; +} + +#endif // NAPI_VERSION >= 8 + +//////////////////////////////////////////////////////////////////////////////// +// Object class +//////////////////////////////////////////////////////////////////////////////// + +template +inline Object::PropertyLValue::operator Value() const { + MaybeOrValue val = Object(_env, _object).Get(_key); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + return val.Unwrap(); +#else + return val; +#endif +} + +template +template +inline Object::PropertyLValue& Object::PropertyLValue::operator=( + ValueType value) { +#ifdef NODE_ADDON_API_ENABLE_MAYBE + MaybeOrValue result = +#endif + Object(_env, _object).Set(_key, value); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + result.Unwrap(); +#endif + return *this; +} + +template +inline Object::PropertyLValue::PropertyLValue(Object object, Key key) + : _env(object.Env()), _object(object), _key(key) {} + +inline Object Object::New(napi_env env) { + napi_value value; + napi_status status = napi_create_object(env, &value); + NAPI_THROW_IF_FAILED(env, status, Object()); + return Object(env, value); +} + +inline void Object::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "Object::CheckCast", "empty value"); + + napi_valuetype type; + napi_status status = napi_typeof(env, value, &type); + NAPI_CHECK(status == napi_ok, "Object::CheckCast", "napi_typeof failed"); + NAPI_CHECK( + type == napi_object, "Object::CheckCast", "value is not napi_object"); +} + +inline Object::Object() : TypeTaggable() {} + +inline Object::Object(napi_env env, napi_value value) + : TypeTaggable(env, value) {} + +inline Object::PropertyLValue Object::operator[]( + const char* utf8name) { + return PropertyLValue(*this, utf8name); +} + +inline Object::PropertyLValue Object::operator[]( + const std::string& utf8name) { + return PropertyLValue(*this, utf8name); +} + +inline Object::PropertyLValue Object::operator[](uint32_t index) { + return PropertyLValue(*this, index); +} + +inline Object::PropertyLValue Object::operator[](Value index) const { + return PropertyLValue(*this, index); +} + +inline MaybeOrValue Object::operator[](const char* utf8name) const { + return Get(utf8name); +} + +inline MaybeOrValue Object::operator[]( + const std::string& utf8name) const { + return Get(utf8name); +} + +inline MaybeOrValue Object::operator[](uint32_t index) const { + return Get(index); +} + +inline MaybeOrValue Object::Has(napi_value key) const { + bool result; + napi_status status = napi_has_property(_env, _value, key, &result); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool); +} + +inline MaybeOrValue Object::Has(Value key) const { + bool result; + napi_status status = napi_has_property(_env, _value, key, &result); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool); +} + +inline MaybeOrValue Object::Has(const char* utf8name) const { + bool result; + napi_status status = napi_has_named_property(_env, _value, utf8name, &result); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool); +} + +inline MaybeOrValue Object::Has(const std::string& utf8name) const { + return Has(utf8name.c_str()); +} + +inline MaybeOrValue Object::HasOwnProperty(napi_value key) const { + bool result; + napi_status status = napi_has_own_property(_env, _value, key, &result); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool); +} + +inline MaybeOrValue Object::HasOwnProperty(Value key) const { + bool result; + napi_status status = napi_has_own_property(_env, _value, key, &result); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool); +} + +inline MaybeOrValue Object::HasOwnProperty(const char* utf8name) const { + napi_value key; + napi_status status = + napi_create_string_utf8(_env, utf8name, std::strlen(utf8name), &key); + NAPI_MAYBE_THROW_IF_FAILED(_env, status, bool); + return HasOwnProperty(key); +} + +inline MaybeOrValue Object::HasOwnProperty( + const std::string& utf8name) const { + return HasOwnProperty(utf8name.c_str()); +} + +inline MaybeOrValue Object::Get(napi_value key) const { + napi_value result; + napi_status status = napi_get_property(_env, _value, key, &result); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, Value(_env, result), Value); +} + +inline MaybeOrValue Object::Get(Value key) const { + napi_value result; + napi_status status = napi_get_property(_env, _value, key, &result); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, Value(_env, result), Value); +} + +inline MaybeOrValue Object::Get(const char* utf8name) const { + napi_value result; + napi_status status = napi_get_named_property(_env, _value, utf8name, &result); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, Value(_env, result), Value); +} + +inline MaybeOrValue Object::Get(const std::string& utf8name) const { + return Get(utf8name.c_str()); +} + +template +inline MaybeOrValue Object::Set(napi_value key, + const ValueType& value) const { + napi_status status = + napi_set_property(_env, _value, key, Value::From(_env, value)); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool); +} + +template +inline MaybeOrValue Object::Set(Value key, const ValueType& value) const { + napi_status status = + napi_set_property(_env, _value, key, Value::From(_env, value)); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool); +} + +template +inline MaybeOrValue Object::Set(const char* utf8name, + const ValueType& value) const { + napi_status status = + napi_set_named_property(_env, _value, utf8name, Value::From(_env, value)); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool); +} + +template +inline MaybeOrValue Object::Set(const std::string& utf8name, + const ValueType& value) const { + return Set(utf8name.c_str(), value); +} + +inline MaybeOrValue Object::Delete(napi_value key) const { + bool result; + napi_status status = napi_delete_property(_env, _value, key, &result); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool); +} + +inline MaybeOrValue Object::Delete(Value key) const { + bool result; + napi_status status = napi_delete_property(_env, _value, key, &result); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool); +} + +inline MaybeOrValue Object::Delete(const char* utf8name) const { + return Delete(String::New(_env, utf8name)); +} + +inline MaybeOrValue Object::Delete(const std::string& utf8name) const { + return Delete(String::New(_env, utf8name)); +} + +inline MaybeOrValue Object::Has(uint32_t index) const { + bool result; + napi_status status = napi_has_element(_env, _value, index, &result); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool); +} + +inline MaybeOrValue Object::Get(uint32_t index) const { + napi_value value; + napi_status status = napi_get_element(_env, _value, index, &value); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, Value(_env, value), Value); +} + +template +inline MaybeOrValue Object::Set(uint32_t index, + const ValueType& value) const { + napi_status status = + napi_set_element(_env, _value, index, Value::From(_env, value)); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool); +} + +inline MaybeOrValue Object::Delete(uint32_t index) const { + bool result; + napi_status status = napi_delete_element(_env, _value, index, &result); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool); +} + +inline MaybeOrValue Object::GetPropertyNames() const { + napi_value result; + napi_status status = napi_get_property_names(_env, _value, &result); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, Array(_env, result), Array); +} + +inline MaybeOrValue Object::DefineProperty( + const PropertyDescriptor& property) const { + napi_status status = napi_define_properties( + _env, + _value, + 1, + reinterpret_cast(&property)); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool); +} + +inline MaybeOrValue Object::DefineProperties( + const std::initializer_list& properties) const { + napi_status status = napi_define_properties( + _env, + _value, + properties.size(), + reinterpret_cast(properties.begin())); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool); +} + +inline MaybeOrValue Object::DefineProperties( + const std::vector& properties) const { + napi_status status = napi_define_properties( + _env, + _value, + properties.size(), + reinterpret_cast(properties.data())); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool); +} + +inline MaybeOrValue Object::InstanceOf( + const Function& constructor) const { + bool result; + napi_status status = napi_instanceof(_env, _value, constructor, &result); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool); +} + +template +inline void Object::AddFinalizer(Finalizer finalizeCallback, T* data) const { + details::FinalizeData* finalizeData = + new details::FinalizeData( + {std::move(finalizeCallback), nullptr}); + napi_status status = + details::AttachData::Wrapper>( + _env, *this, data, finalizeData); + if (status != napi_ok) { + delete finalizeData; + NAPI_THROW_IF_FAILED_VOID(_env, status); + } +} + +template +inline void Object::AddFinalizer(Finalizer finalizeCallback, + T* data, + Hint* finalizeHint) const { + details::FinalizeData* finalizeData = + new details::FinalizeData( + {std::move(finalizeCallback), finalizeHint}); + napi_status status = details:: + AttachData::WrapperWithHint>( + _env, *this, data, finalizeData); + if (status != napi_ok) { + delete finalizeData; + NAPI_THROW_IF_FAILED_VOID(_env, status); + } +} + +#ifdef NAPI_CPP_EXCEPTIONS +inline Object::const_iterator::const_iterator(const Object* object, + const Type type) { + _object = object; + _keys = object->GetPropertyNames(); + _index = type == Type::BEGIN ? 0 : _keys.Length(); +} + +inline Object::const_iterator Napi::Object::begin() const { + const_iterator it(this, Object::const_iterator::Type::BEGIN); + return it; +} + +inline Object::const_iterator Napi::Object::end() const { + const_iterator it(this, Object::const_iterator::Type::END); + return it; +} + +inline Object::const_iterator& Object::const_iterator::operator++() { + ++_index; + return *this; +} + +inline bool Object::const_iterator::operator==( + const const_iterator& other) const { + return _index == other._index; +} + +inline bool Object::const_iterator::operator!=( + const const_iterator& other) const { + return _index != other._index; +} + +inline const std::pair> +Object::const_iterator::operator*() const { + const Value key = _keys[_index]; + const PropertyLValue value = (*_object)[key]; + return {key, value}; +} + +inline Object::iterator::iterator(Object* object, const Type type) { + _object = object; + _keys = object->GetPropertyNames(); + _index = type == Type::BEGIN ? 0 : _keys.Length(); +} + +inline Object::iterator Napi::Object::begin() { + iterator it(this, Object::iterator::Type::BEGIN); + return it; +} + +inline Object::iterator Napi::Object::end() { + iterator it(this, Object::iterator::Type::END); + return it; +} + +inline Object::iterator& Object::iterator::operator++() { + ++_index; + return *this; +} + +inline bool Object::iterator::operator==(const iterator& other) const { + return _index == other._index; +} + +inline bool Object::iterator::operator!=(const iterator& other) const { + return _index != other._index; +} + +inline std::pair> +Object::iterator::operator*() { + Value key = _keys[_index]; + PropertyLValue value = (*_object)[key]; + return {key, value}; +} +#endif // NAPI_CPP_EXCEPTIONS + +#if NAPI_VERSION >= 8 +inline MaybeOrValue Object::Freeze() const { + napi_status status = napi_object_freeze(_env, _value); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool); +} + +inline MaybeOrValue Object::Seal() const { + napi_status status = napi_object_seal(_env, _value); + NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool); +} +#endif // NAPI_VERSION >= 8 + +//////////////////////////////////////////////////////////////////////////////// +// External class +//////////////////////////////////////////////////////////////////////////////// + +template +inline External External::New(napi_env env, T* data) { + napi_value value; + napi_status status = + napi_create_external(env, data, nullptr, nullptr, &value); + NAPI_THROW_IF_FAILED(env, status, External()); + return External(env, value); +} + +template +template +inline External External::New(napi_env env, + T* data, + Finalizer finalizeCallback) { + napi_value value; + details::FinalizeData* finalizeData = + new details::FinalizeData( + {std::move(finalizeCallback), nullptr}); + napi_status status = + napi_create_external(env, + data, + details::FinalizeData::Wrapper, + finalizeData, + &value); + if (status != napi_ok) { + delete finalizeData; + NAPI_THROW_IF_FAILED(env, status, External()); + } + return External(env, value); +} + +template +template +inline External External::New(napi_env env, + T* data, + Finalizer finalizeCallback, + Hint* finalizeHint) { + napi_value value; + details::FinalizeData* finalizeData = + new details::FinalizeData( + {std::move(finalizeCallback), finalizeHint}); + napi_status status = napi_create_external( + env, + data, + details::FinalizeData::WrapperWithHint, + finalizeData, + &value); + if (status != napi_ok) { + delete finalizeData; + NAPI_THROW_IF_FAILED(env, status, External()); + } + return External(env, value); +} + +template +inline void External::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "External::CheckCast", "empty value"); + + napi_valuetype type; + napi_status status = napi_typeof(env, value, &type); + NAPI_CHECK(status == napi_ok, "External::CheckCast", "napi_typeof failed"); + NAPI_CHECK(type == napi_external, + "External::CheckCast", + "value is not napi_external"); +} + +template +inline External::External() : TypeTaggable() {} + +template +inline External::External(napi_env env, napi_value value) + : TypeTaggable(env, value) {} + +template +inline T* External::Data() const { + void* data; + napi_status status = napi_get_value_external(_env, _value, &data); + NAPI_THROW_IF_FAILED(_env, status, nullptr); + return reinterpret_cast(data); +} + +//////////////////////////////////////////////////////////////////////////////// +// Array class +//////////////////////////////////////////////////////////////////////////////// + +inline Array Array::New(napi_env env) { + napi_value value; + napi_status status = napi_create_array(env, &value); + NAPI_THROW_IF_FAILED(env, status, Array()); + return Array(env, value); +} + +inline Array Array::New(napi_env env, size_t length) { + napi_value value; + napi_status status = napi_create_array_with_length(env, length, &value); + NAPI_THROW_IF_FAILED(env, status, Array()); + return Array(env, value); +} + +inline void Array::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "Array::CheckCast", "empty value"); + + bool result; + napi_status status = napi_is_array(env, value, &result); + NAPI_CHECK(status == napi_ok, "Array::CheckCast", "napi_is_array failed"); + NAPI_CHECK(result, "Array::CheckCast", "value is not array"); +} + +inline Array::Array() : Object() {} + +inline Array::Array(napi_env env, napi_value value) : Object(env, value) {} + +inline uint32_t Array::Length() const { + uint32_t result; + napi_status status = napi_get_array_length(_env, _value, &result); + NAPI_THROW_IF_FAILED(_env, status, 0); + return result; +} + +//////////////////////////////////////////////////////////////////////////////// +// ArrayBuffer class +//////////////////////////////////////////////////////////////////////////////// + +inline ArrayBuffer ArrayBuffer::New(napi_env env, size_t byteLength) { + napi_value value; + void* data; + napi_status status = napi_create_arraybuffer(env, byteLength, &data, &value); + NAPI_THROW_IF_FAILED(env, status, ArrayBuffer()); + + return ArrayBuffer(env, value); +} + +#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED +inline ArrayBuffer ArrayBuffer::New(napi_env env, + void* externalData, + size_t byteLength) { + napi_value value; + napi_status status = napi_create_external_arraybuffer( + env, externalData, byteLength, nullptr, nullptr, &value); + NAPI_THROW_IF_FAILED(env, status, ArrayBuffer()); + + return ArrayBuffer(env, value); +} + +template +inline ArrayBuffer ArrayBuffer::New(napi_env env, + void* externalData, + size_t byteLength, + Finalizer finalizeCallback) { + napi_value value; + details::FinalizeData* finalizeData = + new details::FinalizeData( + {std::move(finalizeCallback), nullptr}); + napi_status status = napi_create_external_arraybuffer( + env, + externalData, + byteLength, + details::FinalizeData::Wrapper, + finalizeData, + &value); + if (status != napi_ok) { + delete finalizeData; + NAPI_THROW_IF_FAILED(env, status, ArrayBuffer()); + } + + return ArrayBuffer(env, value); +} + +template +inline ArrayBuffer ArrayBuffer::New(napi_env env, + void* externalData, + size_t byteLength, + Finalizer finalizeCallback, + Hint* finalizeHint) { + napi_value value; + details::FinalizeData* finalizeData = + new details::FinalizeData( + {std::move(finalizeCallback), finalizeHint}); + napi_status status = napi_create_external_arraybuffer( + env, + externalData, + byteLength, + details::FinalizeData::WrapperWithHint, + finalizeData, + &value); + if (status != napi_ok) { + delete finalizeData; + NAPI_THROW_IF_FAILED(env, status, ArrayBuffer()); + } + + return ArrayBuffer(env, value); +} +#endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED + +inline void ArrayBuffer::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "ArrayBuffer::CheckCast", "empty value"); + + bool result; + napi_status status = napi_is_arraybuffer(env, value, &result); + NAPI_CHECK(status == napi_ok, + "ArrayBuffer::CheckCast", + "napi_is_arraybuffer failed"); + NAPI_CHECK(result, "ArrayBuffer::CheckCast", "value is not arraybuffer"); +} + +inline ArrayBuffer::ArrayBuffer() : Object() {} + +inline ArrayBuffer::ArrayBuffer(napi_env env, napi_value value) + : Object(env, value) {} + +inline void* ArrayBuffer::Data() { + void* data; + napi_status status = napi_get_arraybuffer_info(_env, _value, &data, nullptr); + NAPI_THROW_IF_FAILED(_env, status, nullptr); + return data; +} + +inline size_t ArrayBuffer::ByteLength() { + size_t length; + napi_status status = + napi_get_arraybuffer_info(_env, _value, nullptr, &length); + NAPI_THROW_IF_FAILED(_env, status, 0); + return length; +} + +#if NAPI_VERSION >= 7 +inline bool ArrayBuffer::IsDetached() const { + bool detached; + napi_status status = napi_is_detached_arraybuffer(_env, _value, &detached); + NAPI_THROW_IF_FAILED(_env, status, false); + return detached; +} + +inline void ArrayBuffer::Detach() { + napi_status status = napi_detach_arraybuffer(_env, _value); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} +#endif // NAPI_VERSION >= 7 + +//////////////////////////////////////////////////////////////////////////////// +// DataView class +//////////////////////////////////////////////////////////////////////////////// +inline DataView DataView::New(napi_env env, Napi::ArrayBuffer arrayBuffer) { + return New(env, arrayBuffer, 0, arrayBuffer.ByteLength()); +} + +inline DataView DataView::New(napi_env env, + Napi::ArrayBuffer arrayBuffer, + size_t byteOffset) { + if (byteOffset > arrayBuffer.ByteLength()) { + NAPI_THROW(RangeError::New( + env, "Start offset is outside the bounds of the buffer"), + DataView()); + } + return New( + env, arrayBuffer, byteOffset, arrayBuffer.ByteLength() - byteOffset); +} + +inline DataView DataView::New(napi_env env, + Napi::ArrayBuffer arrayBuffer, + size_t byteOffset, + size_t byteLength) { + if (byteOffset + byteLength > arrayBuffer.ByteLength()) { + NAPI_THROW(RangeError::New(env, "Invalid DataView length"), DataView()); + } + napi_value value; + napi_status status = + napi_create_dataview(env, byteLength, arrayBuffer, byteOffset, &value); + NAPI_THROW_IF_FAILED(env, status, DataView()); + return DataView(env, value); +} + +inline void DataView::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "DataView::CheckCast", "empty value"); + + bool result; + napi_status status = napi_is_dataview(env, value, &result); + NAPI_CHECK( + status == napi_ok, "DataView::CheckCast", "napi_is_dataview failed"); + NAPI_CHECK(result, "DataView::CheckCast", "value is not dataview"); +} + +inline DataView::DataView() : Object() {} + +inline DataView::DataView(napi_env env, napi_value value) : Object(env, value) { + napi_status status = napi_get_dataview_info(_env, + _value /* dataView */, + &_length /* byteLength */, + &_data /* data */, + nullptr /* arrayBuffer */, + nullptr /* byteOffset */); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +inline Napi::ArrayBuffer DataView::ArrayBuffer() const { + napi_value arrayBuffer; + napi_status status = napi_get_dataview_info(_env, + _value /* dataView */, + nullptr /* byteLength */, + nullptr /* data */, + &arrayBuffer /* arrayBuffer */, + nullptr /* byteOffset */); + NAPI_THROW_IF_FAILED(_env, status, Napi::ArrayBuffer()); + return Napi::ArrayBuffer(_env, arrayBuffer); +} + +inline size_t DataView::ByteOffset() const { + size_t byteOffset; + napi_status status = napi_get_dataview_info(_env, + _value /* dataView */, + nullptr /* byteLength */, + nullptr /* data */, + nullptr /* arrayBuffer */, + &byteOffset /* byteOffset */); + NAPI_THROW_IF_FAILED(_env, status, 0); + return byteOffset; +} + +inline size_t DataView::ByteLength() const { + return _length; +} + +inline void* DataView::Data() const { + return _data; +} + +inline float DataView::GetFloat32(size_t byteOffset) const { + return ReadData(byteOffset); +} + +inline double DataView::GetFloat64(size_t byteOffset) const { + return ReadData(byteOffset); +} + +inline int8_t DataView::GetInt8(size_t byteOffset) const { + return ReadData(byteOffset); +} + +inline int16_t DataView::GetInt16(size_t byteOffset) const { + return ReadData(byteOffset); +} + +inline int32_t DataView::GetInt32(size_t byteOffset) const { + return ReadData(byteOffset); +} + +inline uint8_t DataView::GetUint8(size_t byteOffset) const { + return ReadData(byteOffset); +} + +inline uint16_t DataView::GetUint16(size_t byteOffset) const { + return ReadData(byteOffset); +} + +inline uint32_t DataView::GetUint32(size_t byteOffset) const { + return ReadData(byteOffset); +} + +inline void DataView::SetFloat32(size_t byteOffset, float value) const { + WriteData(byteOffset, value); +} + +inline void DataView::SetFloat64(size_t byteOffset, double value) const { + WriteData(byteOffset, value); +} + +inline void DataView::SetInt8(size_t byteOffset, int8_t value) const { + WriteData(byteOffset, value); +} + +inline void DataView::SetInt16(size_t byteOffset, int16_t value) const { + WriteData(byteOffset, value); +} + +inline void DataView::SetInt32(size_t byteOffset, int32_t value) const { + WriteData(byteOffset, value); +} + +inline void DataView::SetUint8(size_t byteOffset, uint8_t value) const { + WriteData(byteOffset, value); +} + +inline void DataView::SetUint16(size_t byteOffset, uint16_t value) const { + WriteData(byteOffset, value); +} + +inline void DataView::SetUint32(size_t byteOffset, uint32_t value) const { + WriteData(byteOffset, value); +} + +template +inline T DataView::ReadData(size_t byteOffset) const { + if (byteOffset + sizeof(T) > _length || + byteOffset + sizeof(T) < byteOffset) { // overflow + NAPI_THROW( + RangeError::New(_env, "Offset is outside the bounds of the DataView"), + 0); + } + + return *reinterpret_cast(static_cast(_data) + byteOffset); +} + +template +inline void DataView::WriteData(size_t byteOffset, T value) const { + if (byteOffset + sizeof(T) > _length || + byteOffset + sizeof(T) < byteOffset) { // overflow + NAPI_THROW_VOID( + RangeError::New(_env, "Offset is outside the bounds of the DataView")); + } + + *reinterpret_cast(static_cast(_data) + byteOffset) = value; +} + +//////////////////////////////////////////////////////////////////////////////// +// TypedArray class +//////////////////////////////////////////////////////////////////////////////// +inline void TypedArray::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "TypedArray::CheckCast", "empty value"); + + bool result; + napi_status status = napi_is_typedarray(env, value, &result); + NAPI_CHECK( + status == napi_ok, "TypedArray::CheckCast", "napi_is_typedarray failed"); + NAPI_CHECK(result, "TypedArray::CheckCast", "value is not typedarray"); +} + +inline TypedArray::TypedArray() + : Object(), _type(napi_typedarray_type::napi_int8_array), _length(0) {} + +inline TypedArray::TypedArray(napi_env env, napi_value value) + : Object(env, value), + _type(napi_typedarray_type::napi_int8_array), + _length(0) { + if (value != nullptr) { + napi_status status = + napi_get_typedarray_info(_env, + _value, + &const_cast(this)->_type, + &const_cast(this)->_length, + nullptr, + nullptr, + nullptr); + NAPI_THROW_IF_FAILED_VOID(_env, status); + } +} + +inline TypedArray::TypedArray(napi_env env, + napi_value value, + napi_typedarray_type type, + size_t length) + : Object(env, value), _type(type), _length(length) {} + +inline napi_typedarray_type TypedArray::TypedArrayType() const { + return _type; +} + +inline uint8_t TypedArray::ElementSize() const { + switch (_type) { + case napi_int8_array: + case napi_uint8_array: + case napi_uint8_clamped_array: + return 1; + case napi_int16_array: + case napi_uint16_array: + return 2; + case napi_int32_array: + case napi_uint32_array: + case napi_float32_array: + return 4; + case napi_float64_array: +#if (NAPI_VERSION > 5) + case napi_bigint64_array: + case napi_biguint64_array: +#endif // (NAPI_VERSION > 5) + return 8; + default: + return 0; + } +} + +inline size_t TypedArray::ElementLength() const { + return _length; +} + +inline size_t TypedArray::ByteOffset() const { + size_t byteOffset; + napi_status status = napi_get_typedarray_info( + _env, _value, nullptr, nullptr, nullptr, nullptr, &byteOffset); + NAPI_THROW_IF_FAILED(_env, status, 0); + return byteOffset; +} + +inline size_t TypedArray::ByteLength() const { + return ElementSize() * ElementLength(); +} + +inline Napi::ArrayBuffer TypedArray::ArrayBuffer() const { + napi_value arrayBuffer; + napi_status status = napi_get_typedarray_info( + _env, _value, nullptr, nullptr, nullptr, &arrayBuffer, nullptr); + NAPI_THROW_IF_FAILED(_env, status, Napi::ArrayBuffer()); + return Napi::ArrayBuffer(_env, arrayBuffer); +} + +//////////////////////////////////////////////////////////////////////////////// +// TypedArrayOf class +//////////////////////////////////////////////////////////////////////////////// +template +inline void TypedArrayOf::CheckCast(napi_env env, napi_value value) { + TypedArray::CheckCast(env, value); + napi_typedarray_type type; + napi_status status = napi_get_typedarray_info( + env, value, &type, nullptr, nullptr, nullptr, nullptr); + NAPI_CHECK(status == napi_ok, + "TypedArrayOf::CheckCast", + "napi_is_typedarray failed"); + + NAPI_CHECK( + (type == TypedArrayTypeForPrimitiveType() || + (type == napi_uint8_clamped_array && std::is_same::value)), + "TypedArrayOf::CheckCast", + "Array type must match the template parameter. (Uint8 arrays may " + "optionally have the \"clamped\" array type.)"); +} + +template +inline TypedArrayOf TypedArrayOf::New(napi_env env, + size_t elementLength, + napi_typedarray_type type) { + Napi::ArrayBuffer arrayBuffer = + Napi::ArrayBuffer::New(env, elementLength * sizeof(T)); + return New(env, elementLength, arrayBuffer, 0, type); +} + +template +inline TypedArrayOf TypedArrayOf::New(napi_env env, + size_t elementLength, + Napi::ArrayBuffer arrayBuffer, + size_t bufferOffset, + napi_typedarray_type type) { + napi_value value; + napi_status status = napi_create_typedarray( + env, type, elementLength, arrayBuffer, bufferOffset, &value); + NAPI_THROW_IF_FAILED(env, status, TypedArrayOf()); + + return TypedArrayOf( + env, + value, + type, + elementLength, + reinterpret_cast(reinterpret_cast(arrayBuffer.Data()) + + bufferOffset)); +} + +template +inline TypedArrayOf::TypedArrayOf() : TypedArray(), _data(nullptr) {} + +template +inline TypedArrayOf::TypedArrayOf(napi_env env, napi_value value) + : TypedArray(env, value), _data(nullptr) { + napi_status status = napi_ok; + if (value != nullptr) { + void* data = nullptr; + status = napi_get_typedarray_info( + _env, _value, &_type, &_length, &data, nullptr, nullptr); + _data = static_cast(data); + } else { + _type = TypedArrayTypeForPrimitiveType(); + _length = 0; + } + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +template +inline TypedArrayOf::TypedArrayOf(napi_env env, + napi_value value, + napi_typedarray_type type, + size_t length, + T* data) + : TypedArray(env, value, type, length), _data(data) { + if (!(type == TypedArrayTypeForPrimitiveType() || + (type == napi_uint8_clamped_array && + std::is_same::value))) { + NAPI_THROW_VOID(TypeError::New( + env, + "Array type must match the template parameter. " + "(Uint8 arrays may optionally have the \"clamped\" array type.)")); + } +} + +template +inline T& TypedArrayOf::operator[](size_t index) { + return _data[index]; +} + +template +inline const T& TypedArrayOf::operator[](size_t index) const { + return _data[index]; +} + +template +inline T* TypedArrayOf::Data() { + return _data; +} + +template +inline const T* TypedArrayOf::Data() const { + return _data; +} + +//////////////////////////////////////////////////////////////////////////////// +// Function class +//////////////////////////////////////////////////////////////////////////////// + +template +inline napi_status CreateFunction(napi_env env, + const char* utf8name, + napi_callback cb, + CbData* data, + napi_value* result) { + napi_status status = + napi_create_function(env, utf8name, NAPI_AUTO_LENGTH, cb, data, result); + if (status == napi_ok) { + status = Napi::details::AttachData(env, *result, data); + } + + return status; +} + +template +inline Function Function::New(napi_env env, const char* utf8name, void* data) { + napi_value result = nullptr; + napi_status status = napi_create_function(env, + utf8name, + NAPI_AUTO_LENGTH, + details::TemplatedVoidCallback, + data, + &result); + NAPI_THROW_IF_FAILED(env, status, Function()); + return Function(env, result); +} + +template +inline Function Function::New(napi_env env, const char* utf8name, void* data) { + napi_value result = nullptr; + napi_status status = napi_create_function(env, + utf8name, + NAPI_AUTO_LENGTH, + details::TemplatedCallback, + data, + &result); + NAPI_THROW_IF_FAILED(env, status, Function()); + return Function(env, result); +} + +template +inline Function Function::New(napi_env env, + const std::string& utf8name, + void* data) { + return Function::New(env, utf8name.c_str(), data); +} + +template +inline Function Function::New(napi_env env, + const std::string& utf8name, + void* data) { + return Function::New(env, utf8name.c_str(), data); +} + +template +inline Function Function::New(napi_env env, + Callable cb, + const char* utf8name, + void* data) { + using ReturnType = decltype(cb(CallbackInfo(nullptr, nullptr))); + using CbData = details::CallbackData; + auto callbackData = new CbData{std::move(cb), data}; + + napi_value value; + napi_status status = + CreateFunction(env, utf8name, CbData::Wrapper, callbackData, &value); + if (status != napi_ok) { + delete callbackData; + NAPI_THROW_IF_FAILED(env, status, Function()); + } + + return Function(env, value); +} + +template +inline Function Function::New(napi_env env, + Callable cb, + const std::string& utf8name, + void* data) { + return New(env, cb, utf8name.c_str(), data); +} + +inline void Function::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "Function::CheckCast", "empty value"); + + napi_valuetype type; + napi_status status = napi_typeof(env, value, &type); + NAPI_CHECK(status == napi_ok, "Function::CheckCast", "napi_typeof failed"); + NAPI_CHECK(type == napi_function, + "Function::CheckCast", + "value is not napi_function"); +} + +inline Function::Function() : Object() {} + +inline Function::Function(napi_env env, napi_value value) + : Object(env, value) {} + +inline MaybeOrValue Function::operator()( + const std::initializer_list& args) const { + return Call(Env().Undefined(), args); +} + +inline MaybeOrValue Function::Call( + const std::initializer_list& args) const { + return Call(Env().Undefined(), args); +} + +inline MaybeOrValue Function::Call( + const std::vector& args) const { + return Call(Env().Undefined(), args); +} + +inline MaybeOrValue Function::Call( + const std::vector& args) const { + return Call(Env().Undefined(), args); +} + +inline MaybeOrValue Function::Call(size_t argc, + const napi_value* args) const { + return Call(Env().Undefined(), argc, args); +} + +inline MaybeOrValue Function::Call( + napi_value recv, const std::initializer_list& args) const { + return Call(recv, args.size(), args.begin()); +} + +inline MaybeOrValue Function::Call( + napi_value recv, const std::vector& args) const { + return Call(recv, args.size(), args.data()); +} + +inline MaybeOrValue Function::Call( + napi_value recv, const std::vector& args) const { + const size_t argc = args.size(); + const size_t stackArgsCount = 6; + napi_value stackArgs[stackArgsCount]; + std::vector heapArgs; + napi_value* argv; + if (argc <= stackArgsCount) { + argv = stackArgs; + } else { + heapArgs.resize(argc); + argv = heapArgs.data(); + } + + for (size_t index = 0; index < argc; index++) { + argv[index] = static_cast(args[index]); + } + + return Call(recv, argc, argv); +} + +inline MaybeOrValue Function::Call(napi_value recv, + size_t argc, + const napi_value* args) const { + napi_value result; + napi_status status = + napi_call_function(_env, recv, _value, argc, args, &result); + NAPI_RETURN_OR_THROW_IF_FAILED( + _env, status, Napi::Value(_env, result), Napi::Value); +} + +inline MaybeOrValue Function::MakeCallback( + napi_value recv, + const std::initializer_list& args, + napi_async_context context) const { + return MakeCallback(recv, args.size(), args.begin(), context); +} + +inline MaybeOrValue Function::MakeCallback( + napi_value recv, + const std::vector& args, + napi_async_context context) const { + return MakeCallback(recv, args.size(), args.data(), context); +} + +inline MaybeOrValue Function::MakeCallback( + napi_value recv, + size_t argc, + const napi_value* args, + napi_async_context context) const { + napi_value result; + napi_status status = + napi_make_callback(_env, context, recv, _value, argc, args, &result); + NAPI_RETURN_OR_THROW_IF_FAILED( + _env, status, Napi::Value(_env, result), Napi::Value); +} + +inline MaybeOrValue Function::New( + const std::initializer_list& args) const { + return New(args.size(), args.begin()); +} + +inline MaybeOrValue Function::New( + const std::vector& args) const { + return New(args.size(), args.data()); +} + +inline MaybeOrValue Function::New(size_t argc, + const napi_value* args) const { + napi_value result; + napi_status status = napi_new_instance(_env, _value, argc, args, &result); + NAPI_RETURN_OR_THROW_IF_FAILED( + _env, status, Napi::Object(_env, result), Napi::Object); +} + +//////////////////////////////////////////////////////////////////////////////// +// Promise class +//////////////////////////////////////////////////////////////////////////////// + +inline Promise::Deferred Promise::Deferred::New(napi_env env) { + return Promise::Deferred(env); +} + +inline Promise::Deferred::Deferred(napi_env env) : _env(env) { + napi_status status = napi_create_promise(_env, &_deferred, &_promise); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +inline Promise Promise::Deferred::Promise() const { + return Napi::Promise(_env, _promise); +} + +inline Napi::Env Promise::Deferred::Env() const { + return Napi::Env(_env); +} + +inline void Promise::Deferred::Resolve(napi_value value) const { + napi_status status = napi_resolve_deferred(_env, _deferred, value); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +inline void Promise::Deferred::Reject(napi_value value) const { + napi_status status = napi_reject_deferred(_env, _deferred, value); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +inline void Promise::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "Promise::CheckCast", "empty value"); + + bool result; + napi_status status = napi_is_promise(env, value, &result); + NAPI_CHECK(status == napi_ok, "Promise::CheckCast", "napi_is_promise failed"); + NAPI_CHECK(result, "Promise::CheckCast", "value is not promise"); +} + +inline Promise::Promise(napi_env env, napi_value value) : Object(env, value) {} + +//////////////////////////////////////////////////////////////////////////////// +// Buffer class +//////////////////////////////////////////////////////////////////////////////// + +template +inline Buffer Buffer::New(napi_env env, size_t length) { + napi_value value; + void* data; + napi_status status = + napi_create_buffer(env, length * sizeof(T), &data, &value); + NAPI_THROW_IF_FAILED(env, status, Buffer()); + return Buffer(env, value); +} + +#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED +template +inline Buffer Buffer::New(napi_env env, T* data, size_t length) { + napi_value value; + napi_status status = napi_create_external_buffer( + env, length * sizeof(T), data, nullptr, nullptr, &value); + NAPI_THROW_IF_FAILED(env, status, Buffer()); + return Buffer(env, value); +} + +template +template +inline Buffer Buffer::New(napi_env env, + T* data, + size_t length, + Finalizer finalizeCallback) { + napi_value value; + details::FinalizeData* finalizeData = + new details::FinalizeData( + {std::move(finalizeCallback), nullptr}); + napi_status status = + napi_create_external_buffer(env, + length * sizeof(T), + data, + details::FinalizeData::Wrapper, + finalizeData, + &value); + if (status != napi_ok) { + delete finalizeData; + NAPI_THROW_IF_FAILED(env, status, Buffer()); + } + return Buffer(env, value); +} + +template +template +inline Buffer Buffer::New(napi_env env, + T* data, + size_t length, + Finalizer finalizeCallback, + Hint* finalizeHint) { + napi_value value; + details::FinalizeData* finalizeData = + new details::FinalizeData( + {std::move(finalizeCallback), finalizeHint}); + napi_status status = napi_create_external_buffer( + env, + length * sizeof(T), + data, + details::FinalizeData::WrapperWithHint, + finalizeData, + &value); + if (status != napi_ok) { + delete finalizeData; + NAPI_THROW_IF_FAILED(env, status, Buffer()); + } + return Buffer(env, value); +} +#endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED + +template +inline Buffer Buffer::NewOrCopy(napi_env env, T* data, size_t length) { +#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED + napi_value value; + napi_status status = napi_create_external_buffer( + env, length * sizeof(T), data, nullptr, nullptr, &value); + if (status == details::napi_no_external_buffers_allowed) { +#endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED + // If we can't create an external buffer, we'll just copy the data. + return Buffer::Copy(env, data, length); +#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED + } + NAPI_THROW_IF_FAILED(env, status, Buffer()); + return Buffer(env, value); +#endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED +} + +template +template +inline Buffer Buffer::NewOrCopy(napi_env env, + T* data, + size_t length, + Finalizer finalizeCallback) { + details::FinalizeData* finalizeData = + new details::FinalizeData( + {std::move(finalizeCallback), nullptr}); +#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED + napi_value value; + napi_status status = + napi_create_external_buffer(env, + length * sizeof(T), + data, + details::FinalizeData::Wrapper, + finalizeData, + &value); + if (status == details::napi_no_external_buffers_allowed) { +#endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED + // If we can't create an external buffer, we'll just copy the data. + Buffer ret = Buffer::Copy(env, data, length); + details::FinalizeData::Wrapper(env, data, finalizeData); + return ret; +#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED + } + if (status != napi_ok) { + delete finalizeData; + NAPI_THROW_IF_FAILED(env, status, Buffer()); + } + return Buffer(env, value); +#endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED +} + +template +template +inline Buffer Buffer::NewOrCopy(napi_env env, + T* data, + size_t length, + Finalizer finalizeCallback, + Hint* finalizeHint) { + details::FinalizeData* finalizeData = + new details::FinalizeData( + {std::move(finalizeCallback), finalizeHint}); +#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED + napi_value value; + napi_status status = napi_create_external_buffer( + env, + length * sizeof(T), + data, + details::FinalizeData::WrapperWithHint, + finalizeData, + &value); + if (status == details::napi_no_external_buffers_allowed) { +#endif + // If we can't create an external buffer, we'll just copy the data. + Buffer ret = Buffer::Copy(env, data, length); + details::FinalizeData::WrapperWithHint( + env, data, finalizeData); + return ret; +#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED + } + if (status != napi_ok) { + delete finalizeData; + NAPI_THROW_IF_FAILED(env, status, Buffer()); + } + return Buffer(env, value); +#endif +} + +template +inline Buffer Buffer::Copy(napi_env env, const T* data, size_t length) { + napi_value value; + napi_status status = + napi_create_buffer_copy(env, length * sizeof(T), data, nullptr, &value); + NAPI_THROW_IF_FAILED(env, status, Buffer()); + return Buffer(env, value); +} + +template +inline void Buffer::CheckCast(napi_env env, napi_value value) { + NAPI_CHECK(value != nullptr, "Buffer::CheckCast", "empty value"); + + bool result; + napi_status status = napi_is_buffer(env, value, &result); + NAPI_CHECK(status == napi_ok, "Buffer::CheckCast", "napi_is_buffer failed"); + NAPI_CHECK(result, "Buffer::CheckCast", "value is not buffer"); +} + +template +inline Buffer::Buffer() : Uint8Array() {} + +template +inline Buffer::Buffer(napi_env env, napi_value value) + : Uint8Array(env, value) {} + +template +inline size_t Buffer::Length() const { + return ByteLength() / sizeof(T); +} + +template +inline T* Buffer::Data() const { + return reinterpret_cast(const_cast(Uint8Array::Data())); +} + +//////////////////////////////////////////////////////////////////////////////// +// Error class +//////////////////////////////////////////////////////////////////////////////// + +inline Error Error::New(napi_env env) { + napi_status status; + napi_value error = nullptr; + bool is_exception_pending; + napi_extended_error_info last_error_info_copy; + + { + // We must retrieve the last error info before doing anything else because + // doing anything else will replace the last error info. + const napi_extended_error_info* last_error_info; + status = napi_get_last_error_info(env, &last_error_info); + NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_get_last_error_info"); + + // All fields of the `napi_extended_error_info` structure gets reset in + // subsequent Node-API function calls on the same `env`. This includes a + // call to `napi_is_exception_pending()`. So here it is necessary to make a + // copy of the information as the `error_code` field is used later on. + memcpy(&last_error_info_copy, + last_error_info, + sizeof(napi_extended_error_info)); + } + + status = napi_is_exception_pending(env, &is_exception_pending); + NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_is_exception_pending"); + + // A pending exception takes precedence over any internal error status. + if (is_exception_pending) { + status = napi_get_and_clear_last_exception(env, &error); + NAPI_FATAL_IF_FAILED( + status, "Error::New", "napi_get_and_clear_last_exception"); + } else { + const char* error_message = last_error_info_copy.error_message != nullptr + ? last_error_info_copy.error_message + : "Error in native callback"; + + napi_value message; + status = napi_create_string_utf8( + env, error_message, std::strlen(error_message), &message); + NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_create_string_utf8"); + + switch (last_error_info_copy.error_code) { + case napi_object_expected: + case napi_string_expected: + case napi_boolean_expected: + case napi_number_expected: + status = napi_create_type_error(env, nullptr, message, &error); + break; + default: + status = napi_create_error(env, nullptr, message, &error); + break; + } + NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_create_error"); + } + + return Error(env, error); +} + +inline Error Error::New(napi_env env, const char* message) { + return Error::New( + env, message, std::strlen(message), napi_create_error); +} + +inline Error Error::New(napi_env env, const std::string& message) { + return Error::New( + env, message.c_str(), message.size(), napi_create_error); +} + +inline NAPI_NO_RETURN void Error::Fatal(const char* location, + const char* message) { + napi_fatal_error(location, NAPI_AUTO_LENGTH, message, NAPI_AUTO_LENGTH); +} + +inline Error::Error() : ObjectReference() {} + +inline Error::Error(napi_env env, napi_value value) + : ObjectReference(env, nullptr) { + if (value != nullptr) { + // Attempting to create a reference on the error object. + // If it's not a Object/Function/Symbol, this call will return an error + // status. + napi_status status = napi_create_reference(env, value, 1, &_ref); + + if (status != napi_ok) { + napi_value wrappedErrorObj; + + // Create an error object + status = napi_create_object(env, &wrappedErrorObj); + NAPI_FATAL_IF_FAILED(status, "Error::Error", "napi_create_object"); + + // property flag that we attach to show the error object is wrapped + napi_property_descriptor wrapObjFlag = { + ERROR_WRAP_VALUE(), // Unique GUID identifier since Symbol isn't a + // viable option + nullptr, + nullptr, + nullptr, + nullptr, + Value::From(env, value), + napi_enumerable, + nullptr}; + + status = napi_define_properties(env, wrappedErrorObj, 1, &wrapObjFlag); +#ifdef NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS + if (status == napi_pending_exception) { + // Test if the pending exception was reported because the environment is + // shutting down. We assume that a status of napi_pending_exception + // coupled with the absence of an actual pending exception means that + // the environment is shutting down. If so, we replace the + // napi_pending_exception status with napi_ok. + bool is_exception_pending = false; + status = napi_is_exception_pending(env, &is_exception_pending); + if (status == napi_ok && !is_exception_pending) { + status = napi_ok; + } else { + status = napi_pending_exception; + } + } +#endif // NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS + NAPI_FATAL_IF_FAILED(status, "Error::Error", "napi_define_properties"); + + // Create a reference on the newly wrapped object + status = napi_create_reference(env, wrappedErrorObj, 1, &_ref); + } + + // Avoid infinite recursion in the failure case. + NAPI_FATAL_IF_FAILED(status, "Error::Error", "napi_create_reference"); + } +} + +inline Object Error::Value() const { + if (_ref == nullptr) { + return Object(_env, nullptr); + } + + napi_value refValue; + napi_status status = napi_get_reference_value(_env, _ref, &refValue); + NAPI_THROW_IF_FAILED(_env, status, Object()); + + napi_valuetype type; + status = napi_typeof(_env, refValue, &type); + NAPI_THROW_IF_FAILED(_env, status, Object()); + + // If refValue isn't a symbol, then we proceed to whether the refValue has the + // wrapped error flag + if (type != napi_symbol) { + // We are checking if the object is wrapped + bool isWrappedObject = false; + + status = napi_has_property(_env, + refValue, + String::From(_env, ERROR_WRAP_VALUE()), + &isWrappedObject); + + // Don't care about status + if (isWrappedObject) { + napi_value unwrappedValue; + status = napi_get_property(_env, + refValue, + String::From(_env, ERROR_WRAP_VALUE()), + &unwrappedValue); + NAPI_THROW_IF_FAILED(_env, status, Object()); + + return Object(_env, unwrappedValue); + } + } + + return Object(_env, refValue); +} + +inline Error::Error(Error&& other) : ObjectReference(std::move(other)) {} + +inline Error& Error::operator=(Error&& other) { + static_cast*>(this)->operator=(std::move(other)); + return *this; +} + +inline Error::Error(const Error& other) : ObjectReference(other) {} + +inline Error& Error::operator=(const Error& other) { + Reset(); + + _env = other.Env(); + HandleScope scope(_env); + + napi_value value = other.Value(); + if (value != nullptr) { + napi_status status = napi_create_reference(_env, value, 1, &_ref); + NAPI_THROW_IF_FAILED(_env, status, *this); + } + + return *this; +} + +inline const std::string& Error::Message() const NAPI_NOEXCEPT { + if (_message.size() == 0 && _env != nullptr) { +#ifdef NAPI_CPP_EXCEPTIONS + try { + _message = Get("message").As(); + } catch (...) { + // Catch all errors here, to include e.g. a std::bad_alloc from + // the std::string::operator=, because this method may not throw. + } +#else // NAPI_CPP_EXCEPTIONS +#if defined(NODE_ADDON_API_ENABLE_MAYBE) + Napi::Value message_val; + if (Get("message").UnwrapTo(&message_val)) { + _message = message_val.As(); + } +#else + _message = Get("message").As(); +#endif +#endif // NAPI_CPP_EXCEPTIONS + } + return _message; +} + +// we created an object on the &_ref +inline void Error::ThrowAsJavaScriptException() const { + HandleScope scope(_env); + if (!IsEmpty()) { +#ifdef NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS + bool pendingException = false; + + // check if there is already a pending exception. If so don't try to throw a + // new one as that is not allowed/possible + napi_status status = napi_is_exception_pending(_env, &pendingException); + + if ((status != napi_ok) || + ((status == napi_ok) && (pendingException == false))) { + // We intentionally don't use `NAPI_THROW_*` macros here to ensure + // that there is no possible recursion as `ThrowAsJavaScriptException` + // is part of `NAPI_THROW_*` macro definition for noexcept. + + status = napi_throw(_env, Value()); + + if (status == napi_pending_exception) { + // The environment must be terminating as we checked earlier and there + // was no pending exception. In this case continuing will result + // in a fatal error and there is nothing the author has done incorrectly + // in their code that is worth flagging through a fatal error + return; + } + } else { + status = napi_pending_exception; + } +#else + // We intentionally don't use `NAPI_THROW_*` macros here to ensure + // that there is no possible recursion as `ThrowAsJavaScriptException` + // is part of `NAPI_THROW_*` macro definition for noexcept. + + napi_status status = napi_throw(_env, Value()); +#endif + +#ifdef NAPI_CPP_EXCEPTIONS + if (status != napi_ok) { + throw Error::New(_env); + } +#else // NAPI_CPP_EXCEPTIONS + NAPI_FATAL_IF_FAILED( + status, "Error::ThrowAsJavaScriptException", "napi_throw"); +#endif // NAPI_CPP_EXCEPTIONS + } +} + +#ifdef NAPI_CPP_EXCEPTIONS + +inline const char* Error::what() const NAPI_NOEXCEPT { + return Message().c_str(); +} + +#endif // NAPI_CPP_EXCEPTIONS + +inline const char* Error::ERROR_WRAP_VALUE() NAPI_NOEXCEPT { + return "4bda9e7e-4913-4dbc-95de-891cbf66598e-errorVal"; +} + +template +inline TError Error::New(napi_env env, + const char* message, + size_t length, + create_error_fn create_error) { + napi_value str; + napi_status status = napi_create_string_utf8(env, message, length, &str); + NAPI_THROW_IF_FAILED(env, status, TError()); + + napi_value error; + status = create_error(env, nullptr, str, &error); + NAPI_THROW_IF_FAILED(env, status, TError()); + + return TError(env, error); +} + +inline TypeError TypeError::New(napi_env env, const char* message) { + return Error::New( + env, message, std::strlen(message), napi_create_type_error); +} + +inline TypeError TypeError::New(napi_env env, const std::string& message) { + return Error::New( + env, message.c_str(), message.size(), napi_create_type_error); +} + +inline TypeError::TypeError() : Error() {} + +inline TypeError::TypeError(napi_env env, napi_value value) + : Error(env, value) {} + +inline RangeError RangeError::New(napi_env env, const char* message) { + return Error::New( + env, message, std::strlen(message), napi_create_range_error); +} + +inline RangeError RangeError::New(napi_env env, const std::string& message) { + return Error::New( + env, message.c_str(), message.size(), napi_create_range_error); +} + +inline RangeError::RangeError() : Error() {} + +inline RangeError::RangeError(napi_env env, napi_value value) + : Error(env, value) {} + +#if NAPI_VERSION > 8 +inline SyntaxError SyntaxError::New(napi_env env, const char* message) { + return Error::New( + env, message, std::strlen(message), node_api_create_syntax_error); +} + +inline SyntaxError SyntaxError::New(napi_env env, const std::string& message) { + return Error::New( + env, message.c_str(), message.size(), node_api_create_syntax_error); +} + +inline SyntaxError::SyntaxError() : Error() {} + +inline SyntaxError::SyntaxError(napi_env env, napi_value value) + : Error(env, value) {} +#endif // NAPI_VERSION > 8 + +//////////////////////////////////////////////////////////////////////////////// +// Reference class +//////////////////////////////////////////////////////////////////////////////// + +template +inline Reference Reference::New(const T& value, + uint32_t initialRefcount) { + napi_env env = value.Env(); + napi_value val = value; + + if (val == nullptr) { + return Reference(env, nullptr); + } + + napi_ref ref; + napi_status status = napi_create_reference(env, value, initialRefcount, &ref); + NAPI_THROW_IF_FAILED(env, status, Reference()); + + return Reference(env, ref); +} + +template +inline Reference::Reference() + : _env(nullptr), _ref(nullptr), _suppressDestruct(false) {} + +template +inline Reference::Reference(napi_env env, napi_ref ref) + : _env(env), _ref(ref), _suppressDestruct(false) {} + +template +inline Reference::~Reference() { + if (_ref != nullptr) { + if (!_suppressDestruct) { + napi_delete_reference(_env, _ref); + } + + _ref = nullptr; + } +} + +template +inline Reference::Reference(Reference&& other) + : _env(other._env), + _ref(other._ref), + _suppressDestruct(other._suppressDestruct) { + other._env = nullptr; + other._ref = nullptr; + other._suppressDestruct = false; +} + +template +inline Reference& Reference::operator=(Reference&& other) { + Reset(); + _env = other._env; + _ref = other._ref; + _suppressDestruct = other._suppressDestruct; + other._env = nullptr; + other._ref = nullptr; + other._suppressDestruct = false; + return *this; +} + +template +inline Reference::Reference(const Reference& other) + : _env(other._env), _ref(nullptr), _suppressDestruct(false) { + HandleScope scope(_env); + + napi_value value = other.Value(); + if (value != nullptr) { + // Copying is a limited scenario (currently only used for Error object) and + // always creates a strong reference to the given value even if the incoming + // reference is weak. + napi_status status = napi_create_reference(_env, value, 1, &_ref); + NAPI_FATAL_IF_FAILED( + status, "Reference::Reference", "napi_create_reference"); + } +} + +template +inline Reference::operator napi_ref() const { + return _ref; +} + +template +inline bool Reference::operator==(const Reference& other) const { + HandleScope scope(_env); + return this->Value().StrictEquals(other.Value()); +} + +template +inline bool Reference::operator!=(const Reference& other) const { + return !this->operator==(other); +} + +template +inline Napi::Env Reference::Env() const { + return Napi::Env(_env); +} + +template +inline bool Reference::IsEmpty() const { + return _ref == nullptr; +} + +template +inline T Reference::Value() const { + if (_ref == nullptr) { + return T(_env, nullptr); + } + + napi_value value; + napi_status status = napi_get_reference_value(_env, _ref, &value); + NAPI_THROW_IF_FAILED(_env, status, T()); + return T(_env, value); +} + +template +inline uint32_t Reference::Ref() const { + uint32_t result; + napi_status status = napi_reference_ref(_env, _ref, &result); + NAPI_THROW_IF_FAILED(_env, status, 0); + return result; +} + +template +inline uint32_t Reference::Unref() const { + uint32_t result; + napi_status status = napi_reference_unref(_env, _ref, &result); + NAPI_THROW_IF_FAILED(_env, status, 0); + return result; +} + +template +inline void Reference::Reset() { + if (_ref != nullptr) { + napi_status status = napi_delete_reference(_env, _ref); + NAPI_THROW_IF_FAILED_VOID(_env, status); + _ref = nullptr; + } +} + +template +inline void Reference::Reset(const T& value, uint32_t refcount) { + Reset(); + _env = value.Env(); + + napi_value val = value; + if (val != nullptr) { + napi_status status = napi_create_reference(_env, value, refcount, &_ref); + NAPI_THROW_IF_FAILED_VOID(_env, status); + } +} + +template +inline void Reference::SuppressDestruct() { + _suppressDestruct = true; +} + +template +inline Reference Weak(T value) { + return Reference::New(value, 0); +} + +inline ObjectReference Weak(Object value) { + return Reference::New(value, 0); +} + +inline FunctionReference Weak(Function value) { + return Reference::New(value, 0); +} + +template +inline Reference Persistent(T value) { + return Reference::New(value, 1); +} + +inline ObjectReference Persistent(Object value) { + return Reference::New(value, 1); +} + +inline FunctionReference Persistent(Function value) { + return Reference::New(value, 1); +} + +//////////////////////////////////////////////////////////////////////////////// +// ObjectReference class +//////////////////////////////////////////////////////////////////////////////// + +inline ObjectReference::ObjectReference() : Reference() {} + +inline ObjectReference::ObjectReference(napi_env env, napi_ref ref) + : Reference(env, ref) {} + +inline ObjectReference::ObjectReference(Reference&& other) + : Reference(std::move(other)) {} + +inline ObjectReference& ObjectReference::operator=(Reference&& other) { + static_cast*>(this)->operator=(std::move(other)); + return *this; +} + +inline ObjectReference::ObjectReference(ObjectReference&& other) + : Reference(std::move(other)) {} + +inline ObjectReference& ObjectReference::operator=(ObjectReference&& other) { + static_cast*>(this)->operator=(std::move(other)); + return *this; +} + +inline ObjectReference::ObjectReference(const ObjectReference& other) + : Reference(other) {} + +inline MaybeOrValue ObjectReference::Get( + const char* utf8name) const { + EscapableHandleScope scope(_env); + MaybeOrValue result = Value().Get(utf8name); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + if (result.IsJust()) { + return Just(scope.Escape(result.Unwrap())); + } + return result; +#else + if (scope.Env().IsExceptionPending()) { + return Value(); + } + return scope.Escape(result); +#endif +} + +inline MaybeOrValue ObjectReference::Get( + const std::string& utf8name) const { + EscapableHandleScope scope(_env); + MaybeOrValue result = Value().Get(utf8name); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + if (result.IsJust()) { + return Just(scope.Escape(result.Unwrap())); + } + return result; +#else + if (scope.Env().IsExceptionPending()) { + return Value(); + } + return scope.Escape(result); +#endif +} + +inline MaybeOrValue ObjectReference::Set(const char* utf8name, + napi_value value) const { + HandleScope scope(_env); + return Value().Set(utf8name, value); +} + +inline MaybeOrValue ObjectReference::Set(const char* utf8name, + Napi::Value value) const { + HandleScope scope(_env); + return Value().Set(utf8name, value); +} + +inline MaybeOrValue ObjectReference::Set(const char* utf8name, + const char* utf8value) const { + HandleScope scope(_env); + return Value().Set(utf8name, utf8value); +} + +inline MaybeOrValue ObjectReference::Set(const char* utf8name, + bool boolValue) const { + HandleScope scope(_env); + return Value().Set(utf8name, boolValue); +} + +inline MaybeOrValue ObjectReference::Set(const char* utf8name, + double numberValue) const { + HandleScope scope(_env); + return Value().Set(utf8name, numberValue); +} + +inline MaybeOrValue ObjectReference::Set(const std::string& utf8name, + napi_value value) const { + HandleScope scope(_env); + return Value().Set(utf8name, value); +} + +inline MaybeOrValue ObjectReference::Set(const std::string& utf8name, + Napi::Value value) const { + HandleScope scope(_env); + return Value().Set(utf8name, value); +} + +inline MaybeOrValue ObjectReference::Set(const std::string& utf8name, + std::string& utf8value) const { + HandleScope scope(_env); + return Value().Set(utf8name, utf8value); +} + +inline MaybeOrValue ObjectReference::Set(const std::string& utf8name, + bool boolValue) const { + HandleScope scope(_env); + return Value().Set(utf8name, boolValue); +} + +inline MaybeOrValue ObjectReference::Set(const std::string& utf8name, + double numberValue) const { + HandleScope scope(_env); + return Value().Set(utf8name, numberValue); +} + +inline MaybeOrValue ObjectReference::Get(uint32_t index) const { + EscapableHandleScope scope(_env); + MaybeOrValue result = Value().Get(index); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + if (result.IsJust()) { + return Just(scope.Escape(result.Unwrap())); + } + return result; +#else + if (scope.Env().IsExceptionPending()) { + return Value(); + } + return scope.Escape(result); +#endif +} + +inline MaybeOrValue ObjectReference::Set(uint32_t index, + napi_value value) const { + HandleScope scope(_env); + return Value().Set(index, value); +} + +inline MaybeOrValue ObjectReference::Set(uint32_t index, + Napi::Value value) const { + HandleScope scope(_env); + return Value().Set(index, value); +} + +inline MaybeOrValue ObjectReference::Set(uint32_t index, + const char* utf8value) const { + HandleScope scope(_env); + return Value().Set(index, utf8value); +} + +inline MaybeOrValue ObjectReference::Set( + uint32_t index, const std::string& utf8value) const { + HandleScope scope(_env); + return Value().Set(index, utf8value); +} + +inline MaybeOrValue ObjectReference::Set(uint32_t index, + bool boolValue) const { + HandleScope scope(_env); + return Value().Set(index, boolValue); +} + +inline MaybeOrValue ObjectReference::Set(uint32_t index, + double numberValue) const { + HandleScope scope(_env); + return Value().Set(index, numberValue); +} + +//////////////////////////////////////////////////////////////////////////////// +// FunctionReference class +//////////////////////////////////////////////////////////////////////////////// + +inline FunctionReference::FunctionReference() : Reference() {} + +inline FunctionReference::FunctionReference(napi_env env, napi_ref ref) + : Reference(env, ref) {} + +inline FunctionReference::FunctionReference(Reference&& other) + : Reference(std::move(other)) {} + +inline FunctionReference& FunctionReference::operator=( + Reference&& other) { + static_cast*>(this)->operator=(std::move(other)); + return *this; +} + +inline FunctionReference::FunctionReference(FunctionReference&& other) + : Reference(std::move(other)) {} + +inline FunctionReference& FunctionReference::operator=( + FunctionReference&& other) { + static_cast*>(this)->operator=(std::move(other)); + return *this; +} + +inline MaybeOrValue FunctionReference::operator()( + const std::initializer_list& args) const { + EscapableHandleScope scope(_env); + MaybeOrValue result = Value()(args); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + if (result.IsJust()) { + return Just(scope.Escape(result.Unwrap())); + } + return result; +#else + if (scope.Env().IsExceptionPending()) { + return Value(); + } + return scope.Escape(result); +#endif +} + +inline MaybeOrValue FunctionReference::Call( + const std::initializer_list& args) const { + EscapableHandleScope scope(_env); + MaybeOrValue result = Value().Call(args); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + if (result.IsJust()) { + return Just(scope.Escape(result.Unwrap())); + } + return result; +#else + if (scope.Env().IsExceptionPending()) { + return Value(); + } + return scope.Escape(result); +#endif +} + +inline MaybeOrValue FunctionReference::Call( + const std::vector& args) const { + EscapableHandleScope scope(_env); + MaybeOrValue result = Value().Call(args); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + if (result.IsJust()) { + return Just(scope.Escape(result.Unwrap())); + } + return result; +#else + if (scope.Env().IsExceptionPending()) { + return Value(); + } + return scope.Escape(result); +#endif +} + +inline MaybeOrValue FunctionReference::Call( + napi_value recv, const std::initializer_list& args) const { + EscapableHandleScope scope(_env); + MaybeOrValue result = Value().Call(recv, args); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + if (result.IsJust()) { + return Just(scope.Escape(result.Unwrap())); + } + return result; +#else + if (scope.Env().IsExceptionPending()) { + return Value(); + } + return scope.Escape(result); +#endif +} + +inline MaybeOrValue FunctionReference::Call( + napi_value recv, const std::vector& args) const { + EscapableHandleScope scope(_env); + MaybeOrValue result = Value().Call(recv, args); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + if (result.IsJust()) { + return Just(scope.Escape(result.Unwrap())); + } + return result; +#else + if (scope.Env().IsExceptionPending()) { + return Value(); + } + return scope.Escape(result); +#endif +} + +inline MaybeOrValue FunctionReference::Call( + napi_value recv, size_t argc, const napi_value* args) const { + EscapableHandleScope scope(_env); + MaybeOrValue result = Value().Call(recv, argc, args); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + if (result.IsJust()) { + return Just(scope.Escape(result.Unwrap())); + } + return result; +#else + if (scope.Env().IsExceptionPending()) { + return Value(); + } + return scope.Escape(result); +#endif +} + +inline MaybeOrValue FunctionReference::MakeCallback( + napi_value recv, + const std::initializer_list& args, + napi_async_context context) const { + EscapableHandleScope scope(_env); + MaybeOrValue result = Value().MakeCallback(recv, args, context); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + if (result.IsJust()) { + return Just(scope.Escape(result.Unwrap())); + } + + return result; +#else + if (scope.Env().IsExceptionPending()) { + return Value(); + } + return scope.Escape(result); +#endif +} + +inline MaybeOrValue FunctionReference::MakeCallback( + napi_value recv, + const std::vector& args, + napi_async_context context) const { + EscapableHandleScope scope(_env); + MaybeOrValue result = Value().MakeCallback(recv, args, context); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + if (result.IsJust()) { + return Just(scope.Escape(result.Unwrap())); + } + return result; +#else + if (scope.Env().IsExceptionPending()) { + return Value(); + } + return scope.Escape(result); +#endif +} + +inline MaybeOrValue FunctionReference::MakeCallback( + napi_value recv, + size_t argc, + const napi_value* args, + napi_async_context context) const { + EscapableHandleScope scope(_env); + MaybeOrValue result = + Value().MakeCallback(recv, argc, args, context); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + if (result.IsJust()) { + return Just(scope.Escape(result.Unwrap())); + } + return result; +#else + if (scope.Env().IsExceptionPending()) { + return Value(); + } + return scope.Escape(result); +#endif +} + +inline MaybeOrValue FunctionReference::New( + const std::initializer_list& args) const { + EscapableHandleScope scope(_env); + MaybeOrValue result = Value().New(args); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + if (result.IsJust()) { + return Just(scope.Escape(result.Unwrap()).As()); + } + return result; +#else + if (scope.Env().IsExceptionPending()) { + return Object(); + } + return scope.Escape(result).As(); +#endif +} + +inline MaybeOrValue FunctionReference::New( + const std::vector& args) const { + EscapableHandleScope scope(_env); + MaybeOrValue result = Value().New(args); +#ifdef NODE_ADDON_API_ENABLE_MAYBE + if (result.IsJust()) { + return Just(scope.Escape(result.Unwrap()).As()); + } + return result; +#else + if (scope.Env().IsExceptionPending()) { + return Object(); + } + return scope.Escape(result).As(); +#endif +} + +//////////////////////////////////////////////////////////////////////////////// +// CallbackInfo class +//////////////////////////////////////////////////////////////////////////////// + +inline CallbackInfo::CallbackInfo(napi_env env, napi_callback_info info) + : _env(env), + _info(info), + _this(nullptr), + _dynamicArgs(nullptr), + _data(nullptr) { + _argc = _staticArgCount; + _argv = _staticArgs; + napi_status status = + napi_get_cb_info(env, info, &_argc, _argv, &_this, &_data); + NAPI_THROW_IF_FAILED_VOID(_env, status); + + if (_argc > _staticArgCount) { + // Use either a fixed-size array (on the stack) or a dynamically-allocated + // array (on the heap) depending on the number of args. + _dynamicArgs = new napi_value[_argc]; + _argv = _dynamicArgs; + + status = napi_get_cb_info(env, info, &_argc, _argv, nullptr, nullptr); + NAPI_THROW_IF_FAILED_VOID(_env, status); + } +} + +inline CallbackInfo::~CallbackInfo() { + if (_dynamicArgs != nullptr) { + delete[] _dynamicArgs; + } +} + +inline CallbackInfo::operator napi_callback_info() const { + return _info; +} + +inline Value CallbackInfo::NewTarget() const { + napi_value newTarget; + napi_status status = napi_get_new_target(_env, _info, &newTarget); + NAPI_THROW_IF_FAILED(_env, status, Value()); + return Value(_env, newTarget); +} + +inline bool CallbackInfo::IsConstructCall() const { + return !NewTarget().IsEmpty(); +} + +inline Napi::Env CallbackInfo::Env() const { + return Napi::Env(_env); +} + +inline size_t CallbackInfo::Length() const { + return _argc; +} + +inline const Value CallbackInfo::operator[](size_t index) const { + return index < _argc ? Value(_env, _argv[index]) : Env().Undefined(); +} + +inline Value CallbackInfo::This() const { + if (_this == nullptr) { + return Env().Undefined(); + } + return Object(_env, _this); +} + +inline void* CallbackInfo::Data() const { + return _data; +} + +inline void CallbackInfo::SetData(void* data) { + _data = data; +} + +//////////////////////////////////////////////////////////////////////////////// +// PropertyDescriptor class +//////////////////////////////////////////////////////////////////////////////// + +template +PropertyDescriptor PropertyDescriptor::Accessor( + const char* utf8name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + + desc.utf8name = utf8name; + desc.getter = details::TemplatedCallback; + desc.attributes = attributes; + desc.data = data; + + return desc; +} + +template +PropertyDescriptor PropertyDescriptor::Accessor( + const std::string& utf8name, + napi_property_attributes attributes, + void* data) { + return Accessor(utf8name.c_str(), attributes, data); +} + +template +PropertyDescriptor PropertyDescriptor::Accessor( + Name name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + + desc.name = name; + desc.getter = details::TemplatedCallback; + desc.attributes = attributes; + desc.data = data; + + return desc; +} + +template +PropertyDescriptor PropertyDescriptor::Accessor( + const char* utf8name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + + desc.utf8name = utf8name; + desc.getter = details::TemplatedCallback; + desc.setter = details::TemplatedVoidCallback; + desc.attributes = attributes; + desc.data = data; + + return desc; +} + +template +PropertyDescriptor PropertyDescriptor::Accessor( + const std::string& utf8name, + napi_property_attributes attributes, + void* data) { + return Accessor(utf8name.c_str(), attributes, data); +} + +template +PropertyDescriptor PropertyDescriptor::Accessor( + Name name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + + desc.name = name; + desc.getter = details::TemplatedCallback; + desc.setter = details::TemplatedVoidCallback; + desc.attributes = attributes; + desc.data = data; + + return desc; +} + +template +inline PropertyDescriptor PropertyDescriptor::Accessor( + Napi::Env env, + Napi::Object object, + const char* utf8name, + Getter getter, + napi_property_attributes attributes, + void* data) { + using CbData = details::CallbackData; + auto callbackData = new CbData({getter, data}); + + napi_status status = AttachData(env, object, callbackData); + if (status != napi_ok) { + delete callbackData; + NAPI_THROW_IF_FAILED(env, status, napi_property_descriptor()); + } + + return PropertyDescriptor({utf8name, + nullptr, + nullptr, + CbData::Wrapper, + nullptr, + nullptr, + attributes, + callbackData}); +} + +template +inline PropertyDescriptor PropertyDescriptor::Accessor( + Napi::Env env, + Napi::Object object, + const std::string& utf8name, + Getter getter, + napi_property_attributes attributes, + void* data) { + return Accessor(env, object, utf8name.c_str(), getter, attributes, data); +} + +template +inline PropertyDescriptor PropertyDescriptor::Accessor( + Napi::Env env, + Napi::Object object, + Name name, + Getter getter, + napi_property_attributes attributes, + void* data) { + using CbData = details::CallbackData; + auto callbackData = new CbData({getter, data}); + + napi_status status = AttachData(env, object, callbackData); + if (status != napi_ok) { + delete callbackData; + NAPI_THROW_IF_FAILED(env, status, napi_property_descriptor()); + } + + return PropertyDescriptor({nullptr, + name, + nullptr, + CbData::Wrapper, + nullptr, + nullptr, + attributes, + callbackData}); +} + +template +inline PropertyDescriptor PropertyDescriptor::Accessor( + Napi::Env env, + Napi::Object object, + const char* utf8name, + Getter getter, + Setter setter, + napi_property_attributes attributes, + void* data) { + using CbData = details::AccessorCallbackData; + auto callbackData = new CbData({getter, setter, data}); + + napi_status status = AttachData(env, object, callbackData); + if (status != napi_ok) { + delete callbackData; + NAPI_THROW_IF_FAILED(env, status, napi_property_descriptor()); + } + + return PropertyDescriptor({utf8name, + nullptr, + nullptr, + CbData::GetterWrapper, + CbData::SetterWrapper, + nullptr, + attributes, + callbackData}); +} + +template +inline PropertyDescriptor PropertyDescriptor::Accessor( + Napi::Env env, + Napi::Object object, + const std::string& utf8name, + Getter getter, + Setter setter, + napi_property_attributes attributes, + void* data) { + return Accessor( + env, object, utf8name.c_str(), getter, setter, attributes, data); +} + +template +inline PropertyDescriptor PropertyDescriptor::Accessor( + Napi::Env env, + Napi::Object object, + Name name, + Getter getter, + Setter setter, + napi_property_attributes attributes, + void* data) { + using CbData = details::AccessorCallbackData; + auto callbackData = new CbData({getter, setter, data}); + + napi_status status = AttachData(env, object, callbackData); + if (status != napi_ok) { + delete callbackData; + NAPI_THROW_IF_FAILED(env, status, napi_property_descriptor()); + } + + return PropertyDescriptor({nullptr, + name, + nullptr, + CbData::GetterWrapper, + CbData::SetterWrapper, + nullptr, + attributes, + callbackData}); +} + +template +inline PropertyDescriptor PropertyDescriptor::Function( + Napi::Env env, + Napi::Object /*object*/, + const char* utf8name, + Callable cb, + napi_property_attributes attributes, + void* data) { + return PropertyDescriptor({utf8name, + nullptr, + nullptr, + nullptr, + nullptr, + Napi::Function::New(env, cb, utf8name, data), + attributes, + nullptr}); +} + +template +inline PropertyDescriptor PropertyDescriptor::Function( + Napi::Env env, + Napi::Object object, + const std::string& utf8name, + Callable cb, + napi_property_attributes attributes, + void* data) { + return Function(env, object, utf8name.c_str(), cb, attributes, data); +} + +template +inline PropertyDescriptor PropertyDescriptor::Function( + Napi::Env env, + Napi::Object /*object*/, + Name name, + Callable cb, + napi_property_attributes attributes, + void* data) { + return PropertyDescriptor({nullptr, + name, + nullptr, + nullptr, + nullptr, + Napi::Function::New(env, cb, nullptr, data), + attributes, + nullptr}); +} + +inline PropertyDescriptor PropertyDescriptor::Value( + const char* utf8name, + napi_value value, + napi_property_attributes attributes) { + return PropertyDescriptor({utf8name, + nullptr, + nullptr, + nullptr, + nullptr, + value, + attributes, + nullptr}); +} + +inline PropertyDescriptor PropertyDescriptor::Value( + const std::string& utf8name, + napi_value value, + napi_property_attributes attributes) { + return Value(utf8name.c_str(), value, attributes); +} + +inline PropertyDescriptor PropertyDescriptor::Value( + napi_value name, napi_value value, napi_property_attributes attributes) { + return PropertyDescriptor( + {nullptr, name, nullptr, nullptr, nullptr, value, attributes, nullptr}); +} + +inline PropertyDescriptor PropertyDescriptor::Value( + Name name, Napi::Value value, napi_property_attributes attributes) { + napi_value nameValue = name; + napi_value valueValue = value; + return PropertyDescriptor::Value(nameValue, valueValue, attributes); +} + +inline PropertyDescriptor::PropertyDescriptor(napi_property_descriptor desc) + : _desc(desc) {} + +inline PropertyDescriptor::operator napi_property_descriptor&() { + return _desc; +} + +inline PropertyDescriptor::operator const napi_property_descriptor&() const { + return _desc; +} + +//////////////////////////////////////////////////////////////////////////////// +// InstanceWrap class +//////////////////////////////////////////////////////////////////////////////// + +template +inline void InstanceWrap::AttachPropData( + napi_env env, napi_value value, const napi_property_descriptor* prop) { + napi_status status; + if (!(prop->attributes & napi_static)) { + if (prop->method == T::InstanceVoidMethodCallbackWrapper) { + status = Napi::details::AttachData( + env, value, static_cast(prop->data)); + NAPI_THROW_IF_FAILED_VOID(env, status); + } else if (prop->method == T::InstanceMethodCallbackWrapper) { + status = Napi::details::AttachData( + env, value, static_cast(prop->data)); + NAPI_THROW_IF_FAILED_VOID(env, status); + } else if (prop->getter == T::InstanceGetterCallbackWrapper || + prop->setter == T::InstanceSetterCallbackWrapper) { + status = Napi::details::AttachData( + env, value, static_cast(prop->data)); + NAPI_THROW_IF_FAILED_VOID(env, status); + } + } +} + +template +inline ClassPropertyDescriptor InstanceWrap::InstanceMethod( + const char* utf8name, + InstanceVoidMethodCallback method, + napi_property_attributes attributes, + void* data) { + InstanceVoidMethodCallbackData* callbackData = + new InstanceVoidMethodCallbackData({method, data}); + + napi_property_descriptor desc = napi_property_descriptor(); + desc.utf8name = utf8name; + desc.method = T::InstanceVoidMethodCallbackWrapper; + desc.data = callbackData; + desc.attributes = attributes; + return desc; +} + +template +inline ClassPropertyDescriptor InstanceWrap::InstanceMethod( + const char* utf8name, + InstanceMethodCallback method, + napi_property_attributes attributes, + void* data) { + InstanceMethodCallbackData* callbackData = + new InstanceMethodCallbackData({method, data}); + + napi_property_descriptor desc = napi_property_descriptor(); + desc.utf8name = utf8name; + desc.method = T::InstanceMethodCallbackWrapper; + desc.data = callbackData; + desc.attributes = attributes; + return desc; +} + +template +inline ClassPropertyDescriptor InstanceWrap::InstanceMethod( + Symbol name, + InstanceVoidMethodCallback method, + napi_property_attributes attributes, + void* data) { + InstanceVoidMethodCallbackData* callbackData = + new InstanceVoidMethodCallbackData({method, data}); + + napi_property_descriptor desc = napi_property_descriptor(); + desc.name = name; + desc.method = T::InstanceVoidMethodCallbackWrapper; + desc.data = callbackData; + desc.attributes = attributes; + return desc; +} + +template +inline ClassPropertyDescriptor InstanceWrap::InstanceMethod( + Symbol name, + InstanceMethodCallback method, + napi_property_attributes attributes, + void* data) { + InstanceMethodCallbackData* callbackData = + new InstanceMethodCallbackData({method, data}); + + napi_property_descriptor desc = napi_property_descriptor(); + desc.name = name; + desc.method = T::InstanceMethodCallbackWrapper; + desc.data = callbackData; + desc.attributes = attributes; + return desc; +} + +template +template ::InstanceVoidMethodCallback method> +inline ClassPropertyDescriptor InstanceWrap::InstanceMethod( + const char* utf8name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.utf8name = utf8name; + desc.method = details::TemplatedInstanceVoidCallback; + desc.data = data; + desc.attributes = attributes; + return desc; +} + +template +template ::InstanceMethodCallback method> +inline ClassPropertyDescriptor InstanceWrap::InstanceMethod( + const char* utf8name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.utf8name = utf8name; + desc.method = details::TemplatedInstanceCallback; + desc.data = data; + desc.attributes = attributes; + return desc; +} + +template +template ::InstanceVoidMethodCallback method> +inline ClassPropertyDescriptor InstanceWrap::InstanceMethod( + Symbol name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.name = name; + desc.method = details::TemplatedInstanceVoidCallback; + desc.data = data; + desc.attributes = attributes; + return desc; +} + +template +template ::InstanceMethodCallback method> +inline ClassPropertyDescriptor InstanceWrap::InstanceMethod( + Symbol name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.name = name; + desc.method = details::TemplatedInstanceCallback; + desc.data = data; + desc.attributes = attributes; + return desc; +} + +template +inline ClassPropertyDescriptor InstanceWrap::InstanceAccessor( + const char* utf8name, + InstanceGetterCallback getter, + InstanceSetterCallback setter, + napi_property_attributes attributes, + void* data) { + InstanceAccessorCallbackData* callbackData = + new InstanceAccessorCallbackData({getter, setter, data}); + + napi_property_descriptor desc = napi_property_descriptor(); + desc.utf8name = utf8name; + desc.getter = getter != nullptr ? T::InstanceGetterCallbackWrapper : nullptr; + desc.setter = setter != nullptr ? T::InstanceSetterCallbackWrapper : nullptr; + desc.data = callbackData; + desc.attributes = attributes; + return desc; +} + +template +inline ClassPropertyDescriptor InstanceWrap::InstanceAccessor( + Symbol name, + InstanceGetterCallback getter, + InstanceSetterCallback setter, + napi_property_attributes attributes, + void* data) { + InstanceAccessorCallbackData* callbackData = + new InstanceAccessorCallbackData({getter, setter, data}); + + napi_property_descriptor desc = napi_property_descriptor(); + desc.name = name; + desc.getter = getter != nullptr ? T::InstanceGetterCallbackWrapper : nullptr; + desc.setter = setter != nullptr ? T::InstanceSetterCallbackWrapper : nullptr; + desc.data = callbackData; + desc.attributes = attributes; + return desc; +} + +template +template ::InstanceGetterCallback getter, + typename InstanceWrap::InstanceSetterCallback setter> +inline ClassPropertyDescriptor InstanceWrap::InstanceAccessor( + const char* utf8name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.utf8name = utf8name; + desc.getter = details::TemplatedInstanceCallback; + desc.setter = This::WrapSetter(This::SetterTag()); + desc.data = data; + desc.attributes = attributes; + return desc; +} + +template +template ::InstanceGetterCallback getter, + typename InstanceWrap::InstanceSetterCallback setter> +inline ClassPropertyDescriptor InstanceWrap::InstanceAccessor( + Symbol name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.name = name; + desc.getter = details::TemplatedInstanceCallback; + desc.setter = This::WrapSetter(This::SetterTag()); + desc.data = data; + desc.attributes = attributes; + return desc; +} + +template +inline ClassPropertyDescriptor InstanceWrap::InstanceValue( + const char* utf8name, + Napi::Value value, + napi_property_attributes attributes) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.utf8name = utf8name; + desc.value = value; + desc.attributes = attributes; + return desc; +} + +template +inline ClassPropertyDescriptor InstanceWrap::InstanceValue( + Symbol name, Napi::Value value, napi_property_attributes attributes) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.name = name; + desc.value = value; + desc.attributes = attributes; + return desc; +} + +template +inline napi_value InstanceWrap::InstanceVoidMethodCallbackWrapper( + napi_env env, napi_callback_info info) { + return details::WrapCallback([&] { + CallbackInfo callbackInfo(env, info); + InstanceVoidMethodCallbackData* callbackData = + reinterpret_cast(callbackInfo.Data()); + callbackInfo.SetData(callbackData->data); + T* instance = T::Unwrap(callbackInfo.This().As()); + auto cb = callbackData->callback; + if (instance) (instance->*cb)(callbackInfo); + return nullptr; + }); +} + +template +inline napi_value InstanceWrap::InstanceMethodCallbackWrapper( + napi_env env, napi_callback_info info) { + return details::WrapCallback([&] { + CallbackInfo callbackInfo(env, info); + InstanceMethodCallbackData* callbackData = + reinterpret_cast(callbackInfo.Data()); + callbackInfo.SetData(callbackData->data); + T* instance = T::Unwrap(callbackInfo.This().As()); + auto cb = callbackData->callback; + return instance ? (instance->*cb)(callbackInfo) : Napi::Value(); + }); +} + +template +inline napi_value InstanceWrap::InstanceGetterCallbackWrapper( + napi_env env, napi_callback_info info) { + return details::WrapCallback([&] { + CallbackInfo callbackInfo(env, info); + InstanceAccessorCallbackData* callbackData = + reinterpret_cast(callbackInfo.Data()); + callbackInfo.SetData(callbackData->data); + T* instance = T::Unwrap(callbackInfo.This().As()); + auto cb = callbackData->getterCallback; + return instance ? (instance->*cb)(callbackInfo) : Napi::Value(); + }); +} + +template +inline napi_value InstanceWrap::InstanceSetterCallbackWrapper( + napi_env env, napi_callback_info info) { + return details::WrapCallback([&] { + CallbackInfo callbackInfo(env, info); + InstanceAccessorCallbackData* callbackData = + reinterpret_cast(callbackInfo.Data()); + callbackInfo.SetData(callbackData->data); + T* instance = T::Unwrap(callbackInfo.This().As()); + auto cb = callbackData->setterCallback; + if (instance) (instance->*cb)(callbackInfo, callbackInfo[0]); + return nullptr; + }); +} + +template +template ::InstanceSetterCallback method> +inline napi_value InstanceWrap::WrappedMethod( + napi_env env, napi_callback_info info) NAPI_NOEXCEPT { + return details::WrapCallback([&] { + const CallbackInfo cbInfo(env, info); + T* instance = T::Unwrap(cbInfo.This().As()); + if (instance) (instance->*method)(cbInfo, cbInfo[0]); + return nullptr; + }); +} + +//////////////////////////////////////////////////////////////////////////////// +// ObjectWrap class +//////////////////////////////////////////////////////////////////////////////// + +template +inline ObjectWrap::ObjectWrap(const Napi::CallbackInfo& callbackInfo) { + napi_env env = callbackInfo.Env(); + napi_value wrapper = callbackInfo.This(); + napi_status status; + napi_ref ref; + T* instance = static_cast(this); + status = napi_wrap(env, wrapper, instance, FinalizeCallback, nullptr, &ref); + NAPI_THROW_IF_FAILED_VOID(env, status); + + Reference* instanceRef = instance; + *instanceRef = Reference(env, ref); +} + +template +inline ObjectWrap::~ObjectWrap() { + // If the JS object still exists at this point, remove the finalizer added + // through `napi_wrap()`. + if (!IsEmpty()) { + Object object = Value(); + // It is not valid to call `napi_remove_wrap()` with an empty `object`. + // This happens e.g. during garbage collection. + if (!object.IsEmpty() && _construction_failed) { + napi_remove_wrap(Env(), object, nullptr); + } + } +} + +template +inline T* ObjectWrap::Unwrap(Object wrapper) { + void* unwrapped; + napi_status status = napi_unwrap(wrapper.Env(), wrapper, &unwrapped); + NAPI_THROW_IF_FAILED(wrapper.Env(), status, nullptr); + return static_cast(unwrapped); +} + +template +inline Function ObjectWrap::DefineClass( + Napi::Env env, + const char* utf8name, + const size_t props_count, + const napi_property_descriptor* descriptors, + void* data) { + napi_status status; + std::vector props(props_count); + + // We copy the descriptors to a local array because before defining the class + // we must replace static method property descriptors with value property + // descriptors such that the value is a function-valued `napi_value` created + // with `CreateFunction()`. + // + // This replacement could be made for instance methods as well, but V8 aborts + // if we do that, because it expects methods defined on the prototype template + // to have `FunctionTemplate`s. + for (size_t index = 0; index < props_count; index++) { + props[index] = descriptors[index]; + napi_property_descriptor* prop = &props[index]; + if (prop->method == T::StaticMethodCallbackWrapper) { + status = + CreateFunction(env, + utf8name, + prop->method, + static_cast(prop->data), + &(prop->value)); + NAPI_THROW_IF_FAILED(env, status, Function()); + prop->method = nullptr; + prop->data = nullptr; + } else if (prop->method == T::StaticVoidMethodCallbackWrapper) { + status = + CreateFunction(env, + utf8name, + prop->method, + static_cast(prop->data), + &(prop->value)); + NAPI_THROW_IF_FAILED(env, status, Function()); + prop->method = nullptr; + prop->data = nullptr; + } + } + + napi_value value; + status = napi_define_class(env, + utf8name, + NAPI_AUTO_LENGTH, + T::ConstructorCallbackWrapper, + data, + props_count, + props.data(), + &value); + NAPI_THROW_IF_FAILED(env, status, Function()); + + // After defining the class we iterate once more over the property descriptors + // and attach the data associated with accessors and instance methods to the + // newly created JavaScript class. + for (size_t idx = 0; idx < props_count; idx++) { + const napi_property_descriptor* prop = &props[idx]; + + if (prop->getter == T::StaticGetterCallbackWrapper || + prop->setter == T::StaticSetterCallbackWrapper) { + status = Napi::details::AttachData( + env, value, static_cast(prop->data)); + NAPI_THROW_IF_FAILED(env, status, Function()); + } else { + // InstanceWrap::AttachPropData is responsible for attaching the data + // of instance methods and accessors. + T::AttachPropData(env, value, prop); + } + } + + return Function(env, value); +} + +template +inline Function ObjectWrap::DefineClass( + Napi::Env env, + const char* utf8name, + const std::initializer_list>& properties, + void* data) { + return DefineClass( + env, + utf8name, + properties.size(), + reinterpret_cast(properties.begin()), + data); +} + +template +inline Function ObjectWrap::DefineClass( + Napi::Env env, + const char* utf8name, + const std::vector>& properties, + void* data) { + return DefineClass( + env, + utf8name, + properties.size(), + reinterpret_cast(properties.data()), + data); +} + +template +inline ClassPropertyDescriptor ObjectWrap::StaticMethod( + const char* utf8name, + StaticVoidMethodCallback method, + napi_property_attributes attributes, + void* data) { + StaticVoidMethodCallbackData* callbackData = + new StaticVoidMethodCallbackData({method, data}); + + napi_property_descriptor desc = napi_property_descriptor(); + desc.utf8name = utf8name; + desc.method = T::StaticVoidMethodCallbackWrapper; + desc.data = callbackData; + desc.attributes = + static_cast(attributes | napi_static); + return desc; +} + +template +inline ClassPropertyDescriptor ObjectWrap::StaticMethod( + const char* utf8name, + StaticMethodCallback method, + napi_property_attributes attributes, + void* data) { + StaticMethodCallbackData* callbackData = + new StaticMethodCallbackData({method, data}); + + napi_property_descriptor desc = napi_property_descriptor(); + desc.utf8name = utf8name; + desc.method = T::StaticMethodCallbackWrapper; + desc.data = callbackData; + desc.attributes = + static_cast(attributes | napi_static); + return desc; +} + +template +inline ClassPropertyDescriptor ObjectWrap::StaticMethod( + Symbol name, + StaticVoidMethodCallback method, + napi_property_attributes attributes, + void* data) { + StaticVoidMethodCallbackData* callbackData = + new StaticVoidMethodCallbackData({method, data}); + + napi_property_descriptor desc = napi_property_descriptor(); + desc.name = name; + desc.method = T::StaticVoidMethodCallbackWrapper; + desc.data = callbackData; + desc.attributes = + static_cast(attributes | napi_static); + return desc; +} + +template +inline ClassPropertyDescriptor ObjectWrap::StaticMethod( + Symbol name, + StaticMethodCallback method, + napi_property_attributes attributes, + void* data) { + StaticMethodCallbackData* callbackData = + new StaticMethodCallbackData({method, data}); + + napi_property_descriptor desc = napi_property_descriptor(); + desc.name = name; + desc.method = T::StaticMethodCallbackWrapper; + desc.data = callbackData; + desc.attributes = + static_cast(attributes | napi_static); + return desc; +} + +template +template ::StaticVoidMethodCallback method> +inline ClassPropertyDescriptor ObjectWrap::StaticMethod( + const char* utf8name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.utf8name = utf8name; + desc.method = details::TemplatedVoidCallback; + desc.data = data; + desc.attributes = + static_cast(attributes | napi_static); + return desc; +} + +template +template ::StaticVoidMethodCallback method> +inline ClassPropertyDescriptor ObjectWrap::StaticMethod( + Symbol name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.name = name; + desc.method = details::TemplatedVoidCallback; + desc.data = data; + desc.attributes = + static_cast(attributes | napi_static); + return desc; +} + +template +template ::StaticMethodCallback method> +inline ClassPropertyDescriptor ObjectWrap::StaticMethod( + const char* utf8name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.utf8name = utf8name; + desc.method = details::TemplatedCallback; + desc.data = data; + desc.attributes = + static_cast(attributes | napi_static); + return desc; +} + +template +template ::StaticMethodCallback method> +inline ClassPropertyDescriptor ObjectWrap::StaticMethod( + Symbol name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.name = name; + desc.method = details::TemplatedCallback; + desc.data = data; + desc.attributes = + static_cast(attributes | napi_static); + return desc; +} + +template +inline ClassPropertyDescriptor ObjectWrap::StaticAccessor( + const char* utf8name, + StaticGetterCallback getter, + StaticSetterCallback setter, + napi_property_attributes attributes, + void* data) { + StaticAccessorCallbackData* callbackData = + new StaticAccessorCallbackData({getter, setter, data}); + + napi_property_descriptor desc = napi_property_descriptor(); + desc.utf8name = utf8name; + desc.getter = getter != nullptr ? T::StaticGetterCallbackWrapper : nullptr; + desc.setter = setter != nullptr ? T::StaticSetterCallbackWrapper : nullptr; + desc.data = callbackData; + desc.attributes = + static_cast(attributes | napi_static); + return desc; +} + +template +inline ClassPropertyDescriptor ObjectWrap::StaticAccessor( + Symbol name, + StaticGetterCallback getter, + StaticSetterCallback setter, + napi_property_attributes attributes, + void* data) { + StaticAccessorCallbackData* callbackData = + new StaticAccessorCallbackData({getter, setter, data}); + + napi_property_descriptor desc = napi_property_descriptor(); + desc.name = name; + desc.getter = getter != nullptr ? T::StaticGetterCallbackWrapper : nullptr; + desc.setter = setter != nullptr ? T::StaticSetterCallbackWrapper : nullptr; + desc.data = callbackData; + desc.attributes = + static_cast(attributes | napi_static); + return desc; +} + +template +template ::StaticGetterCallback getter, + typename ObjectWrap::StaticSetterCallback setter> +inline ClassPropertyDescriptor ObjectWrap::StaticAccessor( + const char* utf8name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.utf8name = utf8name; + desc.getter = details::TemplatedCallback; + desc.setter = This::WrapStaticSetter(This::StaticSetterTag()); + desc.data = data; + desc.attributes = + static_cast(attributes | napi_static); + return desc; +} + +template +template ::StaticGetterCallback getter, + typename ObjectWrap::StaticSetterCallback setter> +inline ClassPropertyDescriptor ObjectWrap::StaticAccessor( + Symbol name, napi_property_attributes attributes, void* data) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.name = name; + desc.getter = details::TemplatedCallback; + desc.setter = This::WrapStaticSetter(This::StaticSetterTag()); + desc.data = data; + desc.attributes = + static_cast(attributes | napi_static); + return desc; +} + +template +inline ClassPropertyDescriptor ObjectWrap::StaticValue( + const char* utf8name, + Napi::Value value, + napi_property_attributes attributes) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.utf8name = utf8name; + desc.value = value; + desc.attributes = + static_cast(attributes | napi_static); + return desc; +} + +template +inline ClassPropertyDescriptor ObjectWrap::StaticValue( + Symbol name, Napi::Value value, napi_property_attributes attributes) { + napi_property_descriptor desc = napi_property_descriptor(); + desc.name = name; + desc.value = value; + desc.attributes = + static_cast(attributes | napi_static); + return desc; +} + +template +inline Value ObjectWrap::OnCalledAsFunction( + const Napi::CallbackInfo& callbackInfo) { + NAPI_THROW( + TypeError::New(callbackInfo.Env(), + "Class constructors cannot be invoked without 'new'"), + Napi::Value()); +} + +template +inline void ObjectWrap::Finalize(Napi::Env /*env*/) {} + +template +inline napi_value ObjectWrap::ConstructorCallbackWrapper( + napi_env env, napi_callback_info info) { + napi_value new_target; + napi_status status = napi_get_new_target(env, info, &new_target); + if (status != napi_ok) return nullptr; + + bool isConstructCall = (new_target != nullptr); + if (!isConstructCall) { + return details::WrapCallback( + [&] { return T::OnCalledAsFunction(CallbackInfo(env, info)); }); + } + + napi_value wrapper = details::WrapCallback([&] { + CallbackInfo callbackInfo(env, info); + T* instance = new T(callbackInfo); +#ifdef NAPI_CPP_EXCEPTIONS + instance->_construction_failed = false; +#else + if (callbackInfo.Env().IsExceptionPending()) { + // We need to clear the exception so that removing the wrap might work. + Error e = callbackInfo.Env().GetAndClearPendingException(); + delete instance; + e.ThrowAsJavaScriptException(); + } else { + instance->_construction_failed = false; + } +#endif // NAPI_CPP_EXCEPTIONS + return callbackInfo.This(); + }); + + return wrapper; +} + +template +inline napi_value ObjectWrap::StaticVoidMethodCallbackWrapper( + napi_env env, napi_callback_info info) { + return details::WrapCallback([&] { + CallbackInfo callbackInfo(env, info); + StaticVoidMethodCallbackData* callbackData = + reinterpret_cast(callbackInfo.Data()); + callbackInfo.SetData(callbackData->data); + callbackData->callback(callbackInfo); + return nullptr; + }); +} + +template +inline napi_value ObjectWrap::StaticMethodCallbackWrapper( + napi_env env, napi_callback_info info) { + return details::WrapCallback([&] { + CallbackInfo callbackInfo(env, info); + StaticMethodCallbackData* callbackData = + reinterpret_cast(callbackInfo.Data()); + callbackInfo.SetData(callbackData->data); + return callbackData->callback(callbackInfo); + }); +} + +template +inline napi_value ObjectWrap::StaticGetterCallbackWrapper( + napi_env env, napi_callback_info info) { + return details::WrapCallback([&] { + CallbackInfo callbackInfo(env, info); + StaticAccessorCallbackData* callbackData = + reinterpret_cast(callbackInfo.Data()); + callbackInfo.SetData(callbackData->data); + return callbackData->getterCallback(callbackInfo); + }); +} + +template +inline napi_value ObjectWrap::StaticSetterCallbackWrapper( + napi_env env, napi_callback_info info) { + return details::WrapCallback([&] { + CallbackInfo callbackInfo(env, info); + StaticAccessorCallbackData* callbackData = + reinterpret_cast(callbackInfo.Data()); + callbackInfo.SetData(callbackData->data); + callbackData->setterCallback(callbackInfo, callbackInfo[0]); + return nullptr; + }); +} + +template +inline void ObjectWrap::FinalizeCallback(napi_env env, + void* data, + void* /*hint*/) { + HandleScope scope(env); + T* instance = static_cast(data); + instance->Finalize(Napi::Env(env)); + delete instance; +} + +template +template ::StaticSetterCallback method> +inline napi_value ObjectWrap::WrappedMethod( + napi_env env, napi_callback_info info) NAPI_NOEXCEPT { + return details::WrapCallback([&] { + const CallbackInfo cbInfo(env, info); + method(cbInfo, cbInfo[0]); + return nullptr; + }); +} + +//////////////////////////////////////////////////////////////////////////////// +// HandleScope class +//////////////////////////////////////////////////////////////////////////////// + +inline HandleScope::HandleScope(napi_env env, napi_handle_scope scope) + : _env(env), _scope(scope) {} + +inline HandleScope::HandleScope(Napi::Env env) : _env(env) { + napi_status status = napi_open_handle_scope(_env, &_scope); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +inline HandleScope::~HandleScope() { + napi_status status = napi_close_handle_scope(_env, _scope); + NAPI_FATAL_IF_FAILED( + status, "HandleScope::~HandleScope", "napi_close_handle_scope"); +} + +inline HandleScope::operator napi_handle_scope() const { + return _scope; +} + +inline Napi::Env HandleScope::Env() const { + return Napi::Env(_env); +} + +//////////////////////////////////////////////////////////////////////////////// +// EscapableHandleScope class +//////////////////////////////////////////////////////////////////////////////// + +inline EscapableHandleScope::EscapableHandleScope( + napi_env env, napi_escapable_handle_scope scope) + : _env(env), _scope(scope) {} + +inline EscapableHandleScope::EscapableHandleScope(Napi::Env env) : _env(env) { + napi_status status = napi_open_escapable_handle_scope(_env, &_scope); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +inline EscapableHandleScope::~EscapableHandleScope() { + napi_status status = napi_close_escapable_handle_scope(_env, _scope); + NAPI_FATAL_IF_FAILED(status, + "EscapableHandleScope::~EscapableHandleScope", + "napi_close_escapable_handle_scope"); +} + +inline EscapableHandleScope::operator napi_escapable_handle_scope() const { + return _scope; +} + +inline Napi::Env EscapableHandleScope::Env() const { + return Napi::Env(_env); +} + +inline Value EscapableHandleScope::Escape(napi_value escapee) { + napi_value result; + napi_status status = napi_escape_handle(_env, _scope, escapee, &result); + NAPI_THROW_IF_FAILED(_env, status, Value()); + return Value(_env, result); +} + +#if (NAPI_VERSION > 2) +//////////////////////////////////////////////////////////////////////////////// +// CallbackScope class +//////////////////////////////////////////////////////////////////////////////// + +inline CallbackScope::CallbackScope(napi_env env, napi_callback_scope scope) + : _env(env), _scope(scope) {} + +inline CallbackScope::CallbackScope(napi_env env, napi_async_context context) + : _env(env) { + napi_status status = + napi_open_callback_scope(_env, Object::New(env), context, &_scope); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +inline CallbackScope::~CallbackScope() { + napi_status status = napi_close_callback_scope(_env, _scope); + NAPI_FATAL_IF_FAILED( + status, "CallbackScope::~CallbackScope", "napi_close_callback_scope"); +} + +inline CallbackScope::operator napi_callback_scope() const { + return _scope; +} + +inline Napi::Env CallbackScope::Env() const { + return Napi::Env(_env); +} +#endif + +//////////////////////////////////////////////////////////////////////////////// +// AsyncContext class +//////////////////////////////////////////////////////////////////////////////// + +inline AsyncContext::AsyncContext(napi_env env, const char* resource_name) + : AsyncContext(env, resource_name, Object::New(env)) {} + +inline AsyncContext::AsyncContext(napi_env env, + const char* resource_name, + const Object& resource) + : _env(env), _context(nullptr) { + napi_value resource_id; + napi_status status = napi_create_string_utf8( + _env, resource_name, NAPI_AUTO_LENGTH, &resource_id); + NAPI_THROW_IF_FAILED_VOID(_env, status); + + status = napi_async_init(_env, resource, resource_id, &_context); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +inline AsyncContext::~AsyncContext() { + if (_context != nullptr) { + napi_async_destroy(_env, _context); + _context = nullptr; + } +} + +inline AsyncContext::AsyncContext(AsyncContext&& other) { + _env = other._env; + other._env = nullptr; + _context = other._context; + other._context = nullptr; +} + +inline AsyncContext& AsyncContext::operator=(AsyncContext&& other) { + _env = other._env; + other._env = nullptr; + _context = other._context; + other._context = nullptr; + return *this; +} + +inline AsyncContext::operator napi_async_context() const { + return _context; +} + +inline Napi::Env AsyncContext::Env() const { + return Napi::Env(_env); +} + +//////////////////////////////////////////////////////////////////////////////// +// AsyncWorker class +//////////////////////////////////////////////////////////////////////////////// + +#if NAPI_HAS_THREADS + +inline AsyncWorker::AsyncWorker(const Function& callback) + : AsyncWorker(callback, "generic") {} + +inline AsyncWorker::AsyncWorker(const Function& callback, + const char* resource_name) + : AsyncWorker(callback, resource_name, Object::New(callback.Env())) {} + +inline AsyncWorker::AsyncWorker(const Function& callback, + const char* resource_name, + const Object& resource) + : AsyncWorker( + Object::New(callback.Env()), callback, resource_name, resource) {} + +inline AsyncWorker::AsyncWorker(const Object& receiver, + const Function& callback) + : AsyncWorker(receiver, callback, "generic") {} + +inline AsyncWorker::AsyncWorker(const Object& receiver, + const Function& callback, + const char* resource_name) + : AsyncWorker( + receiver, callback, resource_name, Object::New(callback.Env())) {} + +inline AsyncWorker::AsyncWorker(const Object& receiver, + const Function& callback, + const char* resource_name, + const Object& resource) + : _env(callback.Env()), + _receiver(Napi::Persistent(receiver)), + _callback(Napi::Persistent(callback)), + _suppress_destruct(false) { + napi_value resource_id; + napi_status status = napi_create_string_latin1( + _env, resource_name, NAPI_AUTO_LENGTH, &resource_id); + NAPI_THROW_IF_FAILED_VOID(_env, status); + + status = napi_create_async_work(_env, + resource, + resource_id, + OnAsyncWorkExecute, + OnAsyncWorkComplete, + this, + &_work); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +inline AsyncWorker::AsyncWorker(Napi::Env env) : AsyncWorker(env, "generic") {} + +inline AsyncWorker::AsyncWorker(Napi::Env env, const char* resource_name) + : AsyncWorker(env, resource_name, Object::New(env)) {} + +inline AsyncWorker::AsyncWorker(Napi::Env env, + const char* resource_name, + const Object& resource) + : _env(env), _receiver(), _callback(), _suppress_destruct(false) { + napi_value resource_id; + napi_status status = napi_create_string_latin1( + _env, resource_name, NAPI_AUTO_LENGTH, &resource_id); + NAPI_THROW_IF_FAILED_VOID(_env, status); + + status = napi_create_async_work(_env, + resource, + resource_id, + OnAsyncWorkExecute, + OnAsyncWorkComplete, + this, + &_work); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +inline AsyncWorker::~AsyncWorker() { + if (_work != nullptr) { + napi_delete_async_work(_env, _work); + _work = nullptr; + } +} + +inline void AsyncWorker::Destroy() { + delete this; +} + +inline AsyncWorker::operator napi_async_work() const { + return _work; +} + +inline Napi::Env AsyncWorker::Env() const { + return Napi::Env(_env); +} + +inline void AsyncWorker::Queue() { + napi_status status = napi_queue_async_work(_env, _work); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +inline void AsyncWorker::Cancel() { + napi_status status = napi_cancel_async_work(_env, _work); + NAPI_THROW_IF_FAILED_VOID(_env, status); +} + +inline ObjectReference& AsyncWorker::Receiver() { + return _receiver; +} + +inline FunctionReference& AsyncWorker::Callback() { + return _callback; +} + +inline void AsyncWorker::SuppressDestruct() { + _suppress_destruct = true; +} + +inline void AsyncWorker::OnOK() { + if (!_callback.IsEmpty()) { + _callback.Call(_receiver.Value(), GetResult(_callback.Env())); + } +} + +inline void AsyncWorker::OnError(const Error& e) { + if (!_callback.IsEmpty()) { + _callback.Call(_receiver.Value(), + std::initializer_list{e.Value()}); + } +} + +inline void AsyncWorker::SetError(const std::string& error) { + _error = error; +} + +inline std::vector AsyncWorker::GetResult(Napi::Env /*env*/) { + return {}; +} +// The OnAsyncWorkExecute method receives an napi_env argument. However, do NOT +// use it within this method, as it does not run on the JavaScript thread and +// must not run any method that would cause JavaScript to run. In practice, +// this means that almost any use of napi_env will be incorrect. +inline void AsyncWorker::OnAsyncWorkExecute(napi_env env, void* asyncworker) { + AsyncWorker* self = static_cast(asyncworker); + self->OnExecute(env); +} +// The OnExecute method receives an napi_env argument. However, do NOT +// use it within this method, as it does not run on the JavaScript thread and +// must not run any method that would cause JavaScript to run. In practice, +// this means that almost any use of napi_env will be incorrect. +inline void AsyncWorker::OnExecute(Napi::Env /*DO_NOT_USE*/) { +#ifdef NAPI_CPP_EXCEPTIONS + try { + Execute(); + } catch (const std::exception& e) { + SetError(e.what()); + } +#else // NAPI_CPP_EXCEPTIONS + Execute(); +#endif // NAPI_CPP_EXCEPTIONS +} + +inline void AsyncWorker::OnAsyncWorkComplete(napi_env env, + napi_status status, + void* asyncworker) { + AsyncWorker* self = static_cast(asyncworker); + self->OnWorkComplete(env, status); +} +inline void AsyncWorker::OnWorkComplete(Napi::Env /*env*/, napi_status status) { + if (status != napi_cancelled) { + HandleScope scope(_env); + details::WrapCallback([&] { + if (_error.size() == 0) { + OnOK(); + } else { + OnError(Error::New(_env, _error)); + } + return nullptr; + }); + } + if (!_suppress_destruct) { + Destroy(); + } +} + +#endif // NAPI_HAS_THREADS + +#if (NAPI_VERSION > 3 && NAPI_HAS_THREADS) +//////////////////////////////////////////////////////////////////////////////// +// TypedThreadSafeFunction class +//////////////////////////////////////////////////////////////////////////////// + +// Starting with NAPI 5, the JavaScript function `func` parameter of +// `napi_create_threadsafe_function` is optional. +#if NAPI_VERSION > 4 +// static, with Callback [missing] Resource [missing] Finalizer [missing] +template +template +inline TypedThreadSafeFunction +TypedThreadSafeFunction::New( + napi_env env, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context) { + TypedThreadSafeFunction tsfn; + + napi_status status = + napi_create_threadsafe_function(env, + nullptr, + nullptr, + String::From(env, resourceName), + maxQueueSize, + initialThreadCount, + nullptr, + nullptr, + context, + CallJsInternal, + &tsfn._tsfn); + if (status != napi_ok) { + NAPI_THROW_IF_FAILED( + env, status, TypedThreadSafeFunction()); + } + + return tsfn; +} + +// static, with Callback [missing] Resource [passed] Finalizer [missing] +template +template +inline TypedThreadSafeFunction +TypedThreadSafeFunction::New( + napi_env env, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context) { + TypedThreadSafeFunction tsfn; + + napi_status status = + napi_create_threadsafe_function(env, + nullptr, + resource, + String::From(env, resourceName), + maxQueueSize, + initialThreadCount, + nullptr, + nullptr, + context, + CallJsInternal, + &tsfn._tsfn); + if (status != napi_ok) { + NAPI_THROW_IF_FAILED( + env, status, TypedThreadSafeFunction()); + } + + return tsfn; +} + +// static, with Callback [missing] Resource [missing] Finalizer [passed] +template +template +inline TypedThreadSafeFunction +TypedThreadSafeFunction::New( + napi_env env, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback, + FinalizerDataType* data) { + TypedThreadSafeFunction tsfn; + + auto* finalizeData = new details:: + ThreadSafeFinalize( + {data, finalizeCallback}); + napi_status status = napi_create_threadsafe_function( + env, + nullptr, + nullptr, + String::From(env, resourceName), + maxQueueSize, + initialThreadCount, + finalizeData, + details::ThreadSafeFinalize:: + FinalizeFinalizeWrapperWithDataAndContext, + context, + CallJsInternal, + &tsfn._tsfn); + if (status != napi_ok) { + delete finalizeData; + NAPI_THROW_IF_FAILED( + env, status, TypedThreadSafeFunction()); + } + + return tsfn; +} + +// static, with Callback [missing] Resource [passed] Finalizer [passed] +template +template +inline TypedThreadSafeFunction +TypedThreadSafeFunction::New( + napi_env env, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback, + FinalizerDataType* data) { + TypedThreadSafeFunction tsfn; + + auto* finalizeData = new details:: + ThreadSafeFinalize( + {data, finalizeCallback}); + napi_status status = napi_create_threadsafe_function( + env, + nullptr, + resource, + String::From(env, resourceName), + maxQueueSize, + initialThreadCount, + finalizeData, + details::ThreadSafeFinalize:: + FinalizeFinalizeWrapperWithDataAndContext, + context, + CallJsInternal, + &tsfn._tsfn); + if (status != napi_ok) { + delete finalizeData; + NAPI_THROW_IF_FAILED( + env, status, TypedThreadSafeFunction()); + } + + return tsfn; +} +#endif + +// static, with Callback [passed] Resource [missing] Finalizer [missing] +template +template +inline TypedThreadSafeFunction +TypedThreadSafeFunction::New( + napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context) { + TypedThreadSafeFunction tsfn; + + napi_status status = + napi_create_threadsafe_function(env, + callback, + nullptr, + String::From(env, resourceName), + maxQueueSize, + initialThreadCount, + nullptr, + nullptr, + context, + CallJsInternal, + &tsfn._tsfn); + if (status != napi_ok) { + NAPI_THROW_IF_FAILED( + env, status, TypedThreadSafeFunction()); + } + + return tsfn; +} + +// static, with Callback [passed] Resource [passed] Finalizer [missing] +template +template +inline TypedThreadSafeFunction +TypedThreadSafeFunction::New( + napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context) { + TypedThreadSafeFunction tsfn; + + napi_status status = + napi_create_threadsafe_function(env, + callback, + resource, + String::From(env, resourceName), + maxQueueSize, + initialThreadCount, + nullptr, + nullptr, + context, + CallJsInternal, + &tsfn._tsfn); + if (status != napi_ok) { + NAPI_THROW_IF_FAILED( + env, status, TypedThreadSafeFunction()); + } + + return tsfn; +} + +// static, with Callback [passed] Resource [missing] Finalizer [passed] +template +template +inline TypedThreadSafeFunction +TypedThreadSafeFunction::New( + napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback, + FinalizerDataType* data) { + TypedThreadSafeFunction tsfn; + + auto* finalizeData = new details:: + ThreadSafeFinalize( + {data, finalizeCallback}); + napi_status status = napi_create_threadsafe_function( + env, + callback, + nullptr, + String::From(env, resourceName), + maxQueueSize, + initialThreadCount, + finalizeData, + details::ThreadSafeFinalize:: + FinalizeFinalizeWrapperWithDataAndContext, + context, + CallJsInternal, + &tsfn._tsfn); + if (status != napi_ok) { + delete finalizeData; + NAPI_THROW_IF_FAILED( + env, status, TypedThreadSafeFunction()); + } + + return tsfn; +} + +// static, with: Callback [passed] Resource [passed] Finalizer [passed] +template +template +inline TypedThreadSafeFunction +TypedThreadSafeFunction::New( + napi_env env, + CallbackType callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback, + FinalizerDataType* data) { + TypedThreadSafeFunction tsfn; + + auto* finalizeData = new details:: + ThreadSafeFinalize( + {data, finalizeCallback}); + napi_status status = napi_create_threadsafe_function( + env, + details::DefaultCallbackWrapper< + CallbackType, + TypedThreadSafeFunction>(env, + callback), + resource, + String::From(env, resourceName), + maxQueueSize, + initialThreadCount, + finalizeData, + details::ThreadSafeFinalize:: + FinalizeFinalizeWrapperWithDataAndContext, + context, + CallJsInternal, + &tsfn._tsfn); + if (status != napi_ok) { + delete finalizeData; + NAPI_THROW_IF_FAILED( + env, status, TypedThreadSafeFunction()); + } + + return tsfn; +} + +template +inline TypedThreadSafeFunction:: + TypedThreadSafeFunction() + : _tsfn() {} + +template +inline TypedThreadSafeFunction:: + TypedThreadSafeFunction(napi_threadsafe_function tsfn) + : _tsfn(tsfn) {} + +template +inline TypedThreadSafeFunction:: +operator napi_threadsafe_function() const { + return _tsfn; +} + +template +inline napi_status +TypedThreadSafeFunction::BlockingCall( + DataType* data) const { + return napi_call_threadsafe_function(_tsfn, data, napi_tsfn_blocking); +} + +template +inline napi_status +TypedThreadSafeFunction::NonBlockingCall( + DataType* data) const { + return napi_call_threadsafe_function(_tsfn, data, napi_tsfn_nonblocking); +} + +template +inline void TypedThreadSafeFunction::Ref( + napi_env env) const { + if (_tsfn != nullptr) { + napi_status status = napi_ref_threadsafe_function(env, _tsfn); + NAPI_THROW_IF_FAILED_VOID(env, status); + } +} + +template +inline void TypedThreadSafeFunction::Unref( + napi_env env) const { + if (_tsfn != nullptr) { + napi_status status = napi_unref_threadsafe_function(env, _tsfn); + NAPI_THROW_IF_FAILED_VOID(env, status); + } +} + +template +inline napi_status +TypedThreadSafeFunction::Acquire() const { + return napi_acquire_threadsafe_function(_tsfn); +} + +template +inline napi_status +TypedThreadSafeFunction::Release() const { + return napi_release_threadsafe_function(_tsfn, napi_tsfn_release); +} + +template +inline napi_status +TypedThreadSafeFunction::Abort() const { + return napi_release_threadsafe_function(_tsfn, napi_tsfn_abort); +} + +template +inline ContextType* +TypedThreadSafeFunction::GetContext() const { + void* context; + napi_status status = napi_get_threadsafe_function_context(_tsfn, &context); + NAPI_FATAL_IF_FAILED(status, + "TypedThreadSafeFunction::GetContext", + "napi_get_threadsafe_function_context"); + return static_cast(context); +} + +// static +template +void TypedThreadSafeFunction::CallJsInternal( + napi_env env, napi_value jsCallback, void* context, void* data) { + details::CallJsWrapper( + env, jsCallback, context, data); +} + +#if NAPI_VERSION == 4 +// static +template +Napi::Function +TypedThreadSafeFunction::EmptyFunctionFactory( + Napi::Env env) { + return Napi::Function::New(env, [](const CallbackInfo& cb) {}); +} + +// static +template +Napi::Function +TypedThreadSafeFunction::FunctionOrEmpty( + Napi::Env env, Napi::Function& callback) { + if (callback.IsEmpty()) { + return EmptyFunctionFactory(env); + } + return callback; +} + +#else +// static +template +std::nullptr_t +TypedThreadSafeFunction::EmptyFunctionFactory( + Napi::Env /*env*/) { + return nullptr; +} + +// static +template +Napi::Function +TypedThreadSafeFunction::FunctionOrEmpty( + Napi::Env /*env*/, Napi::Function& callback) { + return callback; +} + +#endif + +//////////////////////////////////////////////////////////////////////////////// +// ThreadSafeFunction class +//////////////////////////////////////////////////////////////////////////////// + +// static +template +inline ThreadSafeFunction ThreadSafeFunction::New(napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount) { + return New( + env, callback, Object(), resourceName, maxQueueSize, initialThreadCount); +} + +// static +template +inline ThreadSafeFunction ThreadSafeFunction::New(napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context) { + return New(env, + callback, + Object(), + resourceName, + maxQueueSize, + initialThreadCount, + context); +} + +// static +template +inline ThreadSafeFunction ThreadSafeFunction::New(napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + Finalizer finalizeCallback) { + return New(env, + callback, + Object(), + resourceName, + maxQueueSize, + initialThreadCount, + finalizeCallback); +} + +// static +template +inline ThreadSafeFunction ThreadSafeFunction::New(napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + Finalizer finalizeCallback, + FinalizerDataType* data) { + return New(env, + callback, + Object(), + resourceName, + maxQueueSize, + initialThreadCount, + finalizeCallback, + data); +} + +// static +template +inline ThreadSafeFunction ThreadSafeFunction::New(napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback) { + return New(env, + callback, + Object(), + resourceName, + maxQueueSize, + initialThreadCount, + context, + finalizeCallback); +} + +// static +template +inline ThreadSafeFunction ThreadSafeFunction::New(napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback, + FinalizerDataType* data) { + return New(env, + callback, + Object(), + resourceName, + maxQueueSize, + initialThreadCount, + context, + finalizeCallback, + data); +} + +// static +template +inline ThreadSafeFunction ThreadSafeFunction::New(napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount) { + return New(env, + callback, + resource, + resourceName, + maxQueueSize, + initialThreadCount, + static_cast(nullptr) /* context */); +} + +// static +template +inline ThreadSafeFunction ThreadSafeFunction::New(napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context) { + return New(env, + callback, + resource, + resourceName, + maxQueueSize, + initialThreadCount, + context, + [](Env, ContextType*) {} /* empty finalizer */); +} + +// static +template +inline ThreadSafeFunction ThreadSafeFunction::New(napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + Finalizer finalizeCallback) { + return New(env, + callback, + resource, + resourceName, + maxQueueSize, + initialThreadCount, + static_cast(nullptr) /* context */, + finalizeCallback, + static_cast(nullptr) /* data */, + details::ThreadSafeFinalize::Wrapper); +} + +// static +template +inline ThreadSafeFunction ThreadSafeFunction::New(napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + Finalizer finalizeCallback, + FinalizerDataType* data) { + return New(env, + callback, + resource, + resourceName, + maxQueueSize, + initialThreadCount, + static_cast(nullptr) /* context */, + finalizeCallback, + data, + details::ThreadSafeFinalize:: + FinalizeWrapperWithData); +} + +// static +template +inline ThreadSafeFunction ThreadSafeFunction::New(napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback) { + return New( + env, + callback, + resource, + resourceName, + maxQueueSize, + initialThreadCount, + context, + finalizeCallback, + static_cast(nullptr) /* data */, + details::ThreadSafeFinalize::FinalizeWrapperWithContext); +} + +// static +template +inline ThreadSafeFunction ThreadSafeFunction::New(napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback, + FinalizerDataType* data) { + return New( + env, + callback, + resource, + resourceName, + maxQueueSize, + initialThreadCount, + context, + finalizeCallback, + data, + details::ThreadSafeFinalize:: + FinalizeFinalizeWrapperWithDataAndContext); +} + +inline ThreadSafeFunction::ThreadSafeFunction() : _tsfn() {} + +inline ThreadSafeFunction::ThreadSafeFunction(napi_threadsafe_function tsfn) + : _tsfn(tsfn) {} + +inline ThreadSafeFunction::operator napi_threadsafe_function() const { + return _tsfn; +} + +inline napi_status ThreadSafeFunction::BlockingCall() const { + return CallInternal(nullptr, napi_tsfn_blocking); +} + +template <> +inline napi_status ThreadSafeFunction::BlockingCall(void* data) const { + return napi_call_threadsafe_function(_tsfn, data, napi_tsfn_blocking); +} + +template +inline napi_status ThreadSafeFunction::BlockingCall(Callback callback) const { + return CallInternal(new CallbackWrapper(callback), napi_tsfn_blocking); +} + +template +inline napi_status ThreadSafeFunction::BlockingCall(DataType* data, + Callback callback) const { + auto wrapper = [data, callback](Env env, Function jsCallback) { + callback(env, jsCallback, data); + }; + return CallInternal(new CallbackWrapper(wrapper), napi_tsfn_blocking); +} + +inline napi_status ThreadSafeFunction::NonBlockingCall() const { + return CallInternal(nullptr, napi_tsfn_nonblocking); +} + +template <> +inline napi_status ThreadSafeFunction::NonBlockingCall(void* data) const { + return napi_call_threadsafe_function(_tsfn, data, napi_tsfn_nonblocking); +} + +template +inline napi_status ThreadSafeFunction::NonBlockingCall( + Callback callback) const { + return CallInternal(new CallbackWrapper(callback), napi_tsfn_nonblocking); +} + +template +inline napi_status ThreadSafeFunction::NonBlockingCall( + DataType* data, Callback callback) const { + auto wrapper = [data, callback](Env env, Function jsCallback) { + callback(env, jsCallback, data); + }; + return CallInternal(new CallbackWrapper(wrapper), napi_tsfn_nonblocking); +} + +inline void ThreadSafeFunction::Ref(napi_env env) const { + if (_tsfn != nullptr) { + napi_status status = napi_ref_threadsafe_function(env, _tsfn); + NAPI_THROW_IF_FAILED_VOID(env, status); + } +} + +inline void ThreadSafeFunction::Unref(napi_env env) const { + if (_tsfn != nullptr) { + napi_status status = napi_unref_threadsafe_function(env, _tsfn); + NAPI_THROW_IF_FAILED_VOID(env, status); + } +} + +inline napi_status ThreadSafeFunction::Acquire() const { + return napi_acquire_threadsafe_function(_tsfn); +} + +inline napi_status ThreadSafeFunction::Release() const { + return napi_release_threadsafe_function(_tsfn, napi_tsfn_release); +} + +inline napi_status ThreadSafeFunction::Abort() const { + return napi_release_threadsafe_function(_tsfn, napi_tsfn_abort); +} + +inline ThreadSafeFunction::ConvertibleContext ThreadSafeFunction::GetContext() + const { + void* context; + napi_status status = napi_get_threadsafe_function_context(_tsfn, &context); + NAPI_FATAL_IF_FAILED(status, + "ThreadSafeFunction::GetContext", + "napi_get_threadsafe_function_context"); + return ConvertibleContext({context}); +} + +// static +template +inline ThreadSafeFunction ThreadSafeFunction::New(napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback, + FinalizerDataType* data, + napi_finalize wrapper) { + static_assert(details::can_make_string::value || + std::is_convertible::value, + "Resource name should be convertible to the string type"); + + ThreadSafeFunction tsfn; + auto* finalizeData = new details:: + ThreadSafeFinalize( + {data, finalizeCallback}); + napi_status status = + napi_create_threadsafe_function(env, + callback, + resource, + Value::From(env, resourceName), + maxQueueSize, + initialThreadCount, + finalizeData, + wrapper, + context, + CallJS, + &tsfn._tsfn); + if (status != napi_ok) { + delete finalizeData; + NAPI_THROW_IF_FAILED(env, status, ThreadSafeFunction()); + } + + return tsfn; +} + +inline napi_status ThreadSafeFunction::CallInternal( + CallbackWrapper* callbackWrapper, + napi_threadsafe_function_call_mode mode) const { + napi_status status = + napi_call_threadsafe_function(_tsfn, callbackWrapper, mode); + if (status != napi_ok && callbackWrapper != nullptr) { + delete callbackWrapper; + } + + return status; +} + +// static +inline void ThreadSafeFunction::CallJS(napi_env env, + napi_value jsCallback, + void* /* context */, + void* data) { + if (env == nullptr && jsCallback == nullptr) { + return; + } + + details::WrapVoidCallback([&]() { + if (data != nullptr) { + auto* callbackWrapper = static_cast(data); + (*callbackWrapper)(env, Function(env, jsCallback)); + delete callbackWrapper; + } else if (jsCallback != nullptr) { + Function(env, jsCallback).Call({}); + } + }); +} + +//////////////////////////////////////////////////////////////////////////////// +// Async Progress Worker Base class +//////////////////////////////////////////////////////////////////////////////// +template +inline AsyncProgressWorkerBase::AsyncProgressWorkerBase( + const Object& receiver, + const Function& callback, + const char* resource_name, + const Object& resource, + size_t queue_size) + : AsyncWorker(receiver, callback, resource_name, resource) { + // Fill all possible arguments to work around ambiguous + // ThreadSafeFunction::New signatures. + _tsfn = ThreadSafeFunction::New(callback.Env(), + callback, + resource, + resource_name, + queue_size, + /** initialThreadCount */ 1, + /** context */ this, + OnThreadSafeFunctionFinalize, + /** finalizeData */ this); +} + +#if NAPI_VERSION > 4 +template +inline AsyncProgressWorkerBase::AsyncProgressWorkerBase( + Napi::Env env, + const char* resource_name, + const Object& resource, + size_t queue_size) + : AsyncWorker(env, resource_name, resource) { + // TODO: Once the changes to make the callback optional for threadsafe + // functions are available on all versions we can remove the dummy Function + // here. + Function callback; + // Fill all possible arguments to work around ambiguous + // ThreadSafeFunction::New signatures. + _tsfn = ThreadSafeFunction::New(env, + callback, + resource, + resource_name, + queue_size, + /** initialThreadCount */ 1, + /** context */ this, + OnThreadSafeFunctionFinalize, + /** finalizeData */ this); +} +#endif + +template +inline AsyncProgressWorkerBase::~AsyncProgressWorkerBase() { + // Abort pending tsfn call. + // Don't send progress events after we've already completed. + // It's ok to call ThreadSafeFunction::Abort and ThreadSafeFunction::Release + // duplicated. + _tsfn.Abort(); +} + +template +inline void AsyncProgressWorkerBase::OnAsyncWorkProgress( + Napi::Env /* env */, Napi::Function /* jsCallback */, void* data) { + ThreadSafeData* tsd = static_cast(data); + tsd->asyncprogressworker()->OnWorkProgress(tsd->data()); + delete tsd; +} + +template +inline napi_status AsyncProgressWorkerBase::NonBlockingCall( + DataType* data) { + auto tsd = new AsyncProgressWorkerBase::ThreadSafeData(this, data); + auto ret = _tsfn.NonBlockingCall(tsd, OnAsyncWorkProgress); + if (ret != napi_ok) { + delete tsd; + } + return ret; +} + +template +inline void AsyncProgressWorkerBase::OnWorkComplete( + Napi::Env /* env */, napi_status status) { + _work_completed = true; + _complete_status = status; + _tsfn.Release(); +} + +template +inline void AsyncProgressWorkerBase::OnThreadSafeFunctionFinalize( + Napi::Env env, void* /* data */, AsyncProgressWorkerBase* context) { + if (context->_work_completed) { + context->AsyncWorker::OnWorkComplete(env, context->_complete_status); + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Async Progress Worker class +//////////////////////////////////////////////////////////////////////////////// +template +inline AsyncProgressWorker::AsyncProgressWorker(const Function& callback) + : AsyncProgressWorker(callback, "generic") {} + +template +inline AsyncProgressWorker::AsyncProgressWorker(const Function& callback, + const char* resource_name) + : AsyncProgressWorker( + callback, resource_name, Object::New(callback.Env())) {} + +template +inline AsyncProgressWorker::AsyncProgressWorker(const Function& callback, + const char* resource_name, + const Object& resource) + : AsyncProgressWorker( + Object::New(callback.Env()), callback, resource_name, resource) {} + +template +inline AsyncProgressWorker::AsyncProgressWorker(const Object& receiver, + const Function& callback) + : AsyncProgressWorker(receiver, callback, "generic") {} + +template +inline AsyncProgressWorker::AsyncProgressWorker(const Object& receiver, + const Function& callback, + const char* resource_name) + : AsyncProgressWorker( + receiver, callback, resource_name, Object::New(callback.Env())) {} + +template +inline AsyncProgressWorker::AsyncProgressWorker(const Object& receiver, + const Function& callback, + const char* resource_name, + const Object& resource) + : AsyncProgressWorkerBase(receiver, callback, resource_name, resource), + _asyncdata(nullptr), + _asyncsize(0), + _signaled(false) {} + +#if NAPI_VERSION > 4 +template +inline AsyncProgressWorker::AsyncProgressWorker(Napi::Env env) + : AsyncProgressWorker(env, "generic") {} + +template +inline AsyncProgressWorker::AsyncProgressWorker(Napi::Env env, + const char* resource_name) + : AsyncProgressWorker(env, resource_name, Object::New(env)) {} + +template +inline AsyncProgressWorker::AsyncProgressWorker(Napi::Env env, + const char* resource_name, + const Object& resource) + : AsyncProgressWorkerBase(env, resource_name, resource), + _asyncdata(nullptr), + _asyncsize(0) {} +#endif + +template +inline AsyncProgressWorker::~AsyncProgressWorker() { + { + std::lock_guard lock(this->_mutex); + _asyncdata = nullptr; + _asyncsize = 0; + } +} + +template +inline void AsyncProgressWorker::Execute() { + ExecutionProgress progress(this); + Execute(progress); +} + +template +inline void AsyncProgressWorker::OnWorkProgress(void*) { + T* data; + size_t size; + bool signaled; + { + std::lock_guard lock(this->_mutex); + data = this->_asyncdata; + size = this->_asyncsize; + signaled = this->_signaled; + this->_asyncdata = nullptr; + this->_asyncsize = 0; + this->_signaled = false; + } + + /** + * The callback of ThreadSafeFunction is not been invoked immediately on the + * callback of uv_async_t (uv io poll), rather the callback of TSFN is + * invoked on the right next uv idle callback. There are chances that during + * the deferring the signal of uv_async_t is been sent again, i.e. potential + * not coalesced two calls of the TSFN callback. + */ + if (data == nullptr && !signaled) { + return; + } + + this->OnProgress(data, size); + delete[] data; +} + +template +inline void AsyncProgressWorker::SendProgress_(const T* data, size_t count) { + T* new_data = new T[count]; + std::copy(data, data + count, new_data); + + T* old_data; + { + std::lock_guard lock(this->_mutex); + old_data = _asyncdata; + _asyncdata = new_data; + _asyncsize = count; + _signaled = false; + } + this->NonBlockingCall(nullptr); + + delete[] old_data; +} + +template +inline void AsyncProgressWorker::Signal() { + { + std::lock_guard lock(this->_mutex); + _signaled = true; + } + this->NonBlockingCall(static_cast(nullptr)); +} + +template +inline void AsyncProgressWorker::ExecutionProgress::Signal() const { + this->_worker->Signal(); +} + +template +inline void AsyncProgressWorker::ExecutionProgress::Send( + const T* data, size_t count) const { + _worker->SendProgress_(data, count); +} + +//////////////////////////////////////////////////////////////////////////////// +// Async Progress Queue Worker class +//////////////////////////////////////////////////////////////////////////////// +template +inline AsyncProgressQueueWorker::AsyncProgressQueueWorker( + const Function& callback) + : AsyncProgressQueueWorker(callback, "generic") {} + +template +inline AsyncProgressQueueWorker::AsyncProgressQueueWorker( + const Function& callback, const char* resource_name) + : AsyncProgressQueueWorker( + callback, resource_name, Object::New(callback.Env())) {} + +template +inline AsyncProgressQueueWorker::AsyncProgressQueueWorker( + const Function& callback, const char* resource_name, const Object& resource) + : AsyncProgressQueueWorker( + Object::New(callback.Env()), callback, resource_name, resource) {} + +template +inline AsyncProgressQueueWorker::AsyncProgressQueueWorker( + const Object& receiver, const Function& callback) + : AsyncProgressQueueWorker(receiver, callback, "generic") {} + +template +inline AsyncProgressQueueWorker::AsyncProgressQueueWorker( + const Object& receiver, const Function& callback, const char* resource_name) + : AsyncProgressQueueWorker( + receiver, callback, resource_name, Object::New(callback.Env())) {} + +template +inline AsyncProgressQueueWorker::AsyncProgressQueueWorker( + const Object& receiver, + const Function& callback, + const char* resource_name, + const Object& resource) + : AsyncProgressWorkerBase>( + receiver, + callback, + resource_name, + resource, + /** unlimited queue size */ 0) {} + +#if NAPI_VERSION > 4 +template +inline AsyncProgressQueueWorker::AsyncProgressQueueWorker(Napi::Env env) + : AsyncProgressQueueWorker(env, "generic") {} + +template +inline AsyncProgressQueueWorker::AsyncProgressQueueWorker( + Napi::Env env, const char* resource_name) + : AsyncProgressQueueWorker(env, resource_name, Object::New(env)) {} + +template +inline AsyncProgressQueueWorker::AsyncProgressQueueWorker( + Napi::Env env, const char* resource_name, const Object& resource) + : AsyncProgressWorkerBase>( + env, resource_name, resource, /** unlimited queue size */ 0) {} +#endif + +template +inline void AsyncProgressQueueWorker::Execute() { + ExecutionProgress progress(this); + Execute(progress); +} + +template +inline void AsyncProgressQueueWorker::OnWorkProgress( + std::pair* datapair) { + if (datapair == nullptr) { + return; + } + + T* data = datapair->first; + size_t size = datapair->second; + + this->OnProgress(data, size); + delete datapair; + delete[] data; +} + +template +inline void AsyncProgressQueueWorker::SendProgress_(const T* data, + size_t count) { + T* new_data = new T[count]; + std::copy(data, data + count, new_data); + + auto pair = new std::pair(new_data, count); + this->NonBlockingCall(pair); +} + +template +inline void AsyncProgressQueueWorker::Signal() const { + this->SendProgress_(static_cast(nullptr), 0); +} + +template +inline void AsyncProgressQueueWorker::OnWorkComplete(Napi::Env env, + napi_status status) { + // Draining queued items in TSFN. + AsyncProgressWorkerBase>::OnWorkComplete(env, status); +} + +template +inline void AsyncProgressQueueWorker::ExecutionProgress::Signal() const { + _worker->SendProgress_(static_cast(nullptr), 0); +} + +template +inline void AsyncProgressQueueWorker::ExecutionProgress::Send( + const T* data, size_t count) const { + _worker->SendProgress_(data, count); +} +#endif // NAPI_VERSION > 3 && NAPI_HAS_THREADS + +//////////////////////////////////////////////////////////////////////////////// +// Memory Management class +//////////////////////////////////////////////////////////////////////////////// + +inline int64_t MemoryManagement::AdjustExternalMemory(Env env, + int64_t change_in_bytes) { + int64_t result; + napi_status status = + napi_adjust_external_memory(env, change_in_bytes, &result); + NAPI_THROW_IF_FAILED(env, status, 0); + return result; +} + +//////////////////////////////////////////////////////////////////////////////// +// Version Management class +//////////////////////////////////////////////////////////////////////////////// + +inline uint32_t VersionManagement::GetNapiVersion(Env env) { + uint32_t result; + napi_status status = napi_get_version(env, &result); + NAPI_THROW_IF_FAILED(env, status, 0); + return result; +} + +inline const napi_node_version* VersionManagement::GetNodeVersion(Env env) { + const napi_node_version* result; + napi_status status = napi_get_node_version(env, &result); + NAPI_THROW_IF_FAILED(env, status, 0); + return result; +} + +#if NAPI_VERSION > 5 +//////////////////////////////////////////////////////////////////////////////// +// Addon class +//////////////////////////////////////////////////////////////////////////////// + +template +inline Object Addon::Init(Env env, Object exports) { + T* addon = new T(env, exports); + env.SetInstanceData(addon); + return addon->entry_point_; +} + +template +inline T* Addon::Unwrap(Object wrapper) { + return wrapper.Env().GetInstanceData(); +} + +template +inline void Addon::DefineAddon( + Object exports, const std::initializer_list& props) { + DefineProperties(exports, props); + entry_point_ = exports; +} + +template +inline Napi::Object Addon::DefineProperties( + Object object, const std::initializer_list& props) { + const napi_property_descriptor* properties = + reinterpret_cast(props.begin()); + size_t size = props.size(); + napi_status status = + napi_define_properties(object.Env(), object, size, properties); + NAPI_THROW_IF_FAILED(object.Env(), status, object); + for (size_t idx = 0; idx < size; idx++) + T::AttachPropData(object.Env(), object, &properties[idx]); + return object; +} +#endif // NAPI_VERSION > 5 + +#if NAPI_VERSION > 2 +template +Env::CleanupHook Env::AddCleanupHook(Hook hook, Arg* arg) { + return CleanupHook(*this, hook, arg); +} + +template +Env::CleanupHook Env::AddCleanupHook(Hook hook) { + return CleanupHook(*this, hook); +} + +template +Env::CleanupHook::CleanupHook() { + data = nullptr; +} + +template +Env::CleanupHook::CleanupHook(Napi::Env env, Hook hook) + : wrapper(Env::CleanupHook::Wrapper) { + data = new CleanupData{std::move(hook), nullptr}; + napi_status status = napi_add_env_cleanup_hook(env, wrapper, data); + if (status != napi_ok) { + delete data; + data = nullptr; + } +} + +template +Env::CleanupHook::CleanupHook(Napi::Env env, Hook hook, Arg* arg) + : wrapper(Env::CleanupHook::WrapperWithArg) { + data = new CleanupData{std::move(hook), arg}; + napi_status status = napi_add_env_cleanup_hook(env, wrapper, data); + if (status != napi_ok) { + delete data; + data = nullptr; + } +} + +template +bool Env::CleanupHook::Remove(Env env) { + napi_status status = napi_remove_env_cleanup_hook(env, wrapper, data); + delete data; + data = nullptr; + return status == napi_ok; +} + +template +bool Env::CleanupHook::IsEmpty() const { + return data == nullptr; +} +#endif // NAPI_VERSION > 2 + +#ifdef NAPI_CPP_CUSTOM_NAMESPACE +} // namespace NAPI_CPP_CUSTOM_NAMESPACE +#endif + +} // namespace Napi + +#endif // SRC_NAPI_INL_H_ diff --git a/node_modules/node-addon-api/napi.h b/node_modules/node-addon-api/napi.h new file mode 100644 index 0000000..9f20cb8 --- /dev/null +++ b/node_modules/node-addon-api/napi.h @@ -0,0 +1,3201 @@ +#ifndef SRC_NAPI_H_ +#define SRC_NAPI_H_ + +#ifndef NAPI_HAS_THREADS +#if !defined(__wasm__) || (defined(__EMSCRIPTEN_PTHREADS__) || \ + (defined(__wasi__) && defined(_REENTRANT))) +#define NAPI_HAS_THREADS 1 +#else +#define NAPI_HAS_THREADS 0 +#endif +#endif + +#include +#include +#include +#include +#if NAPI_HAS_THREADS +#include +#endif // NAPI_HAS_THREADS +#include +#include + +// VS2015 RTM has bugs with constexpr, so require min of VS2015 Update 3 (known +// good version) +#if !defined(_MSC_VER) || _MSC_FULL_VER >= 190024210 +#define NAPI_HAS_CONSTEXPR 1 +#endif + +// VS2013 does not support char16_t literal strings, so we'll work around it +// using wchar_t strings and casting them. This is safe as long as the character +// sizes are the same. +#if defined(_MSC_VER) && _MSC_VER <= 1800 +static_assert(sizeof(char16_t) == sizeof(wchar_t), + "Size mismatch between char16_t and wchar_t"); +#define NAPI_WIDE_TEXT(x) reinterpret_cast(L##x) +#else +#define NAPI_WIDE_TEXT(x) u##x +#endif + +// If C++ exceptions are not explicitly enabled or disabled, enable them +// if exceptions were enabled in the compiler settings. +#if !defined(NAPI_CPP_EXCEPTIONS) && !defined(NAPI_DISABLE_CPP_EXCEPTIONS) +#if defined(_CPPUNWIND) || defined(__EXCEPTIONS) +#define NAPI_CPP_EXCEPTIONS +#else +#error Exception support not detected. \ + Define either NAPI_CPP_EXCEPTIONS or NAPI_DISABLE_CPP_EXCEPTIONS. +#endif +#endif + +// If C++ NAPI_CPP_EXCEPTIONS are enabled, NODE_ADDON_API_ENABLE_MAYBE should +// not be set +#if defined(NAPI_CPP_EXCEPTIONS) && defined(NODE_ADDON_API_ENABLE_MAYBE) +#error NODE_ADDON_API_ENABLE_MAYBE should not be set when \ + NAPI_CPP_EXCEPTIONS is defined. +#endif + +#ifdef _NOEXCEPT +#define NAPI_NOEXCEPT _NOEXCEPT +#else +#define NAPI_NOEXCEPT noexcept +#endif + +#ifdef NAPI_CPP_EXCEPTIONS + +// When C++ exceptions are enabled, Errors are thrown directly. There is no need +// to return anything after the throw statements. The variadic parameter is an +// optional return value that is ignored. +// We need _VOID versions of the macros to avoid warnings resulting from +// leaving the NAPI_THROW_* `...` argument empty. + +#define NAPI_THROW(e, ...) throw e +#define NAPI_THROW_VOID(e) throw e + +#define NAPI_THROW_IF_FAILED(env, status, ...) \ + if ((status) != napi_ok) throw Napi::Error::New(env); + +#define NAPI_THROW_IF_FAILED_VOID(env, status) \ + if ((status) != napi_ok) throw Napi::Error::New(env); + +#else // NAPI_CPP_EXCEPTIONS + +// When C++ exceptions are disabled, Errors are thrown as JavaScript exceptions, +// which are pending until the callback returns to JS. The variadic parameter +// is an optional return value; usually it is an empty result. +// We need _VOID versions of the macros to avoid warnings resulting from +// leaving the NAPI_THROW_* `...` argument empty. + +#define NAPI_THROW(e, ...) \ + do { \ + (e).ThrowAsJavaScriptException(); \ + return __VA_ARGS__; \ + } while (0) + +#define NAPI_THROW_VOID(e) \ + do { \ + (e).ThrowAsJavaScriptException(); \ + return; \ + } while (0) + +#define NAPI_THROW_IF_FAILED(env, status, ...) \ + if ((status) != napi_ok) { \ + Napi::Error::New(env).ThrowAsJavaScriptException(); \ + return __VA_ARGS__; \ + } + +#define NAPI_THROW_IF_FAILED_VOID(env, status) \ + if ((status) != napi_ok) { \ + Napi::Error::New(env).ThrowAsJavaScriptException(); \ + return; \ + } + +#endif // NAPI_CPP_EXCEPTIONS + +#ifdef NODE_ADDON_API_ENABLE_MAYBE +#define NAPI_MAYBE_THROW_IF_FAILED(env, status, type) \ + NAPI_THROW_IF_FAILED(env, status, Napi::Nothing()) + +#define NAPI_RETURN_OR_THROW_IF_FAILED(env, status, result, type) \ + NAPI_MAYBE_THROW_IF_FAILED(env, status, type); \ + return Napi::Just(result); +#else +#define NAPI_MAYBE_THROW_IF_FAILED(env, status, type) \ + NAPI_THROW_IF_FAILED(env, status, type()) + +#define NAPI_RETURN_OR_THROW_IF_FAILED(env, status, result, type) \ + NAPI_MAYBE_THROW_IF_FAILED(env, status, type); \ + return result; +#endif + +#define NAPI_DISALLOW_ASSIGN(CLASS) void operator=(const CLASS&) = delete; +#define NAPI_DISALLOW_COPY(CLASS) CLASS(const CLASS&) = delete; + +#define NAPI_DISALLOW_ASSIGN_COPY(CLASS) \ + NAPI_DISALLOW_ASSIGN(CLASS) \ + NAPI_DISALLOW_COPY(CLASS) + +#define NAPI_CHECK(condition, location, message) \ + do { \ + if (!(condition)) { \ + Napi::Error::Fatal((location), (message)); \ + } \ + } while (0) + +#define NAPI_FATAL_IF_FAILED(status, location, message) \ + NAPI_CHECK((status) == napi_ok, location, message) + +//////////////////////////////////////////////////////////////////////////////// +/// Node-API C++ Wrapper Classes +/// +/// These classes wrap the "Node-API" ABI-stable C APIs for Node.js, providing a +/// C++ object model and C++ exception-handling semantics with low overhead. +/// The wrappers are all header-only so that they do not affect the ABI. +//////////////////////////////////////////////////////////////////////////////// +namespace Napi { + +#ifdef NAPI_CPP_CUSTOM_NAMESPACE +// NAPI_CPP_CUSTOM_NAMESPACE can be #define'd per-addon to avoid symbol +// conflicts between different instances of node-addon-api + +// First dummy definition of the namespace to make sure that Napi::(name) still +// refers to the right things inside this file. +namespace NAPI_CPP_CUSTOM_NAMESPACE {} +using namespace NAPI_CPP_CUSTOM_NAMESPACE; + +namespace NAPI_CPP_CUSTOM_NAMESPACE { +#endif + +// Forward declarations +class Env; +class Value; +class Boolean; +class Number; +#if NAPI_VERSION > 5 +class BigInt; +#endif // NAPI_VERSION > 5 +#if (NAPI_VERSION > 4) +class Date; +#endif +class String; +class Object; +class Array; +class ArrayBuffer; +class Function; +class Error; +class PropertyDescriptor; +class CallbackInfo; +class TypedArray; +template +class TypedArrayOf; + +using Int8Array = + TypedArrayOf; ///< Typed-array of signed 8-bit integers +using Uint8Array = + TypedArrayOf; ///< Typed-array of unsigned 8-bit integers +using Int16Array = + TypedArrayOf; ///< Typed-array of signed 16-bit integers +using Uint16Array = + TypedArrayOf; ///< Typed-array of unsigned 16-bit integers +using Int32Array = + TypedArrayOf; ///< Typed-array of signed 32-bit integers +using Uint32Array = + TypedArrayOf; ///< Typed-array of unsigned 32-bit integers +using Float32Array = + TypedArrayOf; ///< Typed-array of 32-bit floating-point values +using Float64Array = + TypedArrayOf; ///< Typed-array of 64-bit floating-point values +#if NAPI_VERSION > 5 +using BigInt64Array = + TypedArrayOf; ///< Typed array of signed 64-bit integers +using BigUint64Array = + TypedArrayOf; ///< Typed array of unsigned 64-bit integers +#endif // NAPI_VERSION > 5 + +/// Defines the signature of a Node-API C++ module's registration callback +/// (init) function. +using ModuleRegisterCallback = Object (*)(Env env, Object exports); + +class MemoryManagement; + +/// A simple Maybe type, representing an object which may or may not have a +/// value. +/// +/// If an API method returns a Maybe<>, the API method can potentially fail +/// either because an exception is thrown, or because an exception is pending, +/// e.g. because a previous API call threw an exception that hasn't been +/// caught yet. In that case, a "Nothing" value is returned. +template +class Maybe { + public: + bool IsNothing() const; + bool IsJust() const; + + /// Short-hand for Unwrap(), which doesn't return a value. Could be used + /// where the actual value of the Maybe is not needed like Object::Set. + /// If this Maybe is nothing (empty), node-addon-api will crash the + /// process. + void Check() const; + + /// Return the value of type T contained in the Maybe. If this Maybe is + /// nothing (empty), node-addon-api will crash the process. + T Unwrap() const; + + /// Return the value of type T contained in the Maybe, or using a default + /// value if this Maybe is nothing (empty). + T UnwrapOr(const T& default_value) const; + + /// Converts this Maybe to a value of type T in the out. If this Maybe is + /// nothing (empty), `false` is returned and `out` is left untouched. + bool UnwrapTo(T* out) const; + + bool operator==(const Maybe& other) const; + bool operator!=(const Maybe& other) const; + + private: + Maybe(); + explicit Maybe(const T& t); + + bool _has_value; + T _value; + + template + friend Maybe Nothing(); + template + friend Maybe Just(const U& u); +}; + +template +inline Maybe Nothing(); + +template +inline Maybe Just(const T& t); + +#if defined(NODE_ADDON_API_ENABLE_MAYBE) +template +using MaybeOrValue = Maybe; +#else +template +using MaybeOrValue = T; +#endif + +/// Environment for Node-API values and operations. +/// +/// All Node-API values and operations must be associated with an environment. +/// An environment instance is always provided to callback functions; that +/// environment must then be used for any creation of Node-API values or other +/// Node-API operations within the callback. (Many methods infer the +/// environment from the `this` instance that the method is called on.) +/// +/// In the future, multiple environments per process may be supported, +/// although current implementations only support one environment per process. +/// +/// In the V8 JavaScript engine, a Node-API environment approximately +/// corresponds to an Isolate. +class Env { + private: + napi_env _env; +#if NAPI_VERSION > 5 + template + static void DefaultFini(Env, T* data); + template + static void DefaultFiniWithHint(Env, DataType* data, HintType* hint); +#endif // NAPI_VERSION > 5 + public: + Env(napi_env env); + + operator napi_env() const; + + Object Global() const; + Value Undefined() const; + Value Null() const; + + bool IsExceptionPending() const; + Error GetAndClearPendingException() const; + + MaybeOrValue RunScript(const char* utf8script) const; + MaybeOrValue RunScript(const std::string& utf8script) const; + MaybeOrValue RunScript(String script) const; + +#if NAPI_VERSION > 2 + template + class CleanupHook; + + template + CleanupHook AddCleanupHook(Hook hook); + + template + CleanupHook AddCleanupHook(Hook hook, Arg* arg); +#endif // NAPI_VERSION > 2 + +#if NAPI_VERSION > 5 + template + T* GetInstanceData() const; + + template + using Finalizer = void (*)(Env, T*); + template fini = Env::DefaultFini> + void SetInstanceData(T* data) const; + + template + using FinalizerWithHint = void (*)(Env, DataType*, HintType*); + template fini = + Env::DefaultFiniWithHint> + void SetInstanceData(DataType* data, HintType* hint) const; +#endif // NAPI_VERSION > 5 + +#if NAPI_VERSION > 2 + template + class CleanupHook { + public: + CleanupHook(); + CleanupHook(Env env, Hook hook, Arg* arg); + CleanupHook(Env env, Hook hook); + bool Remove(Env env); + bool IsEmpty() const; + + private: + static inline void Wrapper(void* data) NAPI_NOEXCEPT; + static inline void WrapperWithArg(void* data) NAPI_NOEXCEPT; + + void (*wrapper)(void* arg); + struct CleanupData { + Hook hook; + Arg* arg; + } * data; + }; +#endif // NAPI_VERSION > 2 + +#if NAPI_VERSION > 8 + const char* GetModuleFileName() const; +#endif // NAPI_VERSION > 8 +}; + +/// A JavaScript value of unknown type. +/// +/// For type-specific operations, convert to one of the Value subclasses using a +/// `To*` or `As()` method. The `To*` methods do type coercion; the `As()` +/// method does not. +/// +/// Napi::Value value = ... +/// if (!value.IsString()) throw Napi::TypeError::New(env, "Invalid +/// arg..."); Napi::String str = value.As(); // Cast to a +/// string value +/// +/// Napi::Value anotherValue = ... +/// bool isTruthy = anotherValue.ToBoolean(); // Coerce to a boolean value +class Value { + public: + Value(); ///< Creates a new _empty_ Value instance. + Value(napi_env env, + napi_value value); ///< Wraps a Node-API value primitive. + + /// Creates a JS value from a C++ primitive. + /// + /// `value` may be any of: + /// - bool + /// - Any integer type + /// - Any floating point type + /// - const char* (encoded using UTF-8, null-terminated) + /// - const char16_t* (encoded using UTF-16-LE, null-terminated) + /// - std::string (encoded using UTF-8) + /// - std::u16string + /// - napi::Value + /// - napi_value + template + static Value From(napi_env env, const T& value); + + /// Converts to a Node-API value primitive. + /// + /// If the instance is _empty_, this returns `nullptr`. + operator napi_value() const; + + /// Tests if this value strictly equals another value. + bool operator==(const Value& other) const; + + /// Tests if this value does not strictly equal another value. + bool operator!=(const Value& other) const; + + /// Tests if this value strictly equals another value. + bool StrictEquals(const Value& other) const; + + /// Gets the environment the value is associated with. + Napi::Env Env() const; + + /// Checks if the value is empty (uninitialized). + /// + /// An empty value is invalid, and most attempts to perform an operation on an + /// empty value will result in an exception. Note an empty value is distinct + /// from JavaScript `null` or `undefined`, which are valid values. + /// + /// When C++ exceptions are disabled at compile time, a method with a `Value` + /// return type may return an empty value to indicate a pending exception. So + /// when not using C++ exceptions, callers should check whether the value is + /// empty before attempting to use it. + bool IsEmpty() const; + + napi_valuetype Type() const; ///< Gets the type of the value. + + bool IsUndefined() + const; ///< Tests if a value is an undefined JavaScript value. + bool IsNull() const; ///< Tests if a value is a null JavaScript value. + bool IsBoolean() const; ///< Tests if a value is a JavaScript boolean. + bool IsNumber() const; ///< Tests if a value is a JavaScript number. +#if NAPI_VERSION > 5 + bool IsBigInt() const; ///< Tests if a value is a JavaScript bigint. +#endif // NAPI_VERSION > 5 +#if (NAPI_VERSION > 4) + bool IsDate() const; ///< Tests if a value is a JavaScript date. +#endif + bool IsString() const; ///< Tests if a value is a JavaScript string. + bool IsSymbol() const; ///< Tests if a value is a JavaScript symbol. + bool IsArray() const; ///< Tests if a value is a JavaScript array. + bool IsArrayBuffer() + const; ///< Tests if a value is a JavaScript array buffer. + bool IsTypedArray() const; ///< Tests if a value is a JavaScript typed array. + bool IsObject() const; ///< Tests if a value is a JavaScript object. + bool IsFunction() const; ///< Tests if a value is a JavaScript function. + bool IsPromise() const; ///< Tests if a value is a JavaScript promise. + bool IsDataView() const; ///< Tests if a value is a JavaScript data view. + bool IsBuffer() const; ///< Tests if a value is a Node buffer. + bool IsExternal() const; ///< Tests if a value is a pointer to external data. + + /// Casts to another type of `Napi::Value`, when the actual type is known or + /// assumed. + /// + /// This conversion does NOT coerce the type. Calling any methods + /// inappropriate for the actual value type will throw `Napi::Error`. + /// + /// If `NODE_ADDON_API_ENABLE_TYPE_CHECK_ON_AS` is defined, this method + /// asserts that the actual type is the expected type. + template + T As() const; + + MaybeOrValue ToBoolean() + const; ///< Coerces a value to a JavaScript boolean. + MaybeOrValue ToNumber() + const; ///< Coerces a value to a JavaScript number. + MaybeOrValue ToString() + const; ///< Coerces a value to a JavaScript string. + MaybeOrValue ToObject() + const; ///< Coerces a value to a JavaScript object. + + protected: + /// !cond INTERNAL + napi_env _env; + napi_value _value; + /// !endcond +}; + +/// A JavaScript boolean value. +class Boolean : public Value { + public: + static Boolean New(napi_env env, ///< Node-API environment + bool value ///< Boolean value + ); + + static void CheckCast(napi_env env, napi_value value); + + Boolean(); ///< Creates a new _empty_ Boolean instance. + Boolean(napi_env env, + napi_value value); ///< Wraps a Node-API value primitive. + + operator bool() const; ///< Converts a Boolean value to a boolean primitive. + bool Value() const; ///< Converts a Boolean value to a boolean primitive. +}; + +/// A JavaScript number value. +class Number : public Value { + public: + static Number New(napi_env env, ///< Node-API environment + double value ///< Number value + ); + + static void CheckCast(napi_env env, napi_value value); + + Number(); ///< Creates a new _empty_ Number instance. + Number(napi_env env, + napi_value value); ///< Wraps a Node-API value primitive. + + operator int32_t() + const; ///< Converts a Number value to a 32-bit signed integer value. + operator uint32_t() + const; ///< Converts a Number value to a 32-bit unsigned integer value. + operator int64_t() + const; ///< Converts a Number value to a 64-bit signed integer value. + operator float() + const; ///< Converts a Number value to a 32-bit floating-point value. + operator double() + const; ///< Converts a Number value to a 64-bit floating-point value. + + int32_t Int32Value() + const; ///< Converts a Number value to a 32-bit signed integer value. + uint32_t Uint32Value() + const; ///< Converts a Number value to a 32-bit unsigned integer value. + int64_t Int64Value() + const; ///< Converts a Number value to a 64-bit signed integer value. + float FloatValue() + const; ///< Converts a Number value to a 32-bit floating-point value. + double DoubleValue() + const; ///< Converts a Number value to a 64-bit floating-point value. +}; + +#if NAPI_VERSION > 5 +/// A JavaScript bigint value. +class BigInt : public Value { + public: + static BigInt New(napi_env env, ///< Node-API environment + int64_t value ///< Number value + ); + static BigInt New(napi_env env, ///< Node-API environment + uint64_t value ///< Number value + ); + + /// Creates a new BigInt object using a specified sign bit and a + /// specified list of digits/words. + /// The resulting number is calculated as: + /// (-1)^sign_bit * (words[0] * (2^64)^0 + words[1] * (2^64)^1 + ...) + static BigInt New(napi_env env, ///< Node-API environment + int sign_bit, ///< Sign bit. 1 if negative. + size_t word_count, ///< Number of words in array + const uint64_t* words ///< Array of words + ); + + static void CheckCast(napi_env env, napi_value value); + + BigInt(); ///< Creates a new _empty_ BigInt instance. + BigInt(napi_env env, + napi_value value); ///< Wraps a Node-API value primitive. + + int64_t Int64Value(bool* lossless) + const; ///< Converts a BigInt value to a 64-bit signed integer value. + uint64_t Uint64Value(bool* lossless) + const; ///< Converts a BigInt value to a 64-bit unsigned integer value. + + size_t WordCount() const; ///< The number of 64-bit words needed to store + ///< the result of ToWords(). + + /// Writes the contents of this BigInt to a specified memory location. + /// `sign_bit` must be provided and will be set to 1 if this BigInt is + /// negative. + /// `*word_count` has to be initialized to the length of the `words` array. + /// Upon return, it will be set to the actual number of words that would + /// be needed to store this BigInt (i.e. the return value of `WordCount()`). + void ToWords(int* sign_bit, size_t* word_count, uint64_t* words); +}; +#endif // NAPI_VERSION > 5 + +#if (NAPI_VERSION > 4) +/// A JavaScript date value. +class Date : public Value { + public: + /// Creates a new Date value from a double primitive. + static Date New(napi_env env, ///< Node-API environment + double value ///< Number value + ); + + static void CheckCast(napi_env env, napi_value value); + + Date(); ///< Creates a new _empty_ Date instance. + Date(napi_env env, napi_value value); ///< Wraps a Node-API value primitive. + operator double() const; ///< Converts a Date value to double primitive + + double ValueOf() const; ///< Converts a Date value to a double primitive. +}; +#endif + +/// A JavaScript string or symbol value (that can be used as a property name). +class Name : public Value { + public: + static void CheckCast(napi_env env, napi_value value); + + Name(); ///< Creates a new _empty_ Name instance. + Name(napi_env env, + napi_value value); ///< Wraps a Node-API value primitive. +}; + +/// A JavaScript string value. +class String : public Name { + public: + /// Creates a new String value from a UTF-8 encoded C++ string. + static String New(napi_env env, ///< Node-API environment + const std::string& value ///< UTF-8 encoded C++ string + ); + + /// Creates a new String value from a UTF-16 encoded C++ string. + static String New(napi_env env, ///< Node-API environment + const std::u16string& value ///< UTF-16 encoded C++ string + ); + + /// Creates a new String value from a UTF-8 encoded C string. + static String New( + napi_env env, ///< Node-API environment + const char* value ///< UTF-8 encoded null-terminated C string + ); + + /// Creates a new String value from a UTF-16 encoded C string. + static String New( + napi_env env, ///< Node-API environment + const char16_t* value ///< UTF-16 encoded null-terminated C string + ); + + /// Creates a new String value from a UTF-8 encoded C string with specified + /// length. + static String New(napi_env env, ///< Node-API environment + const char* value, ///< UTF-8 encoded C string (not + ///< necessarily null-terminated) + size_t length ///< length of the string in bytes + ); + + /// Creates a new String value from a UTF-16 encoded C string with specified + /// length. + static String New( + napi_env env, ///< Node-API environment + const char16_t* value, ///< UTF-16 encoded C string (not necessarily + ///< null-terminated) + size_t length ///< Length of the string in 2-byte code units + ); + + /// Creates a new String based on the original object's type. + /// + /// `value` may be any of: + /// - const char* (encoded using UTF-8, null-terminated) + /// - const char16_t* (encoded using UTF-16-LE, null-terminated) + /// - std::string (encoded using UTF-8) + /// - std::u16string + template + static String From(napi_env env, const T& value); + + static void CheckCast(napi_env env, napi_value value); + + String(); ///< Creates a new _empty_ String instance. + String(napi_env env, + napi_value value); ///< Wraps a Node-API value primitive. + + operator std::string() + const; ///< Converts a String value to a UTF-8 encoded C++ string. + operator std::u16string() + const; ///< Converts a String value to a UTF-16 encoded C++ string. + std::string Utf8Value() + const; ///< Converts a String value to a UTF-8 encoded C++ string. + std::u16string Utf16Value() + const; ///< Converts a String value to a UTF-16 encoded C++ string. +}; + +/// A JavaScript symbol value. +class Symbol : public Name { + public: + /// Creates a new Symbol value with an optional description. + static Symbol New( + napi_env env, ///< Node-API environment + const char* description = + nullptr ///< Optional UTF-8 encoded null-terminated C string + /// describing the symbol + ); + + /// Creates a new Symbol value with a description. + static Symbol New( + napi_env env, ///< Node-API environment + const std::string& + description ///< UTF-8 encoded C++ string describing the symbol + ); + + /// Creates a new Symbol value with a description. + static Symbol New(napi_env env, ///< Node-API environment + String description ///< String value describing the symbol + ); + + /// Creates a new Symbol value with a description. + static Symbol New( + napi_env env, ///< Node-API environment + napi_value description ///< String value describing the symbol + ); + + /// Get a public Symbol (e.g. Symbol.iterator). + static MaybeOrValue WellKnown(napi_env, const std::string& name); + + // Create a symbol in the global registry, UTF-8 Encoded cpp string + static MaybeOrValue For(napi_env env, const std::string& description); + + // Create a symbol in the global registry, C style string (null terminated) + static MaybeOrValue For(napi_env env, const char* description); + + // Create a symbol in the global registry, String value describing the symbol + static MaybeOrValue For(napi_env env, String description); + + // Create a symbol in the global registry, napi_value describing the symbol + static MaybeOrValue For(napi_env env, napi_value description); + + static void CheckCast(napi_env env, napi_value value); + + Symbol(); ///< Creates a new _empty_ Symbol instance. + Symbol(napi_env env, + napi_value value); ///< Wraps a Node-API value primitive. +}; + +class TypeTaggable : public Value { + public: +#if NAPI_VERSION >= 8 + void TypeTag(const napi_type_tag* type_tag) const; + bool CheckTypeTag(const napi_type_tag* type_tag) const; +#endif // NAPI_VERSION >= 8 + protected: + TypeTaggable(); + TypeTaggable(napi_env env, napi_value value); +}; + +/// A JavaScript object value. +class Object : public TypeTaggable { + public: + /// Enables property and element assignments using indexing syntax. + /// + /// This is a convenient helper to get and set object properties. As + /// getting and setting object properties may throw with JavaScript + /// exceptions, it is notable that these operations may fail. + /// When NODE_ADDON_API_ENABLE_MAYBE is defined, the process will abort + /// on JavaScript exceptions. + /// + /// Example: + /// + /// Napi::Value propertyValue = object1['A']; + /// object2['A'] = propertyValue; + /// Napi::Value elementValue = array[0]; + /// array[1] = elementValue; + template + class PropertyLValue { + public: + /// Converts an L-value to a value. + operator Value() const; + + /// Assigns a value to the property. The type of value can be + /// anything supported by `Object::Set`. + template + PropertyLValue& operator=(ValueType value); + + private: + PropertyLValue() = delete; + PropertyLValue(Object object, Key key); + napi_env _env; + napi_value _object; + Key _key; + + friend class Napi::Object; + }; + + /// Creates a new Object value. + static Object New(napi_env env ///< Node-API environment + ); + + static void CheckCast(napi_env env, napi_value value); + + Object(); ///< Creates a new _empty_ Object instance. + Object(napi_env env, + napi_value value); ///< Wraps a Node-API value primitive. + + /// Gets or sets a named property. + PropertyLValue operator[]( + const char* utf8name ///< UTF-8 encoded null-terminated property name + ); + + /// Gets or sets a named property. + PropertyLValue operator[]( + const std::string& utf8name ///< UTF-8 encoded property name + ); + + /// Gets or sets an indexed property or array element. + PropertyLValue operator[]( + uint32_t index /// Property / element index + ); + + /// Gets or sets an indexed property or array element. + PropertyLValue operator[](Value index /// Property / element index + ) const; + + /// Gets a named property. + MaybeOrValue operator[]( + const char* utf8name ///< UTF-8 encoded null-terminated property name + ) const; + + /// Gets a named property. + MaybeOrValue operator[]( + const std::string& utf8name ///< UTF-8 encoded property name + ) const; + + /// Gets an indexed property or array element. + MaybeOrValue operator[](uint32_t index ///< Property / element index + ) const; + + /// Checks whether a property is present. + MaybeOrValue Has(napi_value key ///< Property key primitive + ) const; + + /// Checks whether a property is present. + MaybeOrValue Has(Value key ///< Property key + ) const; + + /// Checks whether a named property is present. + MaybeOrValue Has( + const char* utf8name ///< UTF-8 encoded null-terminated property name + ) const; + + /// Checks whether a named property is present. + MaybeOrValue Has( + const std::string& utf8name ///< UTF-8 encoded property name + ) const; + + /// Checks whether a own property is present. + MaybeOrValue HasOwnProperty(napi_value key ///< Property key primitive + ) const; + + /// Checks whether a own property is present. + MaybeOrValue HasOwnProperty(Value key ///< Property key + ) const; + + /// Checks whether a own property is present. + MaybeOrValue HasOwnProperty( + const char* utf8name ///< UTF-8 encoded null-terminated property name + ) const; + + /// Checks whether a own property is present. + MaybeOrValue HasOwnProperty( + const std::string& utf8name ///< UTF-8 encoded property name + ) const; + + /// Gets a property. + MaybeOrValue Get(napi_value key ///< Property key primitive + ) const; + + /// Gets a property. + MaybeOrValue Get(Value key ///< Property key + ) const; + + /// Gets a named property. + MaybeOrValue Get( + const char* utf8name ///< UTF-8 encoded null-terminated property name + ) const; + + /// Gets a named property. + MaybeOrValue Get( + const std::string& utf8name ///< UTF-8 encoded property name + ) const; + + /// Sets a property. + template + MaybeOrValue Set(napi_value key, ///< Property key primitive + const ValueType& value ///< Property value primitive + ) const; + + /// Sets a property. + template + MaybeOrValue Set(Value key, ///< Property key + const ValueType& value ///< Property value + ) const; + + /// Sets a named property. + template + MaybeOrValue Set( + const char* utf8name, ///< UTF-8 encoded null-terminated property name + const ValueType& value) const; + + /// Sets a named property. + template + MaybeOrValue Set( + const std::string& utf8name, ///< UTF-8 encoded property name + const ValueType& value ///< Property value primitive + ) const; + + /// Delete property. + MaybeOrValue Delete(napi_value key ///< Property key primitive + ) const; + + /// Delete property. + MaybeOrValue Delete(Value key ///< Property key + ) const; + + /// Delete property. + MaybeOrValue Delete( + const char* utf8name ///< UTF-8 encoded null-terminated property name + ) const; + + /// Delete property. + MaybeOrValue Delete( + const std::string& utf8name ///< UTF-8 encoded property name + ) const; + + /// Checks whether an indexed property is present. + MaybeOrValue Has(uint32_t index ///< Property / element index + ) const; + + /// Gets an indexed property or array element. + MaybeOrValue Get(uint32_t index ///< Property / element index + ) const; + + /// Sets an indexed property or array element. + template + MaybeOrValue Set(uint32_t index, ///< Property / element index + const ValueType& value ///< Property value primitive + ) const; + + /// Deletes an indexed property or array element. + MaybeOrValue Delete(uint32_t index ///< Property / element index + ) const; + + /// This operation can fail in case of Proxy.[[OwnPropertyKeys]] and + /// Proxy.[[GetOwnProperty]] calling into JavaScript. See: + /// - + /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-ownpropertykeys + /// - + /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-getownproperty-p + MaybeOrValue GetPropertyNames() const; ///< Get all property names + + /// Defines a property on the object. + /// + /// This operation can fail in case of Proxy.[[DefineOwnProperty]] calling + /// into JavaScript. See + /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-defineownproperty-p-desc + MaybeOrValue DefineProperty( + const PropertyDescriptor& + property ///< Descriptor for the property to be defined + ) const; + + /// Defines properties on the object. + /// + /// This operation can fail in case of Proxy.[[DefineOwnProperty]] calling + /// into JavaScript. See + /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-defineownproperty-p-desc + MaybeOrValue DefineProperties( + const std::initializer_list& properties + ///< List of descriptors for the properties to be defined + ) const; + + /// Defines properties on the object. + /// + /// This operation can fail in case of Proxy.[[DefineOwnProperty]] calling + /// into JavaScript. See + /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-defineownproperty-p-desc + MaybeOrValue DefineProperties( + const std::vector& properties + ///< Vector of descriptors for the properties to be defined + ) const; + + /// Checks if an object is an instance created by a constructor function. + /// + /// This is equivalent to the JavaScript `instanceof` operator. + /// + /// This operation can fail in case of Proxy.[[GetPrototypeOf]] calling into + /// JavaScript. + /// See + /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-getprototypeof + MaybeOrValue InstanceOf( + const Function& constructor ///< Constructor function + ) const; + + template + inline void AddFinalizer(Finalizer finalizeCallback, T* data) const; + + template + inline void AddFinalizer(Finalizer finalizeCallback, + T* data, + Hint* finalizeHint) const; + +#ifdef NAPI_CPP_EXCEPTIONS + class const_iterator; + + inline const_iterator begin() const; + + inline const_iterator end() const; + + class iterator; + + inline iterator begin(); + + inline iterator end(); +#endif // NAPI_CPP_EXCEPTIONS + +#if NAPI_VERSION >= 8 + /// This operation can fail in case of Proxy.[[GetPrototypeOf]] calling into + /// JavaScript. + /// See + /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-getprototypeof + MaybeOrValue Freeze() const; + /// This operation can fail in case of Proxy.[[GetPrototypeOf]] calling into + /// JavaScript. + /// See + /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-getprototypeof + MaybeOrValue Seal() const; +#endif // NAPI_VERSION >= 8 +}; + +template +class External : public TypeTaggable { + public: + static External New(napi_env env, T* data); + + // Finalizer must implement `void operator()(Env env, T* data)`. + template + static External New(napi_env env, T* data, Finalizer finalizeCallback); + // Finalizer must implement `void operator()(Env env, T* data, Hint* hint)`. + template + static External New(napi_env env, + T* data, + Finalizer finalizeCallback, + Hint* finalizeHint); + + static void CheckCast(napi_env env, napi_value value); + + External(); + External(napi_env env, napi_value value); + + T* Data() const; +}; + +class Array : public Object { + public: + static Array New(napi_env env); + static Array New(napi_env env, size_t length); + + static void CheckCast(napi_env env, napi_value value); + + Array(); + Array(napi_env env, napi_value value); + + uint32_t Length() const; +}; + +#ifdef NAPI_CPP_EXCEPTIONS +class Object::const_iterator { + private: + enum class Type { BEGIN, END }; + + inline const_iterator(const Object* object, const Type type); + + public: + inline const_iterator& operator++(); + + inline bool operator==(const const_iterator& other) const; + + inline bool operator!=(const const_iterator& other) const; + + inline const std::pair> operator*() + const; + + private: + const Napi::Object* _object; + Array _keys; + uint32_t _index; + + friend class Object; +}; + +class Object::iterator { + private: + enum class Type { BEGIN, END }; + + inline iterator(Object* object, const Type type); + + public: + inline iterator& operator++(); + + inline bool operator==(const iterator& other) const; + + inline bool operator!=(const iterator& other) const; + + inline std::pair> operator*(); + + private: + Napi::Object* _object; + Array _keys; + uint32_t _index; + + friend class Object; +}; +#endif // NAPI_CPP_EXCEPTIONS + +/// A JavaScript array buffer value. +class ArrayBuffer : public Object { + public: + /// Creates a new ArrayBuffer instance over a new automatically-allocated + /// buffer. + static ArrayBuffer New( + napi_env env, ///< Node-API environment + size_t byteLength ///< Length of the buffer to be allocated, in bytes + ); + +#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED + /// Creates a new ArrayBuffer instance, using an external buffer with + /// specified byte length. + static ArrayBuffer New( + napi_env env, ///< Node-API environment + void* externalData, ///< Pointer to the external buffer to be used by + ///< the array + size_t byteLength ///< Length of the external buffer to be used by the + ///< array, in bytes + ); + + /// Creates a new ArrayBuffer instance, using an external buffer with + /// specified byte length. + template + static ArrayBuffer New( + napi_env env, ///< Node-API environment + void* externalData, ///< Pointer to the external buffer to be used by + ///< the array + size_t byteLength, ///< Length of the external buffer to be used by the + ///< array, + /// in bytes + Finalizer finalizeCallback ///< Function to be called when the array + ///< buffer is destroyed; + /// must implement `void operator()(Env env, + /// void* externalData)` + ); + + /// Creates a new ArrayBuffer instance, using an external buffer with + /// specified byte length. + template + static ArrayBuffer New( + napi_env env, ///< Node-API environment + void* externalData, ///< Pointer to the external buffer to be used by + ///< the array + size_t byteLength, ///< Length of the external buffer to be used by the + ///< array, + /// in bytes + Finalizer finalizeCallback, ///< Function to be called when the array + ///< buffer is destroyed; + /// must implement `void operator()(Env + /// env, void* externalData, Hint* hint)` + Hint* finalizeHint ///< Hint (second parameter) to be passed to the + ///< finalize callback + ); +#endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED + + static void CheckCast(napi_env env, napi_value value); + + ArrayBuffer(); ///< Creates a new _empty_ ArrayBuffer instance. + ArrayBuffer(napi_env env, + napi_value value); ///< Wraps a Node-API value primitive. + + void* Data(); ///< Gets a pointer to the data buffer. + size_t ByteLength(); ///< Gets the length of the array buffer in bytes. + +#if NAPI_VERSION >= 7 + bool IsDetached() const; + void Detach(); +#endif // NAPI_VERSION >= 7 +}; + +/// A JavaScript typed-array value with unknown array type. +/// +/// For type-specific operations, cast to a `TypedArrayOf` instance using the +/// `As()` method: +/// +/// Napi::TypedArray array = ... +/// if (t.TypedArrayType() == napi_int32_array) { +/// Napi::Int32Array int32Array = t.As(); +/// } +class TypedArray : public Object { + public: + static void CheckCast(napi_env env, napi_value value); + + TypedArray(); ///< Creates a new _empty_ TypedArray instance. + TypedArray(napi_env env, + napi_value value); ///< Wraps a Node-API value primitive. + + napi_typedarray_type TypedArrayType() + const; ///< Gets the type of this typed-array. + Napi::ArrayBuffer ArrayBuffer() const; ///< Gets the backing array buffer. + + uint8_t ElementSize() + const; ///< Gets the size in bytes of one element in the array. + size_t ElementLength() const; ///< Gets the number of elements in the array. + size_t ByteOffset() + const; ///< Gets the offset into the buffer where the array starts. + size_t ByteLength() const; ///< Gets the length of the array in bytes. + + protected: + /// !cond INTERNAL + napi_typedarray_type _type; + size_t _length; + + TypedArray(napi_env env, + napi_value value, + napi_typedarray_type type, + size_t length); + + template + static +#if defined(NAPI_HAS_CONSTEXPR) + constexpr +#endif + napi_typedarray_type + TypedArrayTypeForPrimitiveType() { + return std::is_same::value ? napi_int8_array + : std::is_same::value ? napi_uint8_array + : std::is_same::value ? napi_int16_array + : std::is_same::value ? napi_uint16_array + : std::is_same::value ? napi_int32_array + : std::is_same::value ? napi_uint32_array + : std::is_same::value ? napi_float32_array + : std::is_same::value ? napi_float64_array +#if NAPI_VERSION > 5 + : std::is_same::value ? napi_bigint64_array + : std::is_same::value ? napi_biguint64_array +#endif // NAPI_VERSION > 5 + : napi_int8_array; + } + /// !endcond +}; + +/// A JavaScript typed-array value with known array type. +/// +/// Note while it is possible to create and access Uint8 "clamped" arrays using +/// this class, the _clamping_ behavior is only applied in JavaScript. +template +class TypedArrayOf : public TypedArray { + public: + /// Creates a new TypedArray instance over a new automatically-allocated array + /// buffer. + /// + /// The array type parameter can normally be omitted (because it is inferred + /// from the template parameter T), except when creating a "clamped" array: + /// + /// Uint8Array::New(env, length, napi_uint8_clamped_array) + static TypedArrayOf New( + napi_env env, ///< Node-API environment + size_t elementLength, ///< Length of the created array, as a number of + ///< elements +#if defined(NAPI_HAS_CONSTEXPR) + napi_typedarray_type type = + TypedArray::TypedArrayTypeForPrimitiveType() +#else + napi_typedarray_type type +#endif + ///< Type of array, if different from the default array type for the + ///< template parameter T. + ); + + /// Creates a new TypedArray instance over a provided array buffer. + /// + /// The array type parameter can normally be omitted (because it is inferred + /// from the template parameter T), except when creating a "clamped" array: + /// + /// Uint8Array::New(env, length, buffer, 0, napi_uint8_clamped_array) + static TypedArrayOf New( + napi_env env, ///< Node-API environment + size_t elementLength, ///< Length of the created array, as a number of + ///< elements + Napi::ArrayBuffer arrayBuffer, ///< Backing array buffer instance to use + size_t bufferOffset, ///< Offset into the array buffer where the + ///< typed-array starts +#if defined(NAPI_HAS_CONSTEXPR) + napi_typedarray_type type = + TypedArray::TypedArrayTypeForPrimitiveType() +#else + napi_typedarray_type type +#endif + ///< Type of array, if different from the default array type for the + ///< template parameter T. + ); + + static void CheckCast(napi_env env, napi_value value); + + TypedArrayOf(); ///< Creates a new _empty_ TypedArrayOf instance. + TypedArrayOf(napi_env env, + napi_value value); ///< Wraps a Node-API value primitive. + + T& operator[](size_t index); ///< Gets or sets an element in the array. + const T& operator[](size_t index) const; ///< Gets an element in the array. + + /// Gets a pointer to the array's backing buffer. + /// + /// This is not necessarily the same as the `ArrayBuffer::Data()` pointer, + /// because the typed-array may have a non-zero `ByteOffset()` into the + /// `ArrayBuffer`. + T* Data(); + + /// Gets a pointer to the array's backing buffer. + /// + /// This is not necessarily the same as the `ArrayBuffer::Data()` pointer, + /// because the typed-array may have a non-zero `ByteOffset()` into the + /// `ArrayBuffer`. + const T* Data() const; + + private: + T* _data; + + TypedArrayOf(napi_env env, + napi_value value, + napi_typedarray_type type, + size_t length, + T* data); +}; + +/// The DataView provides a low-level interface for reading/writing multiple +/// number types in an ArrayBuffer irrespective of the platform's endianness. +class DataView : public Object { + public: + static DataView New(napi_env env, Napi::ArrayBuffer arrayBuffer); + static DataView New(napi_env env, + Napi::ArrayBuffer arrayBuffer, + size_t byteOffset); + static DataView New(napi_env env, + Napi::ArrayBuffer arrayBuffer, + size_t byteOffset, + size_t byteLength); + + static void CheckCast(napi_env env, napi_value value); + + DataView(); ///< Creates a new _empty_ DataView instance. + DataView(napi_env env, + napi_value value); ///< Wraps a Node-API value primitive. + + Napi::ArrayBuffer ArrayBuffer() const; ///< Gets the backing array buffer. + size_t ByteOffset() + const; ///< Gets the offset into the buffer where the array starts. + size_t ByteLength() const; ///< Gets the length of the array in bytes. + + void* Data() const; + + float GetFloat32(size_t byteOffset) const; + double GetFloat64(size_t byteOffset) const; + int8_t GetInt8(size_t byteOffset) const; + int16_t GetInt16(size_t byteOffset) const; + int32_t GetInt32(size_t byteOffset) const; + uint8_t GetUint8(size_t byteOffset) const; + uint16_t GetUint16(size_t byteOffset) const; + uint32_t GetUint32(size_t byteOffset) const; + + void SetFloat32(size_t byteOffset, float value) const; + void SetFloat64(size_t byteOffset, double value) const; + void SetInt8(size_t byteOffset, int8_t value) const; + void SetInt16(size_t byteOffset, int16_t value) const; + void SetInt32(size_t byteOffset, int32_t value) const; + void SetUint8(size_t byteOffset, uint8_t value) const; + void SetUint16(size_t byteOffset, uint16_t value) const; + void SetUint32(size_t byteOffset, uint32_t value) const; + + private: + template + T ReadData(size_t byteOffset) const; + + template + void WriteData(size_t byteOffset, T value) const; + + void* _data; + size_t _length; +}; + +class Function : public Object { + public: + using VoidCallback = void (*)(const CallbackInfo& info); + using Callback = Value (*)(const CallbackInfo& info); + + template + static Function New(napi_env env, + const char* utf8name = nullptr, + void* data = nullptr); + + template + static Function New(napi_env env, + const char* utf8name = nullptr, + void* data = nullptr); + + template + static Function New(napi_env env, + const std::string& utf8name, + void* data = nullptr); + + template + static Function New(napi_env env, + const std::string& utf8name, + void* data = nullptr); + + /// Callable must implement operator() accepting a const CallbackInfo& + /// and return either void or Value. + template + static Function New(napi_env env, + Callable cb, + const char* utf8name = nullptr, + void* data = nullptr); + /// Callable must implement operator() accepting a const CallbackInfo& + /// and return either void or Value. + template + static Function New(napi_env env, + Callable cb, + const std::string& utf8name, + void* data = nullptr); + + static void CheckCast(napi_env env, napi_value value); + + Function(); + Function(napi_env env, napi_value value); + + MaybeOrValue operator()( + const std::initializer_list& args) const; + + MaybeOrValue Call(const std::initializer_list& args) const; + MaybeOrValue Call(const std::vector& args) const; + MaybeOrValue Call(const std::vector& args) const; + MaybeOrValue Call(size_t argc, const napi_value* args) const; + MaybeOrValue Call(napi_value recv, + const std::initializer_list& args) const; + MaybeOrValue Call(napi_value recv, + const std::vector& args) const; + MaybeOrValue Call(napi_value recv, + const std::vector& args) const; + MaybeOrValue Call(napi_value recv, + size_t argc, + const napi_value* args) const; + + MaybeOrValue MakeCallback( + napi_value recv, + const std::initializer_list& args, + napi_async_context context = nullptr) const; + MaybeOrValue MakeCallback(napi_value recv, + const std::vector& args, + napi_async_context context = nullptr) const; + MaybeOrValue MakeCallback(napi_value recv, + size_t argc, + const napi_value* args, + napi_async_context context = nullptr) const; + + MaybeOrValue New(const std::initializer_list& args) const; + MaybeOrValue New(const std::vector& args) const; + MaybeOrValue New(size_t argc, const napi_value* args) const; +}; + +class Promise : public Object { + public: + class Deferred { + public: + static Deferred New(napi_env env); + Deferred(napi_env env); + + Napi::Promise Promise() const; + Napi::Env Env() const; + + void Resolve(napi_value value) const; + void Reject(napi_value value) const; + + private: + napi_env _env; + napi_deferred _deferred; + napi_value _promise; + }; + + static void CheckCast(napi_env env, napi_value value); + + Promise(napi_env env, napi_value value); +}; + +template +class Buffer : public Uint8Array { + public: + static Buffer New(napi_env env, size_t length); +#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED + static Buffer New(napi_env env, T* data, size_t length); + + // Finalizer must implement `void operator()(Env env, T* data)`. + template + static Buffer New(napi_env env, + T* data, + size_t length, + Finalizer finalizeCallback); + // Finalizer must implement `void operator()(Env env, T* data, Hint* hint)`. + template + static Buffer New(napi_env env, + T* data, + size_t length, + Finalizer finalizeCallback, + Hint* finalizeHint); +#endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED + + static Buffer NewOrCopy(napi_env env, T* data, size_t length); + // Finalizer must implement `void operator()(Env env, T* data)`. + template + static Buffer NewOrCopy(napi_env env, + T* data, + size_t length, + Finalizer finalizeCallback); + // Finalizer must implement `void operator()(Env env, T* data, Hint* hint)`. + template + static Buffer NewOrCopy(napi_env env, + T* data, + size_t length, + Finalizer finalizeCallback, + Hint* finalizeHint); + + static Buffer Copy(napi_env env, const T* data, size_t length); + + static void CheckCast(napi_env env, napi_value value); + + Buffer(); + Buffer(napi_env env, napi_value value); + size_t Length() const; + T* Data() const; + + private: +}; + +/// Holds a counted reference to a value; initially a weak reference unless +/// otherwise specified, may be changed to/from a strong reference by adjusting +/// the refcount. +/// +/// The referenced value is not immediately destroyed when the reference count +/// is zero; it is merely then eligible for garbage-collection if there are no +/// other references to the value. +template +class Reference { + public: + static Reference New(const T& value, uint32_t initialRefcount = 0); + + Reference(); + Reference(napi_env env, napi_ref ref); + ~Reference(); + + // A reference can be moved but cannot be copied. + Reference(Reference&& other); + Reference& operator=(Reference&& other); + NAPI_DISALLOW_ASSIGN(Reference) + + operator napi_ref() const; + bool operator==(const Reference& other) const; + bool operator!=(const Reference& other) const; + + Napi::Env Env() const; + bool IsEmpty() const; + + // Note when getting the value of a Reference it is usually correct to do so + // within a HandleScope so that the value handle gets cleaned up efficiently. + T Value() const; + + uint32_t Ref() const; + uint32_t Unref() const; + void Reset(); + void Reset(const T& value, uint32_t refcount = 0); + + // Call this on a reference that is declared as static data, to prevent its + // destructor from running at program shutdown time, which would attempt to + // reset the reference when the environment is no longer valid. Avoid using + // this if at all possible. If you do need to use static data, MAKE SURE to + // warn your users that your addon is NOT threadsafe. + void SuppressDestruct(); + + protected: + Reference(const Reference&); + + /// !cond INTERNAL + napi_env _env; + napi_ref _ref; + /// !endcond + + private: + bool _suppressDestruct; +}; + +class ObjectReference : public Reference { + public: + ObjectReference(); + ObjectReference(napi_env env, napi_ref ref); + + // A reference can be moved but cannot be copied. + ObjectReference(Reference&& other); + ObjectReference& operator=(Reference&& other); + ObjectReference(ObjectReference&& other); + ObjectReference& operator=(ObjectReference&& other); + NAPI_DISALLOW_ASSIGN(ObjectReference) + + MaybeOrValue Get(const char* utf8name) const; + MaybeOrValue Get(const std::string& utf8name) const; + MaybeOrValue Set(const char* utf8name, napi_value value) const; + MaybeOrValue Set(const char* utf8name, Napi::Value value) const; + MaybeOrValue Set(const char* utf8name, const char* utf8value) const; + MaybeOrValue Set(const char* utf8name, bool boolValue) const; + MaybeOrValue Set(const char* utf8name, double numberValue) const; + MaybeOrValue Set(const std::string& utf8name, napi_value value) const; + MaybeOrValue Set(const std::string& utf8name, Napi::Value value) const; + MaybeOrValue Set(const std::string& utf8name, + std::string& utf8value) const; + MaybeOrValue Set(const std::string& utf8name, bool boolValue) const; + MaybeOrValue Set(const std::string& utf8name, double numberValue) const; + + MaybeOrValue Get(uint32_t index) const; + MaybeOrValue Set(uint32_t index, const napi_value value) const; + MaybeOrValue Set(uint32_t index, const Napi::Value value) const; + MaybeOrValue Set(uint32_t index, const char* utf8value) const; + MaybeOrValue Set(uint32_t index, const std::string& utf8value) const; + MaybeOrValue Set(uint32_t index, bool boolValue) const; + MaybeOrValue Set(uint32_t index, double numberValue) const; + + protected: + ObjectReference(const ObjectReference&); +}; + +class FunctionReference : public Reference { + public: + FunctionReference(); + FunctionReference(napi_env env, napi_ref ref); + + // A reference can be moved but cannot be copied. + FunctionReference(Reference&& other); + FunctionReference& operator=(Reference&& other); + FunctionReference(FunctionReference&& other); + FunctionReference& operator=(FunctionReference&& other); + NAPI_DISALLOW_ASSIGN_COPY(FunctionReference) + + MaybeOrValue operator()( + const std::initializer_list& args) const; + + MaybeOrValue Call( + const std::initializer_list& args) const; + MaybeOrValue Call(const std::vector& args) const; + MaybeOrValue Call( + napi_value recv, const std::initializer_list& args) const; + MaybeOrValue Call(napi_value recv, + const std::vector& args) const; + MaybeOrValue Call(napi_value recv, + size_t argc, + const napi_value* args) const; + + MaybeOrValue MakeCallback( + napi_value recv, + const std::initializer_list& args, + napi_async_context context = nullptr) const; + MaybeOrValue MakeCallback( + napi_value recv, + const std::vector& args, + napi_async_context context = nullptr) const; + MaybeOrValue MakeCallback( + napi_value recv, + size_t argc, + const napi_value* args, + napi_async_context context = nullptr) const; + + MaybeOrValue New(const std::initializer_list& args) const; + MaybeOrValue New(const std::vector& args) const; +}; + +// Shortcuts to creating a new reference with inferred type and refcount = 0. +template +Reference Weak(T value); +ObjectReference Weak(Object value); +FunctionReference Weak(Function value); + +// Shortcuts to creating a new reference with inferred type and refcount = 1. +template +Reference Persistent(T value); +ObjectReference Persistent(Object value); +FunctionReference Persistent(Function value); + +/// A persistent reference to a JavaScript error object. Use of this class +/// depends somewhat on whether C++ exceptions are enabled at compile time. +/// +/// ### Handling Errors With C++ Exceptions +/// +/// If C++ exceptions are enabled, then the `Error` class extends +/// `std::exception` and enables integrated error-handling for C++ exceptions +/// and JavaScript exceptions. +/// +/// If a Node-API call fails without executing any JavaScript code (for +/// example due to an invalid argument), then the Node-API wrapper +/// automatically converts and throws the error as a C++ exception of type +/// `Napi::Error`. Or if a JavaScript function called by C++ code via Node-API +/// throws a JavaScript exception, then the Node-API wrapper automatically +/// converts and throws it as a C++ exception of type `Napi::Error`. +/// +/// If a C++ exception of type `Napi::Error` escapes from a Node-API C++ +/// callback, then the Node-API wrapper automatically converts and throws it +/// as a JavaScript exception. Therefore, catching a C++ exception of type +/// `Napi::Error` prevents a JavaScript exception from being thrown. +/// +/// #### Example 1A - Throwing a C++ exception: +/// +/// Napi::Env env = ... +/// throw Napi::Error::New(env, "Example exception"); +/// +/// Following C++ statements will not be executed. The exception will bubble +/// up as a C++ exception of type `Napi::Error`, until it is either caught +/// while still in C++, or else automatically propataged as a JavaScript +/// exception when the callback returns to JavaScript. +/// +/// #### Example 2A - Propagating a Node-API C++ exception: +/// +/// Napi::Function jsFunctionThatThrows = someObj.As(); +/// Napi::Value result = jsFunctionThatThrows({ arg1, arg2 }); +/// +/// Following C++ statements will not be executed. The exception will bubble +/// up as a C++ exception of type `Napi::Error`, until it is either caught +/// while still in C++, or else automatically propagated as a JavaScript +/// exception when the callback returns to JavaScript. +/// +/// #### Example 3A - Handling a Node-API C++ exception: +/// +/// Napi::Function jsFunctionThatThrows = someObj.As(); +/// Napi::Value result; +/// try { +/// result = jsFunctionThatThrows({ arg1, arg2 }); +/// } catch (const Napi::Error& e) { +/// cerr << "Caught JavaScript exception: " + e.what(); +/// } +/// +/// Since the exception was caught here, it will not be propagated as a +/// JavaScript exception. +/// +/// ### Handling Errors Without C++ Exceptions +/// +/// If C++ exceptions are disabled (by defining `NAPI_DISABLE_CPP_EXCEPTIONS`) +/// then this class does not extend `std::exception`, and APIs in the `Napi` +/// namespace do not throw C++ exceptions when they fail. Instead, they raise +/// _pending_ JavaScript exceptions and return _empty_ `Value`s. Calling code +/// should check `Value::IsEmpty()` before attempting to use a returned value, +/// and may use methods on the `Env` class to check for, get, and clear a +/// pending JavaScript exception. If the pending exception is not cleared, it +/// will be thrown when the native callback returns to JavaScript. +/// +/// #### Example 1B - Throwing a JS exception +/// +/// Napi::Env env = ... +/// Napi::Error::New(env, "Example +/// exception").ThrowAsJavaScriptException(); return; +/// +/// After throwing a JS exception, the code should generally return +/// immediately from the native callback, after performing any necessary +/// cleanup. +/// +/// #### Example 2B - Propagating a Node-API JS exception: +/// +/// Napi::Function jsFunctionThatThrows = someObj.As(); +/// Napi::Value result = jsFunctionThatThrows({ arg1, arg2 }); +/// if (result.IsEmpty()) return; +/// +/// An empty value result from a Node-API call indicates an error occurred, +/// and a JavaScript exception is pending. To let the exception propagate, the +/// code should generally return immediately from the native callback, after +/// performing any necessary cleanup. +/// +/// #### Example 3B - Handling a Node-API JS exception: +/// +/// Napi::Function jsFunctionThatThrows = someObj.As(); +/// Napi::Value result = jsFunctionThatThrows({ arg1, arg2 }); +/// if (result.IsEmpty()) { +/// Napi::Error e = env.GetAndClearPendingException(); +/// cerr << "Caught JavaScript exception: " + e.Message(); +/// } +/// +/// Since the exception was cleared here, it will not be propagated as a +/// JavaScript exception after the native callback returns. +class Error : public ObjectReference +#ifdef NAPI_CPP_EXCEPTIONS + , + public std::exception +#endif // NAPI_CPP_EXCEPTIONS +{ + public: + static Error New(napi_env env); + static Error New(napi_env env, const char* message); + static Error New(napi_env env, const std::string& message); + + static NAPI_NO_RETURN void Fatal(const char* location, const char* message); + + Error(); + Error(napi_env env, napi_value value); + + // An error can be moved or copied. + Error(Error&& other); + Error& operator=(Error&& other); + Error(const Error&); + Error& operator=(const Error&); + + const std::string& Message() const NAPI_NOEXCEPT; + void ThrowAsJavaScriptException() const; + + Object Value() const; + +#ifdef NAPI_CPP_EXCEPTIONS + const char* what() const NAPI_NOEXCEPT override; +#endif // NAPI_CPP_EXCEPTIONS + + protected: + /// !cond INTERNAL + using create_error_fn = napi_status (*)(napi_env envb, + napi_value code, + napi_value msg, + napi_value* result); + + template + static TError New(napi_env env, + const char* message, + size_t length, + create_error_fn create_error); + /// !endcond + + private: + static inline const char* ERROR_WRAP_VALUE() NAPI_NOEXCEPT; + mutable std::string _message; +}; + +class TypeError : public Error { + public: + static TypeError New(napi_env env, const char* message); + static TypeError New(napi_env env, const std::string& message); + + TypeError(); + TypeError(napi_env env, napi_value value); +}; + +class RangeError : public Error { + public: + static RangeError New(napi_env env, const char* message); + static RangeError New(napi_env env, const std::string& message); + + RangeError(); + RangeError(napi_env env, napi_value value); +}; + +#if NAPI_VERSION > 8 +class SyntaxError : public Error { + public: + static SyntaxError New(napi_env env, const char* message); + static SyntaxError New(napi_env env, const std::string& message); + + SyntaxError(); + SyntaxError(napi_env env, napi_value value); +}; +#endif // NAPI_VERSION > 8 + +class CallbackInfo { + public: + CallbackInfo(napi_env env, napi_callback_info info); + ~CallbackInfo(); + + // Disallow copying to prevent multiple free of _dynamicArgs + NAPI_DISALLOW_ASSIGN_COPY(CallbackInfo) + + Napi::Env Env() const; + Value NewTarget() const; + bool IsConstructCall() const; + size_t Length() const; + const Value operator[](size_t index) const; + Value This() const; + void* Data() const; + void SetData(void* data); + explicit operator napi_callback_info() const; + + private: + const size_t _staticArgCount = 6; + napi_env _env; + napi_callback_info _info; + napi_value _this; + size_t _argc; + napi_value* _argv; + napi_value _staticArgs[6]; + napi_value* _dynamicArgs; + void* _data; +}; + +class PropertyDescriptor { + public: + using GetterCallback = Napi::Value (*)(const Napi::CallbackInfo& info); + using SetterCallback = void (*)(const Napi::CallbackInfo& info); + +#ifndef NODE_ADDON_API_DISABLE_DEPRECATED + template + static PropertyDescriptor Accessor( + const char* utf8name, + Getter getter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Accessor( + const std::string& utf8name, + Getter getter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Accessor( + napi_value name, + Getter getter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Accessor( + Name name, + Getter getter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Accessor( + const char* utf8name, + Getter getter, + Setter setter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Accessor( + const std::string& utf8name, + Getter getter, + Setter setter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Accessor( + napi_value name, + Getter getter, + Setter setter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Accessor( + Name name, + Getter getter, + Setter setter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Function( + const char* utf8name, + Callable cb, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Function( + const std::string& utf8name, + Callable cb, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Function( + napi_value name, + Callable cb, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Function( + Name name, + Callable cb, + napi_property_attributes attributes = napi_default, + void* data = nullptr); +#endif // !NODE_ADDON_API_DISABLE_DEPRECATED + + template + static PropertyDescriptor Accessor( + const char* utf8name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + + template + static PropertyDescriptor Accessor( + const std::string& utf8name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + + template + static PropertyDescriptor Accessor( + Name name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + + template + static PropertyDescriptor Accessor( + const char* utf8name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + + template + static PropertyDescriptor Accessor( + const std::string& utf8name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + + template + static PropertyDescriptor Accessor( + Name name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + + template + static PropertyDescriptor Accessor( + Napi::Env env, + Napi::Object object, + const char* utf8name, + Getter getter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Accessor( + Napi::Env env, + Napi::Object object, + const std::string& utf8name, + Getter getter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Accessor( + Napi::Env env, + Napi::Object object, + Name name, + Getter getter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Accessor( + Napi::Env env, + Napi::Object object, + const char* utf8name, + Getter getter, + Setter setter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Accessor( + Napi::Env env, + Napi::Object object, + const std::string& utf8name, + Getter getter, + Setter setter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Accessor( + Napi::Env env, + Napi::Object object, + Name name, + Getter getter, + Setter setter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Function( + Napi::Env env, + Napi::Object object, + const char* utf8name, + Callable cb, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Function( + Napi::Env env, + Napi::Object object, + const std::string& utf8name, + Callable cb, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor Function( + Napi::Env env, + Napi::Object object, + Name name, + Callable cb, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + static PropertyDescriptor Value( + const char* utf8name, + napi_value value, + napi_property_attributes attributes = napi_default); + static PropertyDescriptor Value( + const std::string& utf8name, + napi_value value, + napi_property_attributes attributes = napi_default); + static PropertyDescriptor Value( + napi_value name, + napi_value value, + napi_property_attributes attributes = napi_default); + static PropertyDescriptor Value( + Name name, + Napi::Value value, + napi_property_attributes attributes = napi_default); + + PropertyDescriptor(napi_property_descriptor desc); + + operator napi_property_descriptor&(); + operator const napi_property_descriptor&() const; + + private: + napi_property_descriptor _desc; +}; + +/// Property descriptor for use with `ObjectWrap::DefineClass()`. +/// +/// This is different from the standalone `PropertyDescriptor` because it is +/// specific to each `ObjectWrap` subclass. This prevents using descriptors +/// from a different class when defining a new class (preventing the callbacks +/// from having incorrect `this` pointers). +template +class ClassPropertyDescriptor { + public: + ClassPropertyDescriptor(napi_property_descriptor desc) : _desc(desc) {} + + operator napi_property_descriptor&() { return _desc; } + operator const napi_property_descriptor&() const { return _desc; } + + private: + napi_property_descriptor _desc; +}; + +template +struct MethodCallbackData { + TCallback callback; + void* data; +}; + +template +struct AccessorCallbackData { + TGetterCallback getterCallback; + TSetterCallback setterCallback; + void* data; +}; + +template +class InstanceWrap { + public: + using InstanceVoidMethodCallback = void (T::*)(const CallbackInfo& info); + using InstanceMethodCallback = Napi::Value (T::*)(const CallbackInfo& info); + using InstanceGetterCallback = Napi::Value (T::*)(const CallbackInfo& info); + using InstanceSetterCallback = void (T::*)(const CallbackInfo& info, + const Napi::Value& value); + + using PropertyDescriptor = ClassPropertyDescriptor; + + static PropertyDescriptor InstanceMethod( + const char* utf8name, + InstanceVoidMethodCallback method, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + static PropertyDescriptor InstanceMethod( + const char* utf8name, + InstanceMethodCallback method, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + static PropertyDescriptor InstanceMethod( + Symbol name, + InstanceVoidMethodCallback method, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + static PropertyDescriptor InstanceMethod( + Symbol name, + InstanceMethodCallback method, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor InstanceMethod( + const char* utf8name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor InstanceMethod( + const char* utf8name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor InstanceMethod( + Symbol name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor InstanceMethod( + Symbol name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + static PropertyDescriptor InstanceAccessor( + const char* utf8name, + InstanceGetterCallback getter, + InstanceSetterCallback setter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + static PropertyDescriptor InstanceAccessor( + Symbol name, + InstanceGetterCallback getter, + InstanceSetterCallback setter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor InstanceAccessor( + const char* utf8name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor InstanceAccessor( + Symbol name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + static PropertyDescriptor InstanceValue( + const char* utf8name, + Napi::Value value, + napi_property_attributes attributes = napi_default); + static PropertyDescriptor InstanceValue( + Symbol name, + Napi::Value value, + napi_property_attributes attributes = napi_default); + + protected: + static void AttachPropData(napi_env env, + napi_value value, + const napi_property_descriptor* prop); + + private: + using This = InstanceWrap; + + using InstanceVoidMethodCallbackData = + MethodCallbackData; + using InstanceMethodCallbackData = + MethodCallbackData; + using InstanceAccessorCallbackData = + AccessorCallbackData; + + static napi_value InstanceVoidMethodCallbackWrapper(napi_env env, + napi_callback_info info); + static napi_value InstanceMethodCallbackWrapper(napi_env env, + napi_callback_info info); + static napi_value InstanceGetterCallbackWrapper(napi_env env, + napi_callback_info info); + static napi_value InstanceSetterCallbackWrapper(napi_env env, + napi_callback_info info); + + template + static napi_value WrappedMethod(napi_env env, + napi_callback_info info) NAPI_NOEXCEPT; + + template + struct SetterTag {}; + + template + static napi_callback WrapSetter(SetterTag) NAPI_NOEXCEPT { + return &This::WrappedMethod; + } + static napi_callback WrapSetter(SetterTag) NAPI_NOEXCEPT { + return nullptr; + } +}; + +/// Base class to be extended by C++ classes exposed to JavaScript; each C++ +/// class instance gets "wrapped" by a JavaScript object that is managed by this +/// class. +/// +/// At initialization time, the `DefineClass()` method must be used to +/// hook up the accessor and method callbacks. It takes a list of +/// property descriptors, which can be constructed via the various +/// static methods on the base class. +/// +/// #### Example: +/// +/// class Example: public Napi::ObjectWrap { +/// public: +/// static void Initialize(Napi::Env& env, Napi::Object& target) { +/// Napi::Function constructor = DefineClass(env, "Example", { +/// InstanceAccessor<&Example::GetSomething, +/// &Example::SetSomething>("value"), +/// InstanceMethod<&Example::DoSomething>("doSomething"), +/// }); +/// target.Set("Example", constructor); +/// } +/// +/// Example(const Napi::CallbackInfo& info); // Constructor +/// Napi::Value GetSomething(const Napi::CallbackInfo& info); +/// void SetSomething(const Napi::CallbackInfo& info, const Napi::Value& +/// value); Napi::Value DoSomething(const Napi::CallbackInfo& info); +/// } +template +class ObjectWrap : public InstanceWrap, public Reference { + public: + ObjectWrap(const CallbackInfo& callbackInfo); + virtual ~ObjectWrap(); + + static T* Unwrap(Object wrapper); + + // Methods exposed to JavaScript must conform to one of these callback + // signatures. + using StaticVoidMethodCallback = void (*)(const CallbackInfo& info); + using StaticMethodCallback = Napi::Value (*)(const CallbackInfo& info); + using StaticGetterCallback = Napi::Value (*)(const CallbackInfo& info); + using StaticSetterCallback = void (*)(const CallbackInfo& info, + const Napi::Value& value); + + using PropertyDescriptor = ClassPropertyDescriptor; + + static Function DefineClass( + Napi::Env env, + const char* utf8name, + const std::initializer_list& properties, + void* data = nullptr); + static Function DefineClass(Napi::Env env, + const char* utf8name, + const std::vector& properties, + void* data = nullptr); + static PropertyDescriptor StaticMethod( + const char* utf8name, + StaticVoidMethodCallback method, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + static PropertyDescriptor StaticMethod( + const char* utf8name, + StaticMethodCallback method, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + static PropertyDescriptor StaticMethod( + Symbol name, + StaticVoidMethodCallback method, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + static PropertyDescriptor StaticMethod( + Symbol name, + StaticMethodCallback method, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor StaticMethod( + const char* utf8name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor StaticMethod( + Symbol name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor StaticMethod( + const char* utf8name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor StaticMethod( + Symbol name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + static PropertyDescriptor StaticAccessor( + const char* utf8name, + StaticGetterCallback getter, + StaticSetterCallback setter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + static PropertyDescriptor StaticAccessor( + Symbol name, + StaticGetterCallback getter, + StaticSetterCallback setter, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor StaticAccessor( + const char* utf8name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + template + static PropertyDescriptor StaticAccessor( + Symbol name, + napi_property_attributes attributes = napi_default, + void* data = nullptr); + static PropertyDescriptor StaticValue( + const char* utf8name, + Napi::Value value, + napi_property_attributes attributes = napi_default); + static PropertyDescriptor StaticValue( + Symbol name, + Napi::Value value, + napi_property_attributes attributes = napi_default); + static Napi::Value OnCalledAsFunction(const Napi::CallbackInfo& callbackInfo); + virtual void Finalize(Napi::Env env); + + private: + using This = ObjectWrap; + + static napi_value ConstructorCallbackWrapper(napi_env env, + napi_callback_info info); + static napi_value StaticVoidMethodCallbackWrapper(napi_env env, + napi_callback_info info); + static napi_value StaticMethodCallbackWrapper(napi_env env, + napi_callback_info info); + static napi_value StaticGetterCallbackWrapper(napi_env env, + napi_callback_info info); + static napi_value StaticSetterCallbackWrapper(napi_env env, + napi_callback_info info); + static void FinalizeCallback(napi_env env, void* data, void* hint); + static Function DefineClass(Napi::Env env, + const char* utf8name, + const size_t props_count, + const napi_property_descriptor* props, + void* data = nullptr); + + using StaticVoidMethodCallbackData = + MethodCallbackData; + using StaticMethodCallbackData = MethodCallbackData; + + using StaticAccessorCallbackData = + AccessorCallbackData; + + template + static napi_value WrappedMethod(napi_env env, + napi_callback_info info) NAPI_NOEXCEPT; + + template + struct StaticSetterTag {}; + + template + static napi_callback WrapStaticSetter(StaticSetterTag) NAPI_NOEXCEPT { + return &This::WrappedMethod; + } + static napi_callback WrapStaticSetter(StaticSetterTag) + NAPI_NOEXCEPT { + return nullptr; + } + + bool _construction_failed = true; +}; + +class HandleScope { + public: + HandleScope(napi_env env, napi_handle_scope scope); + explicit HandleScope(Napi::Env env); + ~HandleScope(); + + // Disallow copying to prevent double close of napi_handle_scope + NAPI_DISALLOW_ASSIGN_COPY(HandleScope) + + operator napi_handle_scope() const; + + Napi::Env Env() const; + + private: + napi_env _env; + napi_handle_scope _scope; +}; + +class EscapableHandleScope { + public: + EscapableHandleScope(napi_env env, napi_escapable_handle_scope scope); + explicit EscapableHandleScope(Napi::Env env); + ~EscapableHandleScope(); + + // Disallow copying to prevent double close of napi_escapable_handle_scope + NAPI_DISALLOW_ASSIGN_COPY(EscapableHandleScope) + + operator napi_escapable_handle_scope() const; + + Napi::Env Env() const; + Value Escape(napi_value escapee); + + private: + napi_env _env; + napi_escapable_handle_scope _scope; +}; + +#if (NAPI_VERSION > 2) +class CallbackScope { + public: + CallbackScope(napi_env env, napi_callback_scope scope); + CallbackScope(napi_env env, napi_async_context context); + virtual ~CallbackScope(); + + // Disallow copying to prevent double close of napi_callback_scope + NAPI_DISALLOW_ASSIGN_COPY(CallbackScope) + + operator napi_callback_scope() const; + + Napi::Env Env() const; + + private: + napi_env _env; + napi_callback_scope _scope; +}; +#endif + +class AsyncContext { + public: + explicit AsyncContext(napi_env env, const char* resource_name); + explicit AsyncContext(napi_env env, + const char* resource_name, + const Object& resource); + virtual ~AsyncContext(); + + AsyncContext(AsyncContext&& other); + AsyncContext& operator=(AsyncContext&& other); + NAPI_DISALLOW_ASSIGN_COPY(AsyncContext) + + operator napi_async_context() const; + + Napi::Env Env() const; + + private: + napi_env _env; + napi_async_context _context; +}; + +#if NAPI_HAS_THREADS +class AsyncWorker { + public: + virtual ~AsyncWorker(); + + NAPI_DISALLOW_ASSIGN_COPY(AsyncWorker) + + operator napi_async_work() const; + + Napi::Env Env() const; + + void Queue(); + void Cancel(); + void SuppressDestruct(); + + ObjectReference& Receiver(); + FunctionReference& Callback(); + + virtual void OnExecute(Napi::Env env); + virtual void OnWorkComplete(Napi::Env env, napi_status status); + + protected: + explicit AsyncWorker(const Function& callback); + explicit AsyncWorker(const Function& callback, const char* resource_name); + explicit AsyncWorker(const Function& callback, + const char* resource_name, + const Object& resource); + explicit AsyncWorker(const Object& receiver, const Function& callback); + explicit AsyncWorker(const Object& receiver, + const Function& callback, + const char* resource_name); + explicit AsyncWorker(const Object& receiver, + const Function& callback, + const char* resource_name, + const Object& resource); + + explicit AsyncWorker(Napi::Env env); + explicit AsyncWorker(Napi::Env env, const char* resource_name); + explicit AsyncWorker(Napi::Env env, + const char* resource_name, + const Object& resource); + + virtual void Execute() = 0; + virtual void OnOK(); + virtual void OnError(const Error& e); + virtual void Destroy(); + virtual std::vector GetResult(Napi::Env env); + + void SetError(const std::string& error); + + private: + static inline void OnAsyncWorkExecute(napi_env env, void* asyncworker); + static inline void OnAsyncWorkComplete(napi_env env, + napi_status status, + void* asyncworker); + + napi_env _env; + napi_async_work _work; + ObjectReference _receiver; + FunctionReference _callback; + std::string _error; + bool _suppress_destruct; +}; +#endif // NAPI_HAS_THREADS + +#if (NAPI_VERSION > 3 && NAPI_HAS_THREADS) +class ThreadSafeFunction { + public: + // This API may only be called from the main thread. + template + static ThreadSafeFunction New(napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount); + + // This API may only be called from the main thread. + template + static ThreadSafeFunction New(napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context); + + // This API may only be called from the main thread. + template + static ThreadSafeFunction New(napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + Finalizer finalizeCallback); + + // This API may only be called from the main thread. + template + static ThreadSafeFunction New(napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + Finalizer finalizeCallback, + FinalizerDataType* data); + + // This API may only be called from the main thread. + template + static ThreadSafeFunction New(napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback); + + // This API may only be called from the main thread. + template + static ThreadSafeFunction New(napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback, + FinalizerDataType* data); + + // This API may only be called from the main thread. + template + static ThreadSafeFunction New(napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount); + + // This API may only be called from the main thread. + template + static ThreadSafeFunction New(napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context); + + // This API may only be called from the main thread. + template + static ThreadSafeFunction New(napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + Finalizer finalizeCallback); + + // This API may only be called from the main thread. + template + static ThreadSafeFunction New(napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + Finalizer finalizeCallback, + FinalizerDataType* data); + + // This API may only be called from the main thread. + template + static ThreadSafeFunction New(napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback); + + // This API may only be called from the main thread. + template + static ThreadSafeFunction New(napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback, + FinalizerDataType* data); + + ThreadSafeFunction(); + ThreadSafeFunction(napi_threadsafe_function tsFunctionValue); + + operator napi_threadsafe_function() const; + + // This API may be called from any thread. + napi_status BlockingCall() const; + + // This API may be called from any thread. + template + napi_status BlockingCall(Callback callback) const; + + // This API may be called from any thread. + template + napi_status BlockingCall(DataType* data, Callback callback) const; + + // This API may be called from any thread. + napi_status NonBlockingCall() const; + + // This API may be called from any thread. + template + napi_status NonBlockingCall(Callback callback) const; + + // This API may be called from any thread. + template + napi_status NonBlockingCall(DataType* data, Callback callback) const; + + // This API may only be called from the main thread. + void Ref(napi_env env) const; + + // This API may only be called from the main thread. + void Unref(napi_env env) const; + + // This API may be called from any thread. + napi_status Acquire() const; + + // This API may be called from any thread. + napi_status Release() const; + + // This API may be called from any thread. + napi_status Abort() const; + + struct ConvertibleContext { + template + operator T*() { + return static_cast(context); + } + void* context; + }; + + // This API may be called from any thread. + ConvertibleContext GetContext() const; + + private: + using CallbackWrapper = std::function; + + template + static ThreadSafeFunction New(napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback, + FinalizerDataType* data, + napi_finalize wrapper); + + napi_status CallInternal(CallbackWrapper* callbackWrapper, + napi_threadsafe_function_call_mode mode) const; + + static void CallJS(napi_env env, + napi_value jsCallback, + void* context, + void* data); + + napi_threadsafe_function _tsfn; +}; + +// A TypedThreadSafeFunction by default has no context (nullptr) and can +// accept any type (void) to its CallJs. +template +class TypedThreadSafeFunction { + public: + // This API may only be called from the main thread. + // Helper function that returns nullptr if running Node-API 5+, otherwise a + // non-empty, no-op Function. This provides the ability to specify at + // compile-time a callback parameter to `New` that safely does no action + // when targeting _any_ Node-API version. +#if NAPI_VERSION > 4 + static std::nullptr_t EmptyFunctionFactory(Napi::Env env); +#else + static Napi::Function EmptyFunctionFactory(Napi::Env env); +#endif + static Napi::Function FunctionOrEmpty(Napi::Env env, + Napi::Function& callback); + +#if NAPI_VERSION > 4 + // This API may only be called from the main thread. + // Creates a new threadsafe function with: + // Callback [missing] Resource [missing] Finalizer [missing] + template + static TypedThreadSafeFunction New( + napi_env env, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context = nullptr); + + // This API may only be called from the main thread. + // Creates a new threadsafe function with: + // Callback [missing] Resource [passed] Finalizer [missing] + template + static TypedThreadSafeFunction New( + napi_env env, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context = nullptr); + + // This API may only be called from the main thread. + // Creates a new threadsafe function with: + // Callback [missing] Resource [missing] Finalizer [passed] + template + static TypedThreadSafeFunction New( + napi_env env, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback, + FinalizerDataType* data = nullptr); + + // This API may only be called from the main thread. + // Creates a new threadsafe function with: + // Callback [missing] Resource [passed] Finalizer [passed] + template + static TypedThreadSafeFunction New( + napi_env env, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback, + FinalizerDataType* data = nullptr); +#endif + + // This API may only be called from the main thread. + // Creates a new threadsafe function with: + // Callback [passed] Resource [missing] Finalizer [missing] + template + static TypedThreadSafeFunction New( + napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context = nullptr); + + // This API may only be called from the main thread. + // Creates a new threadsafe function with: + // Callback [passed] Resource [passed] Finalizer [missing] + template + static TypedThreadSafeFunction New( + napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context = nullptr); + + // This API may only be called from the main thread. + // Creates a new threadsafe function with: + // Callback [passed] Resource [missing] Finalizer [passed] + template + static TypedThreadSafeFunction New( + napi_env env, + const Function& callback, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback, + FinalizerDataType* data = nullptr); + + // This API may only be called from the main thread. + // Creates a new threadsafe function with: + // Callback [passed] Resource [passed] Finalizer [passed] + template + static TypedThreadSafeFunction New( + napi_env env, + CallbackType callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback, + FinalizerDataType* data = nullptr); + + TypedThreadSafeFunction(); + TypedThreadSafeFunction(napi_threadsafe_function tsFunctionValue); + + operator napi_threadsafe_function() const; + + // This API may be called from any thread. + napi_status BlockingCall(DataType* data = nullptr) const; + + // This API may be called from any thread. + napi_status NonBlockingCall(DataType* data = nullptr) const; + + // This API may only be called from the main thread. + void Ref(napi_env env) const; + + // This API may only be called from the main thread. + void Unref(napi_env env) const; + + // This API may be called from any thread. + napi_status Acquire() const; + + // This API may be called from any thread. + napi_status Release() const; + + // This API may be called from any thread. + napi_status Abort() const; + + // This API may be called from any thread. + ContextType* GetContext() const; + + private: + template + static TypedThreadSafeFunction New( + napi_env env, + const Function& callback, + const Object& resource, + ResourceString resourceName, + size_t maxQueueSize, + size_t initialThreadCount, + ContextType* context, + Finalizer finalizeCallback, + FinalizerDataType* data, + napi_finalize wrapper); + + static void CallJsInternal(napi_env env, + napi_value jsCallback, + void* context, + void* data); + + protected: + napi_threadsafe_function _tsfn; +}; +template +class AsyncProgressWorkerBase : public AsyncWorker { + public: + virtual void OnWorkProgress(DataType* data) = 0; + class ThreadSafeData { + public: + ThreadSafeData(AsyncProgressWorkerBase* asyncprogressworker, DataType* data) + : _asyncprogressworker(asyncprogressworker), _data(data) {} + + AsyncProgressWorkerBase* asyncprogressworker() { + return _asyncprogressworker; + }; + DataType* data() { return _data; }; + + private: + AsyncProgressWorkerBase* _asyncprogressworker; + DataType* _data; + }; + void OnWorkComplete(Napi::Env env, napi_status status) override; + + protected: + explicit AsyncProgressWorkerBase(const Object& receiver, + const Function& callback, + const char* resource_name, + const Object& resource, + size_t queue_size = 1); + virtual ~AsyncProgressWorkerBase(); + +// Optional callback of Napi::ThreadSafeFunction only available after +// NAPI_VERSION 4. Refs: https://github.com/nodejs/node/pull/27791 +#if NAPI_VERSION > 4 + explicit AsyncProgressWorkerBase(Napi::Env env, + const char* resource_name, + const Object& resource, + size_t queue_size = 1); +#endif + + static inline void OnAsyncWorkProgress(Napi::Env env, + Napi::Function jsCallback, + void* data); + + napi_status NonBlockingCall(DataType* data); + + private: + ThreadSafeFunction _tsfn; + bool _work_completed = false; + napi_status _complete_status; + static inline void OnThreadSafeFunctionFinalize( + Napi::Env env, void* data, AsyncProgressWorkerBase* context); +}; + +template +class AsyncProgressWorker : public AsyncProgressWorkerBase { + public: + virtual ~AsyncProgressWorker(); + + class ExecutionProgress { + friend class AsyncProgressWorker; + + public: + void Signal() const; + void Send(const T* data, size_t count) const; + + private: + explicit ExecutionProgress(AsyncProgressWorker* worker) : _worker(worker) {} + AsyncProgressWorker* const _worker; + }; + + void OnWorkProgress(void*) override; + + protected: + explicit AsyncProgressWorker(const Function& callback); + explicit AsyncProgressWorker(const Function& callback, + const char* resource_name); + explicit AsyncProgressWorker(const Function& callback, + const char* resource_name, + const Object& resource); + explicit AsyncProgressWorker(const Object& receiver, + const Function& callback); + explicit AsyncProgressWorker(const Object& receiver, + const Function& callback, + const char* resource_name); + explicit AsyncProgressWorker(const Object& receiver, + const Function& callback, + const char* resource_name, + const Object& resource); + +// Optional callback of Napi::ThreadSafeFunction only available after +// NAPI_VERSION 4. Refs: https://github.com/nodejs/node/pull/27791 +#if NAPI_VERSION > 4 + explicit AsyncProgressWorker(Napi::Env env); + explicit AsyncProgressWorker(Napi::Env env, const char* resource_name); + explicit AsyncProgressWorker(Napi::Env env, + const char* resource_name, + const Object& resource); +#endif + virtual void Execute(const ExecutionProgress& progress) = 0; + virtual void OnProgress(const T* data, size_t count) = 0; + + private: + void Execute() override; + void Signal(); + void SendProgress_(const T* data, size_t count); + + std::mutex _mutex; + T* _asyncdata; + size_t _asyncsize; + bool _signaled; +}; + +template +class AsyncProgressQueueWorker + : public AsyncProgressWorkerBase> { + public: + virtual ~AsyncProgressQueueWorker(){}; + + class ExecutionProgress { + friend class AsyncProgressQueueWorker; + + public: + void Signal() const; + void Send(const T* data, size_t count) const; + + private: + explicit ExecutionProgress(AsyncProgressQueueWorker* worker) + : _worker(worker) {} + AsyncProgressQueueWorker* const _worker; + }; + + void OnWorkComplete(Napi::Env env, napi_status status) override; + void OnWorkProgress(std::pair*) override; + + protected: + explicit AsyncProgressQueueWorker(const Function& callback); + explicit AsyncProgressQueueWorker(const Function& callback, + const char* resource_name); + explicit AsyncProgressQueueWorker(const Function& callback, + const char* resource_name, + const Object& resource); + explicit AsyncProgressQueueWorker(const Object& receiver, + const Function& callback); + explicit AsyncProgressQueueWorker(const Object& receiver, + const Function& callback, + const char* resource_name); + explicit AsyncProgressQueueWorker(const Object& receiver, + const Function& callback, + const char* resource_name, + const Object& resource); + +// Optional callback of Napi::ThreadSafeFunction only available after +// NAPI_VERSION 4. Refs: https://github.com/nodejs/node/pull/27791 +#if NAPI_VERSION > 4 + explicit AsyncProgressQueueWorker(Napi::Env env); + explicit AsyncProgressQueueWorker(Napi::Env env, const char* resource_name); + explicit AsyncProgressQueueWorker(Napi::Env env, + const char* resource_name, + const Object& resource); +#endif + virtual void Execute(const ExecutionProgress& progress) = 0; + virtual void OnProgress(const T* data, size_t count) = 0; + + private: + void Execute() override; + void Signal() const; + void SendProgress_(const T* data, size_t count); +}; +#endif // NAPI_VERSION > 3 && NAPI_HAS_THREADS + +// Memory management. +class MemoryManagement { + public: + static int64_t AdjustExternalMemory(Env env, int64_t change_in_bytes); +}; + +// Version management +class VersionManagement { + public: + static uint32_t GetNapiVersion(Env env); + static const napi_node_version* GetNodeVersion(Env env); +}; + +#if NAPI_VERSION > 5 +template +class Addon : public InstanceWrap { + public: + static inline Object Init(Env env, Object exports); + static T* Unwrap(Object wrapper); + + protected: + using AddonProp = ClassPropertyDescriptor; + void DefineAddon(Object exports, + const std::initializer_list& props); + Napi::Object DefineProperties(Object object, + const std::initializer_list& props); + + private: + Object entry_point_; +}; +#endif // NAPI_VERSION > 5 + +#ifdef NAPI_CPP_CUSTOM_NAMESPACE +} // namespace NAPI_CPP_CUSTOM_NAMESPACE +#endif + +} // namespace Napi + +// Inline implementations of all the above class methods are included here. +#include "napi-inl.h" + +#endif // SRC_NAPI_H_ diff --git a/node_modules/node-addon-api/node_addon_api.gyp b/node_modules/node-addon-api/node_addon_api.gyp new file mode 100644 index 0000000..29905ed --- /dev/null +++ b/node_modules/node-addon-api/node_addon_api.gyp @@ -0,0 +1,32 @@ +{ + 'targets': [ + { + 'target_name': 'node_addon_api', + 'type': 'none', + 'sources': [ 'napi.h', 'napi-inl.h' ], + 'direct_dependent_settings': { + 'include_dirs': [ '.' ], + 'includes': ['noexcept.gypi'], + } + }, + { + 'target_name': 'node_addon_api_except', + 'type': 'none', + 'sources': [ 'napi.h', 'napi-inl.h' ], + 'direct_dependent_settings': { + 'include_dirs': [ '.' ], + 'includes': ['except.gypi'], + } + }, + { + 'target_name': 'node_addon_api_maybe', + 'type': 'none', + 'sources': [ 'napi.h', 'napi-inl.h' ], + 'direct_dependent_settings': { + 'include_dirs': [ '.' ], + 'includes': ['noexcept.gypi'], + 'defines': ['NODE_ADDON_API_ENABLE_MAYBE'] + } + }, + ] +} diff --git a/node_modules/node-addon-api/node_api.gyp b/node_modules/node-addon-api/node_api.gyp new file mode 100644 index 0000000..4ff0ae7 --- /dev/null +++ b/node_modules/node-addon-api/node_api.gyp @@ -0,0 +1,9 @@ +{ + 'targets': [ + { + 'target_name': 'nothing', + 'type': 'static_library', + 'sources': [ 'nothing.c' ] + } + ] +} diff --git a/node_modules/node-addon-api/noexcept.gypi b/node_modules/node-addon-api/noexcept.gypi new file mode 100644 index 0000000..404a05f --- /dev/null +++ b/node_modules/node-addon-api/noexcept.gypi @@ -0,0 +1,26 @@ +{ + 'defines': [ 'NAPI_DISABLE_CPP_EXCEPTIONS' ], + 'cflags': [ '-fno-exceptions' ], + 'cflags_cc': [ '-fno-exceptions' ], + 'conditions': [ + ["OS=='win'", { + # _HAS_EXCEPTIONS is already defined and set to 0 in common.gypi + #"defines": [ + # "_HAS_EXCEPTIONS=0" + #], + "msvs_settings": { + "VCCLCompilerTool": { + 'ExceptionHandling': 0, + 'EnablePREfast': 'true', + }, + }, + }], + ["OS=='mac'", { + 'xcode_settings': { + 'CLANG_CXX_LIBRARY': 'libc++', + 'MACOSX_DEPLOYMENT_TARGET': '10.7', + 'GCC_ENABLE_CPP_EXCEPTIONS': 'NO', + }, + }], + ], +} diff --git a/node_modules/node-addon-api/nothing.c b/node_modules/node-addon-api/nothing.c new file mode 100644 index 0000000..e69de29 diff --git a/node_modules/node-addon-api/package-support.json b/node_modules/node-addon-api/package-support.json new file mode 100644 index 0000000..10d3607 --- /dev/null +++ b/node_modules/node-addon-api/package-support.json @@ -0,0 +1,21 @@ +{ + "versions": [ + { + "version": "*", + "target": { + "node": "active" + }, + "response": { + "type": "time-permitting", + "paid": false, + "contact": { + "name": "node-addon-api team", + "url": "https://github.com/nodejs/node-addon-api/issues" + } + }, + "backing": [ { "project": "https://github.com/nodejs" }, + { "foundation": "https://openjsf.org/" } + ] + } + ] +} diff --git a/node_modules/node-addon-api/package.json b/node_modules/node-addon-api/package.json new file mode 100644 index 0000000..d772ddc --- /dev/null +++ b/node_modules/node-addon-api/package.json @@ -0,0 +1,480 @@ +{ + "bugs": { + "url": "https://github.com/nodejs/node-addon-api/issues" + }, + "contributors": [ + { + "name": "Abhishek Kumar Singh", + "url": "https://github.com/abhi11210646" + }, + { + "name": "Alba Mendez", + "url": "https://github.com/jmendeth" + }, + { + "name": "Alexander Floh", + "url": "https://github.com/alexanderfloh" + }, + { + "name": "Ammar Faizi", + "url": "https://github.com/ammarfaizi2" + }, + { + "name": "András Timár, Dr", + "url": "https://github.com/timarandras" + }, + { + "name": "Andrew Petersen", + "url": "https://github.com/kirbysayshi" + }, + { + "name": "Anisha Rohra", + "url": "https://github.com/anisha-rohra" + }, + { + "name": "Anna Henningsen", + "url": "https://github.com/addaleax" + }, + { + "name": "Arnaud Botella", + "url": "https://github.com/BotellaA" + }, + { + "name": "Arunesh Chandra", + "url": "https://github.com/aruneshchandra" + }, + { + "name": "Azlan Mukhtar", + "url": "https://github.com/azlan" + }, + { + "name": "Ben Berman", + "url": "https://github.com/rivertam" + }, + { + "name": "Benjamin Byholm", + "url": "https://github.com/kkoopa" + }, + { + "name": "Bill Gallafent", + "url": "https://github.com/gallafent" + }, + { + "name": "blagoev", + "url": "https://github.com/blagoev" + }, + { + "name": "Bruce A. MacNaughton", + "url": "https://github.com/bmacnaughton" + }, + { + "name": "Cory Mickelson", + "url": "https://github.com/corymickelson" + }, + { + "name": "Daniel Bevenius", + "url": "https://github.com/danbev" + }, + { + "name": "Dante Calderón", + "url": "https://github.com/dantehemerson" + }, + { + "name": "Darshan Sen", + "url": "https://github.com/RaisinTen" + }, + { + "name": "David Halls", + "url": "https://github.com/davedoesdev" + }, + { + "name": "Deepak Rajamohan", + "url": "https://github.com/deepakrkris" + }, + { + "name": "Dmitry Ashkadov", + "url": "https://github.com/dmitryash" + }, + { + "name": "Dongjin Na", + "url": "https://github.com/nadongguri" + }, + { + "name": "Doni Rubiagatra", + "url": "https://github.com/rubiagatra" + }, + { + "name": "Eric Bickle", + "url": "https://github.com/ebickle" + }, + { + "name": "extremeheat", + "url": "https://github.com/extremeheat" + }, + { + "name": "Feng Yu", + "url": "https://github.com/F3n67u" + }, + { + "name": "Ferdinand Holzer", + "url": "https://github.com/fholzer" + }, + { + "name": "Gabriel Schulhof", + "url": "https://github.com/gabrielschulhof" + }, + { + "name": "Guenter Sandner", + "url": "https://github.com/gms1" + }, + { + "name": "Gus Caplan", + "url": "https://github.com/devsnek" + }, + { + "name": "Helio Frota", + "url": "https://github.com/helio-frota" + }, + { + "name": "Hitesh Kanwathirtha", + "url": "https://github.com/digitalinfinity" + }, + { + "name": "ikokostya", + "url": "https://github.com/ikokostya" + }, + { + "name": "Jack Xia", + "url": "https://github.com/JckXia" + }, + { + "name": "Jake Barnes", + "url": "https://github.com/DuBistKomisch" + }, + { + "name": "Jake Yoon", + "url": "https://github.com/yjaeseok" + }, + { + "name": "Jason Ginchereau", + "url": "https://github.com/jasongin" + }, + { + "name": "Jenny", + "url": "https://github.com/egg-bread" + }, + { + "name": "Jeroen Janssen", + "url": "https://github.com/japj" + }, + { + "name": "Jim Schlight", + "url": "https://github.com/jschlight" + }, + { + "name": "Jinho Bang", + "url": "https://github.com/romandev" + }, + { + "name": "José Expósito", + "url": "https://github.com/JoseExposito" + }, + { + "name": "joshgarde", + "url": "https://github.com/joshgarde" + }, + { + "name": "Julian Mesa", + "url": "https://github.com/julianmesa-gitkraken" + }, + { + "name": "Kasumi Hanazuki", + "url": "https://github.com/hanazuki" + }, + { + "name": "Kelvin", + "url": "https://github.com/kelvinhammond" + }, + { + "name": "Kevin Eady", + "url": "https://github.com/KevinEady" + }, + { + "name": "Kévin VOYER", + "url": "https://github.com/kecsou" + }, + { + "name": "kidneysolo", + "url": "https://github.com/kidneysolo" + }, + { + "name": "Koki Nishihara", + "url": "https://github.com/Nishikoh" + }, + { + "name": "Konstantin Tarkus", + "url": "https://github.com/koistya" + }, + { + "name": "Kyle Farnung", + "url": "https://github.com/kfarnung" + }, + { + "name": "Kyle Kovacs", + "url": "https://github.com/nullromo" + }, + { + "name": "legendecas", + "url": "https://github.com/legendecas" + }, + { + "name": "LongYinan", + "url": "https://github.com/Brooooooklyn" + }, + { + "name": "Lovell Fuller", + "url": "https://github.com/lovell" + }, + { + "name": "Luciano Martorella", + "url": "https://github.com/lmartorella" + }, + { + "name": "mastergberry", + "url": "https://github.com/mastergberry" + }, + { + "name": "Mathias Küsel", + "url": "https://github.com/mathiask88" + }, + { + "name": "Mathias Stearn", + "url": "https://github.com/RedBeard0531" + }, + { + "name": "Matteo Collina", + "url": "https://github.com/mcollina" + }, + { + "name": "Michael Dawson", + "url": "https://github.com/mhdawson" + }, + { + "name": "Michael Price", + "url": "https://github.com/mikepricedev" + }, + { + "name": "Michele Campus", + "url": "https://github.com/kYroL01" + }, + { + "name": "Mikhail Cheshkov", + "url": "https://github.com/mcheshkov" + }, + { + "name": "nempoBu4", + "url": "https://github.com/nempoBu4" + }, + { + "name": "Nicola Del Gobbo", + "url": "https://github.com/NickNaso" + }, + { + "name": "Nick Soggin", + "url": "https://github.com/iSkore" + }, + { + "name": "Nikolai Vavilov", + "url": "https://github.com/seishun" + }, + { + "name": "Nurbol Alpysbayev", + "url": "https://github.com/anurbol" + }, + { + "name": "pacop", + "url": "https://github.com/pacop" + }, + { + "name": "Peter Šándor", + "url": "https://github.com/petersandor" + }, + { + "name": "Philipp Renoth", + "url": "https://github.com/DaAitch" + }, + { + "name": "rgerd", + "url": "https://github.com/rgerd" + }, + { + "name": "Richard Lau", + "url": "https://github.com/richardlau" + }, + { + "name": "Rolf Timmermans", + "url": "https://github.com/rolftimmermans" + }, + { + "name": "Ross Weir", + "url": "https://github.com/ross-weir" + }, + { + "name": "Ryuichi Okumura", + "url": "https://github.com/okuryu" + }, + { + "name": "Saint Gabriel", + "url": "https://github.com/chineduG" + }, + { + "name": "Sampson Gao", + "url": "https://github.com/sampsongao" + }, + { + "name": "Sam Roberts", + "url": "https://github.com/sam-github" + }, + { + "name": "strager", + "url": "https://github.com/strager" + }, + { + "name": "Taylor Woll", + "url": "https://github.com/boingoing" + }, + { + "name": "Thomas Gentilhomme", + "url": "https://github.com/fraxken" + }, + { + "name": "Tim Rach", + "url": "https://github.com/timrach" + }, + { + "name": "Tobias Nießen", + "url": "https://github.com/tniessen" + }, + { + "name": "todoroff", + "url": "https://github.com/todoroff" + }, + { + "name": "Toyo Li", + "url": "https://github.com/toyobayashi" + }, + { + "name": "Tux3", + "url": "https://github.com/tux3" + }, + { + "name": "Vlad Velmisov", + "url": "https://github.com/Velmisov" + }, + { + "name": "Vladimir Morozov", + "url": "https://github.com/vmoroz" + + }, + { + "name": "WenheLI", + "url": "https://github.com/WenheLI" + }, + { + "name": "Xuguang Mei", + "url": "https://github.com/meixg" + }, + { + "name": "Yohei Kishimoto", + "url": "https://github.com/morokosi" + }, + { + "name": "Yulong Wang", + "url": "https://github.com/fs-eire" + }, + { + "name": "Ziqiu Zhao", + "url": "https://github.com/ZzqiZQute" + }, + { + "name": "Feng Yu", + "url": "https://github.com/F3n67u" + }, + { + "name": "wanlu wang", + "url": "https://github.com/wanlu" + }, + { + "name": "Caleb Hearon", + "url": "https://github.com/chearon" + }, + { + "name": "Marx", + "url": "https://github.com/MarxJiao" + }, + { + "name": "Ömer AKGÜL", + "url": "https://github.com/tuhalf" + } + ], + "description": "Node.js API (Node-API)", + "devDependencies": { + "benchmark": "^2.1.4", + "bindings": "^1.5.0", + "clang-format": "^1.4.0", + "eslint": "^7.32.0", + "eslint-config-semistandard": "^16.0.0", + "eslint-config-standard": "^16.0.3", + "eslint-plugin-import": "^2.24.2", + "eslint-plugin-node": "^11.1.0", + "eslint-plugin-promise": "^5.1.0", + "fs-extra": "^11.1.1", + "path": "^0.12.7", + "pre-commit": "^1.2.2", + "safe-buffer": "^5.1.1" + }, + "directories": {}, + "gypfile": false, + "homepage": "https://github.com/nodejs/node-addon-api", + "keywords": [ + "n-api", + "napi", + "addon", + "native", + "bindings", + "c", + "c++", + "nan", + "node-addon-api" + ], + "license": "MIT", + "main": "index.js", + "name": "node-addon-api", + "readme": "README.md", + "repository": { + "type": "git", + "url": "git://github.com/nodejs/node-addon-api.git" + }, + "files": [ + "*.{c,h,gyp,gypi}", + "package-support.json", + "tools/" + ], + "scripts": { + "prebenchmark": "node-gyp rebuild -C benchmark", + "benchmark": "node benchmark", + "pretest": "node-gyp rebuild -C test", + "test": "node test", + "test:debug": "node-gyp rebuild -C test --debug && NODE_API_BUILD_CONFIG=Debug node ./test/index.js", + "predev": "node-gyp rebuild -C test --debug", + "dev": "node test", + "predev:incremental": "node-gyp configure build -C test --debug", + "dev:incremental": "node test", + "doc": "doxygen doc/Doxyfile", + "lint": "node tools/eslint-format && node tools/clang-format", + "lint:fix": "node tools/clang-format --fix && node tools/eslint-format --fix" + }, + "pre-commit": "lint", + "version": "7.1.1", + "support": true +} diff --git a/node_modules/node-addon-api/tools/README.md b/node_modules/node-addon-api/tools/README.md new file mode 100644 index 0000000..6b80e94 --- /dev/null +++ b/node_modules/node-addon-api/tools/README.md @@ -0,0 +1,73 @@ +# Tools + +## clang-format + +The clang-format checking tools is designed to check changed lines of code compared to given git-refs. + +## Migration Script + +The migration tool is designed to reduce repetitive work in the migration process. However, the script is not aiming to convert every thing for you. There are usually some small fixes and major reconstruction required. + +### How To Use + +To run the conversion script, first make sure you have the latest `node-addon-api` in your `node_modules` directory. +``` +npm install node-addon-api +``` + +Then run the script passing your project directory +``` +node ./node_modules/node-addon-api/tools/conversion.js ./ +``` + +After finish, recompile and debug things that are missed by the script. + + +### Quick Fixes +Here is the list of things that can be fixed easily. + 1. Change your methods' return value to void if it doesn't return value to JavaScript. + 2. Use `.` to access attribute or to invoke member function in Napi::Object instead of `->`. + 3. `Napi::New(env, value);` to `Napi::[Type]::New(env, value); + + +### Major Reconstructions +The implementation of `Napi::ObjectWrap` is significantly different from NAN's. `Napi::ObjectWrap` takes a pointer to the wrapped object and creates a reference to the wrapped object inside ObjectWrap constructor. `Napi::ObjectWrap` also associates wrapped object's instance methods to Javascript module instead of static methods like NAN. + +So if you use Nan::ObjectWrap in your module, you will need to execute the following steps. + + 1. Convert your [ClassName]::New function to a constructor function that takes a `Napi::CallbackInfo`. Declare it as +``` +[ClassName](const Napi::CallbackInfo& info); +``` +and define it as +``` +[ClassName]::[ClassName](const Napi::CallbackInfo& info) : Napi::ObjectWrap<[ClassName]>(info){ + ... +} +``` +This way, the `Napi::ObjectWrap` constructor will be invoked after the object has been instantiated and `Napi::ObjectWrap` can use the `this` pointer to create a reference to the wrapped object. + + 2. Move your original constructor code into the new constructor. Delete your original constructor. + 3. In your class initialization function, associate native methods in the following way. +``` +Napi::FunctionReference constructor; + +void [ClassName]::Init(Napi::Env env, Napi::Object exports, Napi::Object module) { + Napi::HandleScope scope(env); + Napi::Function ctor = DefineClass(env, "Canvas", { + InstanceMethod<&[ClassName]::Func1>("Func1"), + InstanceMethod<&[ClassName]::Func2>("Func2"), + InstanceAccessor<&[ClassName]::ValueGetter>("Value"), + StaticMethod<&[ClassName]::StaticMethod>("MethodName"), + InstanceValue("Value", Napi::[Type]::New(env, value)), + }); + + constructor = Napi::Persistent(ctor); + constructor .SuppressDestruct(); + exports.Set("[ClassName]", ctor); +} +``` + 4. In function where you need to Unwrap the ObjectWrap in NAN like `[ClassName]* native = Nan::ObjectWrap::Unwrap<[ClassName]>(info.This());`, use `this` pointer directly as the unwrapped object as each ObjectWrap instance is associated with a unique object instance. + + +If you still find issues after following this guide, please leave us an issue describing your problem and we will try to resolve it. diff --git a/node_modules/node-addon-api/tools/check-napi.js b/node_modules/node-addon-api/tools/check-napi.js new file mode 100644 index 0000000..9199af3 --- /dev/null +++ b/node_modules/node-addon-api/tools/check-napi.js @@ -0,0 +1,99 @@ +'use strict'; +// Descend into a directory structure and, for each file matching *.node, output +// based on the imports found in the file whether it's an N-API module or not. + +const fs = require('fs'); +const path = require('path'); + +// Read the output of the command, break it into lines, and use the reducer to +// decide whether the file is an N-API module or not. +function checkFile (file, command, argv, reducer) { + const child = require('child_process').spawn(command, argv, { + stdio: ['inherit', 'pipe', 'inherit'] + }); + let leftover = ''; + let isNapi; + child.stdout.on('data', (chunk) => { + if (isNapi === undefined) { + chunk = (leftover + chunk.toString()).split(/[\r\n]+/); + leftover = chunk.pop(); + isNapi = chunk.reduce(reducer, isNapi); + if (isNapi !== undefined) { + child.kill(); + } + } + }); + child.on('close', (code, signal) => { + if ((code === null && signal !== null) || (code !== 0)) { + console.log( + command + ' exited with code: ' + code + ' and signal: ' + signal); + } else { + // Green if it's a N-API module, red otherwise. + console.log( + '\x1b[' + (isNapi ? '42' : '41') + 'm' + + (isNapi ? ' N-API' : 'Not N-API') + + '\x1b[0m: ' + file); + } + }); +} + +// Use nm -a to list symbols. +function checkFileUNIX (file) { + checkFile(file, 'nm', ['-a', file], (soFar, line) => { + if (soFar === undefined) { + line = line.match(/([0-9a-f]*)? ([a-zA-Z]) (.*$)/); + if (line[2] === 'U') { + if (/^napi/.test(line[3])) { + soFar = true; + } + } + } + return soFar; + }); +} + +// Use dumpbin /imports to list symbols. +function checkFileWin32 (file) { + checkFile(file, 'dumpbin', ['/imports', file], (soFar, line) => { + if (soFar === undefined) { + line = line.match(/([0-9a-f]*)? +([a-zA-Z0-9]) (.*$)/); + if (line && /^napi/.test(line[line.length - 1])) { + soFar = true; + } + } + return soFar; + }); +} + +// Descend into a directory structure and pass each file ending in '.node' to +// one of the above checks, depending on the OS. +function recurse (top) { + fs.readdir(top, (error, items) => { + if (error) { + throw new Error('error reading directory ' + top + ': ' + error); + } + items.forEach((item) => { + item = path.join(top, item); + fs.stat(item, ((item) => (error, stats) => { + if (error) { + throw new Error('error about ' + item + ': ' + error); + } + if (stats.isDirectory()) { + recurse(item); + } else if (/[.]node$/.test(item) && + // Explicitly ignore files called 'nothing.node' because they are + // artefacts of node-addon-api having identified a version of + // Node.js that ships with a correct implementation of N-API. + path.basename(item) !== 'nothing.node') { + process.platform === 'win32' + ? checkFileWin32(item) + : checkFileUNIX(item); + } + })(item)); + }); + }); +} + +// Start with the directory given on the command line or the current directory +// if nothing was given. +recurse(process.argv.length > 3 ? process.argv[2] : '.'); diff --git a/node_modules/node-addon-api/tools/clang-format.js b/node_modules/node-addon-api/tools/clang-format.js new file mode 100644 index 0000000..e4bb4f5 --- /dev/null +++ b/node_modules/node-addon-api/tools/clang-format.js @@ -0,0 +1,71 @@ +#!/usr/bin/env node + +const spawn = require('child_process').spawnSync; +const path = require('path'); + +const filesToCheck = ['*.h', '*.cc']; +const FORMAT_START = process.env.FORMAT_START || 'main'; + +function main (args) { + let fix = false; + while (args.length > 0) { + switch (args[0]) { + case '-f': + case '--fix': + fix = true; + break; + default: + } + args.shift(); + } + + const clangFormatPath = path.dirname(require.resolve('clang-format')); + const binary = process.platform === 'win32' + ? 'node_modules\\.bin\\clang-format.cmd' + : 'node_modules/.bin/clang-format'; + const options = ['--binary=' + binary, '--style=file']; + if (fix) { + options.push(FORMAT_START); + } else { + options.push('--diff', FORMAT_START); + } + + const gitClangFormatPath = path.join(clangFormatPath, 'bin/git-clang-format'); + const result = spawn( + 'python', + [gitClangFormatPath, ...options, '--', ...filesToCheck], + { encoding: 'utf-8' } + ); + + if (result.stderr) { + console.error('Error running git-clang-format:', result.stderr); + return 2; + } + + const clangFormatOutput = result.stdout.trim(); + // Bail fast if in fix mode. + if (fix) { + console.log(clangFormatOutput); + return 0; + } + // Detect if there is any complains from clang-format + if ( + clangFormatOutput !== '' && + clangFormatOutput !== 'no modified files to format' && + clangFormatOutput !== 'clang-format did not modify any files' + ) { + console.error(clangFormatOutput); + const fixCmd = 'npm run lint:fix'; + console.error(` + ERROR: please run "${fixCmd}" to format changes in your commit + Note that when running the command locally, please keep your local + main branch and working branch up to date with nodejs/node-addon-api + to exclude un-related complains. + Or you can run "env FORMAT_START=upstream/main ${fixCmd}".`); + return 1; + } +} + +if (require.main === module) { + process.exitCode = main(process.argv.slice(2)); +} diff --git a/node_modules/node-addon-api/tools/conversion.js b/node_modules/node-addon-api/tools/conversion.js new file mode 100644 index 0000000..f89245a --- /dev/null +++ b/node_modules/node-addon-api/tools/conversion.js @@ -0,0 +1,301 @@ +#! /usr/bin/env node + +'use strict'; + +const fs = require('fs'); +const path = require('path'); + +const args = process.argv.slice(2); +const dir = args[0]; +if (!dir) { + console.log('Usage: node ' + path.basename(__filename) + ' '); + process.exit(1); +} + +const NodeApiVersion = require('../package.json').version; + +const disable = args[1]; +let ConfigFileOperations; +if (disable !== '--disable' && dir !== '--disable') { + ConfigFileOperations = { + 'package.json': [ + [/([ ]*)"dependencies": {/g, '$1"dependencies": {\n$1 "node-addon-api": "' + NodeApiVersion + '",'], + [/[ ]*"nan": *"[^"]+"(,|)[\n\r]/g, ''] + ], + 'binding.gyp': [ + [/([ ]*)'include_dirs': \[/g, '$1\'include_dirs\': [\n$1 \'\s+(\w+)\s*=\s*Nan::New\([\w\d:]+\);(?:\w+->Reset\(\1\))?\s+\1->SetClassName\(Nan::String::New\("(\w+)"\)\);/g, 'Napi::Function $1 = DefineClass(env, "$2", {'], + [/Local\s+(\w+)\s*=\s*Nan::New\([\w\d:]+\);\s+(\w+)\.Reset\((\1)\);\s+\1->SetClassName\((Nan::String::New|Nan::New<(v8::)*String>)\("(.+?)"\)\);/g, 'Napi::Function $1 = DefineClass(env, "$6", {'], + [/Local\s+(\w+)\s*=\s*Nan::New\([\w\d:]+\);(?:\w+->Reset\(\1\))?\s+\1->SetClassName\(Nan::String::New\("(\w+)"\)\);/g, 'Napi::Function $1 = DefineClass(env, "$2", {'], + [/Nan::New\(([\w\d:]+)\)->GetFunction\(\)/g, 'Napi::Function::New(env, $1)'], + [/Nan::New\(([\w\d:]+)\)->GetFunction()/g, 'Napi::Function::New(env, $1);'], + [/Nan::New\(([\w\d:]+)\)/g, 'Napi::Function::New(env, $1)'], + [/Nan::New\(([\w\d:]+)\)/g, 'Napi::Function::New(env, $1)'], + + // FunctionTemplate to FunctionReference + [/Nan::Persistent<(v8::)*FunctionTemplate>/g, 'Napi::FunctionReference'], + [/Nan::Persistent<(v8::)*Function>/g, 'Napi::FunctionReference'], + [/v8::Local/g, 'Napi::FunctionReference'], + [/Local/g, 'Napi::FunctionReference'], + [/v8::FunctionTemplate/g, 'Napi::FunctionReference'], + [/FunctionTemplate/g, 'Napi::FunctionReference'], + + [/([ ]*)Nan::SetPrototypeMethod\(\w+, "(\w+)", (\w+)\);/g, '$1InstanceMethod("$2", &$3),'], + [/([ ]*)(?:\w+\.Reset\(\w+\);\s+)?\(target\)\.Set\("(\w+)",\s*Nan::GetFunction\((\w+)\)\);/gm, + '});\n\n' + + '$1constructor = Napi::Persistent($3);\n' + + '$1constructor.SuppressDestruct();\n' + + '$1target.Set("$2", $3);'], + + // TODO: Other attribute combinations + [/static_cast\(ReadOnly\s*\|\s*DontDelete\)/gm, + 'static_cast(napi_enumerable | napi_configurable)'], + + [/([\w\d:<>]+?)::Cast\((.+?)\)/g, '$2.As<$1>()'], + + [/\*Nan::Utf8String\(([^)]+)\)/g, '$1->As().Utf8Value().c_str()'], + [/Nan::Utf8String +(\w+)\(([^)]+)\)/g, 'std::string $1 = $2.As()'], + [/Nan::Utf8String/g, 'std::string'], + + [/v8::String::Utf8Value (.+?)\((.+?)\)/g, 'Napi::String $1(env, $2)'], + [/String::Utf8Value (.+?)\((.+?)\)/g, 'Napi::String $1(env, $2)'], + [/\.length\(\)/g, '.Length()'], + + [/Nan::MakeCallback\(([^,]+),[\s\\]+([^,]+),/gm, '$2.MakeCallback($1,'], + + [/class\s+(\w+)\s*:\s*public\s+Nan::ObjectWrap/g, 'class $1 : public Napi::ObjectWrap<$1>'], + [/(\w+)\(([^)]*)\)\s*:\s*Nan::ObjectWrap\(\)\s*(,)?/gm, '$1($2) : Napi::ObjectWrap<$1>()$3'], + + // HandleOKCallback to OnOK + [/HandleOKCallback/g, 'OnOK'], + // HandleErrorCallback to OnError + [/HandleErrorCallback/g, 'OnError'], + + // ex. .As() to .As() + [/\.As\(\)/g, '.As()'], + [/\.As<(Value|Boolean|String|Number|Object|Array|Symbol|External|Function)>\(\)/g, '.As()'], + + // ex. Nan::New(info[0]) to Napi::Number::New(info[0]) + [/Nan::New<(v8::)*Integer>\((.+?)\)/g, 'Napi::Number::New(env, $2)'], + [/Nan::New\(([0-9.]+)\)/g, 'Napi::Number::New(env, $1)'], + [/Nan::New<(v8::)*String>\("(.+?)"\)/g, 'Napi::String::New(env, "$2")'], + [/Nan::New\("(.+?)"\)/g, 'Napi::String::New(env, "$1")'], + [/Nan::New<(v8::)*(.+?)>\(\)/g, 'Napi::$2::New(env)'], + [/Nan::New<(.+?)>\(\)/g, 'Napi::$1::New(env)'], + [/Nan::New<(v8::)*(.+?)>\(/g, 'Napi::$2::New(env, '], + [/Nan::New<(.+?)>\(/g, 'Napi::$1::New(env, '], + [/Nan::NewBuffer\(/g, 'Napi::Buffer::New(env, '], + // TODO: Properly handle this + [/Nan::New\(/g, 'Napi::New(env, '], + + [/\.IsInt32\(\)/g, '.IsNumber()'], + [/->IsInt32\(\)/g, '.IsNumber()'], + + [/(.+?)->BooleanValue\(\)/g, '$1.As().Value()'], + [/(.+?)->Int32Value\(\)/g, '$1.As().Int32Value()'], + [/(.+?)->Uint32Value\(\)/g, '$1.As().Uint32Value()'], + [/(.+?)->IntegerValue\(\)/g, '$1.As().Int64Value()'], + [/(.+?)->NumberValue\(\)/g, '$1.As().DoubleValue()'], + + // ex. Nan::To(info[0]) to info[0].Value() + [/Nan::To\((.+?)\)/g, '$2.To()'], + [/Nan::To<(Boolean|String|Number|Object|Array|Symbol|Function)>\((.+?)\)/g, '$2.To()'], + // ex. Nan::To(info[0]) to info[0].As().Value() + [/Nan::To\((.+?)\)/g, '$1.As().Value()'], + // ex. Nan::To(info[0]) to info[0].As().Int32Value() + [/Nan::To\((.+?)\)/g, '$1.As().Int32Value()'], + // ex. Nan::To(info[0]) to info[0].As().Int32Value() + [/Nan::To\((.+?)\)/g, '$1.As().Int32Value()'], + // ex. Nan::To(info[0]) to info[0].As().Uint32Value() + [/Nan::To\((.+?)\)/g, '$1.As().Uint32Value()'], + // ex. Nan::To(info[0]) to info[0].As().Int64Value() + [/Nan::To\((.+?)\)/g, '$1.As().Int64Value()'], + // ex. Nan::To(info[0]) to info[0].As().FloatValue() + [/Nan::To\((.+?)\)/g, '$1.As().FloatValue()'], + // ex. Nan::To(info[0]) to info[0].As().DoubleValue() + [/Nan::To\((.+?)\)/g, '$1.As().DoubleValue()'], + + [/Nan::New\((\w+)\)->HasInstance\((\w+)\)/g, '$2.InstanceOf($1.Value())'], + + [/Nan::Has\(([^,]+),\s*/gm, '($1).Has('], + [/\.Has\([\s|\\]*Nan::New<(v8::)*String>\(([^)]+)\)\)/gm, '.Has($1)'], + [/\.Has\([\s|\\]*Nan::New\(([^)]+)\)\)/gm, '.Has($1)'], + + [/Nan::Get\(([^,]+),\s*/gm, '($1).Get('], + [/\.Get\([\s|\\]*Nan::New<(v8::)*String>\(([^)]+)\)\)/gm, '.Get($1)'], + [/\.Get\([\s|\\]*Nan::New\(([^)]+)\)\)/gm, '.Get($1)'], + + [/Nan::Set\(([^,]+),\s*/gm, '($1).Set('], + [/\.Set\([\s|\\]*Nan::New<(v8::)*String>\(([^)]+)\)\s*,/gm, '.Set($1,'], + [/\.Set\([\s|\\]*Nan::New\(([^)]+)\)\s*,/gm, '.Set($1,'], + + // ex. node::Buffer::HasInstance(info[0]) to info[0].IsBuffer() + [/node::Buffer::HasInstance\((.+?)\)/g, '$1.IsBuffer()'], + // ex. node::Buffer::Length(info[0]) to info[0].Length() + [/node::Buffer::Length\((.+?)\)/g, '$1.As>().Length()'], + // ex. node::Buffer::Data(info[0]) to info[0].Data() + [/node::Buffer::Data\((.+?)\)/g, '$1.As>().Data()'], + [/Nan::CopyBuffer\(/g, 'Napi::Buffer::Copy(env, '], + + // Nan::AsyncQueueWorker(worker) + [/Nan::AsyncQueueWorker\((.+)\);/g, '$1.Queue();'], + [/Nan::(Undefined|Null|True|False)\(\)/g, 'env.$1()'], + + // Nan::ThrowError(error) to Napi::Error::New(env, error).ThrowAsJavaScriptException() + [/([ ]*)return Nan::Throw(\w*?)Error\((.+?)\);/g, '$1Napi::$2Error::New(env, $3).ThrowAsJavaScriptException();\n$1return env.Null();'], + [/Nan::Throw(\w*?)Error\((.+?)\);\n(\s*)return;/g, 'Napi::$1Error::New(env, $2).ThrowAsJavaScriptException();\n$3return env.Null();'], + [/Nan::Throw(\w*?)Error\((.+?)\);/g, 'Napi::$1Error::New(env, $2).ThrowAsJavaScriptException();\n'], + // Nan::RangeError(error) to Napi::RangeError::New(env, error) + [/Nan::(\w*?)Error\((.+)\)/g, 'Napi::$1Error::New(env, $2)'], + + [/Nan::Set\((.+?),\n* *(.+?),\n* *(.+?),\n* *(.+?)\)/g, '$1.Set($2, $3, $4)'], + + [/Nan::(Escapable)?HandleScope\s+(\w+)\s*;/g, 'Napi::$1HandleScope $2(env);'], + [/Nan::(Escapable)?HandleScope/g, 'Napi::$1HandleScope'], + [/Nan::ForceSet\(([^,]+), ?/g, '$1->DefineProperty('], + [/\.ForceSet\(Napi::String::New\(env, "(\w+)"\),\s*?/g, '.DefineProperty("$1", '], + // [ /Nan::GetPropertyNames\(([^,]+)\)/, '$1->GetPropertyNames()' ], + [/Nan::Equals\(([^,]+),/g, '$1.StrictEquals('], + + [/(.+)->Set\(/g, '$1.Set('], + + [/Nan::Callback/g, 'Napi::FunctionReference'], + + [/Nan::Persistent/g, 'Napi::ObjectReference'], + [/Nan::ADDON_REGISTER_FUNCTION_ARGS_TYPE target/g, 'Napi::Env& env, Napi::Object& target'], + + [/(\w+)\*\s+(\w+)\s*=\s*Nan::ObjectWrap::Unwrap<\w+>\(info\.This\(\)\);/g, '$1* $2 = this;'], + [/Nan::ObjectWrap::Unwrap<(\w+)>\((.*)\);/g, '$2.Unwrap<$1>();'], + + [/Nan::NAN_METHOD_RETURN_TYPE/g, 'void'], + [/NAN_INLINE/g, 'inline'], + + [/Nan::NAN_METHOD_ARGS_TYPE/g, 'const Napi::CallbackInfo&'], + [/NAN_METHOD\(([\w\d:]+?)\)/g, 'Napi::Value $1(const Napi::CallbackInfo& info)'], + [/static\s*NAN_GETTER\(([\w\d:]+?)\)/g, 'Napi::Value $1(const Napi::CallbackInfo& info)'], + [/NAN_GETTER\(([\w\d:]+?)\)/g, 'Napi::Value $1(const Napi::CallbackInfo& info)'], + [/static\s*NAN_SETTER\(([\w\d:]+?)\)/g, 'void $1(const Napi::CallbackInfo& info, const Napi::Value& value)'], + [/NAN_SETTER\(([\w\d:]+?)\)/g, 'void $1(const Napi::CallbackInfo& info, const Napi::Value& value)'], + [/void Init\((v8::)*Local<(v8::)*Object> exports\)/g, 'Napi::Object Init(Napi::Env env, Napi::Object exports)'], + [/NAN_MODULE_INIT\(([\w\d:]+?)\);/g, 'Napi::Object $1(Napi::Env env, Napi::Object exports);'], + [/NAN_MODULE_INIT\(([\w\d:]+?)\)/g, 'Napi::Object $1(Napi::Env env, Napi::Object exports)'], + + [/::(Init(?:ialize)?)\(target\)/g, '::$1(env, target, module)'], + [/constructor_template/g, 'constructor'], + + [/Nan::FunctionCallbackInfo<(v8::)?Value>[ ]*& [ ]*info\)[ ]*{\n*([ ]*)/gm, 'Napi::CallbackInfo& info) {\n$2Napi::Env env = info.Env();\n$2'], + [/Nan::FunctionCallbackInfo<(v8::)*Value>\s*&\s*info\);/g, 'Napi::CallbackInfo& info);'], + [/Nan::FunctionCallbackInfo<(v8::)*Value>\s*&/g, 'Napi::CallbackInfo&'], + + [/Buffer::HasInstance\(([^)]+)\)/g, '$1.IsBuffer()'], + + [/info\[(\d+)\]->/g, 'info[$1].'], + [/info\[([\w\d]+)\]->/g, 'info[$1].'], + [/info\.This\(\)->/g, 'info.This().'], + [/->Is(Object|String|Int32|Number)\(\)/g, '.Is$1()'], + [/info.GetReturnValue\(\).SetUndefined\(\)/g, 'return env.Undefined()'], + [/info\.GetReturnValue\(\)\.Set\(((\n|.)+?)\);/g, 'return $1;'], + + // ex. Local to Napi::Value + [/v8::Local/g, 'Napi::$1'], + [/Local<(Value|Boolean|String|Number|Object|Array|Symbol|External|Function)>/g, 'Napi::$1'], + + // Declare an env in helper functions that take a Napi::Value + [/(\w+)\(Napi::Value (\w+)(,\s*[^()]+)?\)\s*{\n*([ ]*)/gm, '$1(Napi::Value $2$3) {\n$4Napi::Env env = $2.Env();\n$4'], + + // delete #include and/or + [/#include +(<|")(?:node|nan).h("|>)/g, '#include $1napi.h$2\n#include $1uv.h$2'], + // NODE_MODULE to NODE_API_MODULE + [/NODE_MODULE/g, 'NODE_API_MODULE'], + [/Nan::/g, 'Napi::'], + [/nan.h/g, 'napi.h'], + + // delete .FromJust() + [/\.FromJust\(\)/g, ''], + // delete .ToLocalCheck() + [/\.ToLocalChecked\(\)/g, ''], + [/^.*->SetInternalFieldCount\(.*$/gm, ''], + + // replace using node; and/or using v8; to using Napi; + [/using (node|v8);/g, 'using Napi;'], + [/using namespace (node|Nan|v8);/g, 'using namespace Napi;'], + // delete using v8::Local; + [/using v8::Local;\n/g, ''], + // replace using v8::XXX; with using Napi::XXX + [/using v8::([A-Za-z]+);/g, 'using Napi::$1;'] + +]; + +const paths = listFiles(dir); +paths.forEach(function (dirEntry) { + const filename = dirEntry.split('\\').pop().split('/').pop(); + + // Check whether the file is a source file or a config file + // then execute function accordingly + const sourcePattern = /.+\.h|.+\.cc|.+\.cpp/; + if (sourcePattern.test(filename)) { + convertFile(dirEntry, SourceFileOperations); + } else if (ConfigFileOperations[filename] != null) { + convertFile(dirEntry, ConfigFileOperations[filename]); + } +}); + +function listFiles (dir, filelist) { + const files = fs.readdirSync(dir); + filelist = filelist || []; + files.forEach(function (file) { + if (file === 'node_modules') { + return; + } + + if (fs.statSync(path.join(dir, file)).isDirectory()) { + filelist = listFiles(path.join(dir, file), filelist); + } else { + filelist.push(path.join(dir, file)); + } + }); + return filelist; +} + +function convert (content, operations) { + for (let i = 0; i < operations.length; i++) { + const operation = operations[i]; + content = content.replace(operation[0], operation[1]); + } + return content; +} + +function convertFile (fileName, operations) { + fs.readFile(fileName, 'utf-8', function (err, file) { + if (err) throw err; + + file = convert(file, operations); + + fs.writeFile(fileName, file, function (err) { + if (err) throw err; + }); + }); +} diff --git a/node_modules/node-addon-api/tools/eslint-format.js b/node_modules/node-addon-api/tools/eslint-format.js new file mode 100644 index 0000000..6923ab7 --- /dev/null +++ b/node_modules/node-addon-api/tools/eslint-format.js @@ -0,0 +1,79 @@ +#!/usr/bin/env node + +const spawn = require('child_process').spawnSync; + +const filesToCheck = '*.js'; +const FORMAT_START = process.env.FORMAT_START || 'main'; +const IS_WIN = process.platform === 'win32'; +const ESLINT_PATH = IS_WIN ? 'node_modules\\.bin\\eslint.cmd' : 'node_modules/.bin/eslint'; + +function main (args) { + let fix = false; + while (args.length > 0) { + switch (args[0]) { + case '-f': + case '--fix': + fix = true; + break; + default: + } + args.shift(); + } + + // Check js files that change on unstaged file + const fileUnStaged = spawn( + 'git', + ['diff', '--name-only', '--diff-filter=d', FORMAT_START, filesToCheck], + { + encoding: 'utf-8' + } + ); + + // Check js files that change on staged file + const fileStaged = spawn( + 'git', + ['diff', '--name-only', '--cached', '--diff-filter=d', FORMAT_START, filesToCheck], + { + encoding: 'utf-8' + } + ); + + const options = [ + ...fileStaged.stdout.split('\n').filter((f) => f !== ''), + ...fileUnStaged.stdout.split('\n').filter((f) => f !== '') + ]; + + if (fix) { + options.push('--fix'); + } + + const result = spawn(ESLINT_PATH, [...options], { + encoding: 'utf-8' + }); + + if (result.error && result.error.errno === 'ENOENT') { + console.error('Eslint not found! Eslint is supposed to be found at ', ESLINT_PATH); + return 2; + } + + if (result.status === 1) { + console.error('Eslint error:', result.stdout); + const fixCmd = 'npm run lint:fix'; + console.error(`ERROR: please run "${fixCmd}" to format changes in your commit + Note that when running the command locally, please keep your local + main branch and working branch up to date with nodejs/node-addon-api + to exclude un-related complains. + Or you can run "env FORMAT_START=upstream/main ${fixCmd}". + Also fix JS files by yourself if necessary.`); + return 1; + } + + if (result.stderr) { + console.error('Error running eslint:', result.stderr); + return 2; + } +} + +if (require.main === module) { + process.exitCode = main(process.argv.slice(2)); +} diff --git a/node_modules/picomatch/CHANGELOG.md b/node_modules/picomatch/CHANGELOG.md new file mode 100644 index 0000000..8ccc6c1 --- /dev/null +++ b/node_modules/picomatch/CHANGELOG.md @@ -0,0 +1,136 @@ +# Release history + +**All notable changes to this project will be documented in this file.** + +The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html). + +
+ Guiding Principles + +- Changelogs are for humans, not machines. +- There should be an entry for every single version. +- The same types of changes should be grouped. +- Versions and sections should be linkable. +- The latest version comes first. +- The release date of each versions is displayed. +- Mention whether you follow Semantic Versioning. + +
+ +
+ Types of changes + +Changelog entries are classified using the following labels _(from [keep-a-changelog](http://keepachangelog.com/)_): + +- `Added` for new features. +- `Changed` for changes in existing functionality. +- `Deprecated` for soon-to-be removed features. +- `Removed` for now removed features. +- `Fixed` for any bug fixes. +- `Security` in case of vulnerabilities. + +
+ +## 2.3.1 (2022-01-02) + +### Fixed + +* Fixes bug when a pattern containing an expression after the closing parenthesis (`/!(*.d).{ts,tsx}`) was incorrectly converted to regexp ([9f241ef](https://github.com/micromatch/picomatch/commit/9f241ef)). + +### Changed + +* Some documentation improvements ([f81d236](https://github.com/micromatch/picomatch/commit/f81d236), [421e0e7](https://github.com/micromatch/picomatch/commit/421e0e7)). + +## 2.3.0 (2021-05-21) + +### Fixed + +* Fixes bug where file names with two dots were not being matched consistently with negation extglobs containing a star ([56083ef](https://github.com/micromatch/picomatch/commit/56083ef)) + +## 2.2.3 (2021-04-10) + +### Fixed + +* Do not skip pattern seperator for square brackets ([fb08a30](https://github.com/micromatch/picomatch/commit/fb08a30)). +* Set negatedExtGlob also if it does not span the whole pattern ([032e3f5](https://github.com/micromatch/picomatch/commit/032e3f5)). + +## 2.2.2 (2020-03-21) + +### Fixed + +* Correctly handle parts of the pattern after parentheses in the `scan` method ([e15b920](https://github.com/micromatch/picomatch/commit/e15b920)). + +## 2.2.1 (2020-01-04) + +* Fixes [#49](https://github.com/micromatch/picomatch/issues/49), so that braces with no sets or ranges are now propertly treated as literals. + +## 2.2.0 (2020-01-04) + +* Disable fastpaths mode for the parse method ([5b8d33f](https://github.com/micromatch/picomatch/commit/5b8d33f)) +* Add `tokens`, `slashes`, and `parts` to the object returned by `picomatch.scan()`. + +## 2.1.0 (2019-10-31) + +* add benchmarks for scan ([4793b92](https://github.com/micromatch/picomatch/commit/4793b92)) +* Add eslint object-curly-spacing rule ([707c650](https://github.com/micromatch/picomatch/commit/707c650)) +* Add prefer-const eslint rule ([5c7501c](https://github.com/micromatch/picomatch/commit/5c7501c)) +* Add support for nonegate in scan API ([275c9b9](https://github.com/micromatch/picomatch/commit/275c9b9)) +* Change lets to consts. Move root import up. ([4840625](https://github.com/micromatch/picomatch/commit/4840625)) +* closes https://github.com/micromatch/picomatch/issues/21 ([766bcb0](https://github.com/micromatch/picomatch/commit/766bcb0)) +* Fix "Extglobs" table in readme ([eb19da8](https://github.com/micromatch/picomatch/commit/eb19da8)) +* fixes https://github.com/micromatch/picomatch/issues/20 ([9caca07](https://github.com/micromatch/picomatch/commit/9caca07)) +* fixes https://github.com/micromatch/picomatch/issues/26 ([fa58f45](https://github.com/micromatch/picomatch/commit/fa58f45)) +* Lint test ([d433a34](https://github.com/micromatch/picomatch/commit/d433a34)) +* lint unit tests ([0159b55](https://github.com/micromatch/picomatch/commit/0159b55)) +* Make scan work with noext ([6c02e03](https://github.com/micromatch/picomatch/commit/6c02e03)) +* minor linting ([c2a2b87](https://github.com/micromatch/picomatch/commit/c2a2b87)) +* minor parser improvements ([197671d](https://github.com/micromatch/picomatch/commit/197671d)) +* remove eslint since it... ([07876fa](https://github.com/micromatch/picomatch/commit/07876fa)) +* remove funding file ([8ebe96d](https://github.com/micromatch/picomatch/commit/8ebe96d)) +* Remove unused funks ([cbc6d54](https://github.com/micromatch/picomatch/commit/cbc6d54)) +* Run eslint during pretest, fix existing eslint findings ([0682367](https://github.com/micromatch/picomatch/commit/0682367)) +* support `noparen` in scan ([3d37569](https://github.com/micromatch/picomatch/commit/3d37569)) +* update changelog ([7b34e77](https://github.com/micromatch/picomatch/commit/7b34e77)) +* update travis ([777f038](https://github.com/micromatch/picomatch/commit/777f038)) +* Use eslint-disable-next-line instead of eslint-disable ([4e7c1fd](https://github.com/micromatch/picomatch/commit/4e7c1fd)) + +## 2.0.7 (2019-05-14) + +* 2.0.7 ([9eb9a71](https://github.com/micromatch/picomatch/commit/9eb9a71)) +* supports lookbehinds ([1f63f7e](https://github.com/micromatch/picomatch/commit/1f63f7e)) +* update .verb.md file with typo change ([2741279](https://github.com/micromatch/picomatch/commit/2741279)) +* fix: typo in README ([0753e44](https://github.com/micromatch/picomatch/commit/0753e44)) + +## 2.0.4 (2019-04-10) + +### Fixed + +- Readme link [fixed](https://github.com/micromatch/picomatch/pull/13/commits/a96ab3aa2b11b6861c23289964613d85563b05df) by @danez. +- `options.capture` now works as expected when fastpaths are enabled. See https://github.com/micromatch/picomatch/pull/12/commits/26aefd71f1cfaf95c37f1c1fcab68a693b037304. Thanks to @DrPizza. + +## 2.0.0 (2019-04-10) + +### Added + +- Adds support for `options.onIgnore`. See the readme for details +- Adds support for `options.onResult`. See the readme for details + +### Breaking changes + +- The unixify option was renamed to `windows` +- caching and all related options and methods have been removed + +## 1.0.0 (2018-11-05) + +- adds `.onMatch` option +- improvements to `.scan` method +- numerous improvements and optimizations for matching and parsing +- better windows path handling + +## 0.1.0 - 2017-04-13 + +First release. + + +[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog diff --git a/node_modules/picomatch/LICENSE b/node_modules/picomatch/LICENSE new file mode 100644 index 0000000..3608dca --- /dev/null +++ b/node_modules/picomatch/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2017-present, Jon Schlinkert. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/picomatch/README.md b/node_modules/picomatch/README.md new file mode 100644 index 0000000..b0526e2 --- /dev/null +++ b/node_modules/picomatch/README.md @@ -0,0 +1,708 @@ +

Picomatch

+ +

+ +version + + +test status + + +coverage status + + +downloads + +

+ +
+
+ +

+Blazing fast and accurate glob matcher written in JavaScript.
+No dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions. +

+ +
+
+ +## Why picomatch? + +* **Lightweight** - No dependencies +* **Minimal** - Tiny API surface. Main export is a function that takes a glob pattern and returns a matcher function. +* **Fast** - Loads in about 2ms (that's several times faster than a [single frame of a HD movie](http://www.endmemo.com/sconvert/framespersecondframespermillisecond.php) at 60fps) +* **Performant** - Use the returned matcher function to speed up repeat matching (like when watching files) +* **Accurate matching** - Using wildcards (`*` and `?`), globstars (`**`) for nested directories, [advanced globbing](#advanced-globbing) with extglobs, braces, and POSIX brackets, and support for escaping special characters with `\` or quotes. +* **Well tested** - Thousands of unit tests + +See the [library comparison](#library-comparisons) to other libraries. + +
+
+ +## Table of Contents + +
Click to expand + +- [Install](#install) +- [Usage](#usage) +- [API](#api) + * [picomatch](#picomatch) + * [.test](#test) + * [.matchBase](#matchbase) + * [.isMatch](#ismatch) + * [.parse](#parse) + * [.scan](#scan) + * [.compileRe](#compilere) + * [.makeRe](#makere) + * [.toRegex](#toregex) +- [Options](#options) + * [Picomatch options](#picomatch-options) + * [Scan Options](#scan-options) + * [Options Examples](#options-examples) +- [Globbing features](#globbing-features) + * [Basic globbing](#basic-globbing) + * [Advanced globbing](#advanced-globbing) + * [Braces](#braces) + * [Matching special characters as literals](#matching-special-characters-as-literals) +- [Library Comparisons](#library-comparisons) +- [Benchmarks](#benchmarks) +- [Philosophies](#philosophies) +- [About](#about) + * [Author](#author) + * [License](#license) + +_(TOC generated by [verb](https://github.com/verbose/verb) using [markdown-toc](https://github.com/jonschlinkert/markdown-toc))_ + +
+ +
+
+ +## Install + +Install with [npm](https://www.npmjs.com/): + +```sh +npm install --save picomatch +``` + +
+ +## Usage + +The main export is a function that takes a glob pattern and an options object and returns a function for matching strings. + +```js +const pm = require('picomatch'); +const isMatch = pm('*.js'); + +console.log(isMatch('abcd')); //=> false +console.log(isMatch('a.js')); //=> true +console.log(isMatch('a.md')); //=> false +console.log(isMatch('a/b.js')); //=> false +``` + +
+ +## API + +### [picomatch](lib/picomatch.js#L32) + +Creates a matcher function from one or more glob patterns. The returned function takes a string to match as its first argument, and returns true if the string is a match. The returned matcher function also takes a boolean as the second argument that, when true, returns an object with additional information. + +**Params** + +* `globs` **{String|Array}**: One or more glob patterns. +* `options` **{Object=}** +* `returns` **{Function=}**: Returns a matcher function. + +**Example** + +```js +const picomatch = require('picomatch'); +// picomatch(glob[, options]); + +const isMatch = picomatch('*.!(*a)'); +console.log(isMatch('a.a')); //=> false +console.log(isMatch('a.b')); //=> true +``` + +### [.test](lib/picomatch.js#L117) + +Test `input` with the given `regex`. This is used by the main `picomatch()` function to test the input string. + +**Params** + +* `input` **{String}**: String to test. +* `regex` **{RegExp}** +* `returns` **{Object}**: Returns an object with matching info. + +**Example** + +```js +const picomatch = require('picomatch'); +// picomatch.test(input, regex[, options]); + +console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/)); +// { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' } +``` + +### [.matchBase](lib/picomatch.js#L161) + +Match the basename of a filepath. + +**Params** + +* `input` **{String}**: String to test. +* `glob` **{RegExp|String}**: Glob pattern or regex created by [.makeRe](#makeRe). +* `returns` **{Boolean}** + +**Example** + +```js +const picomatch = require('picomatch'); +// picomatch.matchBase(input, glob[, options]); +console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true +``` + +### [.isMatch](lib/picomatch.js#L183) + +Returns true if **any** of the given glob `patterns` match the specified `string`. + +**Params** + +* **{String|Array}**: str The string to test. +* **{String|Array}**: patterns One or more glob patterns to use for matching. +* **{Object}**: See available [options](#options). +* `returns` **{Boolean}**: Returns true if any patterns match `str` + +**Example** + +```js +const picomatch = require('picomatch'); +// picomatch.isMatch(string, patterns[, options]); + +console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true +console.log(picomatch.isMatch('a.a', 'b.*')); //=> false +``` + +### [.parse](lib/picomatch.js#L199) + +Parse a glob pattern to create the source string for a regular expression. + +**Params** + +* `pattern` **{String}** +* `options` **{Object}** +* `returns` **{Object}**: Returns an object with useful properties and output to be used as a regex source string. + +**Example** + +```js +const picomatch = require('picomatch'); +const result = picomatch.parse(pattern[, options]); +``` + +### [.scan](lib/picomatch.js#L231) + +Scan a glob pattern to separate the pattern into segments. + +**Params** + +* `input` **{String}**: Glob pattern to scan. +* `options` **{Object}** +* `returns` **{Object}**: Returns an object with + +**Example** + +```js +const picomatch = require('picomatch'); +// picomatch.scan(input[, options]); + +const result = picomatch.scan('!./foo/*.js'); +console.log(result); +{ prefix: '!./', + input: '!./foo/*.js', + start: 3, + base: 'foo', + glob: '*.js', + isBrace: false, + isBracket: false, + isGlob: true, + isExtglob: false, + isGlobstar: false, + negated: true } +``` + +### [.compileRe](lib/picomatch.js#L245) + +Compile a regular expression from the `state` object returned by the +[parse()](#parse) method. + +**Params** + +* `state` **{Object}** +* `options` **{Object}** +* `returnOutput` **{Boolean}**: Intended for implementors, this argument allows you to return the raw output from the parser. +* `returnState` **{Boolean}**: Adds the state to a `state` property on the returned regex. Useful for implementors and debugging. +* `returns` **{RegExp}** + +### [.makeRe](lib/picomatch.js#L286) + +Create a regular expression from a parsed glob pattern. + +**Params** + +* `state` **{String}**: The object returned from the `.parse` method. +* `options` **{Object}** +* `returnOutput` **{Boolean}**: Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result. +* `returnState` **{Boolean}**: Implementors may use this argument to return the state from the parsed glob with the returned regular expression. +* `returns` **{RegExp}**: Returns a regex created from the given pattern. + +**Example** + +```js +const picomatch = require('picomatch'); +const state = picomatch.parse('*.js'); +// picomatch.compileRe(state[, options]); + +console.log(picomatch.compileRe(state)); +//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ +``` + +### [.toRegex](lib/picomatch.js#L321) + +Create a regular expression from the given regex source string. + +**Params** + +* `source` **{String}**: Regular expression source string. +* `options` **{Object}** +* `returns` **{RegExp}** + +**Example** + +```js +const picomatch = require('picomatch'); +// picomatch.toRegex(source[, options]); + +const { output } = picomatch.parse('*.js'); +console.log(picomatch.toRegex(output)); +//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ +``` + +
+ +## Options + +### Picomatch options + +The following options may be used with the main `picomatch()` function or any of the methods on the picomatch API. + +| **Option** | **Type** | **Default value** | **Description** | +| --- | --- | --- | --- | +| `basename` | `boolean` | `false` | If set, then patterns without slashes will be matched against the basename of the path if it contains slashes. For example, `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`. | +| `bash` | `boolean` | `false` | Follow bash matching rules more strictly - disallows backslashes as escape characters, and treats single stars as globstars (`**`). | +| `capture` | `boolean` | `undefined` | Return regex matches in supporting methods. | +| `contains` | `boolean` | `undefined` | Allows glob to match any part of the given string(s). | +| `cwd` | `string` | `process.cwd()` | Current working directory. Used by `picomatch.split()` | +| `debug` | `boolean` | `undefined` | Debug regular expressions when an error is thrown. | +| `dot` | `boolean` | `false` | Enable dotfile matching. By default, dotfiles are ignored unless a `.` is explicitly defined in the pattern, or `options.dot` is true | +| `expandRange` | `function` | `undefined` | Custom function for expanding ranges in brace patterns, such as `{a..z}`. The function receives the range values as two arguments, and it must return a string to be used in the generated regex. It's recommended that returned strings be wrapped in parentheses. | +| `failglob` | `boolean` | `false` | Throws an error if no matches are found. Based on the bash option of the same name. | +| `fastpaths` | `boolean` | `true` | To speed up processing, full parsing is skipped for a handful common glob patterns. Disable this behavior by setting this option to `false`. | +| `flags` | `string` | `undefined` | Regex flags to use in the generated regex. If defined, the `nocase` option will be overridden. | +| [format](#optionsformat) | `function` | `undefined` | Custom function for formatting the returned string. This is useful for removing leading slashes, converting Windows paths to Posix paths, etc. | +| `ignore` | `array\|string` | `undefined` | One or more glob patterns for excluding strings that should not be matched from the result. | +| `keepQuotes` | `boolean` | `false` | Retain quotes in the generated regex, since quotes may also be used as an alternative to backslashes. | +| `literalBrackets` | `boolean` | `undefined` | When `true`, brackets in the glob pattern will be escaped so that only literal brackets will be matched. | +| `matchBase` | `boolean` | `false` | Alias for `basename` | +| `maxLength` | `boolean` | `65536` | Limit the max length of the input string. An error is thrown if the input string is longer than this value. | +| `nobrace` | `boolean` | `false` | Disable brace matching, so that `{a,b}` and `{1..3}` would be treated as literal characters. | +| `nobracket` | `boolean` | `undefined` | Disable matching with regex brackets. | +| `nocase` | `boolean` | `false` | Make matching case-insensitive. Equivalent to the regex `i` flag. Note that this option is overridden by the `flags` option. | +| `nodupes` | `boolean` | `true` | Deprecated, use `nounique` instead. This option will be removed in a future major release. By default duplicates are removed. Disable uniquification by setting this option to false. | +| `noext` | `boolean` | `false` | Alias for `noextglob` | +| `noextglob` | `boolean` | `false` | Disable support for matching with extglobs (like `+(a\|b)`) | +| `noglobstar` | `boolean` | `false` | Disable support for matching nested directories with globstars (`**`) | +| `nonegate` | `boolean` | `false` | Disable support for negating with leading `!` | +| `noquantifiers` | `boolean` | `false` | Disable support for regex quantifiers (like `a{1,2}`) and treat them as brace patterns to be expanded. | +| [onIgnore](#optionsonIgnore) | `function` | `undefined` | Function to be called on ignored items. | +| [onMatch](#optionsonMatch) | `function` | `undefined` | Function to be called on matched items. | +| [onResult](#optionsonResult) | `function` | `undefined` | Function to be called on all items, regardless of whether or not they are matched or ignored. | +| `posix` | `boolean` | `false` | Support POSIX character classes ("posix brackets"). | +| `posixSlashes` | `boolean` | `undefined` | Convert all slashes in file paths to forward slashes. This does not convert slashes in the glob pattern itself | +| `prepend` | `boolean` | `undefined` | String to prepend to the generated regex used for matching. | +| `regex` | `boolean` | `false` | Use regular expression rules for `+` (instead of matching literal `+`), and for stars that follow closing parentheses or brackets (as in `)*` and `]*`). | +| `strictBrackets` | `boolean` | `undefined` | Throw an error if brackets, braces, or parens are imbalanced. | +| `strictSlashes` | `boolean` | `undefined` | When true, picomatch won't match trailing slashes with single stars. | +| `unescape` | `boolean` | `undefined` | Remove backslashes preceding escaped characters in the glob pattern. By default, backslashes are retained. | +| `unixify` | `boolean` | `undefined` | Alias for `posixSlashes`, for backwards compatibility. | + +picomatch has automatic detection for regex positive and negative lookbehinds. If the pattern contains a negative lookbehind, you must be using Node.js >= 8.10 or else picomatch will throw an error. + +### Scan Options + +In addition to the main [picomatch options](#picomatch-options), the following options may also be used with the [.scan](#scan) method. + +| **Option** | **Type** | **Default value** | **Description** | +| --- | --- | --- | --- | +| `tokens` | `boolean` | `false` | When `true`, the returned object will include an array of tokens (objects), representing each path "segment" in the scanned glob pattern | +| `parts` | `boolean` | `false` | When `true`, the returned object will include an array of strings representing each path "segment" in the scanned glob pattern. This is automatically enabled when `options.tokens` is true | + +**Example** + +```js +const picomatch = require('picomatch'); +const result = picomatch.scan('!./foo/*.js', { tokens: true }); +console.log(result); +// { +// prefix: '!./', +// input: '!./foo/*.js', +// start: 3, +// base: 'foo', +// glob: '*.js', +// isBrace: false, +// isBracket: false, +// isGlob: true, +// isExtglob: false, +// isGlobstar: false, +// negated: true, +// maxDepth: 2, +// tokens: [ +// { value: '!./', depth: 0, isGlob: false, negated: true, isPrefix: true }, +// { value: 'foo', depth: 1, isGlob: false }, +// { value: '*.js', depth: 1, isGlob: true } +// ], +// slashes: [ 2, 6 ], +// parts: [ 'foo', '*.js' ] +// } +``` + +
+ +### Options Examples + +#### options.expandRange + +**Type**: `function` + +**Default**: `undefined` + +Custom function for expanding ranges in brace patterns. The [fill-range](https://github.com/jonschlinkert/fill-range) library is ideal for this purpose, or you can use custom code to do whatever you need. + +**Example** + +The following example shows how to create a glob that matches a folder + +```js +const fill = require('fill-range'); +const regex = pm.makeRe('foo/{01..25}/bar', { + expandRange(a, b) { + return `(${fill(a, b, { toRegex: true })})`; + } +}); + +console.log(regex); +//=> /^(?:foo\/((?:0[1-9]|1[0-9]|2[0-5]))\/bar)$/ + +console.log(regex.test('foo/00/bar')) // false +console.log(regex.test('foo/01/bar')) // true +console.log(regex.test('foo/10/bar')) // true +console.log(regex.test('foo/22/bar')) // true +console.log(regex.test('foo/25/bar')) // true +console.log(regex.test('foo/26/bar')) // false +``` + +#### options.format + +**Type**: `function` + +**Default**: `undefined` + +Custom function for formatting strings before they're matched. + +**Example** + +```js +// strip leading './' from strings +const format = str => str.replace(/^\.\//, ''); +const isMatch = picomatch('foo/*.js', { format }); +console.log(isMatch('./foo/bar.js')); //=> true +``` + +#### options.onMatch + +```js +const onMatch = ({ glob, regex, input, output }) => { + console.log({ glob, regex, input, output }); +}; + +const isMatch = picomatch('*', { onMatch }); +isMatch('foo'); +isMatch('bar'); +isMatch('baz'); +``` + +#### options.onIgnore + +```js +const onIgnore = ({ glob, regex, input, output }) => { + console.log({ glob, regex, input, output }); +}; + +const isMatch = picomatch('*', { onIgnore, ignore: 'f*' }); +isMatch('foo'); +isMatch('bar'); +isMatch('baz'); +``` + +#### options.onResult + +```js +const onResult = ({ glob, regex, input, output }) => { + console.log({ glob, regex, input, output }); +}; + +const isMatch = picomatch('*', { onResult, ignore: 'f*' }); +isMatch('foo'); +isMatch('bar'); +isMatch('baz'); +``` + +
+
+ +## Globbing features + +* [Basic globbing](#basic-globbing) (Wildcard matching) +* [Advanced globbing](#advanced-globbing) (extglobs, posix brackets, brace matching) + +### Basic globbing + +| **Character** | **Description** | +| --- | --- | +| `*` | Matches any character zero or more times, excluding path separators. Does _not match_ path separators or hidden files or directories ("dotfiles"), unless explicitly enabled by setting the `dot` option to `true`. | +| `**` | Matches any character zero or more times, including path separators. Note that `**` will only match path separators (`/`, and `\\` on Windows) when they are the only characters in a path segment. Thus, `foo**/bar` is equivalent to `foo*/bar`, and `foo/a**b/bar` is equivalent to `foo/a*b/bar`, and _more than two_ consecutive stars in a glob path segment are regarded as _a single star_. Thus, `foo/***/bar` is equivalent to `foo/*/bar`. | +| `?` | Matches any character excluding path separators one time. Does _not match_ path separators or leading dots. | +| `[abc]` | Matches any characters inside the brackets. For example, `[abc]` would match the characters `a`, `b` or `c`, and nothing else. | + +#### Matching behavior vs. Bash + +Picomatch's matching features and expected results in unit tests are based on Bash's unit tests and the Bash 4.3 specification, with the following exceptions: + +* Bash will match `foo/bar/baz` with `*`. Picomatch only matches nested directories with `**`. +* Bash greedily matches with negated extglobs. For example, Bash 4.3 says that `!(foo)*` should match `foo` and `foobar`, since the trailing `*` bracktracks to match the preceding pattern. This is very memory-inefficient, and IMHO, also incorrect. Picomatch would return `false` for both `foo` and `foobar`. + +
+ +### Advanced globbing + +* [extglobs](#extglobs) +* [POSIX brackets](#posix-brackets) +* [Braces](#brace-expansion) + +#### Extglobs + +| **Pattern** | **Description** | +| --- | --- | +| `@(pattern)` | Match _only one_ consecutive occurrence of `pattern` | +| `*(pattern)` | Match _zero or more_ consecutive occurrences of `pattern` | +| `+(pattern)` | Match _one or more_ consecutive occurrences of `pattern` | +| `?(pattern)` | Match _zero or **one**_ consecutive occurrences of `pattern` | +| `!(pattern)` | Match _anything but_ `pattern` | + +**Examples** + +```js +const pm = require('picomatch'); + +// *(pattern) matches ZERO or more of "pattern" +console.log(pm.isMatch('a', 'a*(z)')); // true +console.log(pm.isMatch('az', 'a*(z)')); // true +console.log(pm.isMatch('azzz', 'a*(z)')); // true + +// +(pattern) matches ONE or more of "pattern" +console.log(pm.isMatch('a', 'a*(z)')); // true +console.log(pm.isMatch('az', 'a*(z)')); // true +console.log(pm.isMatch('azzz', 'a*(z)')); // true + +// supports multiple extglobs +console.log(pm.isMatch('foo.bar', '!(foo).!(bar)')); // false + +// supports nested extglobs +console.log(pm.isMatch('foo.bar', '!(!(foo)).!(!(bar))')); // true +``` + +#### POSIX brackets + +POSIX classes are disabled by default. Enable this feature by setting the `posix` option to true. + +**Enable POSIX bracket support** + +```js +console.log(pm.makeRe('[[:word:]]+', { posix: true })); +//=> /^(?:(?=.)[A-Za-z0-9_]+\/?)$/ +``` + +**Supported POSIX classes** + +The following named POSIX bracket expressions are supported: + +* `[:alnum:]` - Alphanumeric characters, equ `[a-zA-Z0-9]` +* `[:alpha:]` - Alphabetical characters, equivalent to `[a-zA-Z]`. +* `[:ascii:]` - ASCII characters, equivalent to `[\\x00-\\x7F]`. +* `[:blank:]` - Space and tab characters, equivalent to `[ \\t]`. +* `[:cntrl:]` - Control characters, equivalent to `[\\x00-\\x1F\\x7F]`. +* `[:digit:]` - Numerical digits, equivalent to `[0-9]`. +* `[:graph:]` - Graph characters, equivalent to `[\\x21-\\x7E]`. +* `[:lower:]` - Lowercase letters, equivalent to `[a-z]`. +* `[:print:]` - Print characters, equivalent to `[\\x20-\\x7E ]`. +* `[:punct:]` - Punctuation and symbols, equivalent to `[\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~]`. +* `[:space:]` - Extended space characters, equivalent to `[ \\t\\r\\n\\v\\f]`. +* `[:upper:]` - Uppercase letters, equivalent to `[A-Z]`. +* `[:word:]` - Word characters (letters, numbers and underscores), equivalent to `[A-Za-z0-9_]`. +* `[:xdigit:]` - Hexadecimal digits, equivalent to `[A-Fa-f0-9]`. + +See the [Bash Reference Manual](https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html) for more information. + +### Braces + +Picomatch does not do brace expansion. For [brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html) and advanced matching with braces, use [micromatch](https://github.com/micromatch/micromatch) instead. Picomatch has very basic support for braces. + +### Matching special characters as literals + +If you wish to match the following special characters in a filepath, and you want to use these characters in your glob pattern, they must be escaped with backslashes or quotes: + +**Special Characters** + +Some characters that are used for matching in regular expressions are also regarded as valid file path characters on some platforms. + +To match any of the following characters as literals: `$^*+?()[] + +Examples: + +```js +console.log(pm.makeRe('foo/bar \\(1\\)')); +console.log(pm.makeRe('foo/bar \\(1\\)')); +``` + +
+
+ +## Library Comparisons + +The following table shows which features are supported by [minimatch](https://github.com/isaacs/minimatch), [micromatch](https://github.com/micromatch/micromatch), [picomatch](https://github.com/micromatch/picomatch), [nanomatch](https://github.com/micromatch/nanomatch), [extglob](https://github.com/micromatch/extglob), [braces](https://github.com/micromatch/braces), and [expand-brackets](https://github.com/micromatch/expand-brackets). + +| **Feature** | `minimatch` | `micromatch` | `picomatch` | `nanomatch` | `extglob` | `braces` | `expand-brackets` | +| --- | --- | --- | --- | --- | --- | --- | --- | +| Wildcard matching (`*?+`) | ✔ | ✔ | ✔ | ✔ | - | - | - | +| Advancing globbing | ✔ | ✔ | ✔ | - | - | - | - | +| Brace _matching_ | ✔ | ✔ | ✔ | - | - | ✔ | - | +| Brace _expansion_ | ✔ | ✔ | - | - | - | ✔ | - | +| Extglobs | partial | ✔ | ✔ | - | ✔ | - | - | +| Posix brackets | - | ✔ | ✔ | - | - | - | ✔ | +| Regular expression syntax | - | ✔ | ✔ | ✔ | ✔ | - | ✔ | +| File system operations | - | - | - | - | - | - | - | + +
+
+ +## Benchmarks + +Performance comparison of picomatch and minimatch. + +``` +# .makeRe star + picomatch x 1,993,050 ops/sec ±0.51% (91 runs sampled) + minimatch x 627,206 ops/sec ±1.96% (87 runs sampled)) + +# .makeRe star; dot=true + picomatch x 1,436,640 ops/sec ±0.62% (91 runs sampled) + minimatch x 525,876 ops/sec ±0.60% (88 runs sampled) + +# .makeRe globstar + picomatch x 1,592,742 ops/sec ±0.42% (90 runs sampled) + minimatch x 962,043 ops/sec ±1.76% (91 runs sampled)d) + +# .makeRe globstars + picomatch x 1,615,199 ops/sec ±0.35% (94 runs sampled) + minimatch x 477,179 ops/sec ±1.33% (91 runs sampled) + +# .makeRe with leading star + picomatch x 1,220,856 ops/sec ±0.40% (92 runs sampled) + minimatch x 453,564 ops/sec ±1.43% (94 runs sampled) + +# .makeRe - basic braces + picomatch x 392,067 ops/sec ±0.70% (90 runs sampled) + minimatch x 99,532 ops/sec ±2.03% (87 runs sampled)) +``` + +
+
+ +## Philosophies + +The goal of this library is to be blazing fast, without compromising on accuracy. + +**Accuracy** + +The number one of goal of this library is accuracy. However, it's not unusual for different glob implementations to have different rules for matching behavior, even with simple wildcard matching. It gets increasingly more complicated when combinations of different features are combined, like when extglobs are combined with globstars, braces, slashes, and so on: `!(**/{a,b,*/c})`. + +Thus, given that there is no canonical glob specification to use as a single source of truth when differences of opinion arise regarding behavior, sometimes we have to implement our best judgement and rely on feedback from users to make improvements. + +**Performance** + +Although this library performs well in benchmarks, and in most cases it's faster than other popular libraries we benchmarked against, we will always choose accuracy over performance. It's not helpful to anyone if our library is faster at returning the wrong answer. + +
+
+ +## About + +
+Contributing + +Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new). + +Please read the [contributing guide](.github/contributing.md) for advice on opening issues, pull requests, and coding standards. + +
+ +
+Running Tests + +Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command: + +```sh +npm install && npm test +``` + +
+ +
+Building docs + +_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_ + +To generate the readme, run the following command: + +```sh +npm install -g verbose/verb#dev verb-generate-readme && verb +``` + +
+ +### Author + +**Jon Schlinkert** + +* [GitHub Profile](https://github.com/jonschlinkert) +* [Twitter Profile](https://twitter.com/jonschlinkert) +* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert) + +### License + +Copyright © 2017-present, [Jon Schlinkert](https://github.com/jonschlinkert). +Released under the [MIT License](LICENSE). diff --git a/node_modules/picomatch/index.js b/node_modules/picomatch/index.js new file mode 100644 index 0000000..d2f2bc5 --- /dev/null +++ b/node_modules/picomatch/index.js @@ -0,0 +1,3 @@ +'use strict'; + +module.exports = require('./lib/picomatch'); diff --git a/node_modules/picomatch/lib/constants.js b/node_modules/picomatch/lib/constants.js new file mode 100644 index 0000000..a62ef38 --- /dev/null +++ b/node_modules/picomatch/lib/constants.js @@ -0,0 +1,179 @@ +'use strict'; + +const path = require('path'); +const WIN_SLASH = '\\\\/'; +const WIN_NO_SLASH = `[^${WIN_SLASH}]`; + +/** + * Posix glob regex + */ + +const DOT_LITERAL = '\\.'; +const PLUS_LITERAL = '\\+'; +const QMARK_LITERAL = '\\?'; +const SLASH_LITERAL = '\\/'; +const ONE_CHAR = '(?=.)'; +const QMARK = '[^/]'; +const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`; +const START_ANCHOR = `(?:^|${SLASH_LITERAL})`; +const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`; +const NO_DOT = `(?!${DOT_LITERAL})`; +const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`; +const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`; +const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`; +const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`; +const STAR = `${QMARK}*?`; + +const POSIX_CHARS = { + DOT_LITERAL, + PLUS_LITERAL, + QMARK_LITERAL, + SLASH_LITERAL, + ONE_CHAR, + QMARK, + END_ANCHOR, + DOTS_SLASH, + NO_DOT, + NO_DOTS, + NO_DOT_SLASH, + NO_DOTS_SLASH, + QMARK_NO_DOT, + STAR, + START_ANCHOR +}; + +/** + * Windows glob regex + */ + +const WINDOWS_CHARS = { + ...POSIX_CHARS, + + SLASH_LITERAL: `[${WIN_SLASH}]`, + QMARK: WIN_NO_SLASH, + STAR: `${WIN_NO_SLASH}*?`, + DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`, + NO_DOT: `(?!${DOT_LITERAL})`, + NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, + NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`, + NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, + QMARK_NO_DOT: `[^.${WIN_SLASH}]`, + START_ANCHOR: `(?:^|[${WIN_SLASH}])`, + END_ANCHOR: `(?:[${WIN_SLASH}]|$)` +}; + +/** + * POSIX Bracket Regex + */ + +const POSIX_REGEX_SOURCE = { + alnum: 'a-zA-Z0-9', + alpha: 'a-zA-Z', + ascii: '\\x00-\\x7F', + blank: ' \\t', + cntrl: '\\x00-\\x1F\\x7F', + digit: '0-9', + graph: '\\x21-\\x7E', + lower: 'a-z', + print: '\\x20-\\x7E ', + punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~', + space: ' \\t\\r\\n\\v\\f', + upper: 'A-Z', + word: 'A-Za-z0-9_', + xdigit: 'A-Fa-f0-9' +}; + +module.exports = { + MAX_LENGTH: 1024 * 64, + POSIX_REGEX_SOURCE, + + // regular expressions + REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g, + REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/, + REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/, + REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g, + REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g, + REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g, + + // Replace globs with equivalent patterns to reduce parsing time. + REPLACEMENTS: { + '***': '*', + '**/**': '**', + '**/**/**': '**' + }, + + // Digits + CHAR_0: 48, /* 0 */ + CHAR_9: 57, /* 9 */ + + // Alphabet chars. + CHAR_UPPERCASE_A: 65, /* A */ + CHAR_LOWERCASE_A: 97, /* a */ + CHAR_UPPERCASE_Z: 90, /* Z */ + CHAR_LOWERCASE_Z: 122, /* z */ + + CHAR_LEFT_PARENTHESES: 40, /* ( */ + CHAR_RIGHT_PARENTHESES: 41, /* ) */ + + CHAR_ASTERISK: 42, /* * */ + + // Non-alphabetic chars. + CHAR_AMPERSAND: 38, /* & */ + CHAR_AT: 64, /* @ */ + CHAR_BACKWARD_SLASH: 92, /* \ */ + CHAR_CARRIAGE_RETURN: 13, /* \r */ + CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */ + CHAR_COLON: 58, /* : */ + CHAR_COMMA: 44, /* , */ + CHAR_DOT: 46, /* . */ + CHAR_DOUBLE_QUOTE: 34, /* " */ + CHAR_EQUAL: 61, /* = */ + CHAR_EXCLAMATION_MARK: 33, /* ! */ + CHAR_FORM_FEED: 12, /* \f */ + CHAR_FORWARD_SLASH: 47, /* / */ + CHAR_GRAVE_ACCENT: 96, /* ` */ + CHAR_HASH: 35, /* # */ + CHAR_HYPHEN_MINUS: 45, /* - */ + CHAR_LEFT_ANGLE_BRACKET: 60, /* < */ + CHAR_LEFT_CURLY_BRACE: 123, /* { */ + CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */ + CHAR_LINE_FEED: 10, /* \n */ + CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */ + CHAR_PERCENT: 37, /* % */ + CHAR_PLUS: 43, /* + */ + CHAR_QUESTION_MARK: 63, /* ? */ + CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */ + CHAR_RIGHT_CURLY_BRACE: 125, /* } */ + CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */ + CHAR_SEMICOLON: 59, /* ; */ + CHAR_SINGLE_QUOTE: 39, /* ' */ + CHAR_SPACE: 32, /* */ + CHAR_TAB: 9, /* \t */ + CHAR_UNDERSCORE: 95, /* _ */ + CHAR_VERTICAL_LINE: 124, /* | */ + CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */ + + SEP: path.sep, + + /** + * Create EXTGLOB_CHARS + */ + + extglobChars(chars) { + return { + '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` }, + '?': { type: 'qmark', open: '(?:', close: ')?' }, + '+': { type: 'plus', open: '(?:', close: ')+' }, + '*': { type: 'star', open: '(?:', close: ')*' }, + '@': { type: 'at', open: '(?:', close: ')' } + }; + }, + + /** + * Create GLOB_CHARS + */ + + globChars(win32) { + return win32 === true ? WINDOWS_CHARS : POSIX_CHARS; + } +}; diff --git a/node_modules/picomatch/lib/parse.js b/node_modules/picomatch/lib/parse.js new file mode 100644 index 0000000..58269d0 --- /dev/null +++ b/node_modules/picomatch/lib/parse.js @@ -0,0 +1,1091 @@ +'use strict'; + +const constants = require('./constants'); +const utils = require('./utils'); + +/** + * Constants + */ + +const { + MAX_LENGTH, + POSIX_REGEX_SOURCE, + REGEX_NON_SPECIAL_CHARS, + REGEX_SPECIAL_CHARS_BACKREF, + REPLACEMENTS +} = constants; + +/** + * Helpers + */ + +const expandRange = (args, options) => { + if (typeof options.expandRange === 'function') { + return options.expandRange(...args, options); + } + + args.sort(); + const value = `[${args.join('-')}]`; + + try { + /* eslint-disable-next-line no-new */ + new RegExp(value); + } catch (ex) { + return args.map(v => utils.escapeRegex(v)).join('..'); + } + + return value; +}; + +/** + * Create the message for a syntax error + */ + +const syntaxError = (type, char) => { + return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`; +}; + +/** + * Parse the given input string. + * @param {String} input + * @param {Object} options + * @return {Object} + */ + +const parse = (input, options) => { + if (typeof input !== 'string') { + throw new TypeError('Expected a string'); + } + + input = REPLACEMENTS[input] || input; + + const opts = { ...options }; + const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH; + + let len = input.length; + if (len > max) { + throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`); + } + + const bos = { type: 'bos', value: '', output: opts.prepend || '' }; + const tokens = [bos]; + + const capture = opts.capture ? '' : '?:'; + const win32 = utils.isWindows(options); + + // create constants based on platform, for windows or posix + const PLATFORM_CHARS = constants.globChars(win32); + const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS); + + const { + DOT_LITERAL, + PLUS_LITERAL, + SLASH_LITERAL, + ONE_CHAR, + DOTS_SLASH, + NO_DOT, + NO_DOT_SLASH, + NO_DOTS_SLASH, + QMARK, + QMARK_NO_DOT, + STAR, + START_ANCHOR + } = PLATFORM_CHARS; + + const globstar = opts => { + return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`; + }; + + const nodot = opts.dot ? '' : NO_DOT; + const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT; + let star = opts.bash === true ? globstar(opts) : STAR; + + if (opts.capture) { + star = `(${star})`; + } + + // minimatch options support + if (typeof opts.noext === 'boolean') { + opts.noextglob = opts.noext; + } + + const state = { + input, + index: -1, + start: 0, + dot: opts.dot === true, + consumed: '', + output: '', + prefix: '', + backtrack: false, + negated: false, + brackets: 0, + braces: 0, + parens: 0, + quotes: 0, + globstar: false, + tokens + }; + + input = utils.removePrefix(input, state); + len = input.length; + + const extglobs = []; + const braces = []; + const stack = []; + let prev = bos; + let value; + + /** + * Tokenizing helpers + */ + + const eos = () => state.index === len - 1; + const peek = state.peek = (n = 1) => input[state.index + n]; + const advance = state.advance = () => input[++state.index] || ''; + const remaining = () => input.slice(state.index + 1); + const consume = (value = '', num = 0) => { + state.consumed += value; + state.index += num; + }; + + const append = token => { + state.output += token.output != null ? token.output : token.value; + consume(token.value); + }; + + const negate = () => { + let count = 1; + + while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) { + advance(); + state.start++; + count++; + } + + if (count % 2 === 0) { + return false; + } + + state.negated = true; + state.start++; + return true; + }; + + const increment = type => { + state[type]++; + stack.push(type); + }; + + const decrement = type => { + state[type]--; + stack.pop(); + }; + + /** + * Push tokens onto the tokens array. This helper speeds up + * tokenizing by 1) helping us avoid backtracking as much as possible, + * and 2) helping us avoid creating extra tokens when consecutive + * characters are plain text. This improves performance and simplifies + * lookbehinds. + */ + + const push = tok => { + if (prev.type === 'globstar') { + const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace'); + const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren')); + + if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) { + state.output = state.output.slice(0, -prev.output.length); + prev.type = 'star'; + prev.value = '*'; + prev.output = star; + state.output += prev.output; + } + } + + if (extglobs.length && tok.type !== 'paren') { + extglobs[extglobs.length - 1].inner += tok.value; + } + + if (tok.value || tok.output) append(tok); + if (prev && prev.type === 'text' && tok.type === 'text') { + prev.value += tok.value; + prev.output = (prev.output || '') + tok.value; + return; + } + + tok.prev = prev; + tokens.push(tok); + prev = tok; + }; + + const extglobOpen = (type, value) => { + const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' }; + + token.prev = prev; + token.parens = state.parens; + token.output = state.output; + const output = (opts.capture ? '(' : '') + token.open; + + increment('parens'); + push({ type, value, output: state.output ? '' : ONE_CHAR }); + push({ type: 'paren', extglob: true, value: advance(), output }); + extglobs.push(token); + }; + + const extglobClose = token => { + let output = token.close + (opts.capture ? ')' : ''); + let rest; + + if (token.type === 'negate') { + let extglobStar = star; + + if (token.inner && token.inner.length > 1 && token.inner.includes('/')) { + extglobStar = globstar(opts); + } + + if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) { + output = token.close = `)$))${extglobStar}`; + } + + if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) { + // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis. + // In this case, we need to parse the string and use it in the output of the original pattern. + // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`. + // + // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`. + const expression = parse(rest, { ...options, fastpaths: false }).output; + + output = token.close = `)${expression})${extglobStar})`; + } + + if (token.prev.type === 'bos') { + state.negatedExtglob = true; + } + } + + push({ type: 'paren', extglob: true, value, output }); + decrement('parens'); + }; + + /** + * Fast paths + */ + + if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) { + let backslashes = false; + + let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => { + if (first === '\\') { + backslashes = true; + return m; + } + + if (first === '?') { + if (esc) { + return esc + first + (rest ? QMARK.repeat(rest.length) : ''); + } + if (index === 0) { + return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : ''); + } + return QMARK.repeat(chars.length); + } + + if (first === '.') { + return DOT_LITERAL.repeat(chars.length); + } + + if (first === '*') { + if (esc) { + return esc + first + (rest ? star : ''); + } + return star; + } + return esc ? m : `\\${m}`; + }); + + if (backslashes === true) { + if (opts.unescape === true) { + output = output.replace(/\\/g, ''); + } else { + output = output.replace(/\\+/g, m => { + return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : ''); + }); + } + } + + if (output === input && opts.contains === true) { + state.output = input; + return state; + } + + state.output = utils.wrapOutput(output, state, options); + return state; + } + + /** + * Tokenize input until we reach end-of-string + */ + + while (!eos()) { + value = advance(); + + if (value === '\u0000') { + continue; + } + + /** + * Escaped characters + */ + + if (value === '\\') { + const next = peek(); + + if (next === '/' && opts.bash !== true) { + continue; + } + + if (next === '.' || next === ';') { + continue; + } + + if (!next) { + value += '\\'; + push({ type: 'text', value }); + continue; + } + + // collapse slashes to reduce potential for exploits + const match = /^\\+/.exec(remaining()); + let slashes = 0; + + if (match && match[0].length > 2) { + slashes = match[0].length; + state.index += slashes; + if (slashes % 2 !== 0) { + value += '\\'; + } + } + + if (opts.unescape === true) { + value = advance(); + } else { + value += advance(); + } + + if (state.brackets === 0) { + push({ type: 'text', value }); + continue; + } + } + + /** + * If we're inside a regex character class, continue + * until we reach the closing bracket. + */ + + if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) { + if (opts.posix !== false && value === ':') { + const inner = prev.value.slice(1); + if (inner.includes('[')) { + prev.posix = true; + + if (inner.includes(':')) { + const idx = prev.value.lastIndexOf('['); + const pre = prev.value.slice(0, idx); + const rest = prev.value.slice(idx + 2); + const posix = POSIX_REGEX_SOURCE[rest]; + if (posix) { + prev.value = pre + posix; + state.backtrack = true; + advance(); + + if (!bos.output && tokens.indexOf(prev) === 1) { + bos.output = ONE_CHAR; + } + continue; + } + } + } + } + + if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) { + value = `\\${value}`; + } + + if (value === ']' && (prev.value === '[' || prev.value === '[^')) { + value = `\\${value}`; + } + + if (opts.posix === true && value === '!' && prev.value === '[') { + value = '^'; + } + + prev.value += value; + append({ value }); + continue; + } + + /** + * If we're inside a quoted string, continue + * until we reach the closing double quote. + */ + + if (state.quotes === 1 && value !== '"') { + value = utils.escapeRegex(value); + prev.value += value; + append({ value }); + continue; + } + + /** + * Double quotes + */ + + if (value === '"') { + state.quotes = state.quotes === 1 ? 0 : 1; + if (opts.keepQuotes === true) { + push({ type: 'text', value }); + } + continue; + } + + /** + * Parentheses + */ + + if (value === '(') { + increment('parens'); + push({ type: 'paren', value }); + continue; + } + + if (value === ')') { + if (state.parens === 0 && opts.strictBrackets === true) { + throw new SyntaxError(syntaxError('opening', '(')); + } + + const extglob = extglobs[extglobs.length - 1]; + if (extglob && state.parens === extglob.parens + 1) { + extglobClose(extglobs.pop()); + continue; + } + + push({ type: 'paren', value, output: state.parens ? ')' : '\\)' }); + decrement('parens'); + continue; + } + + /** + * Square brackets + */ + + if (value === '[') { + if (opts.nobracket === true || !remaining().includes(']')) { + if (opts.nobracket !== true && opts.strictBrackets === true) { + throw new SyntaxError(syntaxError('closing', ']')); + } + + value = `\\${value}`; + } else { + increment('brackets'); + } + + push({ type: 'bracket', value }); + continue; + } + + if (value === ']') { + if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) { + push({ type: 'text', value, output: `\\${value}` }); + continue; + } + + if (state.brackets === 0) { + if (opts.strictBrackets === true) { + throw new SyntaxError(syntaxError('opening', '[')); + } + + push({ type: 'text', value, output: `\\${value}` }); + continue; + } + + decrement('brackets'); + + const prevValue = prev.value.slice(1); + if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) { + value = `/${value}`; + } + + prev.value += value; + append({ value }); + + // when literal brackets are explicitly disabled + // assume we should match with a regex character class + if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) { + continue; + } + + const escaped = utils.escapeRegex(prev.value); + state.output = state.output.slice(0, -prev.value.length); + + // when literal brackets are explicitly enabled + // assume we should escape the brackets to match literal characters + if (opts.literalBrackets === true) { + state.output += escaped; + prev.value = escaped; + continue; + } + + // when the user specifies nothing, try to match both + prev.value = `(${capture}${escaped}|${prev.value})`; + state.output += prev.value; + continue; + } + + /** + * Braces + */ + + if (value === '{' && opts.nobrace !== true) { + increment('braces'); + + const open = { + type: 'brace', + value, + output: '(', + outputIndex: state.output.length, + tokensIndex: state.tokens.length + }; + + braces.push(open); + push(open); + continue; + } + + if (value === '}') { + const brace = braces[braces.length - 1]; + + if (opts.nobrace === true || !brace) { + push({ type: 'text', value, output: value }); + continue; + } + + let output = ')'; + + if (brace.dots === true) { + const arr = tokens.slice(); + const range = []; + + for (let i = arr.length - 1; i >= 0; i--) { + tokens.pop(); + if (arr[i].type === 'brace') { + break; + } + if (arr[i].type !== 'dots') { + range.unshift(arr[i].value); + } + } + + output = expandRange(range, opts); + state.backtrack = true; + } + + if (brace.comma !== true && brace.dots !== true) { + const out = state.output.slice(0, brace.outputIndex); + const toks = state.tokens.slice(brace.tokensIndex); + brace.value = brace.output = '\\{'; + value = output = '\\}'; + state.output = out; + for (const t of toks) { + state.output += (t.output || t.value); + } + } + + push({ type: 'brace', value, output }); + decrement('braces'); + braces.pop(); + continue; + } + + /** + * Pipes + */ + + if (value === '|') { + if (extglobs.length > 0) { + extglobs[extglobs.length - 1].conditions++; + } + push({ type: 'text', value }); + continue; + } + + /** + * Commas + */ + + if (value === ',') { + let output = value; + + const brace = braces[braces.length - 1]; + if (brace && stack[stack.length - 1] === 'braces') { + brace.comma = true; + output = '|'; + } + + push({ type: 'comma', value, output }); + continue; + } + + /** + * Slashes + */ + + if (value === '/') { + // if the beginning of the glob is "./", advance the start + // to the current index, and don't add the "./" characters + // to the state. This greatly simplifies lookbehinds when + // checking for BOS characters like "!" and "." (not "./") + if (prev.type === 'dot' && state.index === state.start + 1) { + state.start = state.index + 1; + state.consumed = ''; + state.output = ''; + tokens.pop(); + prev = bos; // reset "prev" to the first token + continue; + } + + push({ type: 'slash', value, output: SLASH_LITERAL }); + continue; + } + + /** + * Dots + */ + + if (value === '.') { + if (state.braces > 0 && prev.type === 'dot') { + if (prev.value === '.') prev.output = DOT_LITERAL; + const brace = braces[braces.length - 1]; + prev.type = 'dots'; + prev.output += value; + prev.value += value; + brace.dots = true; + continue; + } + + if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') { + push({ type: 'text', value, output: DOT_LITERAL }); + continue; + } + + push({ type: 'dot', value, output: DOT_LITERAL }); + continue; + } + + /** + * Question marks + */ + + if (value === '?') { + const isGroup = prev && prev.value === '('; + if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { + extglobOpen('qmark', value); + continue; + } + + if (prev && prev.type === 'paren') { + const next = peek(); + let output = value; + + if (next === '<' && !utils.supportsLookbehinds()) { + throw new Error('Node.js v10 or higher is required for regex lookbehinds'); + } + + if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) { + output = `\\${value}`; + } + + push({ type: 'text', value, output }); + continue; + } + + if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) { + push({ type: 'qmark', value, output: QMARK_NO_DOT }); + continue; + } + + push({ type: 'qmark', value, output: QMARK }); + continue; + } + + /** + * Exclamation + */ + + if (value === '!') { + if (opts.noextglob !== true && peek() === '(') { + if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) { + extglobOpen('negate', value); + continue; + } + } + + if (opts.nonegate !== true && state.index === 0) { + negate(); + continue; + } + } + + /** + * Plus + */ + + if (value === '+') { + if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { + extglobOpen('plus', value); + continue; + } + + if ((prev && prev.value === '(') || opts.regex === false) { + push({ type: 'plus', value, output: PLUS_LITERAL }); + continue; + } + + if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) { + push({ type: 'plus', value }); + continue; + } + + push({ type: 'plus', value: PLUS_LITERAL }); + continue; + } + + /** + * Plain text + */ + + if (value === '@') { + if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { + push({ type: 'at', extglob: true, value, output: '' }); + continue; + } + + push({ type: 'text', value }); + continue; + } + + /** + * Plain text + */ + + if (value !== '*') { + if (value === '$' || value === '^') { + value = `\\${value}`; + } + + const match = REGEX_NON_SPECIAL_CHARS.exec(remaining()); + if (match) { + value += match[0]; + state.index += match[0].length; + } + + push({ type: 'text', value }); + continue; + } + + /** + * Stars + */ + + if (prev && (prev.type === 'globstar' || prev.star === true)) { + prev.type = 'star'; + prev.star = true; + prev.value += value; + prev.output = star; + state.backtrack = true; + state.globstar = true; + consume(value); + continue; + } + + let rest = remaining(); + if (opts.noextglob !== true && /^\([^?]/.test(rest)) { + extglobOpen('star', value); + continue; + } + + if (prev.type === 'star') { + if (opts.noglobstar === true) { + consume(value); + continue; + } + + const prior = prev.prev; + const before = prior.prev; + const isStart = prior.type === 'slash' || prior.type === 'bos'; + const afterStar = before && (before.type === 'star' || before.type === 'globstar'); + + if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) { + push({ type: 'star', value, output: '' }); + continue; + } + + const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace'); + const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren'); + if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) { + push({ type: 'star', value, output: '' }); + continue; + } + + // strip consecutive `/**/` + while (rest.slice(0, 3) === '/**') { + const after = input[state.index + 4]; + if (after && after !== '/') { + break; + } + rest = rest.slice(3); + consume('/**', 3); + } + + if (prior.type === 'bos' && eos()) { + prev.type = 'globstar'; + prev.value += value; + prev.output = globstar(opts); + state.output = prev.output; + state.globstar = true; + consume(value); + continue; + } + + if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) { + state.output = state.output.slice(0, -(prior.output + prev.output).length); + prior.output = `(?:${prior.output}`; + + prev.type = 'globstar'; + prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)'); + prev.value += value; + state.globstar = true; + state.output += prior.output + prev.output; + consume(value); + continue; + } + + if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') { + const end = rest[1] !== void 0 ? '|$' : ''; + + state.output = state.output.slice(0, -(prior.output + prev.output).length); + prior.output = `(?:${prior.output}`; + + prev.type = 'globstar'; + prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`; + prev.value += value; + + state.output += prior.output + prev.output; + state.globstar = true; + + consume(value + advance()); + + push({ type: 'slash', value: '/', output: '' }); + continue; + } + + if (prior.type === 'bos' && rest[0] === '/') { + prev.type = 'globstar'; + prev.value += value; + prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`; + state.output = prev.output; + state.globstar = true; + consume(value + advance()); + push({ type: 'slash', value: '/', output: '' }); + continue; + } + + // remove single star from output + state.output = state.output.slice(0, -prev.output.length); + + // reset previous token to globstar + prev.type = 'globstar'; + prev.output = globstar(opts); + prev.value += value; + + // reset output with globstar + state.output += prev.output; + state.globstar = true; + consume(value); + continue; + } + + const token = { type: 'star', value, output: star }; + + if (opts.bash === true) { + token.output = '.*?'; + if (prev.type === 'bos' || prev.type === 'slash') { + token.output = nodot + token.output; + } + push(token); + continue; + } + + if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) { + token.output = value; + push(token); + continue; + } + + if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') { + if (prev.type === 'dot') { + state.output += NO_DOT_SLASH; + prev.output += NO_DOT_SLASH; + + } else if (opts.dot === true) { + state.output += NO_DOTS_SLASH; + prev.output += NO_DOTS_SLASH; + + } else { + state.output += nodot; + prev.output += nodot; + } + + if (peek() !== '*') { + state.output += ONE_CHAR; + prev.output += ONE_CHAR; + } + } + + push(token); + } + + while (state.brackets > 0) { + if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']')); + state.output = utils.escapeLast(state.output, '['); + decrement('brackets'); + } + + while (state.parens > 0) { + if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')')); + state.output = utils.escapeLast(state.output, '('); + decrement('parens'); + } + + while (state.braces > 0) { + if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}')); + state.output = utils.escapeLast(state.output, '{'); + decrement('braces'); + } + + if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) { + push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` }); + } + + // rebuild the output if we had to backtrack at any point + if (state.backtrack === true) { + state.output = ''; + + for (const token of state.tokens) { + state.output += token.output != null ? token.output : token.value; + + if (token.suffix) { + state.output += token.suffix; + } + } + } + + return state; +}; + +/** + * Fast paths for creating regular expressions for common glob patterns. + * This can significantly speed up processing and has very little downside + * impact when none of the fast paths match. + */ + +parse.fastpaths = (input, options) => { + const opts = { ...options }; + const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH; + const len = input.length; + if (len > max) { + throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`); + } + + input = REPLACEMENTS[input] || input; + const win32 = utils.isWindows(options); + + // create constants based on platform, for windows or posix + const { + DOT_LITERAL, + SLASH_LITERAL, + ONE_CHAR, + DOTS_SLASH, + NO_DOT, + NO_DOTS, + NO_DOTS_SLASH, + STAR, + START_ANCHOR + } = constants.globChars(win32); + + const nodot = opts.dot ? NO_DOTS : NO_DOT; + const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT; + const capture = opts.capture ? '' : '?:'; + const state = { negated: false, prefix: '' }; + let star = opts.bash === true ? '.*?' : STAR; + + if (opts.capture) { + star = `(${star})`; + } + + const globstar = opts => { + if (opts.noglobstar === true) return star; + return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`; + }; + + const create = str => { + switch (str) { + case '*': + return `${nodot}${ONE_CHAR}${star}`; + + case '.*': + return `${DOT_LITERAL}${ONE_CHAR}${star}`; + + case '*.*': + return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`; + + case '*/*': + return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`; + + case '**': + return nodot + globstar(opts); + + case '**/*': + return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`; + + case '**/*.*': + return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`; + + case '**/.*': + return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`; + + default: { + const match = /^(.*?)\.(\w+)$/.exec(str); + if (!match) return; + + const source = create(match[1]); + if (!source) return; + + return source + DOT_LITERAL + match[2]; + } + } + }; + + const output = utils.removePrefix(input, state); + let source = create(output); + + if (source && opts.strictSlashes !== true) { + source += `${SLASH_LITERAL}?`; + } + + return source; +}; + +module.exports = parse; diff --git a/node_modules/picomatch/lib/picomatch.js b/node_modules/picomatch/lib/picomatch.js new file mode 100644 index 0000000..782d809 --- /dev/null +++ b/node_modules/picomatch/lib/picomatch.js @@ -0,0 +1,342 @@ +'use strict'; + +const path = require('path'); +const scan = require('./scan'); +const parse = require('./parse'); +const utils = require('./utils'); +const constants = require('./constants'); +const isObject = val => val && typeof val === 'object' && !Array.isArray(val); + +/** + * Creates a matcher function from one or more glob patterns. The + * returned function takes a string to match as its first argument, + * and returns true if the string is a match. The returned matcher + * function also takes a boolean as the second argument that, when true, + * returns an object with additional information. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch(glob[, options]); + * + * const isMatch = picomatch('*.!(*a)'); + * console.log(isMatch('a.a')); //=> false + * console.log(isMatch('a.b')); //=> true + * ``` + * @name picomatch + * @param {String|Array} `globs` One or more glob patterns. + * @param {Object=} `options` + * @return {Function=} Returns a matcher function. + * @api public + */ + +const picomatch = (glob, options, returnState = false) => { + if (Array.isArray(glob)) { + const fns = glob.map(input => picomatch(input, options, returnState)); + const arrayMatcher = str => { + for (const isMatch of fns) { + const state = isMatch(str); + if (state) return state; + } + return false; + }; + return arrayMatcher; + } + + const isState = isObject(glob) && glob.tokens && glob.input; + + if (glob === '' || (typeof glob !== 'string' && !isState)) { + throw new TypeError('Expected pattern to be a non-empty string'); + } + + const opts = options || {}; + const posix = utils.isWindows(options); + const regex = isState + ? picomatch.compileRe(glob, options) + : picomatch.makeRe(glob, options, false, true); + + const state = regex.state; + delete regex.state; + + let isIgnored = () => false; + if (opts.ignore) { + const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null }; + isIgnored = picomatch(opts.ignore, ignoreOpts, returnState); + } + + const matcher = (input, returnObject = false) => { + const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix }); + const result = { glob, state, regex, posix, input, output, match, isMatch }; + + if (typeof opts.onResult === 'function') { + opts.onResult(result); + } + + if (isMatch === false) { + result.isMatch = false; + return returnObject ? result : false; + } + + if (isIgnored(input)) { + if (typeof opts.onIgnore === 'function') { + opts.onIgnore(result); + } + result.isMatch = false; + return returnObject ? result : false; + } + + if (typeof opts.onMatch === 'function') { + opts.onMatch(result); + } + return returnObject ? result : true; + }; + + if (returnState) { + matcher.state = state; + } + + return matcher; +}; + +/** + * Test `input` with the given `regex`. This is used by the main + * `picomatch()` function to test the input string. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.test(input, regex[, options]); + * + * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/)); + * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' } + * ``` + * @param {String} `input` String to test. + * @param {RegExp} `regex` + * @return {Object} Returns an object with matching info. + * @api public + */ + +picomatch.test = (input, regex, options, { glob, posix } = {}) => { + if (typeof input !== 'string') { + throw new TypeError('Expected input to be a string'); + } + + if (input === '') { + return { isMatch: false, output: '' }; + } + + const opts = options || {}; + const format = opts.format || (posix ? utils.toPosixSlashes : null); + let match = input === glob; + let output = (match && format) ? format(input) : input; + + if (match === false) { + output = format ? format(input) : input; + match = output === glob; + } + + if (match === false || opts.capture === true) { + if (opts.matchBase === true || opts.basename === true) { + match = picomatch.matchBase(input, regex, options, posix); + } else { + match = regex.exec(output); + } + } + + return { isMatch: Boolean(match), match, output }; +}; + +/** + * Match the basename of a filepath. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.matchBase(input, glob[, options]); + * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true + * ``` + * @param {String} `input` String to test. + * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe). + * @return {Boolean} + * @api public + */ + +picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => { + const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options); + return regex.test(path.basename(input)); +}; + +/** + * Returns true if **any** of the given glob `patterns` match the specified `string`. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.isMatch(string, patterns[, options]); + * + * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true + * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false + * ``` + * @param {String|Array} str The string to test. + * @param {String|Array} patterns One or more glob patterns to use for matching. + * @param {Object} [options] See available [options](#options). + * @return {Boolean} Returns true if any patterns match `str` + * @api public + */ + +picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str); + +/** + * Parse a glob pattern to create the source string for a regular + * expression. + * + * ```js + * const picomatch = require('picomatch'); + * const result = picomatch.parse(pattern[, options]); + * ``` + * @param {String} `pattern` + * @param {Object} `options` + * @return {Object} Returns an object with useful properties and output to be used as a regex source string. + * @api public + */ + +picomatch.parse = (pattern, options) => { + if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options)); + return parse(pattern, { ...options, fastpaths: false }); +}; + +/** + * Scan a glob pattern to separate the pattern into segments. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.scan(input[, options]); + * + * const result = picomatch.scan('!./foo/*.js'); + * console.log(result); + * { prefix: '!./', + * input: '!./foo/*.js', + * start: 3, + * base: 'foo', + * glob: '*.js', + * isBrace: false, + * isBracket: false, + * isGlob: true, + * isExtglob: false, + * isGlobstar: false, + * negated: true } + * ``` + * @param {String} `input` Glob pattern to scan. + * @param {Object} `options` + * @return {Object} Returns an object with + * @api public + */ + +picomatch.scan = (input, options) => scan(input, options); + +/** + * Compile a regular expression from the `state` object returned by the + * [parse()](#parse) method. + * + * @param {Object} `state` + * @param {Object} `options` + * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser. + * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging. + * @return {RegExp} + * @api public + */ + +picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => { + if (returnOutput === true) { + return state.output; + } + + const opts = options || {}; + const prepend = opts.contains ? '' : '^'; + const append = opts.contains ? '' : '$'; + + let source = `${prepend}(?:${state.output})${append}`; + if (state && state.negated === true) { + source = `^(?!${source}).*$`; + } + + const regex = picomatch.toRegex(source, options); + if (returnState === true) { + regex.state = state; + } + + return regex; +}; + +/** + * Create a regular expression from a parsed glob pattern. + * + * ```js + * const picomatch = require('picomatch'); + * const state = picomatch.parse('*.js'); + * // picomatch.compileRe(state[, options]); + * + * console.log(picomatch.compileRe(state)); + * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ + * ``` + * @param {String} `state` The object returned from the `.parse` method. + * @param {Object} `options` + * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result. + * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression. + * @return {RegExp} Returns a regex created from the given pattern. + * @api public + */ + +picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => { + if (!input || typeof input !== 'string') { + throw new TypeError('Expected a non-empty string'); + } + + let parsed = { negated: false, fastpaths: true }; + + if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) { + parsed.output = parse.fastpaths(input, options); + } + + if (!parsed.output) { + parsed = parse(input, options); + } + + return picomatch.compileRe(parsed, options, returnOutput, returnState); +}; + +/** + * Create a regular expression from the given regex source string. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.toRegex(source[, options]); + * + * const { output } = picomatch.parse('*.js'); + * console.log(picomatch.toRegex(output)); + * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ + * ``` + * @param {String} `source` Regular expression source string. + * @param {Object} `options` + * @return {RegExp} + * @api public + */ + +picomatch.toRegex = (source, options) => { + try { + const opts = options || {}; + return new RegExp(source, opts.flags || (opts.nocase ? 'i' : '')); + } catch (err) { + if (options && options.debug === true) throw err; + return /$^/; + } +}; + +/** + * Picomatch constants. + * @return {Object} + */ + +picomatch.constants = constants; + +/** + * Expose "picomatch" + */ + +module.exports = picomatch; diff --git a/node_modules/picomatch/lib/scan.js b/node_modules/picomatch/lib/scan.js new file mode 100644 index 0000000..e59cd7a --- /dev/null +++ b/node_modules/picomatch/lib/scan.js @@ -0,0 +1,391 @@ +'use strict'; + +const utils = require('./utils'); +const { + CHAR_ASTERISK, /* * */ + CHAR_AT, /* @ */ + CHAR_BACKWARD_SLASH, /* \ */ + CHAR_COMMA, /* , */ + CHAR_DOT, /* . */ + CHAR_EXCLAMATION_MARK, /* ! */ + CHAR_FORWARD_SLASH, /* / */ + CHAR_LEFT_CURLY_BRACE, /* { */ + CHAR_LEFT_PARENTHESES, /* ( */ + CHAR_LEFT_SQUARE_BRACKET, /* [ */ + CHAR_PLUS, /* + */ + CHAR_QUESTION_MARK, /* ? */ + CHAR_RIGHT_CURLY_BRACE, /* } */ + CHAR_RIGHT_PARENTHESES, /* ) */ + CHAR_RIGHT_SQUARE_BRACKET /* ] */ +} = require('./constants'); + +const isPathSeparator = code => { + return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH; +}; + +const depth = token => { + if (token.isPrefix !== true) { + token.depth = token.isGlobstar ? Infinity : 1; + } +}; + +/** + * Quickly scans a glob pattern and returns an object with a handful of + * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists), + * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not + * with `!(`) and `negatedExtglob` (true if the path starts with `!(`). + * + * ```js + * const pm = require('picomatch'); + * console.log(pm.scan('foo/bar/*.js')); + * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' } + * ``` + * @param {String} `str` + * @param {Object} `options` + * @return {Object} Returns an object with tokens and regex source string. + * @api public + */ + +const scan = (input, options) => { + const opts = options || {}; + + const length = input.length - 1; + const scanToEnd = opts.parts === true || opts.scanToEnd === true; + const slashes = []; + const tokens = []; + const parts = []; + + let str = input; + let index = -1; + let start = 0; + let lastIndex = 0; + let isBrace = false; + let isBracket = false; + let isGlob = false; + let isExtglob = false; + let isGlobstar = false; + let braceEscaped = false; + let backslashes = false; + let negated = false; + let negatedExtglob = false; + let finished = false; + let braces = 0; + let prev; + let code; + let token = { value: '', depth: 0, isGlob: false }; + + const eos = () => index >= length; + const peek = () => str.charCodeAt(index + 1); + const advance = () => { + prev = code; + return str.charCodeAt(++index); + }; + + while (index < length) { + code = advance(); + let next; + + if (code === CHAR_BACKWARD_SLASH) { + backslashes = token.backslashes = true; + code = advance(); + + if (code === CHAR_LEFT_CURLY_BRACE) { + braceEscaped = true; + } + continue; + } + + if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) { + braces++; + + while (eos() !== true && (code = advance())) { + if (code === CHAR_BACKWARD_SLASH) { + backslashes = token.backslashes = true; + advance(); + continue; + } + + if (code === CHAR_LEFT_CURLY_BRACE) { + braces++; + continue; + } + + if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) { + isBrace = token.isBrace = true; + isGlob = token.isGlob = true; + finished = true; + + if (scanToEnd === true) { + continue; + } + + break; + } + + if (braceEscaped !== true && code === CHAR_COMMA) { + isBrace = token.isBrace = true; + isGlob = token.isGlob = true; + finished = true; + + if (scanToEnd === true) { + continue; + } + + break; + } + + if (code === CHAR_RIGHT_CURLY_BRACE) { + braces--; + + if (braces === 0) { + braceEscaped = false; + isBrace = token.isBrace = true; + finished = true; + break; + } + } + } + + if (scanToEnd === true) { + continue; + } + + break; + } + + if (code === CHAR_FORWARD_SLASH) { + slashes.push(index); + tokens.push(token); + token = { value: '', depth: 0, isGlob: false }; + + if (finished === true) continue; + if (prev === CHAR_DOT && index === (start + 1)) { + start += 2; + continue; + } + + lastIndex = index + 1; + continue; + } + + if (opts.noext !== true) { + const isExtglobChar = code === CHAR_PLUS + || code === CHAR_AT + || code === CHAR_ASTERISK + || code === CHAR_QUESTION_MARK + || code === CHAR_EXCLAMATION_MARK; + + if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) { + isGlob = token.isGlob = true; + isExtglob = token.isExtglob = true; + finished = true; + if (code === CHAR_EXCLAMATION_MARK && index === start) { + negatedExtglob = true; + } + + if (scanToEnd === true) { + while (eos() !== true && (code = advance())) { + if (code === CHAR_BACKWARD_SLASH) { + backslashes = token.backslashes = true; + code = advance(); + continue; + } + + if (code === CHAR_RIGHT_PARENTHESES) { + isGlob = token.isGlob = true; + finished = true; + break; + } + } + continue; + } + break; + } + } + + if (code === CHAR_ASTERISK) { + if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true; + isGlob = token.isGlob = true; + finished = true; + + if (scanToEnd === true) { + continue; + } + break; + } + + if (code === CHAR_QUESTION_MARK) { + isGlob = token.isGlob = true; + finished = true; + + if (scanToEnd === true) { + continue; + } + break; + } + + if (code === CHAR_LEFT_SQUARE_BRACKET) { + while (eos() !== true && (next = advance())) { + if (next === CHAR_BACKWARD_SLASH) { + backslashes = token.backslashes = true; + advance(); + continue; + } + + if (next === CHAR_RIGHT_SQUARE_BRACKET) { + isBracket = token.isBracket = true; + isGlob = token.isGlob = true; + finished = true; + break; + } + } + + if (scanToEnd === true) { + continue; + } + + break; + } + + if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) { + negated = token.negated = true; + start++; + continue; + } + + if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) { + isGlob = token.isGlob = true; + + if (scanToEnd === true) { + while (eos() !== true && (code = advance())) { + if (code === CHAR_LEFT_PARENTHESES) { + backslashes = token.backslashes = true; + code = advance(); + continue; + } + + if (code === CHAR_RIGHT_PARENTHESES) { + finished = true; + break; + } + } + continue; + } + break; + } + + if (isGlob === true) { + finished = true; + + if (scanToEnd === true) { + continue; + } + + break; + } + } + + if (opts.noext === true) { + isExtglob = false; + isGlob = false; + } + + let base = str; + let prefix = ''; + let glob = ''; + + if (start > 0) { + prefix = str.slice(0, start); + str = str.slice(start); + lastIndex -= start; + } + + if (base && isGlob === true && lastIndex > 0) { + base = str.slice(0, lastIndex); + glob = str.slice(lastIndex); + } else if (isGlob === true) { + base = ''; + glob = str; + } else { + base = str; + } + + if (base && base !== '' && base !== '/' && base !== str) { + if (isPathSeparator(base.charCodeAt(base.length - 1))) { + base = base.slice(0, -1); + } + } + + if (opts.unescape === true) { + if (glob) glob = utils.removeBackslashes(glob); + + if (base && backslashes === true) { + base = utils.removeBackslashes(base); + } + } + + const state = { + prefix, + input, + start, + base, + glob, + isBrace, + isBracket, + isGlob, + isExtglob, + isGlobstar, + negated, + negatedExtglob + }; + + if (opts.tokens === true) { + state.maxDepth = 0; + if (!isPathSeparator(code)) { + tokens.push(token); + } + state.tokens = tokens; + } + + if (opts.parts === true || opts.tokens === true) { + let prevIndex; + + for (let idx = 0; idx < slashes.length; idx++) { + const n = prevIndex ? prevIndex + 1 : start; + const i = slashes[idx]; + const value = input.slice(n, i); + if (opts.tokens) { + if (idx === 0 && start !== 0) { + tokens[idx].isPrefix = true; + tokens[idx].value = prefix; + } else { + tokens[idx].value = value; + } + depth(tokens[idx]); + state.maxDepth += tokens[idx].depth; + } + if (idx !== 0 || value !== '') { + parts.push(value); + } + prevIndex = i; + } + + if (prevIndex && prevIndex + 1 < input.length) { + const value = input.slice(prevIndex + 1); + parts.push(value); + + if (opts.tokens) { + tokens[tokens.length - 1].value = value; + depth(tokens[tokens.length - 1]); + state.maxDepth += tokens[tokens.length - 1].depth; + } + } + + state.slashes = slashes; + state.parts = parts; + } + + return state; +}; + +module.exports = scan; diff --git a/node_modules/picomatch/lib/utils.js b/node_modules/picomatch/lib/utils.js new file mode 100644 index 0000000..c3ca766 --- /dev/null +++ b/node_modules/picomatch/lib/utils.js @@ -0,0 +1,64 @@ +'use strict'; + +const path = require('path'); +const win32 = process.platform === 'win32'; +const { + REGEX_BACKSLASH, + REGEX_REMOVE_BACKSLASH, + REGEX_SPECIAL_CHARS, + REGEX_SPECIAL_CHARS_GLOBAL +} = require('./constants'); + +exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val); +exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str); +exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str); +exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1'); +exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/'); + +exports.removeBackslashes = str => { + return str.replace(REGEX_REMOVE_BACKSLASH, match => { + return match === '\\' ? '' : match; + }); +}; + +exports.supportsLookbehinds = () => { + const segs = process.version.slice(1).split('.').map(Number); + if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) { + return true; + } + return false; +}; + +exports.isWindows = options => { + if (options && typeof options.windows === 'boolean') { + return options.windows; + } + return win32 === true || path.sep === '\\'; +}; + +exports.escapeLast = (input, char, lastIdx) => { + const idx = input.lastIndexOf(char, lastIdx); + if (idx === -1) return input; + if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1); + return `${input.slice(0, idx)}\\${input.slice(idx)}`; +}; + +exports.removePrefix = (input, state = {}) => { + let output = input; + if (output.startsWith('./')) { + output = output.slice(2); + state.prefix = './'; + } + return output; +}; + +exports.wrapOutput = (input, state = {}, options = {}) => { + const prepend = options.contains ? '' : '^'; + const append = options.contains ? '' : '$'; + + let output = `${prepend}(?:${input})${append}`; + if (state.negated === true) { + output = `(?:^(?!${output}).*$)`; + } + return output; +}; diff --git a/node_modules/picomatch/package.json b/node_modules/picomatch/package.json new file mode 100644 index 0000000..3db22d4 --- /dev/null +++ b/node_modules/picomatch/package.json @@ -0,0 +1,81 @@ +{ + "name": "picomatch", + "description": "Blazing fast and accurate glob matcher written in JavaScript, with no dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.", + "version": "2.3.1", + "homepage": "https://github.com/micromatch/picomatch", + "author": "Jon Schlinkert (https://github.com/jonschlinkert)", + "funding": "https://github.com/sponsors/jonschlinkert", + "repository": "micromatch/picomatch", + "bugs": { + "url": "https://github.com/micromatch/picomatch/issues" + }, + "license": "MIT", + "files": [ + "index.js", + "lib" + ], + "main": "index.js", + "engines": { + "node": ">=8.6" + }, + "scripts": { + "lint": "eslint --cache --cache-location node_modules/.cache/.eslintcache --report-unused-disable-directives --ignore-path .gitignore .", + "mocha": "mocha --reporter dot", + "test": "npm run lint && npm run mocha", + "test:ci": "npm run test:cover", + "test:cover": "nyc npm run mocha" + }, + "devDependencies": { + "eslint": "^6.8.0", + "fill-range": "^7.0.1", + "gulp-format-md": "^2.0.0", + "mocha": "^6.2.2", + "nyc": "^15.0.0", + "time-require": "github:jonschlinkert/time-require" + }, + "keywords": [ + "glob", + "match", + "picomatch" + ], + "nyc": { + "reporter": [ + "html", + "lcov", + "text-summary" + ] + }, + "verb": { + "toc": { + "render": true, + "method": "preWrite", + "maxdepth": 3 + }, + "layout": "empty", + "tasks": [ + "readme" + ], + "plugins": [ + "gulp-format-md" + ], + "lint": { + "reflinks": true + }, + "related": { + "list": [ + "braces", + "micromatch" + ] + }, + "reflinks": [ + "braces", + "expand-brackets", + "extglob", + "fill-range", + "micromatch", + "minimatch", + "nanomatch", + "picomatch" + ] + } +} diff --git a/node_modules/readdirp/LICENSE b/node_modules/readdirp/LICENSE new file mode 100644 index 0000000..037cbb4 --- /dev/null +++ b/node_modules/readdirp/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/node_modules/readdirp/README.md b/node_modules/readdirp/README.md new file mode 100644 index 0000000..df8d32d --- /dev/null +++ b/node_modules/readdirp/README.md @@ -0,0 +1,120 @@ +# readdirp [![Weekly downloads](https://img.shields.io/npm/dw/readdirp.svg)](https://github.com/paulmillr/readdirp) + +Recursive version of fs.readdir. Exposes a **stream API** (with small RAM & CPU footprint) and a **promise API**. + +```sh +npm install readdirp +jsr add jsr:@paulmillr/readdirp +``` + +```javascript +// Use streams to achieve small RAM & CPU footprint. +// 1) Streams example with for-await. +import readdirp from 'readdirp'; +for await (const entry of readdirp('.')) { + const {path} = entry; + console.log(`${JSON.stringify({path})}`); +} + +// 2) Streams example, non for-await. +// Print out all JS files along with their size within the current folder & subfolders. +import readdirp from 'readdirp'; +readdirp('.', {alwaysStat: true, fileFilter: (f) => f.basename.endsWith('.js')}) + .on('data', (entry) => { + const {path, stats: {size}} = entry; + console.log(`${JSON.stringify({path, size})}`); + }) + // Optionally call stream.destroy() in `warn()` in order to abort and cause 'close' to be emitted + .on('warn', error => console.error('non-fatal error', error)) + .on('error', error => console.error('fatal error', error)) + .on('end', () => console.log('done')); + +// 3) Promise example. More RAM and CPU than streams / for-await. +import { readdirpPromise } from 'readdirp'; +const files = await readdirpPromise('.'); +console.log(files.map(file => file.path)); + +// Other options. +import readdirp from 'readdirp'; +readdirp('test', { + fileFilter: (f) => f.basename.endsWith('.js'), + directoryFilter: (d) => d.basename !== '.git', + // directoryFilter: (di) => di.basename.length === 9 + type: 'files_directories', + depth: 1 +}); +``` + +## API + +`const stream = readdirp(root[, options])` — **Stream API** + +- Reads given root recursively and returns a `stream` of [entry infos](#entryinfo) +- Optionally can be used like `for await (const entry of stream)` with node.js 10+ (`asyncIterator`). +- `on('data', (entry) => {})` [entry info](#entryinfo) for every file / dir. +- `on('warn', (error) => {})` non-fatal `Error` that prevents a file / dir from being processed. Example: inaccessible to the user. +- `on('error', (error) => {})` fatal `Error` which also ends the stream. Example: illegal options where passed. +- `on('end')` — we are done. Called when all entries were found and no more will be emitted. +- `on('close')` — stream is destroyed via `stream.destroy()`. + Could be useful if you want to manually abort even on a non fatal error. + At that point the stream is no longer `readable` and no more entries, warning or errors are emitted +- To learn more about streams, consult the very detailed [nodejs streams documentation](https://nodejs.org/api/stream.html) + or the [stream-handbook](https://github.com/substack/stream-handbook) + +`const entries = await readdirp.promise(root[, options])` — **Promise API**. Returns a list of [entry infos](#entryinfo). + +First argument is awalys `root`, path in which to start reading and recursing into subdirectories. + +### options + +- `fileFilter`: filter to include or exclude files + - **Function**: a function that takes an entry info as a parameter and returns true to include or false to exclude the entry +- `directoryFilter`: filter to include/exclude directories found and to recurse into. Directories that do not pass a filter will not be recursed into. +- `depth: 5`: depth at which to stop recursing even if more subdirectories are found +- `type: 'files'`: determines if data events on the stream should be emitted for `'files'` (default), `'directories'`, `'files_directories'`, or `'all'`. Setting to `'all'` will also include entries for other types of file descriptors like character devices, unix sockets and named pipes. +- `alwaysStat: false`: always return `stats` property for every file. Default is `false`, readdirp will return `Dirent` entries. Setting it to `true` can double readdir execution time - use it only when you need file `size`, `mtime` etc. Cannot be enabled on node <10.10.0. +- `lstat: false`: include symlink entries in the stream along with files. When `true`, `fs.lstat` would be used instead of `fs.stat` + +### `EntryInfo` + +Has the following properties: + +- `path: 'assets/javascripts/react.js'`: path to the file/directory (relative to given root) +- `fullPath: '/Users/dev/projects/app/assets/javascripts/react.js'`: full path to the file/directory found +- `basename: 'react.js'`: name of the file/directory +- `dirent: fs.Dirent`: built-in [dir entry object](https://nodejs.org/api/fs.html#fs_class_fs_dirent) - only with `alwaysStat: false` +- `stats: fs.Stats`: built in [stat object](https://nodejs.org/api/fs.html#fs_class_fs_stats) - only with `alwaysStat: true` + +## Changelog + +- 4.0 (Aug 25, 2024) rewritten in typescript, producing hybrid common.js / esm module. + - Remove glob support and all dependencies + - Make sure you're using `let {readdirp} = require('readdirp')` in common.js +- 3.5 (Oct 13, 2020) disallows recursive directory-based symlinks. + Before, it could have entered infinite loop. +- 3.4 (Mar 19, 2020) adds support for directory-based symlinks. +- 3.3 (Dec 6, 2019) stabilizes RAM consumption and enables perf management with `highWaterMark` option. Fixes race conditions related to `for-await` looping. +- 3.2 (Oct 14, 2019) improves performance by 250% and makes streams implementation more idiomatic. +- 3.1 (Jul 7, 2019) brings `bigint` support to `stat` output on Windows. This is backwards-incompatible for some cases. Be careful. It you use it incorrectly, you'll see "TypeError: Cannot mix BigInt and other types, use explicit conversions". +- 3.0 brings huge performance improvements and stream backpressure support. +- Upgrading 2.x to 3.x: + - Signature changed from `readdirp(options)` to `readdirp(root, options)` + - Replaced callback API with promise API. + - Renamed `entryType` option to `type` + - Renamed `entryType: 'both'` to `'files_directories'` + - `EntryInfo` + - Renamed `stat` to `stats` + - Emitted only when `alwaysStat: true` + - `dirent` is emitted instead of `stats` by default with `alwaysStat: false` + - Renamed `name` to `basename` + - Removed `parentDir` and `fullParentDir` properties +- Supported node.js versions: + - 4.x: node 14+ + - 3.x: node 8+ + - 2.x: node 0.6+ + +## License + +Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller () + +MIT License, see [LICENSE](LICENSE) file. diff --git a/node_modules/readdirp/esm/index.d.ts b/node_modules/readdirp/esm/index.d.ts new file mode 100644 index 0000000..df93940 --- /dev/null +++ b/node_modules/readdirp/esm/index.d.ts @@ -0,0 +1,108 @@ +/** + * Recursive version of readdir. Exposes a streaming API and promise API. + * Streaming API allows to use a small amount of RAM. + * + * @module + * @example +```js +import readdirp from 'readdirp'; +for await (const entry of readdirp('.')) { + const {path} = entry; + console.log(`${JSON.stringify({path})}`); +} +``` + */ +/*! readdirp - MIT License (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com) */ +import type { Stats, Dirent } from 'node:fs'; +import { Readable } from 'node:stream'; +/** Path in file system. */ +export type Path = string; +/** Emitted entry. Contains relative & absolute path, basename, and either stats or dirent. */ +export interface EntryInfo { + path: string; + fullPath: string; + stats?: Stats; + dirent?: Dirent; + basename: string; +} +/** Path or dir entries (files) */ +export type PathOrDirent = Dirent | Path; +/** Filterer for files */ +export type Tester = (entryInfo: EntryInfo) => boolean; +export type Predicate = string[] | string | Tester; +export declare const EntryTypes: { + readonly FILE_TYPE: "files"; + readonly DIR_TYPE: "directories"; + readonly FILE_DIR_TYPE: "files_directories"; + readonly EVERYTHING_TYPE: "all"; +}; +export type EntryType = (typeof EntryTypes)[keyof typeof EntryTypes]; +/** + * Options for readdirp. + * * type: files, directories, or both + * * lstat: whether to use symlink-friendly stat + * * depth: max depth + * * alwaysStat: whether to use stat (more resources) or dirent + * * highWaterMark: streaming param, specifies max amount of resources per entry + */ +export type ReaddirpOptions = { + root: string; + fileFilter?: Predicate; + directoryFilter?: Predicate; + type?: EntryType; + lstat?: boolean; + depth?: number; + alwaysStat?: boolean; + highWaterMark?: number; +}; +/** Directory entry. Contains path, depth count, and files. */ +export interface DirEntry { + files: PathOrDirent[]; + depth: number; + path: Path; +} +/** Readable readdir stream, emitting new files as they're being listed. */ +export declare class ReaddirpStream extends Readable { + parents: any[]; + reading: boolean; + parent?: DirEntry; + _stat: Function; + _maxDepth: number; + _wantsDir: boolean; + _wantsFile: boolean; + _wantsEverything: boolean; + _root: Path; + _isDirent: boolean; + _statsProp: 'dirent' | 'stats'; + _rdOptions: { + encoding: 'utf8'; + withFileTypes: boolean; + }; + _fileFilter: Tester; + _directoryFilter: Tester; + constructor(options?: Partial); + _read(batch: number): Promise; + _exploreDir(path: Path, depth: number): Promise<{ + files: string[] | undefined; + depth: number; + path: string; + }>; + _formatEntry(dirent: PathOrDirent, path: Path): Promise; + _onError(err: Error): void; + _getEntryType(entry: EntryInfo): Promise; + _includeAsFile(entry: EntryInfo): boolean | undefined; +} +/** + * Streaming version: Reads all files and directories in given root recursively. + * Consumes ~constant small amount of RAM. + * @param root Root directory + * @param options Options to specify root (start directory), filters and recursion depth + */ +export declare function readdirp(root: Path, options?: Partial): ReaddirpStream; +/** + * Promise version: Reads all files and directories in given root recursively. + * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed. + * @returns array of paths and their entry infos + */ +export declare function readdirpPromise(root: Path, options?: Partial): Promise; +export default readdirp; diff --git a/node_modules/readdirp/esm/index.js b/node_modules/readdirp/esm/index.js new file mode 100644 index 0000000..ae8ca78 --- /dev/null +++ b/node_modules/readdirp/esm/index.js @@ -0,0 +1,257 @@ +import { stat, lstat, readdir, realpath } from 'node:fs/promises'; +import { Readable } from 'node:stream'; +import { resolve as presolve, relative as prelative, join as pjoin, sep as psep } from 'node:path'; +export const EntryTypes = { + FILE_TYPE: 'files', + DIR_TYPE: 'directories', + FILE_DIR_TYPE: 'files_directories', + EVERYTHING_TYPE: 'all', +}; +const defaultOptions = { + root: '.', + fileFilter: (_entryInfo) => true, + directoryFilter: (_entryInfo) => true, + type: EntryTypes.FILE_TYPE, + lstat: false, + depth: 2147483648, + alwaysStat: false, + highWaterMark: 4096, +}; +Object.freeze(defaultOptions); +const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR'; +const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]); +const ALL_TYPES = [ + EntryTypes.DIR_TYPE, + EntryTypes.EVERYTHING_TYPE, + EntryTypes.FILE_DIR_TYPE, + EntryTypes.FILE_TYPE, +]; +const DIR_TYPES = new Set([ + EntryTypes.DIR_TYPE, + EntryTypes.EVERYTHING_TYPE, + EntryTypes.FILE_DIR_TYPE, +]); +const FILE_TYPES = new Set([ + EntryTypes.EVERYTHING_TYPE, + EntryTypes.FILE_DIR_TYPE, + EntryTypes.FILE_TYPE, +]); +const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code); +const wantBigintFsStats = process.platform === 'win32'; +const emptyFn = (_entryInfo) => true; +const normalizeFilter = (filter) => { + if (filter === undefined) + return emptyFn; + if (typeof filter === 'function') + return filter; + if (typeof filter === 'string') { + const fl = filter.trim(); + return (entry) => entry.basename === fl; + } + if (Array.isArray(filter)) { + const trItems = filter.map((item) => item.trim()); + return (entry) => trItems.some((f) => entry.basename === f); + } + return emptyFn; +}; +/** Readable readdir stream, emitting new files as they're being listed. */ +export class ReaddirpStream extends Readable { + constructor(options = {}) { + super({ + objectMode: true, + autoDestroy: true, + highWaterMark: options.highWaterMark, + }); + const opts = { ...defaultOptions, ...options }; + const { root, type } = opts; + this._fileFilter = normalizeFilter(opts.fileFilter); + this._directoryFilter = normalizeFilter(opts.directoryFilter); + const statMethod = opts.lstat ? lstat : stat; + // Use bigint stats if it's windows and stat() supports options (node 10+). + if (wantBigintFsStats) { + this._stat = (path) => statMethod(path, { bigint: true }); + } + else { + this._stat = statMethod; + } + this._maxDepth = opts.depth ?? defaultOptions.depth; + this._wantsDir = type ? DIR_TYPES.has(type) : false; + this._wantsFile = type ? FILE_TYPES.has(type) : false; + this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE; + this._root = presolve(root); + this._isDirent = !opts.alwaysStat; + this._statsProp = this._isDirent ? 'dirent' : 'stats'; + this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent }; + // Launch stream with one parent, the root dir. + this.parents = [this._exploreDir(root, 1)]; + this.reading = false; + this.parent = undefined; + } + async _read(batch) { + if (this.reading) + return; + this.reading = true; + try { + while (!this.destroyed && batch > 0) { + const par = this.parent; + const fil = par && par.files; + if (fil && fil.length > 0) { + const { path, depth } = par; + const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path)); + const awaited = await Promise.all(slice); + for (const entry of awaited) { + if (!entry) + continue; + if (this.destroyed) + return; + const entryType = await this._getEntryType(entry); + if (entryType === 'directory' && this._directoryFilter(entry)) { + if (depth <= this._maxDepth) { + this.parents.push(this._exploreDir(entry.fullPath, depth + 1)); + } + if (this._wantsDir) { + this.push(entry); + batch--; + } + } + else if ((entryType === 'file' || this._includeAsFile(entry)) && + this._fileFilter(entry)) { + if (this._wantsFile) { + this.push(entry); + batch--; + } + } + } + } + else { + const parent = this.parents.pop(); + if (!parent) { + this.push(null); + break; + } + this.parent = await parent; + if (this.destroyed) + return; + } + } + } + catch (error) { + this.destroy(error); + } + finally { + this.reading = false; + } + } + async _exploreDir(path, depth) { + let files; + try { + files = await readdir(path, this._rdOptions); + } + catch (error) { + this._onError(error); + } + return { files, depth, path }; + } + async _formatEntry(dirent, path) { + let entry; + const basename = this._isDirent ? dirent.name : dirent; + try { + const fullPath = presolve(pjoin(path, basename)); + entry = { path: prelative(this._root, fullPath), fullPath, basename }; + entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath); + } + catch (err) { + this._onError(err); + return; + } + return entry; + } + _onError(err) { + if (isNormalFlowError(err) && !this.destroyed) { + this.emit('warn', err); + } + else { + this.destroy(err); + } + } + async _getEntryType(entry) { + // entry may be undefined, because a warning or an error were emitted + // and the statsProp is undefined + if (!entry && this._statsProp in entry) { + return ''; + } + const stats = entry[this._statsProp]; + if (stats.isFile()) + return 'file'; + if (stats.isDirectory()) + return 'directory'; + if (stats && stats.isSymbolicLink()) { + const full = entry.fullPath; + try { + const entryRealPath = await realpath(full); + const entryRealPathStats = await lstat(entryRealPath); + if (entryRealPathStats.isFile()) { + return 'file'; + } + if (entryRealPathStats.isDirectory()) { + const len = entryRealPath.length; + if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) { + const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`); + // @ts-ignore + recursiveError.code = RECURSIVE_ERROR_CODE; + return this._onError(recursiveError); + } + return 'directory'; + } + } + catch (error) { + this._onError(error); + return ''; + } + } + } + _includeAsFile(entry) { + const stats = entry && entry[this._statsProp]; + return stats && this._wantsEverything && !stats.isDirectory(); + } +} +/** + * Streaming version: Reads all files and directories in given root recursively. + * Consumes ~constant small amount of RAM. + * @param root Root directory + * @param options Options to specify root (start directory), filters and recursion depth + */ +export function readdirp(root, options = {}) { + // @ts-ignore + let type = options.entryType || options.type; + if (type === 'both') + type = EntryTypes.FILE_DIR_TYPE; // backwards-compatibility + if (type) + options.type = type; + if (!root) { + throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)'); + } + else if (typeof root !== 'string') { + throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)'); + } + else if (type && !ALL_TYPES.includes(type)) { + throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`); + } + options.root = root; + return new ReaddirpStream(options); +} +/** + * Promise version: Reads all files and directories in given root recursively. + * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed. + * @returns array of paths and their entry infos + */ +export function readdirpPromise(root, options = {}) { + return new Promise((resolve, reject) => { + const files = []; + readdirp(root, options) + .on('data', (entry) => files.push(entry)) + .on('end', () => resolve(files)) + .on('error', (error) => reject(error)); + }); +} +export default readdirp; diff --git a/node_modules/readdirp/esm/package.json b/node_modules/readdirp/esm/package.json new file mode 100644 index 0000000..8769641 --- /dev/null +++ b/node_modules/readdirp/esm/package.json @@ -0,0 +1 @@ +{ "type": "module", "sideEffects": false } diff --git a/node_modules/readdirp/index.d.ts b/node_modules/readdirp/index.d.ts new file mode 100644 index 0000000..df93940 --- /dev/null +++ b/node_modules/readdirp/index.d.ts @@ -0,0 +1,108 @@ +/** + * Recursive version of readdir. Exposes a streaming API and promise API. + * Streaming API allows to use a small amount of RAM. + * + * @module + * @example +```js +import readdirp from 'readdirp'; +for await (const entry of readdirp('.')) { + const {path} = entry; + console.log(`${JSON.stringify({path})}`); +} +``` + */ +/*! readdirp - MIT License (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com) */ +import type { Stats, Dirent } from 'node:fs'; +import { Readable } from 'node:stream'; +/** Path in file system. */ +export type Path = string; +/** Emitted entry. Contains relative & absolute path, basename, and either stats or dirent. */ +export interface EntryInfo { + path: string; + fullPath: string; + stats?: Stats; + dirent?: Dirent; + basename: string; +} +/** Path or dir entries (files) */ +export type PathOrDirent = Dirent | Path; +/** Filterer for files */ +export type Tester = (entryInfo: EntryInfo) => boolean; +export type Predicate = string[] | string | Tester; +export declare const EntryTypes: { + readonly FILE_TYPE: "files"; + readonly DIR_TYPE: "directories"; + readonly FILE_DIR_TYPE: "files_directories"; + readonly EVERYTHING_TYPE: "all"; +}; +export type EntryType = (typeof EntryTypes)[keyof typeof EntryTypes]; +/** + * Options for readdirp. + * * type: files, directories, or both + * * lstat: whether to use symlink-friendly stat + * * depth: max depth + * * alwaysStat: whether to use stat (more resources) or dirent + * * highWaterMark: streaming param, specifies max amount of resources per entry + */ +export type ReaddirpOptions = { + root: string; + fileFilter?: Predicate; + directoryFilter?: Predicate; + type?: EntryType; + lstat?: boolean; + depth?: number; + alwaysStat?: boolean; + highWaterMark?: number; +}; +/** Directory entry. Contains path, depth count, and files. */ +export interface DirEntry { + files: PathOrDirent[]; + depth: number; + path: Path; +} +/** Readable readdir stream, emitting new files as they're being listed. */ +export declare class ReaddirpStream extends Readable { + parents: any[]; + reading: boolean; + parent?: DirEntry; + _stat: Function; + _maxDepth: number; + _wantsDir: boolean; + _wantsFile: boolean; + _wantsEverything: boolean; + _root: Path; + _isDirent: boolean; + _statsProp: 'dirent' | 'stats'; + _rdOptions: { + encoding: 'utf8'; + withFileTypes: boolean; + }; + _fileFilter: Tester; + _directoryFilter: Tester; + constructor(options?: Partial); + _read(batch: number): Promise; + _exploreDir(path: Path, depth: number): Promise<{ + files: string[] | undefined; + depth: number; + path: string; + }>; + _formatEntry(dirent: PathOrDirent, path: Path): Promise; + _onError(err: Error): void; + _getEntryType(entry: EntryInfo): Promise; + _includeAsFile(entry: EntryInfo): boolean | undefined; +} +/** + * Streaming version: Reads all files and directories in given root recursively. + * Consumes ~constant small amount of RAM. + * @param root Root directory + * @param options Options to specify root (start directory), filters and recursion depth + */ +export declare function readdirp(root: Path, options?: Partial): ReaddirpStream; +/** + * Promise version: Reads all files and directories in given root recursively. + * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed. + * @returns array of paths and their entry infos + */ +export declare function readdirpPromise(root: Path, options?: Partial): Promise; +export default readdirp; diff --git a/node_modules/readdirp/index.js b/node_modules/readdirp/index.js new file mode 100644 index 0000000..0e08e13 --- /dev/null +++ b/node_modules/readdirp/index.js @@ -0,0 +1,263 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ReaddirpStream = exports.EntryTypes = void 0; +exports.readdirp = readdirp; +exports.readdirpPromise = readdirpPromise; +const promises_1 = require("node:fs/promises"); +const node_stream_1 = require("node:stream"); +const node_path_1 = require("node:path"); +exports.EntryTypes = { + FILE_TYPE: 'files', + DIR_TYPE: 'directories', + FILE_DIR_TYPE: 'files_directories', + EVERYTHING_TYPE: 'all', +}; +const defaultOptions = { + root: '.', + fileFilter: (_entryInfo) => true, + directoryFilter: (_entryInfo) => true, + type: exports.EntryTypes.FILE_TYPE, + lstat: false, + depth: 2147483648, + alwaysStat: false, + highWaterMark: 4096, +}; +Object.freeze(defaultOptions); +const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR'; +const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]); +const ALL_TYPES = [ + exports.EntryTypes.DIR_TYPE, + exports.EntryTypes.EVERYTHING_TYPE, + exports.EntryTypes.FILE_DIR_TYPE, + exports.EntryTypes.FILE_TYPE, +]; +const DIR_TYPES = new Set([ + exports.EntryTypes.DIR_TYPE, + exports.EntryTypes.EVERYTHING_TYPE, + exports.EntryTypes.FILE_DIR_TYPE, +]); +const FILE_TYPES = new Set([ + exports.EntryTypes.EVERYTHING_TYPE, + exports.EntryTypes.FILE_DIR_TYPE, + exports.EntryTypes.FILE_TYPE, +]); +const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code); +const wantBigintFsStats = process.platform === 'win32'; +const emptyFn = (_entryInfo) => true; +const normalizeFilter = (filter) => { + if (filter === undefined) + return emptyFn; + if (typeof filter === 'function') + return filter; + if (typeof filter === 'string') { + const fl = filter.trim(); + return (entry) => entry.basename === fl; + } + if (Array.isArray(filter)) { + const trItems = filter.map((item) => item.trim()); + return (entry) => trItems.some((f) => entry.basename === f); + } + return emptyFn; +}; +/** Readable readdir stream, emitting new files as they're being listed. */ +class ReaddirpStream extends node_stream_1.Readable { + constructor(options = {}) { + super({ + objectMode: true, + autoDestroy: true, + highWaterMark: options.highWaterMark, + }); + const opts = { ...defaultOptions, ...options }; + const { root, type } = opts; + this._fileFilter = normalizeFilter(opts.fileFilter); + this._directoryFilter = normalizeFilter(opts.directoryFilter); + const statMethod = opts.lstat ? promises_1.lstat : promises_1.stat; + // Use bigint stats if it's windows and stat() supports options (node 10+). + if (wantBigintFsStats) { + this._stat = (path) => statMethod(path, { bigint: true }); + } + else { + this._stat = statMethod; + } + this._maxDepth = opts.depth ?? defaultOptions.depth; + this._wantsDir = type ? DIR_TYPES.has(type) : false; + this._wantsFile = type ? FILE_TYPES.has(type) : false; + this._wantsEverything = type === exports.EntryTypes.EVERYTHING_TYPE; + this._root = (0, node_path_1.resolve)(root); + this._isDirent = !opts.alwaysStat; + this._statsProp = this._isDirent ? 'dirent' : 'stats'; + this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent }; + // Launch stream with one parent, the root dir. + this.parents = [this._exploreDir(root, 1)]; + this.reading = false; + this.parent = undefined; + } + async _read(batch) { + if (this.reading) + return; + this.reading = true; + try { + while (!this.destroyed && batch > 0) { + const par = this.parent; + const fil = par && par.files; + if (fil && fil.length > 0) { + const { path, depth } = par; + const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path)); + const awaited = await Promise.all(slice); + for (const entry of awaited) { + if (!entry) + continue; + if (this.destroyed) + return; + const entryType = await this._getEntryType(entry); + if (entryType === 'directory' && this._directoryFilter(entry)) { + if (depth <= this._maxDepth) { + this.parents.push(this._exploreDir(entry.fullPath, depth + 1)); + } + if (this._wantsDir) { + this.push(entry); + batch--; + } + } + else if ((entryType === 'file' || this._includeAsFile(entry)) && + this._fileFilter(entry)) { + if (this._wantsFile) { + this.push(entry); + batch--; + } + } + } + } + else { + const parent = this.parents.pop(); + if (!parent) { + this.push(null); + break; + } + this.parent = await parent; + if (this.destroyed) + return; + } + } + } + catch (error) { + this.destroy(error); + } + finally { + this.reading = false; + } + } + async _exploreDir(path, depth) { + let files; + try { + files = await (0, promises_1.readdir)(path, this._rdOptions); + } + catch (error) { + this._onError(error); + } + return { files, depth, path }; + } + async _formatEntry(dirent, path) { + let entry; + const basename = this._isDirent ? dirent.name : dirent; + try { + const fullPath = (0, node_path_1.resolve)((0, node_path_1.join)(path, basename)); + entry = { path: (0, node_path_1.relative)(this._root, fullPath), fullPath, basename }; + entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath); + } + catch (err) { + this._onError(err); + return; + } + return entry; + } + _onError(err) { + if (isNormalFlowError(err) && !this.destroyed) { + this.emit('warn', err); + } + else { + this.destroy(err); + } + } + async _getEntryType(entry) { + // entry may be undefined, because a warning or an error were emitted + // and the statsProp is undefined + if (!entry && this._statsProp in entry) { + return ''; + } + const stats = entry[this._statsProp]; + if (stats.isFile()) + return 'file'; + if (stats.isDirectory()) + return 'directory'; + if (stats && stats.isSymbolicLink()) { + const full = entry.fullPath; + try { + const entryRealPath = await (0, promises_1.realpath)(full); + const entryRealPathStats = await (0, promises_1.lstat)(entryRealPath); + if (entryRealPathStats.isFile()) { + return 'file'; + } + if (entryRealPathStats.isDirectory()) { + const len = entryRealPath.length; + if (full.startsWith(entryRealPath) && full.substr(len, 1) === node_path_1.sep) { + const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`); + // @ts-ignore + recursiveError.code = RECURSIVE_ERROR_CODE; + return this._onError(recursiveError); + } + return 'directory'; + } + } + catch (error) { + this._onError(error); + return ''; + } + } + } + _includeAsFile(entry) { + const stats = entry && entry[this._statsProp]; + return stats && this._wantsEverything && !stats.isDirectory(); + } +} +exports.ReaddirpStream = ReaddirpStream; +/** + * Streaming version: Reads all files and directories in given root recursively. + * Consumes ~constant small amount of RAM. + * @param root Root directory + * @param options Options to specify root (start directory), filters and recursion depth + */ +function readdirp(root, options = {}) { + // @ts-ignore + let type = options.entryType || options.type; + if (type === 'both') + type = exports.EntryTypes.FILE_DIR_TYPE; // backwards-compatibility + if (type) + options.type = type; + if (!root) { + throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)'); + } + else if (typeof root !== 'string') { + throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)'); + } + else if (type && !ALL_TYPES.includes(type)) { + throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`); + } + options.root = root; + return new ReaddirpStream(options); +} +/** + * Promise version: Reads all files and directories in given root recursively. + * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed. + * @returns array of paths and their entry infos + */ +function readdirpPromise(root, options = {}) { + return new Promise((resolve, reject) => { + const files = []; + readdirp(root, options) + .on('data', (entry) => files.push(entry)) + .on('end', () => resolve(files)) + .on('error', (error) => reject(error)); + }); +} +exports.default = readdirp; diff --git a/node_modules/readdirp/package.json b/node_modules/readdirp/package.json new file mode 100644 index 0000000..118177c --- /dev/null +++ b/node_modules/readdirp/package.json @@ -0,0 +1,70 @@ +{ + "name": "readdirp", + "description": "Recursive version of fs.readdir with small RAM & CPU footprint.", + "version": "4.1.2", + "homepage": "https://github.com/paulmillr/readdirp", + "repository": { + "type": "git", + "url": "git://github.com/paulmillr/readdirp.git" + }, + "license": "MIT", + "bugs": { + "url": "https://github.com/paulmillr/readdirp/issues" + }, + "author": "Thorsten Lorenz (thlorenz.com)", + "contributors": [ + "Thorsten Lorenz (thlorenz.com)", + "Paul Miller (https://paulmillr.com)" + ], + "engines": { + "node": ">= 14.18.0" + }, + "files": [ + "index.js", + "index.d.ts", + "index.d.ts.map", + "index.js.map", + "esm" + ], + "main": "./index.js", + "module": "./esm/index.js", + "types": "./index.d.ts", + "exports": { + ".": { + "import": "./esm/index.js", + "require": "./index.js" + } + }, + "sideEffects": false, + "keywords": [ + "recursive", + "fs", + "stream", + "streams", + "readdir", + "filesystem", + "find", + "filter" + ], + "scripts": { + "build": "tsc && tsc -p tsconfig.cjs.json", + "lint": "prettier --check index.ts test/index.test.js", + "format": "prettier --write index.ts test/index.test.js", + "test": "node test/index.test.js", + "test:coverage": "c8 node test/index.test.js" + }, + "devDependencies": { + "@paulmillr/jsbt": "0.3.1", + "@types/node": "20.14.8", + "c8": "10.1.3", + "chai": "4.3.4", + "chai-subset": "1.6.0", + "micro-should": "0.5.0", + "prettier": "3.1.1", + "typescript": "5.5.2" + }, + "funding": { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } +} \ No newline at end of file diff --git a/node_modules/sass/LICENSE b/node_modules/sass/LICENSE new file mode 100644 index 0000000..98869a8 --- /dev/null +++ b/node_modules/sass/LICENSE @@ -0,0 +1,1661 @@ +Dart Sass license: + +Copyright (c) 2016, Google Inc. + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +-------------------------------------------------------------------------------- + +Dart SDK license: + +Copyright 2012, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +_fe_analyzer_shared license: + +Copyright 2019, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +analyzer, protobuf and protoc_plugin license: + +Copyright 2013, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +archive license: + +The MIT License + +Copyright (c) 2013-2021 Brendan Duncan. +All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +-------------------------------------------------------------------------------- + +args, csslib and logging license: + +Copyright 2013, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +async, cli_util, collection, mime, stream_channel and typed_data license: + +Copyright 2015, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +boolean_selector, meta and shelf_packages_handler license: + +Copyright 2016, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +charcode license: + +Copyright 2014, the Dart project authors. All rights reserved. +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google Inc. nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +checked_yaml license: + +Copyright 2019, the Dart project authors. All rights reserved. +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google Inc. nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +cli_pkg license: + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +-------------------------------------------------------------------------------- + +cli_repl license: + +Copyright (c) 2018, Jennifer Thakar. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the project nor the names of its contributors may be + used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +convert, crypto, shelf_static, source_map_stack_trace and vm_service license: + +Copyright 2015, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +coverage, dartdoc, glob, http, http_parser, matcher, path, pool, pub_semver, +source_span, string_scanner, test and watcher license: + +Copyright 2014, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +dart_mappable and type_plus license: + +MIT License + +Copyright (c) 2021 Kilian Schulte + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +-------------------------------------------------------------------------------- + +ffi and package_config license: + +Copyright 2019, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +file license: + +Copyright 2017, the Dart project authors. All rights reserved. +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google Inc. nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- + +fixnum, http_multi_server, oauth2, shelf, shelf_web_socket, source_maps and +stack_trace license: + +Copyright 2014, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +frontend_server_client license: + +Copyright 2020, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +grinder and webkit_inspection_protocol license: + +Copyright 2013, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +html license: + +Copyright (c) 2006-2012 The Authors + +Contributors: +James Graham - jg307@cam.ac.uk +Anne van Kesteren - annevankesteren@gmail.com +Lachlan Hunt - lachlan.hunt@lachy.id.au +Matt McDonald - kanashii@kanashii.ca +Sam Ruby - rubys@intertwingly.net +Ian Hickson (Google) - ian@hixie.ch +Thomas Broyer - t.broyer@ltgt.net +Jacques Distler - distler@golem.ph.utexas.edu +Henri Sivonen - hsivonen@iki.fi +Adam Barth - abarth@webkit.org +Eric Seidel - eric@webkit.org +The Mozilla Foundation (contributions from Henri Sivonen since 2008) +David Flanagan (Mozilla) - dflanagan@mozilla.com +Google LLC (contributed the Dart port) - misc@dartlang.org + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +-------------------------------------------------------------------------------- + +io, stream_transform and term_glyph license: + +Copyright 2017, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +js license: + +Copyright 2012, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +json_annotation license: + +Copyright 2017, the Dart project authors. All rights reserved. +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google Inc. nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +lints license: + +Copyright 2021, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +markdown license: + +Copyright 2012, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +native_stack_traces license: + +Copyright 2020, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +native_synchronization license: + +Copyright 2023, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +node_interop license: + +Copyright (c) 2017, Anatoly Pulyaevskiy. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +node_preamble license: + +The MIT License (MIT) + +Copyright (c) 2015 Michael Bullington + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +=== + +Copyright 2012, the Dart project authors. All rights reserved. +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google Inc. nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +petitparser license: + +The MIT License + +Copyright (c) 2006-2025 Lukas Renggli. +All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + + +-------------------------------------------------------------------------------- + +pub_api_client license: + +MIT License + +Copyright (c) 2020 Leo Farias + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + + +-------------------------------------------------------------------------------- + +pubspec_parse license: + +Copyright 2018, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +retry license: + + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +-------------------------------------------------------------------------------- + +test_api and test_core license: + +Copyright 2018, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +test_descriptor and web_socket_channel license: + +Copyright 2016, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +test_process license: + +Copyright 2017, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +web license: + +Copyright 2023, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +web_socket license: + +Copyright 2024, the Dart project authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google LLC nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +-------------------------------------------------------------------------------- + +xml license: + +The MIT License + +Copyright (c) 2006-2023 Lukas Renggli. +All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + + +-------------------------------------------------------------------------------- + +yaml license: + +Copyright (c) 2014, the Dart project authors. +Copyright (c) 2006, Kirill Simonov. + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/node_modules/sass/README.md b/node_modules/sass/README.md new file mode 100644 index 0000000..c7ad591 --- /dev/null +++ b/node_modules/sass/README.md @@ -0,0 +1,173 @@ +A pure JavaScript implementation of [Sass][sass]. **Sass makes CSS fun again**. + + + + + + + +
+ Sass logo + + npm statistics + + GitHub actions build status +
+ Appveyor build status +
+ +[sass]: https://sass-lang.com/ + +This package is a distribution of [Dart Sass][], compiled to pure JavaScript +with no native code or external dependencies. It provides a command-line `sass` +executable and a Node.js API. + +[Dart Sass]: https://github.com/sass/dart-sass + +* [Usage](#usage) +* [See Also](#see-also) +* [Behavioral Differences from Ruby Sass](#behavioral-differences-from-ruby-sass) + +## Usage + +You can install Sass globally using `npm install -g sass` which will provide +access to the `sass` executable. You can also add it to your project using +`npm install --save-dev sass`. This provides the executable as well as a +library: + +[npm]: https://www.npmjs.com/package/sass + +```js +const sass = require('sass'); + +const result = sass.compile(scssFilename); + +// OR + +// Note that `compileAsync()` is substantially slower than `compile()`. +const result = await sass.compileAsync(scssFilename); +``` + +See [the Sass website][js api] for full API documentation. + +[js api]: https://sass-lang.com/documentation/js-api + +### Legacy API + +Dart Sass also supports an older JavaScript API that's fully compatible with +[Node Sass] (with a few exceptions listed below), with support for both the +[`render()`] and [`renderSync()`] functions. This API is considered deprecated +and will be removed in Dart Sass 2.0.0, so it should be avoided in new projects. + +[Node Sass]: https://github.com/sass/node-sass +[`render()`]: https://sass-lang.com/documentation/js-api/functions/render +[`renderSync()`]: https://sass-lang.com/documentation/js-api/functions/renderSync + +Sass's support for the legacy JavaScript API has the following limitations: + +* Only the `"expanded"` and `"compressed"` values of [`outputStyle`] are + supported. + +* Dart Sass doesn't support the [`precision`] option. Dart Sass defaults to a + sufficiently high precision for all existing browsers, and making this + customizable would make the code substantially less efficient. + +* Dart Sass doesn't support the [`sourceComments`] option. Source maps are the + recommended way of locating the origin of generated selectors. + +[`outputStyle`]: https://sass-lang.com/documentation/js-api/interfaces/LegacySharedOptions#outputStyle +[`precision`]: https://github.com/sass/node-sass#precision +[`sourceComments`]: https://github.com/sass/node-sass#sourcecomments + +## See Also + +* [Dart Sass][], from which this package is compiled, can be used either as a + stand-alone executable or as a Dart library. Running Dart Sass on the Dart VM + is substantially faster than running the pure JavaScript version, so this may + be appropriate for performance-sensitive applications. The Dart API is also + (currently) more user-friendly than the JavaScript API. See + [the Dart Sass README][Using Dart Sass] for details on how to use it. + +* [Node Sass][], which is a wrapper around [LibSass][], the C++ implementation + of Sass. Node Sass supports the same API as this package and is also faster + (although it's usually a little slower than Dart Sass). However, it requires a + native library which may be difficult to install, and it's generally slower to + add features and fix bugs. + +[Using Dart Sass]: https://github.com/sass/dart-sass#using-dart-sass +[Node Sass]: https://www.npmjs.com/package/node-sass +[LibSass]: https://sass-lang.com/libsass + +## Behavioral Differences from Ruby Sass + +There are a few intentional behavioral differences between Dart Sass and Ruby +Sass. These are generally places where Ruby Sass has an undesired behavior, and +it's substantially easier to implement the correct behavior than it would be to +implement compatible behavior. These should all have tracking bugs against Ruby +Sass to update the reference behavior. + +1. `@extend` only accepts simple selectors, as does the second argument of + `selector-extend()`. See [issue 1599][]. + +2. Subject selectors are not supported. See [issue 1126][]. + +3. Pseudo selector arguments are parsed as ``s rather than + having a more limited custom parsing. See [issue 2120][]. + +4. The numeric precision is set to 10. See [issue 1122][]. + +5. The indented syntax parser is more flexible: it doesn't require consistent + indentation across the whole document. See [issue 2176][]. + +6. Colors do not support channel-by-channel arithmetic. See [issue 2144][]. + +7. Unitless numbers aren't `==` to unit numbers with the same value. In + addition, map keys follow the same logic as `==`-equality. See + [issue 1496][]. + +8. `rgba()` and `hsla()` alpha values with percentage units are interpreted as + percentages. Other units are forbidden. See [issue 1525][]. + +9. Too many variable arguments passed to a function is an error. See + [issue 1408][]. + +10. Allow `@extend` to reach outside a media query if there's an identical + `@extend` defined outside that query. This isn't tracked explicitly, because + it'll be irrelevant when [issue 1050][] is fixed. + +11. Some selector pseudos containing placeholder selectors will be compiled + where they wouldn't be in Ruby Sass. This better matches the semantics of + the selectors in question, and is more efficient. See [issue 2228][]. + +12. The old-style `:property value` syntax is not supported in the indented + syntax. See [issue 2245][]. + +13. The reference combinator is not supported. See [issue 303][]. + +14. Universal selector unification is symmetrical. See [issue 2247][]. + +15. `@extend` doesn't produce an error if it matches but fails to unify. See + [issue 2250][]. + +16. Dart Sass currently only supports UTF-8 documents. We'd like to support + more, but Dart currently doesn't support them. See [dart-lang/sdk#11744][], + for example. + +[issue 1599]: https://github.com/sass/sass/issues/1599 +[issue 1126]: https://github.com/sass/sass/issues/1126 +[issue 2120]: https://github.com/sass/sass/issues/2120 +[issue 1122]: https://github.com/sass/sass/issues/1122 +[issue 2176]: https://github.com/sass/sass/issues/2176 +[issue 2144]: https://github.com/sass/sass/issues/2144 +[issue 1496]: https://github.com/sass/sass/issues/1496 +[issue 1525]: https://github.com/sass/sass/issues/1525 +[issue 1408]: https://github.com/sass/sass/issues/1408 +[issue 1050]: https://github.com/sass/sass/issues/1050 +[issue 2228]: https://github.com/sass/sass/issues/2228 +[issue 2245]: https://github.com/sass/sass/issues/2245 +[issue 303]: https://github.com/sass/sass/issues/303 +[issue 2247]: https://github.com/sass/sass/issues/2247 +[issue 2250]: https://github.com/sass/sass/issues/2250 +[dart-lang/sdk#11744]: https://github.com/dart-lang/sdk/issues/11744 + +Disclaimer: this is not an official Google product. diff --git a/node_modules/sass/package.json b/node_modules/sass/package.json new file mode 100644 index 0000000..2b0b9e9 --- /dev/null +++ b/node_modules/sass/package.json @@ -0,0 +1 @@ +{"name":"sass","description":"A pure JavaScript implementation of Sass.","license":"MIT","bugs":"https://github.com/sass/dart-sass/issues","homepage":"https://github.com/sass/dart-sass","repository":{"type":"git","url":"https://github.com/sass/dart-sass"},"author":{"name":"Natalie Weizenbaum","email":"nweiz@google.com","url":"https://github.com/nex3"},"engines":{"node":">=14.0.0"},"dependencies":{"chokidar":"^4.0.0","immutable":"^5.0.2","source-map-js":">=0.6.2 <2.0.0"},"optionalDependencies":{"@parcel/watcher":"^2.4.1"},"keywords":["style","scss","sass","preprocessor","css"],"types":"types/index.d.ts","exports":{"types":"./types/index.d.ts","node":{"require":"./sass.node.js","default":"./sass.node.mjs"},"default":{"require":"./sass.default.cjs","default":"./sass.default.js"}},"version":"1.86.3","bin":{"sass":"sass.js"},"main":"sass.node.js"} \ No newline at end of file diff --git a/node_modules/sass/sass.dart.js b/node_modules/sass/sass.dart.js new file mode 100644 index 0000000..e88fea5 --- /dev/null +++ b/node_modules/sass/sass.dart.js @@ -0,0 +1,127285 @@ +// Because of vitejs/vite#12340, there's no way to reliably detect whether we're +// running as a (possibly bundled/polyfilled) ESM module or as a CommonJS +// module. In order to work everywhere, we have to provide the load function via +// a side channel on the global object. We write it as a stack so that multiple +// cli_pkg packages can depend on one another without clobbering their exports. +if (!globalThis._cliPkgExports) { + globalThis._cliPkgExports = []; +} +let _cliPkgExports = {}; +globalThis._cliPkgExports.push(_cliPkgExports); + +_cliPkgExports.load = function(_cliPkgRequires, _cliPkgExportParam) { +var dartNodeIsActuallyNode = typeof process !== "undefined" && (process.versions || {}).hasOwnProperty('node'); + +// make sure to keep this as 'var' +// we don't want block scoping +var self = dartNodeIsActuallyNode ? Object.create(globalThis) : globalThis; + +self.scheduleImmediate = typeof setImmediate !== "undefined" + ? function (cb) { + setImmediate(cb); + } + : function(cb) { + setTimeout(cb, 0); + }; + +// CommonJS globals. +if (typeof require !== "undefined") { + self.require = require; +} +self.exports = _cliPkgExportParam || _cliPkgExports; + +// Node.js specific exports, check to see if they exist & or polyfilled + +if (typeof process !== "undefined") { + self.process = process; +} + +if (typeof __dirname !== "undefined") { + self.__dirname = __dirname; +} + +if (typeof __filename !== "undefined") { + self.__filename = __filename; +} + +if (typeof Buffer !== "undefined") { + self.Buffer = Buffer; +} + +// if we're running in a browser, Dart supports most of this out of box +// make sure we only run these in Node.js environment + +if (dartNodeIsActuallyNode) { + // This line is to: + // 1) Prevent Webpack from bundling. + // 2) In Webpack on Node.js, make sure we're using the native Node.js require, which is available via __non_webpack_require__ + // https://github.com/mbullington/node_preamble.dart/issues/18#issuecomment-527305561 + var url = ("undefined" !== typeof __webpack_require__ ? __non_webpack_require__ : require)("url"); + + // Setting `self.location=` in Electron throws a `TypeError`, so we define it + // as a property instead to be safe. + Object.defineProperty(self, "location", { + value: { + get href() { + if (url.pathToFileURL) { + return url.pathToFileURL(process.cwd()).href + "/"; + } else { + // This isn't really a correct transformation, but it's the best we have + // for versions of Node <10.12.0 which introduced `url.pathToFileURL()`. + // For example, it will fail for paths that contain characters that need + // to be escaped in URLs. + return "file://" + (function() { + var cwd = process.cwd(); + if (process.platform != "win32") return cwd; + return "/" + cwd.replace(/\\/g, "/"); + })() + "/" + } + } + } + }); + + (function() { + function computeCurrentScript() { + try { + throw new Error(); + } catch(e) { + var stack = e.stack; + var re = new RegExp("^ *at [^(]*\\((.*):[0-9]*:[0-9]*\\)$", "mg"); + var lastMatch = null; + do { + var match = re.exec(stack); + if (match != null) lastMatch = match; + } while (match != null); + return lastMatch[1]; + } + } + + // Setting `self.document=` isn't known to throw an error anywhere like + // `self.location=` does on Electron, but it's better to be future-proof + // just in case.. + var cachedCurrentScript = null; + Object.defineProperty(self, "document", { + value: { + get currentScript() { + if (cachedCurrentScript == null) { + cachedCurrentScript = {src: computeCurrentScript()}; + } + return cachedCurrentScript; + } + } + }); + })(); + + self.dartDeferredLibraryLoader = function(uri, successCallback, errorCallback) { + try { + load(uri); + successCallback(); + } catch (error) { + errorCallback(error); + } + }; +} + +Object.defineProperty(self, 'parcel_watcher', { get: _cliPkgRequires.parcel_watcher }); +self.immutable = _cliPkgRequires.immutable; +self.chokidar = _cliPkgRequires.chokidar; +self.readline = _cliPkgRequires.readline; +self.fs = _cliPkgRequires.fs; +self.nodeModule = _cliPkgRequires.nodeModule; +self.stream = _cliPkgRequires.stream; +self.util = _cliPkgRequires.util; +// Generated by dart2js (NullSafetyMode.sound, trust primitives, omit checks, lax runtime type, csp, intern-composite-values), the Dart to JavaScript compiler version: 3.7.2. +// The code supports the following hooks: +// dartPrint(message): +// if this function is defined it is called instead of the Dart [print] +// method. +// +// dartMainRunner(main, args): +// if this function is defined, the Dart [main] method will not be invoked +// directly. Instead, a closure that will invoke [main], and its arguments +// [args] is passed to [dartMainRunner]. +// +// dartDeferredLibraryLoader(uri, successCallback, errorCallback, loadId, loadPriority): +// if this function is defined, it will be called when a deferred library +// is loaded. It should load and eval the javascript of `uri`, and call +// successCallback. If it fails to do so, it should call errorCallback with +// an error. The loadId argument is the deferred import that resulted in +// this uri being loaded. The loadPriority argument is an arbitrary argument +// string forwarded from the 'dart2js:load-priority' pragma option. +// dartDeferredLibraryMultiLoader(uris, successCallback, errorCallback, loadId, loadPriority): +// if this function is defined, it will be called when a deferred library +// is loaded. It should load and eval the javascript of every URI in `uris`, +// and call successCallback. If it fails to do so, it should call +// errorCallback with an error. The loadId argument is the deferred import +// that resulted in this uri being loaded. The loadPriority argument is an +// arbitrary argument string forwarded from the 'dart2js:load-priority' +// pragma option. +// +// dartCallInstrumentation(id, qualifiedName): +// if this function is defined, it will be called at each entry of a +// method or constructor. Used only when compiling programs with +// --experiment-call-instrumentation. +(function dartProgram() { + function copyProperties(from, to) { + var keys = Object.keys(from); + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + to[key] = from[key]; + } + } + function mixinPropertiesHard(from, to) { + var keys = Object.keys(from); + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!to.hasOwnProperty(key)) { + to[key] = from[key]; + } + } + } + function mixinPropertiesEasy(from, to) { + Object.assign(to, from); + } + var supportsDirectProtoAccess = function() { + var cls = function() { + }; + cls.prototype = {p: {}}; + var object = new cls(); + if (!(Object.getPrototypeOf(object) && Object.getPrototypeOf(object).p === cls.prototype.p)) + return false; + try { + if (typeof navigator != "undefined" && typeof navigator.userAgent == "string" && navigator.userAgent.indexOf("Chrome/") >= 0) + return true; + if (typeof version == "function" && version.length == 0) { + var v = version(); + if (/^\d+\.\d+\.\d+\.\d+$/.test(v)) + return true; + } + } catch (_) { + } + return false; + }(); + function inherit(cls, sup) { + cls.prototype.constructor = cls; + cls.prototype["$is" + cls.name] = cls; + if (sup != null) { + if (supportsDirectProtoAccess) { + Object.setPrototypeOf(cls.prototype, sup.prototype); + return; + } + var clsPrototype = Object.create(sup.prototype); + copyProperties(cls.prototype, clsPrototype); + cls.prototype = clsPrototype; + } + } + function inheritMany(sup, classes) { + for (var i = 0; i < classes.length; i++) { + inherit(classes[i], sup); + } + } + function mixinEasy(cls, mixin) { + mixinPropertiesEasy(mixin.prototype, cls.prototype); + cls.prototype.constructor = cls; + } + function mixinHard(cls, mixin) { + mixinPropertiesHard(mixin.prototype, cls.prototype); + cls.prototype.constructor = cls; + } + function lazy(holder, name, getterName, initializer) { + var uninitializedSentinel = holder; + holder[name] = uninitializedSentinel; + holder[getterName] = function() { + if (holder[name] === uninitializedSentinel) { + holder[name] = initializer(); + } + holder[getterName] = function() { + return this[name]; + }; + return holder[name]; + }; + } + function lazyFinal(holder, name, getterName, initializer) { + var uninitializedSentinel = holder; + holder[name] = uninitializedSentinel; + holder[getterName] = function() { + if (holder[name] === uninitializedSentinel) { + var value = initializer(); + if (holder[name] !== uninitializedSentinel) { + A.throwLateFieldADI(name); + } + holder[name] = value; + } + var finalValue = holder[name]; + holder[getterName] = function() { + return finalValue; + }; + return finalValue; + }; + } + function makeConstList(list) { + list.$flags = 7; + return list; + } + function convertToFastObject(properties) { + function t() { + } + t.prototype = properties; + new t(); + return properties; + } + function convertAllToFastObject(arrayOfObjects) { + for (var i = 0; i < arrayOfObjects.length; ++i) { + convertToFastObject(arrayOfObjects[i]); + } + } + var functionCounter = 0; + function instanceTearOffGetter(isIntercepted, parameters) { + var cache = null; + return isIntercepted ? function(receiver) { + if (cache === null) + cache = A.closureFromTearOff(parameters); + return new cache(receiver, this); + } : function() { + if (cache === null) + cache = A.closureFromTearOff(parameters); + return new cache(this, null); + }; + } + function staticTearOffGetter(parameters) { + var cache = null; + return function() { + if (cache === null) + cache = A.closureFromTearOff(parameters).prototype; + return cache; + }; + } + var typesOffset = 0; + function tearOffParameters(container, isStatic, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, needsDirectAccess) { + if (typeof funType == "number") { + funType += typesOffset; + } + return {co: container, iS: isStatic, iI: isIntercepted, rC: requiredParameterCount, dV: optionalParameterDefaultValues, cs: callNames, fs: funsOrNames, fT: funType, aI: applyIndex || 0, nDA: needsDirectAccess}; + } + function installStaticTearOff(holder, getterName, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex) { + var parameters = tearOffParameters(holder, true, false, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, false); + var getterFunction = staticTearOffGetter(parameters); + holder[getterName] = getterFunction; + } + function installInstanceTearOff(prototype, getterName, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, needsDirectAccess) { + isIntercepted = !!isIntercepted; + var parameters = tearOffParameters(prototype, false, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, !!needsDirectAccess); + var getterFunction = instanceTearOffGetter(isIntercepted, parameters); + prototype[getterName] = getterFunction; + } + function setOrUpdateInterceptorsByTag(newTags) { + var tags = init.interceptorsByTag; + if (!tags) { + init.interceptorsByTag = newTags; + return; + } + copyProperties(newTags, tags); + } + function setOrUpdateLeafTags(newTags) { + var tags = init.leafTags; + if (!tags) { + init.leafTags = newTags; + return; + } + copyProperties(newTags, tags); + } + function updateTypes(newTypes) { + var types = init.types; + var length = types.length; + types.push.apply(types, newTypes); + return length; + } + function updateHolder(holder, newHolder) { + copyProperties(newHolder, holder); + return holder; + } + var hunkHelpers = function() { + var mkInstance = function(isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, applyIndex) { + return function(container, getterName, name, funType) { + return installInstanceTearOff(container, getterName, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, [name], funType, applyIndex, false); + }; + }, + mkStatic = function(requiredParameterCount, optionalParameterDefaultValues, callNames, applyIndex) { + return function(container, getterName, name, funType) { + return installStaticTearOff(container, getterName, requiredParameterCount, optionalParameterDefaultValues, callNames, [name], funType, applyIndex); + }; + }; + return {inherit: inherit, inheritMany: inheritMany, mixin: mixinEasy, mixinHard: mixinHard, installStaticTearOff: installStaticTearOff, installInstanceTearOff: installInstanceTearOff, _instance_0u: mkInstance(0, 0, null, ["call$0"], 0), _instance_1u: mkInstance(0, 1, null, ["call$1"], 0), _instance_2u: mkInstance(0, 2, null, ["call$2"], 0), _instance_0i: mkInstance(1, 0, null, ["call$0"], 0), _instance_1i: mkInstance(1, 1, null, ["call$1"], 0), _instance_2i: mkInstance(1, 2, null, ["call$2"], 0), _static_0: mkStatic(0, null, ["call$0"], 0), _static_1: mkStatic(1, null, ["call$1"], 0), _static_2: mkStatic(2, null, ["call$2"], 0), makeConstList: makeConstList, lazy: lazy, lazyFinal: lazyFinal, updateHolder: updateHolder, convertToFastObject: convertToFastObject, updateTypes: updateTypes, setOrUpdateInterceptorsByTag: setOrUpdateInterceptorsByTag, setOrUpdateLeafTags: setOrUpdateLeafTags}; + }(); + function initializeDeferredHunk(hunk) { + typesOffset = init.types.length; + hunk(hunkHelpers, init, holders, $); + } + var J = { + makeDispatchRecord(interceptor, proto, extension, indexability) { + return {i: interceptor, p: proto, e: extension, x: indexability}; + }, + getNativeInterceptor(object) { + var proto, objectProto, $constructor, interceptor, t1, + record = object[init.dispatchPropertyName]; + if (record == null) + if ($.initNativeDispatchFlag == null) { + A.initNativeDispatch(); + record = object[init.dispatchPropertyName]; + } + if (record != null) { + proto = record.p; + if (false === proto) + return record.i; + if (true === proto) + return object; + objectProto = Object.getPrototypeOf(object); + if (proto === objectProto) + return record.i; + if (record.e === objectProto) + throw A.wrapException(A.UnimplementedError$("Return interceptor for " + A.S(proto(object, record)))); + } + $constructor = object.constructor; + if ($constructor == null) + interceptor = null; + else { + t1 = $._JS_INTEROP_INTERCEPTOR_TAG; + if (t1 == null) + t1 = $._JS_INTEROP_INTERCEPTOR_TAG = init.getIsolateTag("_$dart_js"); + interceptor = $constructor[t1]; + } + if (interceptor != null) + return interceptor; + interceptor = A.lookupAndCacheInterceptor(object); + if (interceptor != null) + return interceptor; + if (typeof object == "function") + return B.JavaScriptFunction_methods; + proto = Object.getPrototypeOf(object); + if (proto == null) + return B.PlainJavaScriptObject_methods; + if (proto === Object.prototype) + return B.PlainJavaScriptObject_methods; + if (typeof $constructor == "function") { + t1 = $._JS_INTEROP_INTERCEPTOR_TAG; + if (t1 == null) + t1 = $._JS_INTEROP_INTERCEPTOR_TAG = init.getIsolateTag("_$dart_js"); + Object.defineProperty($constructor, t1, {value: B.UnknownJavaScriptObject_methods, enumerable: false, writable: true, configurable: true}); + return B.UnknownJavaScriptObject_methods; + } + return B.UnknownJavaScriptObject_methods; + }, + JSArray_JSArray$fixed($length, $E) { + if ($length < 0 || $length > 4294967295) + throw A.wrapException(A.RangeError$range($length, 0, 4294967295, "length", null)); + return J.JSArray_JSArray$markFixed(new Array($length), $E); + }, + JSArray_JSArray$allocateFixed($length, $E) { + if ($length > 4294967295) + throw A.wrapException(A.RangeError$range($length, 0, 4294967295, "length", null)); + return J.JSArray_JSArray$markFixed(new Array($length), $E); + }, + JSArray_JSArray$growable($length, $E) { + if ($length < 0) + throw A.wrapException(A.ArgumentError$("Length must be a non-negative integer: " + $length, null)); + return A._setArrayType(new Array($length), $E._eval$1("JSArray<0>")); + }, + JSArray_JSArray$allocateGrowable($length, $E) { + if ($length < 0) + throw A.wrapException(A.ArgumentError$("Length must be a non-negative integer: " + $length, null)); + return A._setArrayType(new Array($length), $E._eval$1("JSArray<0>")); + }, + JSArray_JSArray$markFixed(allocation, $E) { + var t1 = A._setArrayType(allocation, $E._eval$1("JSArray<0>")); + t1.$flags = 1; + return t1; + }, + JSArray__compareAny(a, b) { + return J.compareTo$1$ns(a, b); + }, + JSString__isWhitespace(codeUnit) { + if (codeUnit < 256) + switch (codeUnit) { + case 9: + case 10: + case 11: + case 12: + case 13: + case 32: + case 133: + case 160: + return true; + default: + return false; + } + switch (codeUnit) { + case 5760: + case 8192: + case 8193: + case 8194: + case 8195: + case 8196: + case 8197: + case 8198: + case 8199: + case 8200: + case 8201: + case 8202: + case 8232: + case 8233: + case 8239: + case 8287: + case 12288: + case 65279: + return true; + default: + return false; + } + }, + JSString__skipLeadingWhitespace(string, index) { + var t1, codeUnit; + for (t1 = string.length; index < t1;) { + codeUnit = string.charCodeAt(index); + if (codeUnit !== 32 && codeUnit !== 13 && !J.JSString__isWhitespace(codeUnit)) + break; + ++index; + } + return index; + }, + JSString__skipTrailingWhitespace(string, index) { + var index0, codeUnit; + for (; index > 0; index = index0) { + index0 = index - 1; + codeUnit = string.charCodeAt(index0); + if (codeUnit !== 32 && codeUnit !== 13 && !J.JSString__isWhitespace(codeUnit)) + break; + } + return index; + }, + getInterceptor$(receiver) { + if (typeof receiver == "number") { + if (Math.floor(receiver) == receiver) + return J.JSInt.prototype; + return J.JSNumNotInt.prototype; + } + if (typeof receiver == "string") + return J.JSString.prototype; + if (receiver == null) + return J.JSNull.prototype; + if (typeof receiver == "boolean") + return J.JSBool.prototype; + if (Array.isArray(receiver)) + return J.JSArray.prototype; + if (typeof receiver != "object") { + if (typeof receiver == "function") + return J.JavaScriptFunction.prototype; + if (typeof receiver == "symbol") + return J.JavaScriptSymbol.prototype; + if (typeof receiver == "bigint") + return J.JavaScriptBigInt.prototype; + return receiver; + } + if (receiver instanceof A.Object) + return receiver; + return J.getNativeInterceptor(receiver); + }, + getInterceptor$ansx(receiver) { + if (typeof receiver == "number") + return J.JSNumber.prototype; + if (typeof receiver == "string") + return J.JSString.prototype; + if (receiver == null) + return receiver; + if (Array.isArray(receiver)) + return J.JSArray.prototype; + if (typeof receiver != "object") { + if (typeof receiver == "function") + return J.JavaScriptFunction.prototype; + if (typeof receiver == "symbol") + return J.JavaScriptSymbol.prototype; + if (typeof receiver == "bigint") + return J.JavaScriptBigInt.prototype; + return receiver; + } + if (receiver instanceof A.Object) + return receiver; + return J.getNativeInterceptor(receiver); + }, + getInterceptor$asx(receiver) { + if (typeof receiver == "string") + return J.JSString.prototype; + if (receiver == null) + return receiver; + if (Array.isArray(receiver)) + return J.JSArray.prototype; + if (typeof receiver != "object") { + if (typeof receiver == "function") + return J.JavaScriptFunction.prototype; + if (typeof receiver == "symbol") + return J.JavaScriptSymbol.prototype; + if (typeof receiver == "bigint") + return J.JavaScriptBigInt.prototype; + return receiver; + } + if (receiver instanceof A.Object) + return receiver; + return J.getNativeInterceptor(receiver); + }, + getInterceptor$ax(receiver) { + if (receiver == null) + return receiver; + if (Array.isArray(receiver)) + return J.JSArray.prototype; + if (typeof receiver != "object") { + if (typeof receiver == "function") + return J.JavaScriptFunction.prototype; + if (typeof receiver == "symbol") + return J.JavaScriptSymbol.prototype; + if (typeof receiver == "bigint") + return J.JavaScriptBigInt.prototype; + return receiver; + } + if (receiver instanceof A.Object) + return receiver; + return J.getNativeInterceptor(receiver); + }, + getInterceptor$in(receiver) { + if (typeof receiver == "number") { + if (Math.floor(receiver) == receiver) + return J.JSInt.prototype; + return J.JSNumNotInt.prototype; + } + if (receiver == null) + return receiver; + if (!(receiver instanceof A.Object)) + return J.UnknownJavaScriptObject.prototype; + return receiver; + }, + getInterceptor$ns(receiver) { + if (typeof receiver == "number") + return J.JSNumber.prototype; + if (typeof receiver == "string") + return J.JSString.prototype; + if (receiver == null) + return receiver; + if (!(receiver instanceof A.Object)) + return J.UnknownJavaScriptObject.prototype; + return receiver; + }, + getInterceptor$s(receiver) { + if (typeof receiver == "string") + return J.JSString.prototype; + if (receiver == null) + return receiver; + if (!(receiver instanceof A.Object)) + return J.UnknownJavaScriptObject.prototype; + return receiver; + }, + getInterceptor$x(receiver) { + if (receiver == null) + return receiver; + if (typeof receiver != "object") { + if (typeof receiver == "function") + return J.JavaScriptFunction.prototype; + if (typeof receiver == "symbol") + return J.JavaScriptSymbol.prototype; + if (typeof receiver == "bigint") + return J.JavaScriptBigInt.prototype; + return receiver; + } + if (receiver instanceof A.Object) + return receiver; + return J.getNativeInterceptor(receiver); + }, + getInterceptor$z(receiver) { + if (receiver == null) + return receiver; + if (!(receiver instanceof A.Object)) + return J.UnknownJavaScriptObject.prototype; + return receiver; + }, + set$AsyncCompiler$x(receiver, value) { + return J.getInterceptor$x(receiver).set$AsyncCompiler(receiver, value); + }, + set$CalculationInterpolation$x(receiver, value) { + return J.getInterceptor$x(receiver).set$CalculationInterpolation(receiver, value); + }, + set$CalculationOperation$x(receiver, value) { + return J.getInterceptor$x(receiver).set$CalculationOperation(receiver, value); + }, + set$Compiler$x(receiver, value) { + return J.getInterceptor$x(receiver).set$Compiler(receiver, value); + }, + set$Exception$x(receiver, value) { + return J.getInterceptor$x(receiver).set$Exception(receiver, value); + }, + set$FALSE$x(receiver, value) { + return J.getInterceptor$x(receiver).set$FALSE(receiver, value); + }, + set$Logger$x(receiver, value) { + return J.getInterceptor$x(receiver).set$Logger(receiver, value); + }, + set$NULL$x(receiver, value) { + return J.getInterceptor$x(receiver).set$NULL(receiver, value); + }, + set$NodePackageImporter$x(receiver, value) { + return J.getInterceptor$x(receiver).set$NodePackageImporter(receiver, value); + }, + set$SassArgumentList$x(receiver, value) { + return J.getInterceptor$x(receiver).set$SassArgumentList(receiver, value); + }, + set$SassBoolean$x(receiver, value) { + return J.getInterceptor$x(receiver).set$SassBoolean(receiver, value); + }, + set$SassCalculation$x(receiver, value) { + return J.getInterceptor$x(receiver).set$SassCalculation(receiver, value); + }, + set$SassColor$x(receiver, value) { + return J.getInterceptor$x(receiver).set$SassColor(receiver, value); + }, + set$SassFunction$x(receiver, value) { + return J.getInterceptor$x(receiver).set$SassFunction(receiver, value); + }, + set$SassList$x(receiver, value) { + return J.getInterceptor$x(receiver).set$SassList(receiver, value); + }, + set$SassMap$x(receiver, value) { + return J.getInterceptor$x(receiver).set$SassMap(receiver, value); + }, + set$SassMixin$x(receiver, value) { + return J.getInterceptor$x(receiver).set$SassMixin(receiver, value); + }, + set$SassNumber$x(receiver, value) { + return J.getInterceptor$x(receiver).set$SassNumber(receiver, value); + }, + set$SassString$x(receiver, value) { + return J.getInterceptor$x(receiver).set$SassString(receiver, value); + }, + set$TRUE$x(receiver, value) { + return J.getInterceptor$x(receiver).set$TRUE(receiver, value); + }, + set$Value$x(receiver, value) { + return J.getInterceptor$x(receiver).set$Value(receiver, value); + }, + set$Version$x(receiver, value) { + return J.getInterceptor$x(receiver).set$Version(receiver, value); + }, + set$cli_pkg_main_0_$x(receiver, value) { + return J.getInterceptor$x(receiver).set$cli_pkg_main_0_(receiver, value); + }, + set$compile$x(receiver, value) { + return J.getInterceptor$x(receiver).set$compile(receiver, value); + }, + set$compileAsync$x(receiver, value) { + return J.getInterceptor$x(receiver).set$compileAsync(receiver, value); + }, + set$compileString$x(receiver, value) { + return J.getInterceptor$x(receiver).set$compileString(receiver, value); + }, + set$compileStringAsync$x(receiver, value) { + return J.getInterceptor$x(receiver).set$compileStringAsync(receiver, value); + }, + set$context$x(receiver, value) { + return J.getInterceptor$x(receiver).set$context(receiver, value); + }, + set$dartValue$x(receiver, value) { + return J.getInterceptor$x(receiver).set$dartValue(receiver, value); + }, + set$deprecations$x(receiver, value) { + return J.getInterceptor$x(receiver).set$deprecations(receiver, value); + }, + set$exitCode$x(receiver, value) { + return J.getInterceptor$x(receiver).set$exitCode(receiver, value); + }, + set$info$x(receiver, value) { + return J.getInterceptor$x(receiver).set$info(receiver, value); + }, + set$initAsyncCompiler$x(receiver, value) { + return J.getInterceptor$x(receiver).set$initAsyncCompiler(receiver, value); + }, + set$initCompiler$x(receiver, value) { + return J.getInterceptor$x(receiver).set$initCompiler(receiver, value); + }, + set$length$asx(receiver, value) { + return J.getInterceptor$asx(receiver).set$length(receiver, value); + }, + set$loadParserExports_$x(receiver, value) { + return J.getInterceptor$x(receiver).set$loadParserExports_(receiver, value); + }, + set$render$x(receiver, value) { + return J.getInterceptor$x(receiver).set$render(receiver, value); + }, + set$renderSync$x(receiver, value) { + return J.getInterceptor$x(receiver).set$renderSync(receiver, value); + }, + set$sassFalse$x(receiver, value) { + return J.getInterceptor$x(receiver).set$sassFalse(receiver, value); + }, + set$sassNull$x(receiver, value) { + return J.getInterceptor$x(receiver).set$sassNull(receiver, value); + }, + set$sassTrue$x(receiver, value) { + return J.getInterceptor$x(receiver).set$sassTrue(receiver, value); + }, + set$types$x(receiver, value) { + return J.getInterceptor$x(receiver).set$types(receiver, value); + }, + get$$prototype$x(receiver) { + return J.getInterceptor$x(receiver).get$$prototype(receiver); + }, + get$_dartException$x(receiver) { + return J.getInterceptor$x(receiver).get$_dartException(receiver); + }, + get$alertAscii$x(receiver) { + return J.getInterceptor$x(receiver).get$alertAscii(receiver); + }, + get$alertColor$x(receiver) { + return J.getInterceptor$x(receiver).get$alertColor(receiver); + }, + get$argv$x(receiver) { + return J.getInterceptor$x(receiver).get$argv(receiver); + }, + get$brackets$x(receiver) { + return J.getInterceptor$x(receiver).get$brackets(receiver); + }, + get$charset$x(receiver) { + return J.getInterceptor$x(receiver).get$charset(receiver); + }, + get$code$x(receiver) { + return J.getInterceptor$x(receiver).get$code(receiver); + }, + get$current$x(receiver) { + return J.getInterceptor$x(receiver).get$current(receiver); + }, + get$dartValue$x(receiver) { + return J.getInterceptor$x(receiver).get$dartValue(receiver); + }, + get$debug$x(receiver) { + return J.getInterceptor$x(receiver).get$debug(receiver); + }, + get$denominatorUnits$x(receiver) { + return J.getInterceptor$x(receiver).get$denominatorUnits(receiver); + }, + get$end$z(receiver) { + return J.getInterceptor$z(receiver).get$end(receiver); + }, + get$env$x(receiver) { + return J.getInterceptor$x(receiver).get$env(receiver); + }, + get$exitCode$x(receiver) { + return J.getInterceptor$x(receiver).get$exitCode(receiver); + }, + get$fatalDeprecations$x(receiver) { + return J.getInterceptor$x(receiver).get$fatalDeprecations(receiver); + }, + get$fiber$x(receiver) { + return J.getInterceptor$x(receiver).get$fiber(receiver); + }, + get$file$x(receiver) { + return J.getInterceptor$x(receiver).get$file(receiver); + }, + get$filename$x(receiver) { + return J.getInterceptor$x(receiver).get$filename(receiver); + }, + get$first$ax(receiver) { + return J.getInterceptor$ax(receiver).get$first(receiver); + }, + get$functions$x(receiver) { + return J.getInterceptor$x(receiver).get$functions(receiver); + }, + get$futureDeprecations$x(receiver) { + return J.getInterceptor$x(receiver).get$futureDeprecations(receiver); + }, + get$hashCode$(receiver) { + return J.getInterceptor$(receiver).get$hashCode(receiver); + }, + get$id$x(receiver) { + return J.getInterceptor$x(receiver).get$id(receiver); + }, + get$importer$x(receiver) { + return J.getInterceptor$x(receiver).get$importer(receiver); + }, + get$importers$x(receiver) { + return J.getInterceptor$x(receiver).get$importers(receiver); + }, + get$isEmpty$asx(receiver) { + return J.getInterceptor$asx(receiver).get$isEmpty(receiver); + }, + get$isNotEmpty$asx(receiver) { + return J.getInterceptor$asx(receiver).get$isNotEmpty(receiver); + }, + get$isTTY$x(receiver) { + return J.getInterceptor$x(receiver).get$isTTY(receiver); + }, + get$iterator$ax(receiver) { + return J.getInterceptor$ax(receiver).get$iterator(receiver); + }, + get$keys$z(receiver) { + return J.getInterceptor$z(receiver).get$keys(receiver); + }, + get$last$ax(receiver) { + return J.getInterceptor$ax(receiver).get$last(receiver); + }, + get$length$asx(receiver) { + return J.getInterceptor$asx(receiver).get$length(receiver); + }, + get$loadPaths$x(receiver) { + return J.getInterceptor$x(receiver).get$loadPaths(receiver); + }, + get$logger$x(receiver) { + return J.getInterceptor$x(receiver).get$logger(receiver); + }, + get$message$x(receiver) { + return J.getInterceptor$x(receiver).get$message(receiver); + }, + get$method$x(receiver) { + return J.getInterceptor$x(receiver).get$method(receiver); + }, + get$mtime$x(receiver) { + return J.getInterceptor$x(receiver).get$mtime(receiver); + }, + get$name$x(receiver) { + return J.getInterceptor$x(receiver).get$name(receiver); + }, + get$numeratorUnits$x(receiver) { + return J.getInterceptor$x(receiver).get$numeratorUnits(receiver); + }, + get$options$x(receiver) { + return J.getInterceptor$x(receiver).get$options(receiver); + }, + get$parent$z(receiver) { + return J.getInterceptor$z(receiver).get$parent(receiver); + }, + get$path$x(receiver) { + return J.getInterceptor$x(receiver).get$path(receiver); + }, + get$platform$x(receiver) { + return J.getInterceptor$x(receiver).get$platform(receiver); + }, + get$quietDeps$x(receiver) { + return J.getInterceptor$x(receiver).get$quietDeps(receiver); + }, + get$quotes$x(receiver) { + return J.getInterceptor$x(receiver).get$quotes(receiver); + }, + get$realpathSync$x(receiver) { + return J.getInterceptor$x(receiver).get$realpathSync(receiver); + }, + get$release$x(receiver) { + return J.getInterceptor$x(receiver).get$release(receiver); + }, + get$reversed$ax(receiver) { + return J.getInterceptor$ax(receiver).get$reversed(receiver); + }, + get$runtimeType$(receiver) { + return J.getInterceptor$(receiver).get$runtimeType(receiver); + }, + get$separator$x(receiver) { + return J.getInterceptor$x(receiver).get$separator(receiver); + }, + get$sign$in(receiver) { + if (typeof receiver === "number") + return receiver > 0 ? 1 : receiver < 0 ? -1 : receiver; + return J.getInterceptor$in(receiver).get$sign(receiver); + }, + get$silenceDeprecations$x(receiver) { + return J.getInterceptor$x(receiver).get$silenceDeprecations(receiver); + }, + get$single$ax(receiver) { + return J.getInterceptor$ax(receiver).get$single(receiver); + }, + get$sourceMap$x(receiver) { + return J.getInterceptor$x(receiver).get$sourceMap(receiver); + }, + get$sourceMapIncludeSources$x(receiver) { + return J.getInterceptor$x(receiver).get$sourceMapIncludeSources(receiver); + }, + get$space$x(receiver) { + return J.getInterceptor$x(receiver).get$space(receiver); + }, + get$span$z(receiver) { + return J.getInterceptor$z(receiver).get$span(receiver); + }, + get$stderr$x(receiver) { + return J.getInterceptor$x(receiver).get$stderr(receiver); + }, + get$stdout$x(receiver) { + return J.getInterceptor$x(receiver).get$stdout(receiver); + }, + get$style$x(receiver) { + return J.getInterceptor$x(receiver).get$style(receiver); + }, + get$syntax$x(receiver) { + return J.getInterceptor$x(receiver).get$syntax(receiver); + }, + get$trace$z(receiver) { + return J.getInterceptor$z(receiver).get$trace(receiver); + }, + get$url$x(receiver) { + return J.getInterceptor$x(receiver).get$url(receiver); + }, + get$verbose$x(receiver) { + return J.getInterceptor$x(receiver).get$verbose(receiver); + }, + get$warn$x(receiver) { + return J.getInterceptor$x(receiver).get$warn(receiver); + }, + get$weight$x(receiver) { + return J.getInterceptor$x(receiver).get$weight(receiver); + }, + $add$ansx(receiver, a0) { + if (typeof receiver == "number" && typeof a0 == "number") + return receiver + a0; + return J.getInterceptor$ansx(receiver).$add(receiver, a0); + }, + $eq$(receiver, a0) { + if (receiver == null) + return a0 == null; + if (typeof receiver != "object") + return a0 != null && receiver === a0; + return J.getInterceptor$(receiver).$eq(receiver, a0); + }, + $index$asx(receiver, a0) { + if (typeof a0 === "number") + if (Array.isArray(receiver) || typeof receiver == "string" || A.isJsIndexable(receiver, receiver[init.dispatchPropertyName])) + if (a0 >>> 0 === a0 && a0 < receiver.length) + return receiver[a0]; + return J.getInterceptor$asx(receiver).$index(receiver, a0); + }, + $indexSet$ax(receiver, a0, a1) { + if (typeof a0 === "number") + if ((Array.isArray(receiver) || A.isJsIndexable(receiver, receiver[init.dispatchPropertyName])) && !(receiver.$flags & 2) && a0 >>> 0 === a0 && a0 < receiver.length) + return receiver[a0] = a1; + return J.getInterceptor$ax(receiver).$indexSet(receiver, a0, a1); + }, + $set$2$x(receiver, a0, a1) { + return J.getInterceptor$x(receiver).$set$2(receiver, a0, a1); + }, + add$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).add$1(receiver, a0); + }, + addAll$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).addAll$1(receiver, a0); + }, + allMatches$1$s(receiver, a0) { + return J.getInterceptor$s(receiver).allMatches$1(receiver, a0); + }, + allMatches$2$s(receiver, a0, a1) { + return J.getInterceptor$s(receiver).allMatches$2(receiver, a0, a1); + }, + any$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).any$1(receiver, a0); + }, + apply$2$x(receiver, a0, a1) { + return J.getInterceptor$x(receiver).apply$2(receiver, a0, a1); + }, + asImmutable$0$x(receiver) { + return J.getInterceptor$x(receiver).asImmutable$0(receiver); + }, + asMutable$0$x(receiver) { + return J.getInterceptor$x(receiver).asMutable$0(receiver); + }, + canonicalize$4$baseImporter$baseUrl$forImport$x(receiver, a0, a1, a2, a3) { + return J.getInterceptor$x(receiver).canonicalize$4$baseImporter$baseUrl$forImport(receiver, a0, a1, a2, a3); + }, + cast$1$0$ax(receiver, $T1) { + return J.getInterceptor$ax(receiver).cast$1$0(receiver, $T1); + }, + close$0$x(receiver) { + return J.getInterceptor$x(receiver).close$0(receiver); + }, + codeUnitAt$1$s(receiver, a0) { + return J.getInterceptor$s(receiver).codeUnitAt$1(receiver, a0); + }, + compareTo$1$ns(receiver, a0) { + return J.getInterceptor$ns(receiver).compareTo$1(receiver, a0); + }, + contains$1$asx(receiver, a0) { + return J.getInterceptor$asx(receiver).contains$1(receiver, a0); + }, + createInterface$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).createInterface$1(receiver, a0); + }, + createRequire$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).createRequire$1(receiver, a0); + }, + elementAt$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).elementAt$1(receiver, a0); + }, + endsWith$1$s(receiver, a0) { + return J.getInterceptor$s(receiver).endsWith$1(receiver, a0); + }, + error$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).error$1(receiver, a0); + }, + every$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).every$1(receiver, a0); + }, + existsSync$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).existsSync$1(receiver, a0); + }, + expand$1$1$ax(receiver, a0, $T1) { + return J.getInterceptor$ax(receiver).expand$1$1(receiver, a0, $T1); + }, + fillRange$3$ax(receiver, a0, a1, a2) { + return J.getInterceptor$ax(receiver).fillRange$3(receiver, a0, a1, a2); + }, + fold$2$ax(receiver, a0, a1) { + return J.getInterceptor$ax(receiver).fold$2(receiver, a0, a1); + }, + forEach$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).forEach$1(receiver, a0); + }, + getRange$2$ax(receiver, a0, a1) { + return J.getInterceptor$ax(receiver).getRange$2(receiver, a0, a1); + }, + getTime$0$x(receiver) { + return J.getInterceptor$x(receiver).getTime$0(receiver); + }, + isDirectory$0$x(receiver) { + return J.getInterceptor$x(receiver).isDirectory$0(receiver); + }, + isFile$0$x(receiver) { + return J.getInterceptor$x(receiver).isFile$0(receiver); + }, + isSymbolicLink$0$x(receiver) { + return J.getInterceptor$x(receiver).isSymbolicLink$0(receiver); + }, + join$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).join$1(receiver, a0); + }, + listen$1$z(receiver, a0) { + return J.getInterceptor$z(receiver).listen$1(receiver, a0); + }, + log$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).log$1(receiver, a0); + }, + lstatSync$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).lstatSync$1(receiver, a0); + }, + map$1$1$ax(receiver, a0, $T1) { + return J.getInterceptor$ax(receiver).map$1$1(receiver, a0, $T1); + }, + matchAsPrefix$2$s(receiver, a0, a1) { + return J.getInterceptor$s(receiver).matchAsPrefix$2(receiver, a0, a1); + }, + mkdirSync$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).mkdirSync$1(receiver, a0); + }, + native$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).native$1(receiver, a0); + }, + noSuchMethod$1$(receiver, a0) { + return J.getInterceptor$(receiver).noSuchMethod$1(receiver, a0); + }, + on$2$x(receiver, a0, a1) { + return J.getInterceptor$x(receiver).on$2(receiver, a0, a1); + }, + parse$0$z(receiver) { + return J.getInterceptor$z(receiver).parse$0(receiver); + }, + readFileSync$2$x(receiver, a0, a1) { + return J.getInterceptor$x(receiver).readFileSync$2(receiver, a0, a1); + }, + readdirSync$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).readdirSync$1(receiver, a0); + }, + remove$1$z(receiver, a0) { + return J.getInterceptor$z(receiver).remove$1(receiver, a0); + }, + removeRange$2$ax(receiver, a0, a1) { + return J.getInterceptor$ax(receiver).removeRange$2(receiver, a0, a1); + }, + replaceFirst$2$s(receiver, a0, a1) { + return J.getInterceptor$s(receiver).replaceFirst$2(receiver, a0, a1); + }, + resolve$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).resolve$1(receiver, a0); + }, + run$0$x(receiver) { + return J.getInterceptor$x(receiver).run$0(receiver); + }, + run$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).run$1(receiver, a0); + }, + setRange$4$ax(receiver, a0, a1, a2, a3) { + return J.getInterceptor$ax(receiver).setRange$4(receiver, a0, a1, a2, a3); + }, + skip$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).skip$1(receiver, a0); + }, + sort$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).sort$1(receiver, a0); + }, + startsWith$1$s(receiver, a0) { + return J.getInterceptor$s(receiver).startsWith$1(receiver, a0); + }, + statSync$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).statSync$1(receiver, a0); + }, + sublist$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).sublist$1(receiver, a0); + }, + substring$1$s(receiver, a0) { + return J.getInterceptor$s(receiver).substring$1(receiver, a0); + }, + substring$2$s(receiver, a0, a1) { + return J.getInterceptor$s(receiver).substring$2(receiver, a0, a1); + }, + take$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).take$1(receiver, a0); + }, + then$1$2$onError$x(receiver, a0, a1, $T1) { + return J.getInterceptor$x(receiver).then$1$2$onError(receiver, a0, a1, $T1); + }, + then$2$x(receiver, a0, a1) { + return J.getInterceptor$x(receiver).then$2(receiver, a0, a1); + }, + toArray$0$x(receiver) { + return J.getInterceptor$x(receiver).toArray$0(receiver); + }, + toList$0$ax(receiver) { + return J.getInterceptor$ax(receiver).toList$0(receiver); + }, + toList$1$growable$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).toList$1$growable(receiver, a0); + }, + toSet$0$ax(receiver) { + return J.getInterceptor$ax(receiver).toSet$0(receiver); + }, + toString$0$(receiver) { + return J.getInterceptor$(receiver).toString$0(receiver); + }, + toString$1$color$(receiver, a0) { + return J.getInterceptor$(receiver).toString$1$color(receiver, a0); + }, + trim$0$s(receiver) { + return J.getInterceptor$s(receiver).trim$0(receiver); + }, + unlinkSync$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).unlinkSync$1(receiver, a0); + }, + visitAtRootRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitAtRootRule$1(receiver, a0); + }, + visitAtRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitAtRule$1(receiver, a0); + }, + visitBinaryOperationExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitBinaryOperationExpression$1(receiver, a0); + }, + visitBooleanExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitBooleanExpression$1(receiver, a0); + }, + visitColorExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitColorExpression$1(receiver, a0); + }, + visitContentBlock$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitContentBlock$1(receiver, a0); + }, + visitContentRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitContentRule$1(receiver, a0); + }, + visitDebugRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitDebugRule$1(receiver, a0); + }, + visitDeclaration$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitDeclaration$1(receiver, a0); + }, + visitEachRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitEachRule$1(receiver, a0); + }, + visitErrorRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitErrorRule$1(receiver, a0); + }, + visitExtendRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitExtendRule$1(receiver, a0); + }, + visitForRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitForRule$1(receiver, a0); + }, + visitForwardRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitForwardRule$1(receiver, a0); + }, + visitFunctionExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitFunctionExpression$1(receiver, a0); + }, + visitFunctionRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitFunctionRule$1(receiver, a0); + }, + visitIfExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitIfExpression$1(receiver, a0); + }, + visitIfRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitIfRule$1(receiver, a0); + }, + visitImportRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitImportRule$1(receiver, a0); + }, + visitIncludeRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitIncludeRule$1(receiver, a0); + }, + visitInterpolatedFunctionExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitInterpolatedFunctionExpression$1(receiver, a0); + }, + visitListExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitListExpression$1(receiver, a0); + }, + visitLoudComment$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitLoudComment$1(receiver, a0); + }, + visitMapExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitMapExpression$1(receiver, a0); + }, + visitMediaRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitMediaRule$1(receiver, a0); + }, + visitMixinRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitMixinRule$1(receiver, a0); + }, + visitNullExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitNullExpression$1(receiver, a0); + }, + visitNumberExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitNumberExpression$1(receiver, a0); + }, + visitParenthesizedExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitParenthesizedExpression$1(receiver, a0); + }, + visitReturnRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitReturnRule$1(receiver, a0); + }, + visitSelectorExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitSelectorExpression$1(receiver, a0); + }, + visitSilentComment$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitSilentComment$1(receiver, a0); + }, + visitStringExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitStringExpression$1(receiver, a0); + }, + visitStyleRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitStyleRule$1(receiver, a0); + }, + visitStylesheet$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitStylesheet$1(receiver, a0); + }, + visitSupportsExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitSupportsExpression$1(receiver, a0); + }, + visitSupportsRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitSupportsRule$1(receiver, a0); + }, + visitUnaryOperationExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitUnaryOperationExpression$1(receiver, a0); + }, + visitUseRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitUseRule$1(receiver, a0); + }, + visitValueExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitValueExpression$1(receiver, a0); + }, + visitVariableDeclaration$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitVariableDeclaration$1(receiver, a0); + }, + visitVariableExpression$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitVariableExpression$1(receiver, a0); + }, + visitWarnRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitWarnRule$1(receiver, a0); + }, + visitWhileRule$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).visitWhileRule$1(receiver, a0); + }, + watch$2$x(receiver, a0, a1) { + return J.getInterceptor$x(receiver).watch$2(receiver, a0, a1); + }, + where$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).where$1(receiver, a0); + }, + write$1$x(receiver, a0) { + return J.getInterceptor$x(receiver).write$1(receiver, a0); + }, + writeFileSync$2$x(receiver, a0, a1) { + return J.getInterceptor$x(receiver).writeFileSync$2(receiver, a0, a1); + }, + yield$0$x(receiver) { + return J.getInterceptor$x(receiver).yield$0(receiver); + }, + Interceptor: function Interceptor() { + }, + JSBool: function JSBool() { + }, + JSNull: function JSNull() { + }, + JavaScriptObject: function JavaScriptObject() { + }, + LegacyJavaScriptObject: function LegacyJavaScriptObject() { + }, + PlainJavaScriptObject: function PlainJavaScriptObject() { + }, + UnknownJavaScriptObject: function UnknownJavaScriptObject() { + }, + JavaScriptFunction: function JavaScriptFunction() { + }, + JavaScriptBigInt: function JavaScriptBigInt() { + }, + JavaScriptSymbol: function JavaScriptSymbol() { + }, + JSArray: function JSArray(t0) { + this.$ti = t0; + }, + JSUnmodifiableArray: function JSUnmodifiableArray(t0) { + this.$ti = t0; + }, + ArrayIterator: function ArrayIterator(t0, t1, t2) { + var _ = this; + _._iterable = t0; + _._length = t1; + _._index = 0; + _._current = null; + _.$ti = t2; + }, + JSNumber: function JSNumber() { + }, + JSInt: function JSInt() { + }, + JSNumNotInt: function JSNumNotInt() { + }, + JSString: function JSString() { + } + }, + A = {JS_CONST: function JS_CONST() { + }, + CastIterable_CastIterable(source, $S, $T) { + if ($S._eval$1("EfficientLengthIterable<0>")._is(source)) + return new A._EfficientLengthCastIterable(source, $S._eval$1("@<0>")._bind$1($T)._eval$1("_EfficientLengthCastIterable<1,2>")); + return new A.CastIterable(source, $S._eval$1("@<0>")._bind$1($T)._eval$1("CastIterable<1,2>")); + }, + LateError$localNI(localName) { + return new A.LateError("Local '" + localName + "' has not been initialized."); + }, + hexDigitValue(char) { + var letter, + digit = char ^ 48; + if (digit <= 9) + return digit; + letter = char | 32; + if (97 <= letter && letter <= 102) + return letter - 87; + return -1; + }, + SystemHash_combine(hash, value) { + hash = hash + value & 536870911; + hash = hash + ((hash & 524287) << 10) & 536870911; + return hash ^ hash >>> 6; + }, + SystemHash_finish(hash) { + hash = hash + ((hash & 67108863) << 3) & 536870911; + hash ^= hash >>> 11; + return hash + ((hash & 16383) << 15) & 536870911; + }, + checkNotNullable(value, $name, $T) { + return value; + }, + isToStringVisiting(object) { + var t1, i; + for (t1 = $.toStringVisiting.length, i = 0; i < t1; ++i) + if (object === $.toStringVisiting[i]) + return true; + return false; + }, + SubListIterable$(_iterable, _start, _endOrLength, $E) { + A.RangeError_checkNotNegative(_start, "start"); + if (_endOrLength != null) { + A.RangeError_checkNotNegative(_endOrLength, "end"); + if (_start > _endOrLength) + A.throwExpression(A.RangeError$range(_start, 0, _endOrLength, "start", null)); + } + return new A.SubListIterable(_iterable, _start, _endOrLength, $E._eval$1("SubListIterable<0>")); + }, + MappedIterable_MappedIterable(iterable, $function, $S, $T) { + if (type$.EfficientLengthIterable_dynamic._is(iterable)) + return new A.EfficientLengthMappedIterable(iterable, $function, $S._eval$1("@<0>")._bind$1($T)._eval$1("EfficientLengthMappedIterable<1,2>")); + return new A.MappedIterable(iterable, $function, $S._eval$1("@<0>")._bind$1($T)._eval$1("MappedIterable<1,2>")); + }, + TakeIterable_TakeIterable(iterable, takeCount, $E) { + var _s9_ = "takeCount"; + A.ArgumentError_checkNotNull(takeCount, _s9_); + A.RangeError_checkNotNegative(takeCount, _s9_); + if (type$.EfficientLengthIterable_dynamic._is(iterable)) + return new A.EfficientLengthTakeIterable(iterable, takeCount, $E._eval$1("EfficientLengthTakeIterable<0>")); + return new A.TakeIterable(iterable, takeCount, $E._eval$1("TakeIterable<0>")); + }, + SkipIterable_SkipIterable(iterable, count, $E) { + var _s5_ = "count"; + if (type$.EfficientLengthIterable_dynamic._is(iterable)) { + A.ArgumentError_checkNotNull(count, _s5_); + A.RangeError_checkNotNegative(count, _s5_); + return new A.EfficientLengthSkipIterable(iterable, count, $E._eval$1("EfficientLengthSkipIterable<0>")); + } + A.ArgumentError_checkNotNull(count, _s5_); + A.RangeError_checkNotNegative(count, _s5_); + return new A.SkipIterable(iterable, count, $E._eval$1("SkipIterable<0>")); + }, + FollowedByIterable_FollowedByIterable$firstEfficient(first, second, $E) { + if ($E._eval$1("EfficientLengthIterable<0>")._is(second)) + return new A.EfficientLengthFollowedByIterable(first, second, $E._eval$1("EfficientLengthFollowedByIterable<0>")); + return new A.FollowedByIterable(first, second, $E._eval$1("FollowedByIterable<0>")); + }, + IterableElementError_noElement() { + return new A.StateError("No element"); + }, + IterableElementError_tooMany() { + return new A.StateError("Too many elements"); + }, + IterableElementError_tooFew() { + return new A.StateError("Too few elements"); + }, + Sort__doSort(a, left, right, compare) { + if (right - left <= 32) + A.Sort__insertionSort(a, left, right, compare); + else + A.Sort__dualPivotQuicksort(a, left, right, compare); + }, + Sort__insertionSort(a, left, right, compare) { + var i, t1, el, j, j0; + for (i = left + 1, t1 = J.getInterceptor$asx(a); i <= right; ++i) { + el = t1.$index(a, i); + j = i; + while (true) { + if (!(j > left && compare.call$2(t1.$index(a, j - 1), el) > 0)) + break; + j0 = j - 1; + t1.$indexSet(a, j, t1.$index(a, j0)); + j = j0; + } + t1.$indexSet(a, j, el); + } + }, + Sort__dualPivotQuicksort(a, left, right, compare) { + var t0, less, great, pivots_are_equal, k, ak, comp, great0, less0, t2, + sixth = B.JSInt_methods._tdivFast$1(right - left + 1, 6), + index1 = left + sixth, + index5 = right - sixth, + index3 = B.JSInt_methods._tdivFast$1(left + right, 2), + index2 = index3 - sixth, + index4 = index3 + sixth, + t1 = J.getInterceptor$asx(a), + el1 = t1.$index(a, index1), + el2 = t1.$index(a, index2), + el3 = t1.$index(a, index3), + el4 = t1.$index(a, index4), + el5 = t1.$index(a, index5); + if (compare.call$2(el1, el2) > 0) { + t0 = el2; + el2 = el1; + el1 = t0; + } + if (compare.call$2(el4, el5) > 0) { + t0 = el5; + el5 = el4; + el4 = t0; + } + if (compare.call$2(el1, el3) > 0) { + t0 = el3; + el3 = el1; + el1 = t0; + } + if (compare.call$2(el2, el3) > 0) { + t0 = el3; + el3 = el2; + el2 = t0; + } + if (compare.call$2(el1, el4) > 0) { + t0 = el4; + el4 = el1; + el1 = t0; + } + if (compare.call$2(el3, el4) > 0) { + t0 = el4; + el4 = el3; + el3 = t0; + } + if (compare.call$2(el2, el5) > 0) { + t0 = el5; + el5 = el2; + el2 = t0; + } + if (compare.call$2(el2, el3) > 0) { + t0 = el3; + el3 = el2; + el2 = t0; + } + if (compare.call$2(el4, el5) > 0) { + t0 = el5; + el5 = el4; + el4 = t0; + } + t1.$indexSet(a, index1, el1); + t1.$indexSet(a, index3, el3); + t1.$indexSet(a, index5, el5); + t1.$indexSet(a, index2, t1.$index(a, left)); + t1.$indexSet(a, index4, t1.$index(a, right)); + less = left + 1; + great = right - 1; + pivots_are_equal = J.$eq$(compare.call$2(el2, el4), 0); + if (pivots_are_equal) + for (k = less; k <= great; ++k) { + ak = t1.$index(a, k); + comp = compare.call$2(ak, el2); + if (comp === 0) + continue; + if (comp < 0) { + if (k !== less) { + t1.$indexSet(a, k, t1.$index(a, less)); + t1.$indexSet(a, less, ak); + } + ++less; + } else + for (; true;) { + comp = compare.call$2(t1.$index(a, great), el2); + if (comp > 0) { + --great; + continue; + } else { + great0 = great - 1; + if (comp < 0) { + t1.$indexSet(a, k, t1.$index(a, less)); + less0 = less + 1; + t1.$indexSet(a, less, t1.$index(a, great)); + t1.$indexSet(a, great, ak); + great = great0; + less = less0; + break; + } else { + t1.$indexSet(a, k, t1.$index(a, great)); + t1.$indexSet(a, great, ak); + great = great0; + break; + } + } + } + } + else + for (k = less; k <= great; ++k) { + ak = t1.$index(a, k); + if (compare.call$2(ak, el2) < 0) { + if (k !== less) { + t1.$indexSet(a, k, t1.$index(a, less)); + t1.$indexSet(a, less, ak); + } + ++less; + } else if (compare.call$2(ak, el4) > 0) + for (; true;) + if (compare.call$2(t1.$index(a, great), el4) > 0) { + --great; + if (great < k) + break; + continue; + } else { + great0 = great - 1; + if (compare.call$2(t1.$index(a, great), el2) < 0) { + t1.$indexSet(a, k, t1.$index(a, less)); + less0 = less + 1; + t1.$indexSet(a, less, t1.$index(a, great)); + t1.$indexSet(a, great, ak); + less = less0; + } else { + t1.$indexSet(a, k, t1.$index(a, great)); + t1.$indexSet(a, great, ak); + } + great = great0; + break; + } + } + t2 = less - 1; + t1.$indexSet(a, left, t1.$index(a, t2)); + t1.$indexSet(a, t2, el2); + t2 = great + 1; + t1.$indexSet(a, right, t1.$index(a, t2)); + t1.$indexSet(a, t2, el4); + A.Sort__doSort(a, left, less - 2, compare); + A.Sort__doSort(a, great + 2, right, compare); + if (pivots_are_equal) + return; + if (less < index1 && great > index5) { + for (; J.$eq$(compare.call$2(t1.$index(a, less), el2), 0);) + ++less; + for (; J.$eq$(compare.call$2(t1.$index(a, great), el4), 0);) + --great; + for (k = less; k <= great; ++k) { + ak = t1.$index(a, k); + if (compare.call$2(ak, el2) === 0) { + if (k !== less) { + t1.$indexSet(a, k, t1.$index(a, less)); + t1.$indexSet(a, less, ak); + } + ++less; + } else if (compare.call$2(ak, el4) === 0) + for (; true;) + if (compare.call$2(t1.$index(a, great), el4) === 0) { + --great; + if (great < k) + break; + continue; + } else { + great0 = great - 1; + if (compare.call$2(t1.$index(a, great), el2) < 0) { + t1.$indexSet(a, k, t1.$index(a, less)); + less0 = less + 1; + t1.$indexSet(a, less, t1.$index(a, great)); + t1.$indexSet(a, great, ak); + less = less0; + } else { + t1.$indexSet(a, k, t1.$index(a, great)); + t1.$indexSet(a, great, ak); + } + great = great0; + break; + } + } + A.Sort__doSort(a, less, great, compare); + } else + A.Sort__doSort(a, less, great, compare); + }, + _CastIterableBase: function _CastIterableBase() { + }, + CastIterator: function CastIterator(t0, t1) { + this._source = t0; + this.$ti = t1; + }, + CastIterable: function CastIterable(t0, t1) { + this._source = t0; + this.$ti = t1; + }, + _EfficientLengthCastIterable: function _EfficientLengthCastIterable(t0, t1) { + this._source = t0; + this.$ti = t1; + }, + _CastListBase: function _CastListBase() { + }, + _CastListBase_sort_closure: function _CastListBase_sort_closure(t0, t1) { + this.$this = t0; + this.compare = t1; + }, + CastList: function CastList(t0, t1) { + this._source = t0; + this.$ti = t1; + }, + CastSet: function CastSet(t0, t1, t2) { + this._source = t0; + this._emptySet = t1; + this.$ti = t2; + }, + CastMap: function CastMap(t0, t1) { + this._source = t0; + this.$ti = t1; + }, + CastMap_forEach_closure: function CastMap_forEach_closure(t0, t1) { + this.$this = t0; + this.f = t1; + }, + CastMap_entries_closure: function CastMap_entries_closure(t0) { + this.$this = t0; + }, + LateError: function LateError(t0) { + this._message = t0; + }, + CodeUnits: function CodeUnits(t0) { + this._string = t0; + }, + nullFuture_closure: function nullFuture_closure() { + }, + SentinelValue: function SentinelValue() { + }, + EfficientLengthIterable: function EfficientLengthIterable() { + }, + ListIterable: function ListIterable() { + }, + SubListIterable: function SubListIterable(t0, t1, t2, t3) { + var _ = this; + _.__internal$_iterable = t0; + _._start = t1; + _._endOrLength = t2; + _.$ti = t3; + }, + ListIterator: function ListIterator(t0, t1, t2) { + var _ = this; + _.__internal$_iterable = t0; + _.__internal$_length = t1; + _.__internal$_index = 0; + _.__internal$_current = null; + _.$ti = t2; + }, + MappedIterable: function MappedIterable(t0, t1, t2) { + this.__internal$_iterable = t0; + this._f = t1; + this.$ti = t2; + }, + EfficientLengthMappedIterable: function EfficientLengthMappedIterable(t0, t1, t2) { + this.__internal$_iterable = t0; + this._f = t1; + this.$ti = t2; + }, + MappedIterator: function MappedIterator(t0, t1, t2) { + var _ = this; + _.__internal$_current = null; + _._iterator = t0; + _._f = t1; + _.$ti = t2; + }, + MappedListIterable: function MappedListIterable(t0, t1, t2) { + this._source = t0; + this._f = t1; + this.$ti = t2; + }, + WhereIterable: function WhereIterable(t0, t1, t2) { + this.__internal$_iterable = t0; + this._f = t1; + this.$ti = t2; + }, + WhereIterator: function WhereIterator(t0, t1) { + this._iterator = t0; + this._f = t1; + }, + ExpandIterable: function ExpandIterable(t0, t1, t2) { + this.__internal$_iterable = t0; + this._f = t1; + this.$ti = t2; + }, + ExpandIterator: function ExpandIterator(t0, t1, t2, t3) { + var _ = this; + _._iterator = t0; + _._f = t1; + _._currentExpansion = t2; + _.__internal$_current = null; + _.$ti = t3; + }, + TakeIterable: function TakeIterable(t0, t1, t2) { + this.__internal$_iterable = t0; + this._takeCount = t1; + this.$ti = t2; + }, + EfficientLengthTakeIterable: function EfficientLengthTakeIterable(t0, t1, t2) { + this.__internal$_iterable = t0; + this._takeCount = t1; + this.$ti = t2; + }, + TakeIterator: function TakeIterator(t0, t1, t2) { + this._iterator = t0; + this._remaining = t1; + this.$ti = t2; + }, + SkipIterable: function SkipIterable(t0, t1, t2) { + this.__internal$_iterable = t0; + this._skipCount = t1; + this.$ti = t2; + }, + EfficientLengthSkipIterable: function EfficientLengthSkipIterable(t0, t1, t2) { + this.__internal$_iterable = t0; + this._skipCount = t1; + this.$ti = t2; + }, + SkipIterator: function SkipIterator(t0, t1) { + this._iterator = t0; + this._skipCount = t1; + }, + SkipWhileIterable: function SkipWhileIterable(t0, t1, t2) { + this.__internal$_iterable = t0; + this._f = t1; + this.$ti = t2; + }, + SkipWhileIterator: function SkipWhileIterator(t0, t1) { + this._iterator = t0; + this._f = t1; + this._hasSkipped = false; + }, + EmptyIterable: function EmptyIterable(t0) { + this.$ti = t0; + }, + EmptyIterator: function EmptyIterator() { + }, + FollowedByIterable: function FollowedByIterable(t0, t1, t2) { + this.__internal$_first = t0; + this._second = t1; + this.$ti = t2; + }, + EfficientLengthFollowedByIterable: function EfficientLengthFollowedByIterable(t0, t1, t2) { + this.__internal$_first = t0; + this._second = t1; + this.$ti = t2; + }, + FollowedByIterator: function FollowedByIterator(t0, t1) { + this._currentIterator = t0; + this._nextIterable = t1; + }, + WhereTypeIterable: function WhereTypeIterable(t0, t1) { + this._source = t0; + this.$ti = t1; + }, + WhereTypeIterator: function WhereTypeIterator(t0, t1) { + this._source = t0; + this.$ti = t1; + }, + NonNullsIterable: function NonNullsIterable(t0, t1) { + this._source = t0; + this.$ti = t1; + }, + NonNullsIterator: function NonNullsIterator(t0) { + this._source = t0; + this.__internal$_current = null; + }, + FixedLengthListMixin: function FixedLengthListMixin() { + }, + UnmodifiableListMixin: function UnmodifiableListMixin() { + }, + UnmodifiableListBase: function UnmodifiableListBase() { + }, + ReversedListIterable: function ReversedListIterable(t0, t1) { + this._source = t0; + this.$ti = t1; + }, + Symbol: function Symbol(t0) { + this.__internal$_name = t0; + }, + __CastListBase__CastIterableBase_ListMixin: function __CastListBase__CastIterableBase_ListMixin() { + }, + ConstantMap_ConstantMap$from(other, $K, $V) { + var allStrings, k, object, index, index0, map, + keys = A.List_List$from(other.get$keys(other), true, $K), + t1 = keys.length, + _i = 0; + while (true) { + if (!(_i < t1)) { + allStrings = true; + break; + } + k = keys[_i]; + if (typeof k != "string" || "__proto__" === k) { + allStrings = false; + break; + } + ++_i; + } + if (allStrings) { + object = {}; + for (index = 0, _i = 0; _i < keys.length; keys.length === t1 || (0, A.throwConcurrentModificationError)(keys), ++_i, index = index0) { + k = keys[_i]; + other.$index(0, k); + index0 = index + 1; + object[k] = index; + } + map = new A.ConstantStringMap(object, A.List_List$from(other.get$values(other), true, $V), $K._eval$1("@<0>")._bind$1($V)._eval$1("ConstantStringMap<1,2>")); + map.$keys = keys; + return map; + } + return new A.ConstantMapView(A.LinkedHashMap_LinkedHashMap$from(other, $K, $V), $K._eval$1("@<0>")._bind$1($V)._eval$1("ConstantMapView<1,2>")); + }, + ConstantMap__throwUnmodifiable() { + throw A.wrapException(A.UnsupportedError$("Cannot modify unmodifiable Map")); + }, + ConstantSet__throwUnmodifiable() { + throw A.wrapException(A.UnsupportedError$("Cannot modify constant Set")); + }, + instantiate1(f, T1) { + var t1 = new A.Instantiation1(f, T1._eval$1("Instantiation1<0>")); + t1.Instantiation$1(f); + return t1; + }, + unminifyOrTag(rawClassName) { + var preserved = init.mangledGlobalNames[rawClassName]; + if (preserved != null) + return preserved; + return rawClassName; + }, + isJsIndexable(object, record) { + var result; + if (record != null) { + result = record.x; + if (result != null) + return result; + } + return type$.JavaScriptIndexingBehavior_dynamic._is(object); + }, + S(value) { + var result; + if (typeof value == "string") + return value; + if (typeof value == "number") { + if (value !== 0) + return "" + value; + } else if (true === value) + return "true"; + else if (false === value) + return "false"; + else if (value == null) + return "null"; + result = J.toString$0$(value); + return result; + }, + JSInvocationMirror$(_memberName, _internalName, _kind, _arguments, _namedArgumentNames, _typeArgumentCount) { + return new A.JSInvocationMirror(_memberName, _kind, _arguments, _namedArgumentNames, _typeArgumentCount); + }, + Primitives_objectHashCode(object) { + var hash, + property = $.Primitives__identityHashCodeProperty; + if (property == null) + property = $.Primitives__identityHashCodeProperty = Symbol("identityHashCode"); + hash = object[property]; + if (hash == null) { + hash = Math.random() * 0x3fffffff | 0; + object[property] = hash; + } + return hash; + }, + Primitives_parseInt(source, radix) { + var decimalMatch, maxCharCode, digitsPart, t1, i, _null = null, + match = /^\s*[+-]?((0x[a-f0-9]+)|(\d+)|([a-z0-9]+))\s*$/i.exec(source); + if (match == null) + return _null; + decimalMatch = match[3]; + if (radix == null) { + if (decimalMatch != null) + return parseInt(source, 10); + if (match[2] != null) + return parseInt(source, 16); + return _null; + } + if (radix < 2 || radix > 36) + throw A.wrapException(A.RangeError$range(radix, 2, 36, "radix", _null)); + if (radix === 10 && decimalMatch != null) + return parseInt(source, 10); + if (radix < 10 || decimalMatch == null) { + maxCharCode = radix <= 10 ? 47 + radix : 86 + radix; + digitsPart = match[1]; + for (t1 = digitsPart.length, i = 0; i < t1; ++i) + if ((digitsPart.charCodeAt(i) | 32) > maxCharCode) + return _null; + } + return parseInt(source, radix); + }, + Primitives_parseDouble(source) { + var result, trimmed; + if (!/^\s*[+-]?(?:Infinity|NaN|(?:\.\d+|\d+(?:\.\d*)?)(?:[eE][+-]?\d+)?)\s*$/.test(source)) + return null; + result = parseFloat(source); + if (isNaN(result)) { + trimmed = B.JSString_methods.trim$0(source); + if (trimmed === "NaN" || trimmed === "+NaN" || trimmed === "-NaN") + return result; + return null; + } + return result; + }, + Primitives_objectTypeName(object) { + return A.Primitives__objectTypeNameNewRti(object); + }, + Primitives__objectTypeNameNewRti(object) { + var interceptor, dispatchName, $constructor, constructorName; + if (object instanceof A.Object) + return A._rtiToString(A.instanceType(object), null); + interceptor = J.getInterceptor$(object); + if (interceptor === B.Interceptor_methods || interceptor === B.JavaScriptObject_methods || type$.UnknownJavaScriptObject._is(object)) { + dispatchName = B.C_JS_CONST(object); + if (dispatchName !== "Object" && dispatchName !== "") + return dispatchName; + $constructor = object.constructor; + if (typeof $constructor == "function") { + constructorName = $constructor.name; + if (typeof constructorName == "string" && constructorName !== "Object" && constructorName !== "") + return constructorName; + } + } + return A._rtiToString(A.instanceType(object), null); + }, + Primitives_safeToString(object) { + if (object == null || typeof object == "number" || A._isBool(object)) + return J.toString$0$(object); + if (typeof object == "string") + return JSON.stringify(object); + if (object instanceof A.Closure) + return object.toString$0(0); + if (object instanceof A._Record) + return object._toString$1(true); + return "Instance of '" + A.Primitives_objectTypeName(object) + "'"; + }, + Primitives_currentUri() { + if (!!self.location) + return self.location.href; + return null; + }, + Primitives__fromCharCodeApply(array) { + var result, i, i0, chunkEnd, + end = array.length; + if (end <= 500) + return String.fromCharCode.apply(null, array); + for (result = "", i = 0; i < end; i = i0) { + i0 = i + 500; + chunkEnd = i0 < end ? i0 : end; + result += String.fromCharCode.apply(null, array.slice(i, chunkEnd)); + } + return result; + }, + Primitives_stringFromCodePoints(codePoints) { + var t1, _i, i, + a = A._setArrayType([], type$.JSArray_int); + for (t1 = codePoints.length, _i = 0; _i < codePoints.length; codePoints.length === t1 || (0, A.throwConcurrentModificationError)(codePoints), ++_i) { + i = codePoints[_i]; + if (!A._isInt(i)) + throw A.wrapException(A.argumentErrorValue(i)); + if (i <= 65535) + a.push(i); + else if (i <= 1114111) { + a.push(55296 + (B.JSInt_methods._shrOtherPositive$1(i - 65536, 10) & 1023)); + a.push(56320 + (i & 1023)); + } else + throw A.wrapException(A.argumentErrorValue(i)); + } + return A.Primitives__fromCharCodeApply(a); + }, + Primitives_stringFromCharCodes(charCodes) { + var t1, _i, i; + for (t1 = charCodes.length, _i = 0; _i < t1; ++_i) { + i = charCodes[_i]; + if (!A._isInt(i)) + throw A.wrapException(A.argumentErrorValue(i)); + if (i < 0) + throw A.wrapException(A.argumentErrorValue(i)); + if (i > 65535) + return A.Primitives_stringFromCodePoints(charCodes); + } + return A.Primitives__fromCharCodeApply(charCodes); + }, + Primitives_stringFromNativeUint8List(charCodes, start, end) { + var i, result, i0, chunkEnd; + if (end <= 500 && start === 0 && end === charCodes.length) + return String.fromCharCode.apply(null, charCodes); + for (i = start, result = ""; i < end; i = i0) { + i0 = i + 500; + chunkEnd = i0 < end ? i0 : end; + result += String.fromCharCode.apply(null, charCodes.subarray(i, chunkEnd)); + } + return result; + }, + Primitives_stringFromCharCode(charCode) { + var bits; + if (0 <= charCode) { + if (charCode <= 65535) + return String.fromCharCode(charCode); + if (charCode <= 1114111) { + bits = charCode - 65536; + return String.fromCharCode((B.JSInt_methods._shrOtherPositive$1(bits, 10) | 55296) >>> 0, bits & 1023 | 56320); + } + } + throw A.wrapException(A.RangeError$range(charCode, 0, 1114111, null, null)); + }, + Primitives_lazyAsJsDate(receiver) { + if (receiver.date === void 0) + receiver.date = new Date(receiver._value); + return receiver.date; + }, + Primitives_getYear(receiver) { + var t1 = A.Primitives_lazyAsJsDate(receiver).getFullYear() + 0; + return t1; + }, + Primitives_getMonth(receiver) { + var t1 = A.Primitives_lazyAsJsDate(receiver).getMonth() + 1; + return t1; + }, + Primitives_getDay(receiver) { + var t1 = A.Primitives_lazyAsJsDate(receiver).getDate() + 0; + return t1; + }, + Primitives_getHours(receiver) { + var t1 = A.Primitives_lazyAsJsDate(receiver).getHours() + 0; + return t1; + }, + Primitives_getMinutes(receiver) { + var t1 = A.Primitives_lazyAsJsDate(receiver).getMinutes() + 0; + return t1; + }, + Primitives_getSeconds(receiver) { + var t1 = A.Primitives_lazyAsJsDate(receiver).getSeconds() + 0; + return t1; + }, + Primitives_getMilliseconds(receiver) { + var t1 = A.Primitives_lazyAsJsDate(receiver).getMilliseconds() + 0; + return t1; + }, + Primitives_functionNoSuchMethod($function, positionalArguments, namedArguments) { + var $arguments, namedArgumentList, t1 = {}; + t1.argumentCount = 0; + $arguments = []; + namedArgumentList = []; + t1.argumentCount = positionalArguments.length; + B.JSArray_methods.addAll$1($arguments, positionalArguments); + t1.names = ""; + if (namedArguments != null && namedArguments.__js_helper$_length !== 0) + namedArguments.forEach$1(0, new A.Primitives_functionNoSuchMethod_closure(t1, namedArgumentList, $arguments)); + return J.noSuchMethod$1$($function, new A.JSInvocationMirror(B.Symbol_call, 0, $arguments, namedArgumentList, 0)); + }, + Primitives_applyFunction($function, positionalArguments, namedArguments) { + var t1, argumentCount, jsStub; + if (Array.isArray(positionalArguments)) + t1 = namedArguments == null || namedArguments.__js_helper$_length === 0; + else + t1 = false; + if (t1) { + argumentCount = positionalArguments.length; + if (argumentCount === 0) { + if (!!$function.call$0) + return $function.call$0(); + } else if (argumentCount === 1) { + if (!!$function.call$1) + return $function.call$1(positionalArguments[0]); + } else if (argumentCount === 2) { + if (!!$function.call$2) + return $function.call$2(positionalArguments[0], positionalArguments[1]); + } else if (argumentCount === 3) { + if (!!$function.call$3) + return $function.call$3(positionalArguments[0], positionalArguments[1], positionalArguments[2]); + } else if (argumentCount === 4) { + if (!!$function.call$4) + return $function.call$4(positionalArguments[0], positionalArguments[1], positionalArguments[2], positionalArguments[3]); + } else if (argumentCount === 5) + if (!!$function.call$5) + return $function.call$5(positionalArguments[0], positionalArguments[1], positionalArguments[2], positionalArguments[3], positionalArguments[4]); + jsStub = $function["call" + "$" + argumentCount]; + if (jsStub != null) + return jsStub.apply($function, positionalArguments); + } + return A.Primitives__generalApplyFunction($function, positionalArguments, namedArguments); + }, + Primitives__generalApplyFunction($function, positionalArguments, namedArguments) { + var defaultValuesClosure, t1, defaultValues, interceptor, jsFunction, maxArguments, missingDefaults, keys, _i, defaultValue, used, t2, + $arguments = Array.isArray(positionalArguments) ? positionalArguments : A.List_List$of(positionalArguments, true, type$.dynamic), + argumentCount = $arguments.length, + requiredParameterCount = $function.$requiredArgCount; + if (argumentCount < requiredParameterCount) + return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments); + defaultValuesClosure = $function.$defaultValues; + t1 = defaultValuesClosure == null; + defaultValues = !t1 ? defaultValuesClosure() : null; + interceptor = J.getInterceptor$($function); + jsFunction = interceptor["call*"]; + if (typeof jsFunction == "string") + jsFunction = interceptor[jsFunction]; + if (t1) { + if (namedArguments != null && namedArguments.__js_helper$_length !== 0) + return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments); + if (argumentCount === requiredParameterCount) + return jsFunction.apply($function, $arguments); + return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments); + } + if (Array.isArray(defaultValues)) { + if (namedArguments != null && namedArguments.__js_helper$_length !== 0) + return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments); + maxArguments = requiredParameterCount + defaultValues.length; + if (argumentCount > maxArguments) + return A.Primitives_functionNoSuchMethod($function, $arguments, null); + if (argumentCount < maxArguments) { + missingDefaults = defaultValues.slice(argumentCount - requiredParameterCount); + if ($arguments === positionalArguments) + $arguments = A.List_List$of($arguments, true, type$.dynamic); + B.JSArray_methods.addAll$1($arguments, missingDefaults); + } + return jsFunction.apply($function, $arguments); + } else { + if (argumentCount > requiredParameterCount) + return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments); + if ($arguments === positionalArguments) + $arguments = A.List_List$of($arguments, true, type$.dynamic); + keys = Object.keys(defaultValues); + if (namedArguments == null) + for (t1 = keys.length, _i = 0; _i < keys.length; keys.length === t1 || (0, A.throwConcurrentModificationError)(keys), ++_i) { + defaultValue = defaultValues[keys[_i]]; + if (B.C__Required === defaultValue) + return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments); + B.JSArray_methods.add$1($arguments, defaultValue); + } + else { + for (t1 = keys.length, used = 0, _i = 0; _i < keys.length; keys.length === t1 || (0, A.throwConcurrentModificationError)(keys), ++_i) { + t2 = keys[_i]; + if (namedArguments.containsKey$1(t2)) { + ++used; + B.JSArray_methods.add$1($arguments, namedArguments.$index(0, t2)); + } else { + defaultValue = defaultValues[t2]; + if (B.C__Required === defaultValue) + return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments); + B.JSArray_methods.add$1($arguments, defaultValue); + } + } + if (used !== namedArguments.__js_helper$_length) + return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments); + } + return jsFunction.apply($function, $arguments); + } + }, + Primitives_extractStackTrace(error) { + var jsError = error.$thrownJsError; + if (jsError == null) + return null; + return A.getTraceFromException(jsError); + }, + Primitives_trySetStackTrace(error, stackTrace) { + var jsError; + if (error.$thrownJsError == null) { + jsError = A.wrapException(error); + error.$thrownJsError = jsError; + jsError.stack = stackTrace.toString$0(0); + } + }, + diagnoseIndexError(indexable, index) { + var $length, _s5_ = "index"; + if (!A._isInt(index)) + return new A.ArgumentError(true, index, _s5_, null); + $length = J.get$length$asx(indexable); + if (index < 0 || index >= $length) + return A.IndexError$withLength(index, $length, indexable, null, _s5_); + return A.RangeError$value(index, _s5_, null); + }, + diagnoseRangeError(start, end, $length) { + if (start < 0 || start > $length) + return A.RangeError$range(start, 0, $length, "start", null); + if (end != null) + if (end < start || end > $length) + return A.RangeError$range(end, start, $length, "end", null); + return new A.ArgumentError(true, end, "end", null); + }, + argumentErrorValue(object) { + return new A.ArgumentError(true, object, null, null); + }, + wrapException(ex) { + return A.initializeExceptionWrapper(new Error(), ex); + }, + initializeExceptionWrapper(wrapper, ex) { + var t1; + if (ex == null) + ex = new A.TypeError(); + wrapper.dartException = ex; + t1 = A.toStringWrapper; + if ("defineProperty" in Object) { + Object.defineProperty(wrapper, "message", {get: t1}); + wrapper.name = ""; + } else + wrapper.toString = t1; + return wrapper; + }, + toStringWrapper() { + return J.toString$0$(this.dartException); + }, + throwExpression(ex) { + throw A.wrapException(ex); + }, + throwExpressionWithWrapper(ex, wrapper) { + throw A.initializeExceptionWrapper(wrapper, ex); + }, + throwUnsupportedOperation(o, operation, verb) { + var wrapper; + if (operation == null) + operation = 0; + if (verb == null) + verb = 0; + wrapper = Error(); + A.throwExpressionWithWrapper(A._diagnoseUnsupportedOperation(o, operation, verb), wrapper); + }, + _diagnoseUnsupportedOperation(o, encodedOperation, encodedVerb) { + var operation, table, tableLength, index, verb, object, flags, article, adjective; + if (typeof encodedOperation == "string") + operation = encodedOperation; + else { + table = "[]=;add;removeWhere;retainWhere;removeRange;setRange;setInt8;setInt16;setInt32;setUint8;setUint16;setUint32;setFloat32;setFloat64".split(";"); + tableLength = table.length; + index = encodedOperation; + if (index > tableLength) { + encodedVerb = index / tableLength | 0; + index %= tableLength; + } + operation = table[index]; + } + verb = typeof encodedVerb == "string" ? encodedVerb : "modify;remove from;add to".split(";")[encodedVerb]; + object = type$.List_dynamic._is(o) ? "list" : "ByteData"; + flags = o.$flags | 0; + article = "a "; + if ((flags & 4) !== 0) + adjective = "constant "; + else if ((flags & 2) !== 0) { + adjective = "unmodifiable "; + article = "an "; + } else + adjective = (flags & 1) !== 0 ? "fixed-length " : ""; + return new A.UnsupportedError("'" + operation + "': Cannot " + verb + " " + article + adjective + object); + }, + throwConcurrentModificationError(collection) { + throw A.wrapException(A.ConcurrentModificationError$(collection)); + }, + TypeErrorDecoder_extractPattern(message) { + var match, $arguments, argumentsExpr, expr, method, receiver; + message = A.quoteStringForRegExp(message.replace(String({}), "$receiver$")); + match = message.match(/\\\$[a-zA-Z]+\\\$/g); + if (match == null) + match = A._setArrayType([], type$.JSArray_String); + $arguments = match.indexOf("\\$arguments\\$"); + argumentsExpr = match.indexOf("\\$argumentsExpr\\$"); + expr = match.indexOf("\\$expr\\$"); + method = match.indexOf("\\$method\\$"); + receiver = match.indexOf("\\$receiver\\$"); + return new A.TypeErrorDecoder(message.replace(new RegExp("\\\\\\$arguments\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$argumentsExpr\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$expr\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$method\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$receiver\\\\\\$", "g"), "((?:x|[^x])*)"), $arguments, argumentsExpr, expr, method, receiver); + }, + TypeErrorDecoder_provokeCallErrorOn(expression) { + return function($expr$) { + var $argumentsExpr$ = "$arguments$"; + try { + $expr$.$method$($argumentsExpr$); + } catch (e) { + return e.message; + } + }(expression); + }, + TypeErrorDecoder_provokePropertyErrorOn(expression) { + return function($expr$) { + try { + $expr$.$method$; + } catch (e) { + return e.message; + } + }(expression); + }, + JsNoSuchMethodError$(_message, match) { + var t1 = match == null, + t2 = t1 ? null : match.method; + return new A.JsNoSuchMethodError(_message, t2, t1 ? null : match.receiver); + }, + unwrapException(ex) { + if (ex == null) + return new A.NullThrownFromJavaScriptException(ex); + if (ex instanceof A.ExceptionAndStackTrace) + return A.saveStackTrace(ex, ex.dartException); + if (typeof ex !== "object") + return ex; + if ("dartException" in ex) + return A.saveStackTrace(ex, ex.dartException); + return A._unwrapNonDartException(ex); + }, + saveStackTrace(ex, error) { + if (type$.Error._is(error)) + if (error.$thrownJsError == null) + error.$thrownJsError = ex; + return error; + }, + _unwrapNonDartException(ex) { + var message, number, ieErrorCode, nsme, notClosure, nullCall, nullLiteralCall, undefCall, undefLiteralCall, nullProperty, undefProperty, undefLiteralProperty, match; + if (!("message" in ex)) + return ex; + message = ex.message; + if ("number" in ex && typeof ex.number == "number") { + number = ex.number; + ieErrorCode = number & 65535; + if ((B.JSInt_methods._shrOtherPositive$1(number, 16) & 8191) === 10) + switch (ieErrorCode) { + case 438: + return A.saveStackTrace(ex, A.JsNoSuchMethodError$(A.S(message) + " (Error " + ieErrorCode + ")", null)); + case 445: + case 5007: + A.S(message); + return A.saveStackTrace(ex, new A.NullError()); + } + } + if (ex instanceof TypeError) { + nsme = $.$get$TypeErrorDecoder_noSuchMethodPattern(); + notClosure = $.$get$TypeErrorDecoder_notClosurePattern(); + nullCall = $.$get$TypeErrorDecoder_nullCallPattern(); + nullLiteralCall = $.$get$TypeErrorDecoder_nullLiteralCallPattern(); + undefCall = $.$get$TypeErrorDecoder_undefinedCallPattern(); + undefLiteralCall = $.$get$TypeErrorDecoder_undefinedLiteralCallPattern(); + nullProperty = $.$get$TypeErrorDecoder_nullPropertyPattern(); + $.$get$TypeErrorDecoder_nullLiteralPropertyPattern(); + undefProperty = $.$get$TypeErrorDecoder_undefinedPropertyPattern(); + undefLiteralProperty = $.$get$TypeErrorDecoder_undefinedLiteralPropertyPattern(); + match = nsme.matchTypeError$1(message); + if (match != null) + return A.saveStackTrace(ex, A.JsNoSuchMethodError$(message, match)); + else { + match = notClosure.matchTypeError$1(message); + if (match != null) { + match.method = "call"; + return A.saveStackTrace(ex, A.JsNoSuchMethodError$(message, match)); + } else if (nullCall.matchTypeError$1(message) != null || nullLiteralCall.matchTypeError$1(message) != null || undefCall.matchTypeError$1(message) != null || undefLiteralCall.matchTypeError$1(message) != null || nullProperty.matchTypeError$1(message) != null || nullLiteralCall.matchTypeError$1(message) != null || undefProperty.matchTypeError$1(message) != null || undefLiteralProperty.matchTypeError$1(message) != null) + return A.saveStackTrace(ex, new A.NullError()); + } + return A.saveStackTrace(ex, new A.UnknownJsTypeError(typeof message == "string" ? message : "")); + } + if (ex instanceof RangeError) { + if (typeof message == "string" && message.indexOf("call stack") !== -1) + return new A.StackOverflowError(); + message = function(ex) { + try { + return String(ex); + } catch (e) { + } + return null; + }(ex); + return A.saveStackTrace(ex, new A.ArgumentError(false, null, null, typeof message == "string" ? message.replace(/^RangeError:\s*/, "") : message)); + } + if (typeof InternalError == "function" && ex instanceof InternalError) + if (typeof message == "string" && message === "too much recursion") + return new A.StackOverflowError(); + return ex; + }, + getTraceFromException(exception) { + var trace; + if (exception instanceof A.ExceptionAndStackTrace) + return exception.stackTrace; + if (exception == null) + return new A._StackTrace(exception); + trace = exception.$cachedTrace; + if (trace != null) + return trace; + trace = new A._StackTrace(exception); + if (typeof exception === "object") + exception.$cachedTrace = trace; + return trace; + }, + objectHashCode(object) { + if (object == null) + return J.get$hashCode$(object); + if (typeof object == "object") + return A.Primitives_objectHashCode(object); + return J.get$hashCode$(object); + }, + constantHashCode(key) { + if (typeof key == "number") + return B.JSNumber_methods.get$hashCode(key); + if (key instanceof A._Type) + return A.Primitives_objectHashCode(key); + if (key instanceof A._Record) + return key.get$hashCode(key); + if (key instanceof A.Symbol) + return key.get$hashCode(0); + return A.objectHashCode(key); + }, + fillLiteralMap(keyValuePairs, result) { + var index, index0, index1, + $length = keyValuePairs.length; + for (index = 0; index < $length; index = index1) { + index0 = index + 1; + index1 = index0 + 1; + result.$indexSet(0, keyValuePairs[index], keyValuePairs[index0]); + } + return result; + }, + fillLiteralSet(values, result) { + var index, + $length = values.length; + for (index = 0; index < $length; ++index) + result.add$1(0, values[index]); + return result; + }, + _invokeClosure(closure, numberOfArguments, arg1, arg2, arg3, arg4) { + switch (numberOfArguments) { + case 0: + return closure.call$0(); + case 1: + return closure.call$1(arg1); + case 2: + return closure.call$2(arg1, arg2); + case 3: + return closure.call$3(arg1, arg2, arg3); + case 4: + return closure.call$4(arg1, arg2, arg3, arg4); + } + throw A.wrapException(new A._Exception("Unsupported number of arguments for wrapped closure")); + }, + convertDartClosureToJS(closure, arity) { + var $function; + if (closure == null) + return null; + $function = closure.$identity; + if (!!$function) + return $function; + $function = A.convertDartClosureToJSUncached(closure, arity); + closure.$identity = $function; + return $function; + }, + convertDartClosureToJSUncached(closure, arity) { + var entry; + switch (arity) { + case 0: + entry = closure.call$0; + break; + case 1: + entry = closure.call$1; + break; + case 2: + entry = closure.call$2; + break; + case 3: + entry = closure.call$3; + break; + case 4: + entry = closure.call$4; + break; + default: + entry = null; + } + if (entry != null) + return entry.bind(closure); + return function(closure, arity, invoke) { + return function(a1, a2, a3, a4) { + return invoke(closure, arity, a1, a2, a3, a4); + }; + }(closure, arity, A._invokeClosure); + }, + Closure_fromTearOff(parameters) { + var $prototype, $constructor, t2, trampoline, applyTrampoline, i, stub, stub0, stubName, stubCallName, + container = parameters.co, + isStatic = parameters.iS, + isIntercepted = parameters.iI, + needsDirectAccess = parameters.nDA, + applyTrampolineIndex = parameters.aI, + funsOrNames = parameters.fs, + callNames = parameters.cs, + $name = funsOrNames[0], + callName = callNames[0], + $function = container[$name], + t1 = parameters.fT; + t1.toString; + $prototype = isStatic ? Object.create(new A.StaticClosure().constructor.prototype) : Object.create(new A.BoundClosure(null, null).constructor.prototype); + $prototype.$initialize = $prototype.constructor; + $constructor = isStatic ? function static_tear_off() { + this.$initialize(); + } : function tear_off(a, b) { + this.$initialize(a, b); + }; + $prototype.constructor = $constructor; + $constructor.prototype = $prototype; + $prototype.$_name = $name; + $prototype.$_target = $function; + t2 = !isStatic; + if (t2) + trampoline = A.Closure_forwardCallTo($name, $function, isIntercepted, needsDirectAccess); + else { + $prototype.$static_name = $name; + trampoline = $function; + } + $prototype.$signature = A.Closure__computeSignatureFunctionNewRti(t1, isStatic, isIntercepted); + $prototype[callName] = trampoline; + for (applyTrampoline = trampoline, i = 1; i < funsOrNames.length; ++i) { + stub = funsOrNames[i]; + if (typeof stub == "string") { + stub0 = container[stub]; + stubName = stub; + stub = stub0; + } else + stubName = ""; + stubCallName = callNames[i]; + if (stubCallName != null) { + if (t2) + stub = A.Closure_forwardCallTo(stubName, stub, isIntercepted, needsDirectAccess); + $prototype[stubCallName] = stub; + } + if (i === applyTrampolineIndex) + applyTrampoline = stub; + } + $prototype["call*"] = applyTrampoline; + $prototype.$requiredArgCount = parameters.rC; + $prototype.$defaultValues = parameters.dV; + return $constructor; + }, + Closure__computeSignatureFunctionNewRti(functionType, isStatic, isIntercepted) { + if (typeof functionType == "number") + return functionType; + if (typeof functionType == "string") { + if (isStatic) + throw A.wrapException("Cannot compute signature for static tearoff."); + return function(recipe, evalOnReceiver) { + return function() { + return evalOnReceiver(this, recipe); + }; + }(functionType, A.BoundClosure_evalRecipe); + } + throw A.wrapException("Error in functionType of tearoff"); + }, + Closure_cspForwardCall(arity, needsDirectAccess, stubName, $function) { + var getReceiver = A.BoundClosure_receiverOf; + switch (needsDirectAccess ? -1 : arity) { + case 0: + return function(entry, receiverOf) { + return function() { + return receiverOf(this)[entry](); + }; + }(stubName, getReceiver); + case 1: + return function(entry, receiverOf) { + return function(a) { + return receiverOf(this)[entry](a); + }; + }(stubName, getReceiver); + case 2: + return function(entry, receiverOf) { + return function(a, b) { + return receiverOf(this)[entry](a, b); + }; + }(stubName, getReceiver); + case 3: + return function(entry, receiverOf) { + return function(a, b, c) { + return receiverOf(this)[entry](a, b, c); + }; + }(stubName, getReceiver); + case 4: + return function(entry, receiverOf) { + return function(a, b, c, d) { + return receiverOf(this)[entry](a, b, c, d); + }; + }(stubName, getReceiver); + case 5: + return function(entry, receiverOf) { + return function(a, b, c, d, e) { + return receiverOf(this)[entry](a, b, c, d, e); + }; + }(stubName, getReceiver); + default: + return function(f, receiverOf) { + return function() { + return f.apply(receiverOf(this), arguments); + }; + }($function, getReceiver); + } + }, + Closure_forwardCallTo(stubName, $function, isIntercepted, needsDirectAccess) { + if (isIntercepted) + return A.Closure_forwardInterceptedCallTo(stubName, $function, needsDirectAccess); + return A.Closure_cspForwardCall($function.length, needsDirectAccess, stubName, $function); + }, + Closure_cspForwardInterceptedCall(arity, needsDirectAccess, stubName, $function) { + var getReceiver = A.BoundClosure_receiverOf, + getInterceptor = A.BoundClosure_interceptorOf; + switch (needsDirectAccess ? -1 : arity) { + case 0: + throw A.wrapException(new A.RuntimeError("Intercepted function with no arguments.")); + case 1: + return function(entry, interceptorOf, receiverOf) { + return function() { + return interceptorOf(this)[entry](receiverOf(this)); + }; + }(stubName, getInterceptor, getReceiver); + case 2: + return function(entry, interceptorOf, receiverOf) { + return function(a) { + return interceptorOf(this)[entry](receiverOf(this), a); + }; + }(stubName, getInterceptor, getReceiver); + case 3: + return function(entry, interceptorOf, receiverOf) { + return function(a, b) { + return interceptorOf(this)[entry](receiverOf(this), a, b); + }; + }(stubName, getInterceptor, getReceiver); + case 4: + return function(entry, interceptorOf, receiverOf) { + return function(a, b, c) { + return interceptorOf(this)[entry](receiverOf(this), a, b, c); + }; + }(stubName, getInterceptor, getReceiver); + case 5: + return function(entry, interceptorOf, receiverOf) { + return function(a, b, c, d) { + return interceptorOf(this)[entry](receiverOf(this), a, b, c, d); + }; + }(stubName, getInterceptor, getReceiver); + case 6: + return function(entry, interceptorOf, receiverOf) { + return function(a, b, c, d, e) { + return interceptorOf(this)[entry](receiverOf(this), a, b, c, d, e); + }; + }(stubName, getInterceptor, getReceiver); + default: + return function(f, interceptorOf, receiverOf) { + return function() { + var a = [receiverOf(this)]; + Array.prototype.push.apply(a, arguments); + return f.apply(interceptorOf(this), a); + }; + }($function, getInterceptor, getReceiver); + } + }, + Closure_forwardInterceptedCallTo(stubName, $function, needsDirectAccess) { + var arity, t1; + if ($.BoundClosure__interceptorFieldNameCache == null) + $.BoundClosure__interceptorFieldNameCache = A.BoundClosure__computeFieldNamed("interceptor"); + if ($.BoundClosure__receiverFieldNameCache == null) + $.BoundClosure__receiverFieldNameCache = A.BoundClosure__computeFieldNamed("receiver"); + arity = $function.length; + t1 = A.Closure_cspForwardInterceptedCall(arity, needsDirectAccess, stubName, $function); + return t1; + }, + closureFromTearOff(parameters) { + return A.Closure_fromTearOff(parameters); + }, + BoundClosure_evalRecipe(closure, recipe) { + return A._Universe_evalInEnvironment(init.typeUniverse, A.instanceType(closure._receiver), recipe); + }, + BoundClosure_receiverOf(closure) { + return closure._receiver; + }, + BoundClosure_interceptorOf(closure) { + return closure._interceptor; + }, + BoundClosure__computeFieldNamed(fieldName) { + var names, i, $name, + template = new A.BoundClosure("receiver", "interceptor"), + t1 = Object.getOwnPropertyNames(template); + t1.$flags = 1; + names = t1; + for (t1 = names.length, i = 0; i < t1; ++i) { + $name = names[i]; + if (template[$name] === fieldName) + return $name; + } + throw A.wrapException(A.ArgumentError$("Field name " + fieldName + " not found.", null)); + }, + throwCyclicInit(staticName) { + throw A.wrapException(new A._CyclicInitializationError(staticName)); + }, + getIsolateAffinityTag($name) { + return init.getIsolateTag($name); + }, + defineProperty(obj, property, value) { + Object.defineProperty(obj, property, {value: value, enumerable: false, writable: true, configurable: true}); + }, + lookupAndCacheInterceptor(obj) { + var interceptor, interceptorClass, altTag, mark, t1, + tag = $.getTagFunction.call$1(obj), + record = $.dispatchRecordsForInstanceTags[tag]; + if (record != null) { + Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true}); + return record.i; + } + interceptor = $.interceptorsForUncacheableTags[tag]; + if (interceptor != null) + return interceptor; + interceptorClass = init.interceptorsByTag[tag]; + if (interceptorClass == null) { + altTag = $.alternateTagFunction.call$2(obj, tag); + if (altTag != null) { + record = $.dispatchRecordsForInstanceTags[altTag]; + if (record != null) { + Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true}); + return record.i; + } + interceptor = $.interceptorsForUncacheableTags[altTag]; + if (interceptor != null) + return interceptor; + interceptorClass = init.interceptorsByTag[altTag]; + tag = altTag; + } + } + if (interceptorClass == null) + return null; + interceptor = interceptorClass.prototype; + mark = tag[0]; + if (mark === "!") { + record = A.makeLeafDispatchRecord(interceptor); + $.dispatchRecordsForInstanceTags[tag] = record; + Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true}); + return record.i; + } + if (mark === "~") { + $.interceptorsForUncacheableTags[tag] = interceptor; + return interceptor; + } + if (mark === "-") { + t1 = A.makeLeafDispatchRecord(interceptor); + Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName, {value: t1, enumerable: false, writable: true, configurable: true}); + return t1.i; + } + if (mark === "+") + return A.patchInteriorProto(obj, interceptor); + if (mark === "*") + throw A.wrapException(A.UnimplementedError$(tag)); + if (init.leafTags[tag] === true) { + t1 = A.makeLeafDispatchRecord(interceptor); + Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName, {value: t1, enumerable: false, writable: true, configurable: true}); + return t1.i; + } else + return A.patchInteriorProto(obj, interceptor); + }, + patchInteriorProto(obj, interceptor) { + var proto = Object.getPrototypeOf(obj); + Object.defineProperty(proto, init.dispatchPropertyName, {value: J.makeDispatchRecord(interceptor, proto, null, null), enumerable: false, writable: true, configurable: true}); + return interceptor; + }, + makeLeafDispatchRecord(interceptor) { + return J.makeDispatchRecord(interceptor, false, null, !!interceptor.$isJavaScriptIndexingBehavior); + }, + makeDefaultDispatchRecord(tag, interceptorClass, proto) { + var interceptor = interceptorClass.prototype; + if (init.leafTags[tag] === true) + return A.makeLeafDispatchRecord(interceptor); + else + return J.makeDispatchRecord(interceptor, proto, null, null); + }, + initNativeDispatch() { + if (true === $.initNativeDispatchFlag) + return; + $.initNativeDispatchFlag = true; + A.initNativeDispatchContinue(); + }, + initNativeDispatchContinue() { + var map, tags, fun, i, tag, proto, record, interceptorClass; + $.dispatchRecordsForInstanceTags = Object.create(null); + $.interceptorsForUncacheableTags = Object.create(null); + A.initHooks(); + map = init.interceptorsByTag; + tags = Object.getOwnPropertyNames(map); + if (typeof window != "undefined") { + window; + fun = function() { + }; + for (i = 0; i < tags.length; ++i) { + tag = tags[i]; + proto = $.prototypeForTagFunction.call$1(tag); + if (proto != null) { + record = A.makeDefaultDispatchRecord(tag, map[tag], proto); + if (record != null) { + Object.defineProperty(proto, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true}); + fun.prototype = proto; + } + } + } + } + for (i = 0; i < tags.length; ++i) { + tag = tags[i]; + if (/^[A-Za-z_]/.test(tag)) { + interceptorClass = map[tag]; + map["!" + tag] = interceptorClass; + map["~" + tag] = interceptorClass; + map["-" + tag] = interceptorClass; + map["+" + tag] = interceptorClass; + map["*" + tag] = interceptorClass; + } + } + }, + initHooks() { + var transformers, i, transformer, getTag, getUnknownTag, prototypeForTag, + hooks = B.C_JS_CONST0(); + hooks = A.applyHooksTransformer(B.C_JS_CONST1, A.applyHooksTransformer(B.C_JS_CONST2, A.applyHooksTransformer(B.C_JS_CONST3, A.applyHooksTransformer(B.C_JS_CONST3, A.applyHooksTransformer(B.C_JS_CONST4, A.applyHooksTransformer(B.C_JS_CONST5, A.applyHooksTransformer(B.C_JS_CONST6(B.C_JS_CONST), hooks))))))); + if (typeof dartNativeDispatchHooksTransformer != "undefined") { + transformers = dartNativeDispatchHooksTransformer; + if (typeof transformers == "function") + transformers = [transformers]; + if (Array.isArray(transformers)) + for (i = 0; i < transformers.length; ++i) { + transformer = transformers[i]; + if (typeof transformer == "function") + hooks = transformer(hooks) || hooks; + } + } + getTag = hooks.getTag; + getUnknownTag = hooks.getUnknownTag; + prototypeForTag = hooks.prototypeForTag; + $.getTagFunction = new A.initHooks_closure(getTag); + $.alternateTagFunction = new A.initHooks_closure0(getUnknownTag); + $.prototypeForTagFunction = new A.initHooks_closure1(prototypeForTag); + }, + applyHooksTransformer(transformer, hooks) { + return transformer(hooks) || hooks; + }, + _RecordN__equalValues(a, b) { + var i; + for (i = 0; i < a.length; ++i) + if (!J.$eq$(a[i], b[i])) + return false; + return true; + }, + createRecordTypePredicate(shape, fieldRtis) { + var $length = fieldRtis.length, + $function = init.rttc["" + $length + ";" + shape]; + if ($function == null) + return null; + if ($length === 0) + return $function; + if ($length === $function.length) + return $function.apply(null, fieldRtis); + return $function(fieldRtis); + }, + JSSyntaxRegExp_makeNative(source, multiLine, caseSensitive, unicode, dotAll, global) { + var m = multiLine ? "m" : "", + i = caseSensitive ? "" : "i", + u = unicode ? "u" : "", + s = dotAll ? "s" : "", + g = global ? "g" : "", + regexp = function(source, modifiers) { + try { + return new RegExp(source, modifiers); + } catch (e) { + return e; + } + }(source, m + i + u + s + g); + if (regexp instanceof RegExp) + return regexp; + throw A.wrapException(A.FormatException$("Illegal RegExp pattern (" + String(regexp) + ")", source, null)); + }, + stringContainsUnchecked(receiver, other, startIndex) { + var t1; + if (typeof other == "string") + return receiver.indexOf(other, startIndex) >= 0; + else if (other instanceof A.JSSyntaxRegExp) { + t1 = B.JSString_methods.substring$1(receiver, startIndex); + return other._nativeRegExp.test(t1); + } else + return !J.allMatches$1$s(other, B.JSString_methods.substring$1(receiver, startIndex)).get$isEmpty(0); + }, + escapeReplacement(replacement) { + if (replacement.indexOf("$", 0) >= 0) + return replacement.replace(/\$/g, "$$$$"); + return replacement; + }, + stringReplaceFirstRE(receiver, regexp, replacement, startIndex) { + var match = regexp._execGlobal$2(receiver, startIndex); + if (match == null) + return receiver; + return A.stringReplaceRangeUnchecked(receiver, match._match.index, match.get$end(0), replacement); + }, + quoteStringForRegExp(string) { + if (/[[\]{}()*+?.\\^$|]/.test(string)) + return string.replace(/[[\]{}()*+?.\\^$|]/g, "\\$&"); + return string; + }, + stringReplaceAllUnchecked(receiver, pattern, replacement) { + var nativeRegexp; + if (typeof pattern == "string") + return A.stringReplaceAllUncheckedString(receiver, pattern, replacement); + if (pattern instanceof A.JSSyntaxRegExp) { + nativeRegexp = pattern.get$_nativeGlobalVersion(); + nativeRegexp.lastIndex = 0; + return receiver.replace(nativeRegexp, A.escapeReplacement(replacement)); + } + return A.stringReplaceAllGeneral(receiver, pattern, replacement); + }, + stringReplaceAllGeneral(receiver, pattern, replacement) { + var t1, startIndex, t2, match; + for (t1 = J.allMatches$1$s(pattern, receiver), t1 = t1.get$iterator(t1), startIndex = 0, t2 = ""; t1.moveNext$0();) { + match = t1.get$current(t1); + t2 = t2 + receiver.substring(startIndex, match.get$start(match)) + replacement; + startIndex = match.get$end(match); + } + t1 = t2 + receiver.substring(startIndex); + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + stringReplaceAllUncheckedString(receiver, pattern, replacement) { + var $length, t1, i; + if (pattern === "") { + if (receiver === "") + return replacement; + $length = receiver.length; + t1 = "" + replacement; + for (i = 0; i < $length; ++i) + t1 = t1 + receiver[i] + replacement; + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + if (receiver.indexOf(pattern, 0) < 0) + return receiver; + if (receiver.length < 500 || replacement.indexOf("$", 0) >= 0) + return receiver.split(pattern).join(replacement); + return receiver.replace(new RegExp(A.quoteStringForRegExp(pattern), "g"), A.escapeReplacement(replacement)); + }, + stringReplaceFirstUnchecked(receiver, pattern, replacement, startIndex) { + var index, t1, matches, match; + if (typeof pattern == "string") { + index = receiver.indexOf(pattern, startIndex); + if (index < 0) + return receiver; + return A.stringReplaceRangeUnchecked(receiver, index, index + pattern.length, replacement); + } + if (pattern instanceof A.JSSyntaxRegExp) + return startIndex === 0 ? receiver.replace(pattern._nativeRegExp, A.escapeReplacement(replacement)) : A.stringReplaceFirstRE(receiver, pattern, replacement, startIndex); + t1 = J.allMatches$2$s(pattern, receiver, startIndex); + matches = t1.get$iterator(t1); + if (!matches.moveNext$0()) + return receiver; + match = matches.get$current(matches); + return B.JSString_methods.replaceRange$3(receiver, match.get$start(match), match.get$end(match), replacement); + }, + stringReplaceRangeUnchecked(receiver, start, end, replacement) { + return receiver.substring(0, start) + replacement + receiver.substring(end); + }, + _Record_1: function _Record_1(t0) { + this._0 = t0; + }, + _Record_2: function _Record_2(t0, t1) { + this._0 = t0; + this._1 = t1; + }, + _Record_2_forImport: function _Record_2_forImport(t0, t1) { + this._0 = t0; + this._1 = t1; + }, + _Record_2_imports_modules: function _Record_2_imports_modules(t0, t1) { + this._0 = t0; + this._1 = t1; + }, + _Record_2_loadedUrls_stylesheet: function _Record_2_loadedUrls_stylesheet(t0, t1) { + this._0 = t0; + this._1 = t1; + }, + _Record_2_sourceMap: function _Record_2_sourceMap(t0, t1) { + this._0 = t0; + this._1 = t1; + }, + _Record_3: function _Record_3(t0, t1, t2) { + this._0 = t0; + this._1 = t1; + this._2 = t2; + }, + _Record_3_deprecation_message_span: function _Record_3_deprecation_message_span(t0, t1, t2) { + this._0 = t0; + this._1 = t1; + this._2 = t2; + }, + _Record_3_forImport: function _Record_3_forImport(t0, t1, t2) { + this._0 = t0; + this._1 = t1; + this._2 = t2; + }, + _Record_3_importer_isDependency: function _Record_3_importer_isDependency(t0, t1, t2) { + this._0 = t0; + this._1 = t1; + this._2 = t2; + }, + _Record_3_originalUrl: function _Record_3_originalUrl(t0, t1, t2) { + this._0 = t0; + this._1 = t1; + this._2 = t2; + }, + _Record_5_named_namedNodes_positional_positionalNodes_separator: function _Record_5_named_namedNodes_positional_positionalNodes_separator(t0) { + this._values = t0; + }, + ConstantMapView: function ConstantMapView(t0, t1) { + this._map = t0; + this.$ti = t1; + }, + ConstantMap: function ConstantMap() { + }, + ConstantStringMap: function ConstantStringMap(t0, t1, t2) { + this._jsIndex = t0; + this._values = t1; + this.$ti = t2; + }, + _KeysOrValues: function _KeysOrValues(t0, t1) { + this._elements = t0; + this.$ti = t1; + }, + _KeysOrValuesOrElementsIterator: function _KeysOrValuesOrElementsIterator(t0, t1, t2) { + var _ = this; + _._elements = t0; + _.__js_helper$_length = t1; + _.__js_helper$_index = 0; + _.__js_helper$_current = null; + _.$ti = t2; + }, + ConstantSet: function ConstantSet() { + }, + ConstantStringSet: function ConstantStringSet(t0, t1, t2) { + this._jsIndex = t0; + this.__js_helper$_length = t1; + this.$ti = t2; + }, + GeneralConstantSet: function GeneralConstantSet(t0, t1) { + this._elements = t0; + this.$ti = t1; + }, + Instantiation: function Instantiation() { + }, + Instantiation1: function Instantiation1(t0, t1) { + this._genericClosure = t0; + this.$ti = t1; + }, + JSInvocationMirror: function JSInvocationMirror(t0, t1, t2, t3, t4) { + var _ = this; + _.__js_helper$_memberName = t0; + _.__js_helper$_kind = t1; + _._arguments = t2; + _._namedArgumentNames = t3; + _._typeArgumentCount = t4; + }, + Primitives_functionNoSuchMethod_closure: function Primitives_functionNoSuchMethod_closure(t0, t1, t2) { + this._box_0 = t0; + this.namedArgumentList = t1; + this.$arguments = t2; + }, + TypeErrorDecoder: function TypeErrorDecoder(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._pattern = t0; + _._arguments = t1; + _._argumentsExpr = t2; + _._expr = t3; + _._method = t4; + _._receiver = t5; + }, + NullError: function NullError() { + }, + JsNoSuchMethodError: function JsNoSuchMethodError(t0, t1, t2) { + this.__js_helper$_message = t0; + this._method = t1; + this._receiver = t2; + }, + UnknownJsTypeError: function UnknownJsTypeError(t0) { + this.__js_helper$_message = t0; + }, + NullThrownFromJavaScriptException: function NullThrownFromJavaScriptException(t0) { + this._irritant = t0; + }, + ExceptionAndStackTrace: function ExceptionAndStackTrace(t0, t1) { + this.dartException = t0; + this.stackTrace = t1; + }, + _StackTrace: function _StackTrace(t0) { + this._exception = t0; + this._trace = null; + }, + Closure: function Closure() { + }, + Closure0Args: function Closure0Args() { + }, + Closure2Args: function Closure2Args() { + }, + TearOffClosure: function TearOffClosure() { + }, + StaticClosure: function StaticClosure() { + }, + BoundClosure: function BoundClosure(t0, t1) { + this._receiver = t0; + this._interceptor = t1; + }, + _CyclicInitializationError: function _CyclicInitializationError(t0) { + this.variableName = t0; + }, + RuntimeError: function RuntimeError(t0) { + this.message = t0; + }, + _Required: function _Required() { + }, + JsLinkedHashMap: function JsLinkedHashMap(t0) { + var _ = this; + _.__js_helper$_length = 0; + _.__js_helper$_last = _.__js_helper$_first = _.__js_helper$_rest = _.__js_helper$_nums = _.__js_helper$_strings = null; + _.__js_helper$_modifications = 0; + _.$ti = t0; + }, + JsLinkedHashMap_addAll_closure: function JsLinkedHashMap_addAll_closure(t0) { + this.$this = t0; + }, + LinkedHashMapCell: function LinkedHashMapCell(t0, t1) { + var _ = this; + _.hashMapCellKey = t0; + _.hashMapCellValue = t1; + _.__js_helper$_previous = _.__js_helper$_next = null; + }, + LinkedHashMapKeysIterable: function LinkedHashMapKeysIterable(t0, t1) { + this.__js_helper$_map = t0; + this.$ti = t1; + }, + LinkedHashMapKeyIterator: function LinkedHashMapKeyIterator(t0, t1, t2) { + var _ = this; + _.__js_helper$_map = t0; + _.__js_helper$_modifications = t1; + _.__js_helper$_cell = t2; + _.__js_helper$_current = null; + }, + LinkedHashMapValuesIterable: function LinkedHashMapValuesIterable(t0, t1) { + this.__js_helper$_map = t0; + this.$ti = t1; + }, + LinkedHashMapValueIterator: function LinkedHashMapValueIterator(t0, t1, t2) { + var _ = this; + _.__js_helper$_map = t0; + _.__js_helper$_modifications = t1; + _.__js_helper$_cell = t2; + _.__js_helper$_current = null; + }, + LinkedHashMapEntriesIterable: function LinkedHashMapEntriesIterable(t0, t1) { + this.__js_helper$_map = t0; + this.$ti = t1; + }, + LinkedHashMapEntryIterator: function LinkedHashMapEntryIterator(t0, t1, t2, t3) { + var _ = this; + _.__js_helper$_map = t0; + _.__js_helper$_modifications = t1; + _.__js_helper$_cell = t2; + _.__js_helper$_current = null; + _.$ti = t3; + }, + JsIdentityLinkedHashMap: function JsIdentityLinkedHashMap(t0) { + var _ = this; + _.__js_helper$_length = 0; + _.__js_helper$_last = _.__js_helper$_first = _.__js_helper$_rest = _.__js_helper$_nums = _.__js_helper$_strings = null; + _.__js_helper$_modifications = 0; + _.$ti = t0; + }, + JsConstantLinkedHashMap: function JsConstantLinkedHashMap(t0) { + var _ = this; + _.__js_helper$_length = 0; + _.__js_helper$_last = _.__js_helper$_first = _.__js_helper$_rest = _.__js_helper$_nums = _.__js_helper$_strings = null; + _.__js_helper$_modifications = 0; + _.$ti = t0; + }, + initHooks_closure: function initHooks_closure(t0) { + this.getTag = t0; + }, + initHooks_closure0: function initHooks_closure0(t0) { + this.getUnknownTag = t0; + }, + initHooks_closure1: function initHooks_closure1(t0) { + this.prototypeForTag = t0; + }, + _Record: function _Record() { + }, + _Record2: function _Record2() { + }, + _Record1: function _Record1() { + }, + _Record3: function _Record3() { + }, + _RecordN: function _RecordN() { + }, + JSSyntaxRegExp: function JSSyntaxRegExp(t0, t1) { + var _ = this; + _.pattern = t0; + _._nativeRegExp = t1; + _._nativeAnchoredRegExp = _._nativeGlobalRegExp = null; + }, + _MatchImplementation: function _MatchImplementation(t0) { + this._match = t0; + }, + _AllMatchesIterable: function _AllMatchesIterable(t0, t1, t2) { + this._re = t0; + this.__js_helper$_string = t1; + this.__js_helper$_start = t2; + }, + _AllMatchesIterator: function _AllMatchesIterator(t0, t1, t2) { + var _ = this; + _._regExp = t0; + _.__js_helper$_string = t1; + _._nextIndex = t2; + _.__js_helper$_current = null; + }, + StringMatch: function StringMatch(t0, t1) { + this.start = t0; + this.pattern = t1; + }, + _StringAllMatchesIterable: function _StringAllMatchesIterable(t0, t1, t2) { + this._input = t0; + this._pattern = t1; + this.__js_helper$_index = t2; + }, + _StringAllMatchesIterator: function _StringAllMatchesIterator(t0, t1, t2) { + var _ = this; + _._input = t0; + _._pattern = t1; + _.__js_helper$_index = t2; + _.__js_helper$_current = null; + }, + throwLateFieldADI(fieldName) { + A.throwExpressionWithWrapper(new A.LateError("Field '" + fieldName + "' has been assigned during initialization."), new Error()); + }, + throwUnnamedLateFieldNI() { + A.throwExpressionWithWrapper(new A.LateError("Field '' has not been initialized."), new Error()); + }, + throwUnnamedLateFieldAI() { + A.throwExpressionWithWrapper(new A.LateError("Field '' has already been initialized."), new Error()); + }, + throwUnnamedLateFieldADI() { + A.throwExpressionWithWrapper(new A.LateError("Field '' has been assigned during initialization."), new Error()); + }, + _Cell$() { + var t1 = new A._Cell(); + return t1.__late_helper$_value = t1; + }, + _Cell: function _Cell() { + this.__late_helper$_value = null; + }, + _ensureNativeList(list) { + return list; + }, + NativeFloat64List_NativeFloat64List$fromList(elements) { + return new Float64Array(A._ensureNativeList(elements)); + }, + NativeInt8List__create1(arg) { + return new Int8Array(arg); + }, + NativeUint8List_NativeUint8List($length) { + return new Uint8Array($length); + }, + _checkValidIndex(index, list, $length) { + if (index >>> 0 !== index || index >= $length) + throw A.wrapException(A.diagnoseIndexError(list, index)); + }, + _checkValidRange(start, end, $length) { + var t1; + if (!(start >>> 0 !== start)) + if (end == null) + t1 = start > $length; + else + t1 = end >>> 0 !== end || start > end || end > $length; + else + t1 = true; + if (t1) + throw A.wrapException(A.diagnoseRangeError(start, end, $length)); + if (end == null) + return $length; + return end; + }, + NativeByteBuffer: function NativeByteBuffer() { + }, + NativeTypedData: function NativeTypedData() { + }, + NativeByteData: function NativeByteData() { + }, + NativeTypedArray: function NativeTypedArray() { + }, + NativeTypedArrayOfDouble: function NativeTypedArrayOfDouble() { + }, + NativeTypedArrayOfInt: function NativeTypedArrayOfInt() { + }, + NativeFloat32List: function NativeFloat32List() { + }, + NativeFloat64List: function NativeFloat64List() { + }, + NativeInt16List: function NativeInt16List() { + }, + NativeInt32List: function NativeInt32List() { + }, + NativeInt8List: function NativeInt8List() { + }, + NativeUint16List: function NativeUint16List() { + }, + NativeUint32List: function NativeUint32List() { + }, + NativeUint8ClampedList: function NativeUint8ClampedList() { + }, + NativeUint8List: function NativeUint8List() { + }, + _NativeTypedArrayOfDouble_NativeTypedArray_ListMixin: function _NativeTypedArrayOfDouble_NativeTypedArray_ListMixin() { + }, + _NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin: function _NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin() { + }, + _NativeTypedArrayOfInt_NativeTypedArray_ListMixin: function _NativeTypedArrayOfInt_NativeTypedArray_ListMixin() { + }, + _NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin: function _NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin() { + }, + Rti__getQuestionFromStar(universe, rti) { + var question = rti._precomputed1; + return question == null ? rti._precomputed1 = A._Universe__lookupQuestionRti(universe, rti._primary, true) : question; + }, + Rti__getFutureFromFutureOr(universe, rti) { + var future = rti._precomputed1; + return future == null ? rti._precomputed1 = A._Universe__lookupInterfaceRti(universe, "Future", [rti._primary]) : future; + }, + Rti__isUnionOfFunctionType(rti) { + var kind = rti._kind; + if (kind === 6 || kind === 7 || kind === 8) + return A.Rti__isUnionOfFunctionType(rti._primary); + return kind === 12 || kind === 13; + }, + Rti__getCanonicalRecipe(rti) { + return rti._canonicalRecipe; + }, + pairwiseIsTest(fieldRtis, values) { + var i, + $length = values.length; + for (i = 0; i < $length; ++i) + if (!fieldRtis[i]._is(values[i])) + return false; + return true; + }, + findType(recipe) { + return A._Universe_eval(init.typeUniverse, recipe, false); + }, + instantiatedGenericFunctionType(genericFunctionRti, instantiationRti) { + var t1, cache, key, probe, rti; + if (genericFunctionRti == null) + return null; + t1 = instantiationRti._rest; + cache = genericFunctionRti._bindCache; + if (cache == null) + cache = genericFunctionRti._bindCache = new Map(); + key = instantiationRti._canonicalRecipe; + probe = cache.get(key); + if (probe != null) + return probe; + rti = A._substitute(init.typeUniverse, genericFunctionRti._primary, t1, 0); + cache.set(key, rti); + return rti; + }, + _substitute(universe, rti, typeArguments, depth) { + var baseType, substitutedBaseType, interfaceTypeArguments, substitutedInterfaceTypeArguments, base, substitutedBase, $arguments, substitutedArguments, t1, fields, substitutedFields, returnType, substitutedReturnType, functionParameters, substitutedFunctionParameters, bounds, substitutedBounds, index, argument, + kind = rti._kind; + switch (kind) { + case 5: + case 1: + case 2: + case 3: + case 4: + return rti; + case 6: + baseType = rti._primary; + substitutedBaseType = A._substitute(universe, baseType, typeArguments, depth); + if (substitutedBaseType === baseType) + return rti; + return A._Universe__lookupStarRti(universe, substitutedBaseType, true); + case 7: + baseType = rti._primary; + substitutedBaseType = A._substitute(universe, baseType, typeArguments, depth); + if (substitutedBaseType === baseType) + return rti; + return A._Universe__lookupQuestionRti(universe, substitutedBaseType, true); + case 8: + baseType = rti._primary; + substitutedBaseType = A._substitute(universe, baseType, typeArguments, depth); + if (substitutedBaseType === baseType) + return rti; + return A._Universe__lookupFutureOrRti(universe, substitutedBaseType, true); + case 9: + interfaceTypeArguments = rti._rest; + substitutedInterfaceTypeArguments = A._substituteArray(universe, interfaceTypeArguments, typeArguments, depth); + if (substitutedInterfaceTypeArguments === interfaceTypeArguments) + return rti; + return A._Universe__lookupInterfaceRti(universe, rti._primary, substitutedInterfaceTypeArguments); + case 10: + base = rti._primary; + substitutedBase = A._substitute(universe, base, typeArguments, depth); + $arguments = rti._rest; + substitutedArguments = A._substituteArray(universe, $arguments, typeArguments, depth); + if (substitutedBase === base && substitutedArguments === $arguments) + return rti; + return A._Universe__lookupBindingRti(universe, substitutedBase, substitutedArguments); + case 11: + t1 = rti._primary; + fields = rti._rest; + substitutedFields = A._substituteArray(universe, fields, typeArguments, depth); + if (substitutedFields === fields) + return rti; + return A._Universe__lookupRecordRti(universe, t1, substitutedFields); + case 12: + returnType = rti._primary; + substitutedReturnType = A._substitute(universe, returnType, typeArguments, depth); + functionParameters = rti._rest; + substitutedFunctionParameters = A._substituteFunctionParameters(universe, functionParameters, typeArguments, depth); + if (substitutedReturnType === returnType && substitutedFunctionParameters === functionParameters) + return rti; + return A._Universe__lookupFunctionRti(universe, substitutedReturnType, substitutedFunctionParameters); + case 13: + bounds = rti._rest; + depth += bounds.length; + substitutedBounds = A._substituteArray(universe, bounds, typeArguments, depth); + base = rti._primary; + substitutedBase = A._substitute(universe, base, typeArguments, depth); + if (substitutedBounds === bounds && substitutedBase === base) + return rti; + return A._Universe__lookupGenericFunctionRti(universe, substitutedBase, substitutedBounds, true); + case 14: + index = rti._primary; + if (index < depth) + return rti; + argument = typeArguments[index - depth]; + if (argument == null) + return rti; + return argument; + default: + throw A.wrapException(A.AssertionError$("Attempted to substitute unexpected RTI kind " + kind)); + } + }, + _substituteArray(universe, rtiArray, typeArguments, depth) { + var changed, i, rti, substitutedRti, + $length = rtiArray.length, + result = A._Utils_newArrayOrEmpty($length); + for (changed = false, i = 0; i < $length; ++i) { + rti = rtiArray[i]; + substitutedRti = A._substitute(universe, rti, typeArguments, depth); + if (substitutedRti !== rti) + changed = true; + result[i] = substitutedRti; + } + return changed ? result : rtiArray; + }, + _substituteNamed(universe, namedArray, typeArguments, depth) { + var changed, i, t1, t2, rti, substitutedRti, + $length = namedArray.length, + result = A._Utils_newArrayOrEmpty($length); + for (changed = false, i = 0; i < $length; i += 3) { + t1 = namedArray[i]; + t2 = namedArray[i + 1]; + rti = namedArray[i + 2]; + substitutedRti = A._substitute(universe, rti, typeArguments, depth); + if (substitutedRti !== rti) + changed = true; + result.splice(i, 3, t1, t2, substitutedRti); + } + return changed ? result : namedArray; + }, + _substituteFunctionParameters(universe, functionParameters, typeArguments, depth) { + var result, + requiredPositional = functionParameters._requiredPositional, + substitutedRequiredPositional = A._substituteArray(universe, requiredPositional, typeArguments, depth), + optionalPositional = functionParameters._optionalPositional, + substitutedOptionalPositional = A._substituteArray(universe, optionalPositional, typeArguments, depth), + named = functionParameters._named, + substitutedNamed = A._substituteNamed(universe, named, typeArguments, depth); + if (substitutedRequiredPositional === requiredPositional && substitutedOptionalPositional === optionalPositional && substitutedNamed === named) + return functionParameters; + result = new A._FunctionParameters(); + result._requiredPositional = substitutedRequiredPositional; + result._optionalPositional = substitutedOptionalPositional; + result._named = substitutedNamed; + return result; + }, + _setArrayType(target, rti) { + target[init.arrayRti] = rti; + return target; + }, + closureFunctionType(closure) { + var signature = closure.$signature; + if (signature != null) { + if (typeof signature == "number") + return A.getTypeFromTypesTable(signature); + return closure.$signature(); + } + return null; + }, + instanceOrFunctionType(object, testRti) { + var rti; + if (A.Rti__isUnionOfFunctionType(testRti)) + if (object instanceof A.Closure) { + rti = A.closureFunctionType(object); + if (rti != null) + return rti; + } + return A.instanceType(object); + }, + instanceType(object) { + if (object instanceof A.Object) + return A._instanceType(object); + if (Array.isArray(object)) + return A._arrayInstanceType(object); + return A._instanceTypeFromConstructor(J.getInterceptor$(object)); + }, + _arrayInstanceType(object) { + var rti = object[init.arrayRti], + defaultRti = type$.JSArray_dynamic; + if (rti == null) + return defaultRti; + if (rti.constructor !== defaultRti.constructor) + return defaultRti; + return rti; + }, + _instanceType(object) { + var rti = object.$ti; + return rti != null ? rti : A._instanceTypeFromConstructor(object); + }, + _instanceTypeFromConstructor(instance) { + var $constructor = instance.constructor, + probe = $constructor.$ccache; + if (probe != null) + return probe; + return A._instanceTypeFromConstructorMiss(instance, $constructor); + }, + _instanceTypeFromConstructorMiss(instance, $constructor) { + var effectiveConstructor = instance instanceof A.Closure ? Object.getPrototypeOf(Object.getPrototypeOf(instance)).constructor : $constructor, + rti = A._Universe_findErasedType(init.typeUniverse, effectiveConstructor.name); + $constructor.$ccache = rti; + return rti; + }, + getTypeFromTypesTable(index) { + var rti, + table = init.types, + type = table[index]; + if (typeof type == "string") { + rti = A._Universe_eval(init.typeUniverse, type, false); + table[index] = rti; + return rti; + } + return type; + }, + getRuntimeTypeOfDartObject(object) { + return A.createRuntimeType(A._instanceType(object)); + }, + getRuntimeTypeOfClosure(closure) { + var rti = A.closureFunctionType(closure); + return A.createRuntimeType(rti == null ? A.instanceType(closure) : rti); + }, + _structuralTypeOf(object) { + var functionRti; + if (object instanceof A._Record) + return A.evaluateRtiForRecord(object.$recipe, object._getFieldValues$0()); + functionRti = object instanceof A.Closure ? A.closureFunctionType(object) : null; + if (functionRti != null) + return functionRti; + if (type$.TrustedGetRuntimeType._is(object)) + return J.get$runtimeType$(object)._rti; + if (Array.isArray(object)) + return A._arrayInstanceType(object); + return A.instanceType(object); + }, + createRuntimeType(rti) { + var t1 = rti._cachedRuntimeType; + return t1 == null ? rti._cachedRuntimeType = A._createRuntimeType(rti) : t1; + }, + _createRuntimeType(rti) { + var starErasedRti, t1, + s = rti._canonicalRecipe, + starErasedRecipe = s.replace(/\*/g, ""); + if (starErasedRecipe === s) + return rti._cachedRuntimeType = new A._Type(rti); + starErasedRti = A._Universe_eval(init.typeUniverse, starErasedRecipe, true); + t1 = starErasedRti._cachedRuntimeType; + return t1 == null ? starErasedRti._cachedRuntimeType = A._createRuntimeType(starErasedRti) : t1; + }, + evaluateRtiForRecord(recordRecipe, valuesList) { + var bindings, i, + values = valuesList, + $length = values.length; + if ($length === 0) + return type$.Record_0; + bindings = A._Universe_evalInEnvironment(init.typeUniverse, A._structuralTypeOf(values[0]), "@<0>"); + for (i = 1; i < $length; ++i) + bindings = A._Universe_bind(init.typeUniverse, bindings, A._structuralTypeOf(values[i])); + return A._Universe_evalInEnvironment(init.typeUniverse, bindings, recordRecipe); + }, + typeLiteral(recipe) { + return A.createRuntimeType(A._Universe_eval(init.typeUniverse, recipe, false)); + }, + _installSpecializedIsTest(object) { + var t1, unstarred, unstarredKind, isFn, $name, predicate, testRti = this; + if (testRti === type$.Object) + return A._finishIsFn(testRti, object, A._isObject); + if (!A.isSoundTopType(testRti)) + t1 = testRti === type$.legacy_Object; + else + t1 = true; + if (t1) + return A._finishIsFn(testRti, object, A._isTop); + t1 = testRti._kind; + if (t1 === 7) + return A._finishIsFn(testRti, object, A._generalNullableIsTestImplementation); + if (t1 === 1) + return A._finishIsFn(testRti, object, A._isNever); + unstarred = t1 === 6 ? testRti._primary : testRti; + unstarredKind = unstarred._kind; + if (unstarredKind === 8) + return A._finishIsFn(testRti, object, A._isFutureOr); + if (unstarred === type$.int) + isFn = A._isInt; + else if (unstarred === type$.double || unstarred === type$.num) + isFn = A._isNum; + else if (unstarred === type$.String) + isFn = A._isString; + else + isFn = unstarred === type$.bool ? A._isBool : null; + if (isFn != null) + return A._finishIsFn(testRti, object, isFn); + if (unstarredKind === 9) { + $name = unstarred._primary; + if (unstarred._rest.every(A.isDefinitelyTopType)) { + testRti._specializedTestResource = "$is" + $name; + if ($name === "List") + return A._finishIsFn(testRti, object, A._isListTestViaProperty); + return A._finishIsFn(testRti, object, A._isTestViaProperty); + } + } else if (unstarredKind === 11) { + predicate = A.createRecordTypePredicate(unstarred._primary, unstarred._rest); + return A._finishIsFn(testRti, object, predicate == null ? A._isNever : predicate); + } + return A._finishIsFn(testRti, object, A._generalIsTestImplementation); + }, + _finishIsFn(testRti, object, isFn) { + testRti._is = isFn; + return testRti._is(object); + }, + _installSpecializedAsCheck(object) { + var t1, testRti = this, + asFn = A._generalAsCheckImplementation; + if (!A.isSoundTopType(testRti)) + t1 = testRti === type$.legacy_Object; + else + t1 = true; + if (t1) + asFn = A._asTop; + else if (testRti === type$.Object) + asFn = A._asObject; + else { + t1 = A.isNullable(testRti); + if (t1) + asFn = A._generalNullableAsCheckImplementation; + } + testRti._as = asFn; + return testRti._as(object); + }, + _nullIs(testRti) { + var kind = testRti._kind, + t1 = true; + if (!A.isSoundTopType(testRti)) + if (!(testRti === type$.legacy_Object)) + if (!(testRti === type$.legacy_Never)) + if (kind !== 7) + if (!(kind === 6 && A._nullIs(testRti._primary))) + t1 = kind === 8 && A._nullIs(testRti._primary) || testRti === type$.Null || testRti === type$.JSNull; + return t1; + }, + _generalIsTestImplementation(object) { + var testRti = this; + if (object == null) + return A._nullIs(testRti); + return A.isSubtype(init.typeUniverse, A.instanceOrFunctionType(object, testRti), testRti); + }, + _generalNullableIsTestImplementation(object) { + if (object == null) + return true; + return this._primary._is(object); + }, + _isTestViaProperty(object) { + var tag, testRti = this; + if (object == null) + return A._nullIs(testRti); + tag = testRti._specializedTestResource; + if (object instanceof A.Object) + return !!object[tag]; + return !!J.getInterceptor$(object)[tag]; + }, + _isListTestViaProperty(object) { + var tag, testRti = this; + if (object == null) + return A._nullIs(testRti); + if (typeof object != "object") + return false; + if (Array.isArray(object)) + return true; + tag = testRti._specializedTestResource; + if (object instanceof A.Object) + return !!object[tag]; + return !!J.getInterceptor$(object)[tag]; + }, + _generalAsCheckImplementation(object) { + var testRti = this; + if (object == null) { + if (A.isNullable(testRti)) + return object; + } else if (testRti._is(object)) + return object; + A._failedAsCheck(object, testRti); + }, + _generalNullableAsCheckImplementation(object) { + var testRti = this; + if (object == null) + return object; + else if (testRti._is(object)) + return object; + A._failedAsCheck(object, testRti); + }, + _failedAsCheck(object, testRti) { + throw A.wrapException(A._TypeError$fromMessage(A._Error_compose(object, A._rtiToString(testRti, null)))); + }, + _Error_compose(object, checkedTypeDescription) { + return A.Error_safeToString(object) + ": type '" + A._rtiToString(A._structuralTypeOf(object), null) + "' is not a subtype of type '" + checkedTypeDescription + "'"; + }, + _TypeError$fromMessage(message) { + return new A._TypeError("TypeError: " + message); + }, + _TypeError__TypeError$forType(object, type) { + return new A._TypeError("TypeError: " + A._Error_compose(object, type)); + }, + _isFutureOr(object) { + var testRti = this, + unstarred = testRti._kind === 6 ? testRti._primary : testRti; + return unstarred._primary._is(object) || A.Rti__getFutureFromFutureOr(init.typeUniverse, unstarred)._is(object); + }, + _isObject(object) { + return object != null; + }, + _asObject(object) { + if (object != null) + return object; + throw A.wrapException(A._TypeError__TypeError$forType(object, "Object")); + }, + _isTop(object) { + return true; + }, + _asTop(object) { + return object; + }, + _isNever(object) { + return false; + }, + _isBool(object) { + return true === object || false === object; + }, + _asBool(object) { + if (true === object) + return true; + if (false === object) + return false; + throw A.wrapException(A._TypeError__TypeError$forType(object, "bool")); + }, + _asBoolS(object) { + if (true === object) + return true; + if (false === object) + return false; + if (object == null) + return object; + throw A.wrapException(A._TypeError__TypeError$forType(object, "bool")); + }, + _asBoolQ(object) { + if (true === object) + return true; + if (false === object) + return false; + if (object == null) + return object; + throw A.wrapException(A._TypeError__TypeError$forType(object, "bool?")); + }, + _asDouble(object) { + if (typeof object == "number") + return object; + throw A.wrapException(A._TypeError__TypeError$forType(object, "double")); + }, + _asDoubleS(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw A.wrapException(A._TypeError__TypeError$forType(object, "double")); + }, + _asDoubleQ(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw A.wrapException(A._TypeError__TypeError$forType(object, "double?")); + }, + _isInt(object) { + return typeof object == "number" && Math.floor(object) === object; + }, + _asInt(object) { + if (typeof object == "number" && Math.floor(object) === object) + return object; + throw A.wrapException(A._TypeError__TypeError$forType(object, "int")); + }, + _asIntS(object) { + if (typeof object == "number" && Math.floor(object) === object) + return object; + if (object == null) + return object; + throw A.wrapException(A._TypeError__TypeError$forType(object, "int")); + }, + _asIntQ(object) { + if (typeof object == "number" && Math.floor(object) === object) + return object; + if (object == null) + return object; + throw A.wrapException(A._TypeError__TypeError$forType(object, "int?")); + }, + _isNum(object) { + return typeof object == "number"; + }, + _asNum(object) { + if (typeof object == "number") + return object; + throw A.wrapException(A._TypeError__TypeError$forType(object, "num")); + }, + _asNumS(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw A.wrapException(A._TypeError__TypeError$forType(object, "num")); + }, + _asNumQ(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw A.wrapException(A._TypeError__TypeError$forType(object, "num?")); + }, + _isString(object) { + return typeof object == "string"; + }, + _asString(object) { + if (typeof object == "string") + return object; + throw A.wrapException(A._TypeError__TypeError$forType(object, "String")); + }, + _asStringS(object) { + if (typeof object == "string") + return object; + if (object == null) + return object; + throw A.wrapException(A._TypeError__TypeError$forType(object, "String")); + }, + _asStringQ(object) { + if (typeof object == "string") + return object; + if (object == null) + return object; + throw A.wrapException(A._TypeError__TypeError$forType(object, "String?")); + }, + _rtiArrayToString(array, genericContext) { + var s, sep, i; + for (s = "", sep = "", i = 0; i < array.length; ++i, sep = ", ") + s += sep + A._rtiToString(array[i], genericContext); + return s; + }, + _recordRtiToString(recordType, genericContext) { + var fieldCount, names, namesIndex, s, comma, i, + partialShape = recordType._primary, + fields = recordType._rest; + if ("" === partialShape) + return "(" + A._rtiArrayToString(fields, genericContext) + ")"; + fieldCount = fields.length; + names = partialShape.split(","); + namesIndex = names.length - fieldCount; + for (s = "(", comma = "", i = 0; i < fieldCount; ++i, comma = ", ") { + s += comma; + if (namesIndex === 0) + s += "{"; + s += A._rtiToString(fields[i], genericContext); + if (namesIndex >= 0) + s += " " + names[namesIndex]; + ++namesIndex; + } + return s + "})"; + }, + _functionRtiToString(functionType, genericContext, bounds) { + var boundsLength, offset, i, t1, t2, typeParametersText, typeSep, boundRti, kind, t3, parameters, requiredPositional, requiredPositionalLength, optionalPositional, optionalPositionalLength, named, namedLength, returnTypeText, argumentsText, sep, _s2_ = ", ", outerContextLength = null; + if (bounds != null) { + boundsLength = bounds.length; + if (genericContext == null) + genericContext = A._setArrayType([], type$.JSArray_String); + else + outerContextLength = genericContext.length; + offset = genericContext.length; + for (i = boundsLength; i > 0; --i) + genericContext.push("T" + (offset + i)); + for (t1 = type$.nullable_Object, t2 = type$.legacy_Object, typeParametersText = "<", typeSep = "", i = 0; i < boundsLength; ++i, typeSep = _s2_) { + typeParametersText = typeParametersText + typeSep + genericContext[genericContext.length - 1 - i]; + boundRti = bounds[i]; + kind = boundRti._kind; + if (!(kind === 2 || kind === 3 || kind === 4 || kind === 5 || boundRti === t1)) + t3 = boundRti === t2; + else + t3 = true; + if (!t3) + typeParametersText += " extends " + A._rtiToString(boundRti, genericContext); + } + typeParametersText += ">"; + } else + typeParametersText = ""; + t1 = functionType._primary; + parameters = functionType._rest; + requiredPositional = parameters._requiredPositional; + requiredPositionalLength = requiredPositional.length; + optionalPositional = parameters._optionalPositional; + optionalPositionalLength = optionalPositional.length; + named = parameters._named; + namedLength = named.length; + returnTypeText = A._rtiToString(t1, genericContext); + for (argumentsText = "", sep = "", i = 0; i < requiredPositionalLength; ++i, sep = _s2_) + argumentsText += sep + A._rtiToString(requiredPositional[i], genericContext); + if (optionalPositionalLength > 0) { + argumentsText += sep + "["; + for (sep = "", i = 0; i < optionalPositionalLength; ++i, sep = _s2_) + argumentsText += sep + A._rtiToString(optionalPositional[i], genericContext); + argumentsText += "]"; + } + if (namedLength > 0) { + argumentsText += sep + "{"; + for (sep = "", i = 0; i < namedLength; i += 3, sep = _s2_) { + argumentsText += sep; + if (named[i + 1]) + argumentsText += "required "; + argumentsText += A._rtiToString(named[i + 2], genericContext) + " " + named[i]; + } + argumentsText += "}"; + } + if (outerContextLength != null) { + genericContext.toString; + genericContext.length = outerContextLength; + } + return typeParametersText + "(" + argumentsText + ") => " + returnTypeText; + }, + _rtiToString(rti, genericContext) { + var questionArgument, s, argumentKind, $name, $arguments, t1, + kind = rti._kind; + if (kind === 5) + return "erased"; + if (kind === 2) + return "dynamic"; + if (kind === 3) + return "void"; + if (kind === 1) + return "Never"; + if (kind === 4) + return "any"; + if (kind === 6) + return A._rtiToString(rti._primary, genericContext); + if (kind === 7) { + questionArgument = rti._primary; + s = A._rtiToString(questionArgument, genericContext); + argumentKind = questionArgument._kind; + return (argumentKind === 12 || argumentKind === 13 ? "(" + s + ")" : s) + "?"; + } + if (kind === 8) + return "FutureOr<" + A._rtiToString(rti._primary, genericContext) + ">"; + if (kind === 9) { + $name = A._unminifyOrTag(rti._primary); + $arguments = rti._rest; + return $arguments.length > 0 ? $name + ("<" + A._rtiArrayToString($arguments, genericContext) + ">") : $name; + } + if (kind === 11) + return A._recordRtiToString(rti, genericContext); + if (kind === 12) + return A._functionRtiToString(rti, genericContext, null); + if (kind === 13) + return A._functionRtiToString(rti._primary, genericContext, rti._rest); + if (kind === 14) { + t1 = rti._primary; + return genericContext[genericContext.length - 1 - t1]; + } + return "?"; + }, + _unminifyOrTag(rawClassName) { + var preserved = init.mangledGlobalNames[rawClassName]; + if (preserved != null) + return preserved; + return rawClassName; + }, + _Universe_findRule(universe, targetType) { + var rule = universe.tR[targetType]; + for (; typeof rule == "string";) + rule = universe.tR[rule]; + return rule; + }, + _Universe_findErasedType(universe, cls) { + var $length, erased, $arguments, i, $interface, + t1 = universe.eT, + probe = t1[cls]; + if (probe == null) + return A._Universe_eval(universe, cls, false); + else if (typeof probe == "number") { + $length = probe; + erased = A._Universe__lookupTerminalRti(universe, 5, "#"); + $arguments = A._Utils_newArrayOrEmpty($length); + for (i = 0; i < $length; ++i) + $arguments[i] = erased; + $interface = A._Universe__lookupInterfaceRti(universe, cls, $arguments); + t1[cls] = $interface; + return $interface; + } else + return probe; + }, + _Universe_addRules(universe, rules) { + return A._Utils_objectAssign(universe.tR, rules); + }, + _Universe_addErasedTypes(universe, types) { + return A._Utils_objectAssign(universe.eT, types); + }, + _Universe_eval(universe, recipe, normalize) { + var rti, + t1 = universe.eC, + probe = t1.get(recipe); + if (probe != null) + return probe; + rti = A._Parser_parse(A._Parser_create(universe, null, recipe, normalize)); + t1.set(recipe, rti); + return rti; + }, + _Universe_evalInEnvironment(universe, environment, recipe) { + var probe, rti, + cache = environment._evalCache; + if (cache == null) + cache = environment._evalCache = new Map(); + probe = cache.get(recipe); + if (probe != null) + return probe; + rti = A._Parser_parse(A._Parser_create(universe, environment, recipe, true)); + cache.set(recipe, rti); + return rti; + }, + _Universe_bind(universe, environment, argumentsRti) { + var argumentsRecipe, probe, rti, + cache = environment._bindCache; + if (cache == null) + cache = environment._bindCache = new Map(); + argumentsRecipe = argumentsRti._canonicalRecipe; + probe = cache.get(argumentsRecipe); + if (probe != null) + return probe; + rti = A._Universe__lookupBindingRti(universe, environment, argumentsRti._kind === 10 ? argumentsRti._rest : [argumentsRti]); + cache.set(argumentsRecipe, rti); + return rti; + }, + _Universe__installTypeTests(universe, rti) { + rti._as = A._installSpecializedAsCheck; + rti._is = A._installSpecializedIsTest; + return rti; + }, + _Universe__lookupTerminalRti(universe, kind, key) { + var rti, t1, + probe = universe.eC.get(key); + if (probe != null) + return probe; + rti = new A.Rti(null, null); + rti._kind = kind; + rti._canonicalRecipe = key; + t1 = A._Universe__installTypeTests(universe, rti); + universe.eC.set(key, t1); + return t1; + }, + _Universe__lookupStarRti(universe, baseType, normalize) { + var t1, + key = baseType._canonicalRecipe + "*", + probe = universe.eC.get(key); + if (probe != null) + return probe; + t1 = A._Universe__createStarRti(universe, baseType, key, normalize); + universe.eC.set(key, t1); + return t1; + }, + _Universe__createStarRti(universe, baseType, key, normalize) { + var baseKind, t1, rti; + if (normalize) { + baseKind = baseType._kind; + if (!A.isSoundTopType(baseType)) + t1 = baseType === type$.Null || baseType === type$.JSNull || baseKind === 7 || baseKind === 6; + else + t1 = true; + if (t1) + return baseType; + } + rti = new A.Rti(null, null); + rti._kind = 6; + rti._primary = baseType; + rti._canonicalRecipe = key; + return A._Universe__installTypeTests(universe, rti); + }, + _Universe__lookupQuestionRti(universe, baseType, normalize) { + var t1, + key = baseType._canonicalRecipe + "?", + probe = universe.eC.get(key); + if (probe != null) + return probe; + t1 = A._Universe__createQuestionRti(universe, baseType, key, normalize); + universe.eC.set(key, t1); + return t1; + }, + _Universe__createQuestionRti(universe, baseType, key, normalize) { + var baseKind, t1, starArgument, rti; + if (normalize) { + baseKind = baseType._kind; + t1 = true; + if (!A.isSoundTopType(baseType)) + if (!(baseType === type$.Null || baseType === type$.JSNull)) + if (baseKind !== 7) + t1 = baseKind === 8 && A.isNullable(baseType._primary); + if (t1) + return baseType; + else if (baseKind === 1 || baseType === type$.legacy_Never) + return type$.Null; + else if (baseKind === 6) { + starArgument = baseType._primary; + if (starArgument._kind === 8 && A.isNullable(starArgument._primary)) + return starArgument; + else + return A.Rti__getQuestionFromStar(universe, baseType); + } + } + rti = new A.Rti(null, null); + rti._kind = 7; + rti._primary = baseType; + rti._canonicalRecipe = key; + return A._Universe__installTypeTests(universe, rti); + }, + _Universe__lookupFutureOrRti(universe, baseType, normalize) { + var t1, + key = baseType._canonicalRecipe + "/", + probe = universe.eC.get(key); + if (probe != null) + return probe; + t1 = A._Universe__createFutureOrRti(universe, baseType, key, normalize); + universe.eC.set(key, t1); + return t1; + }, + _Universe__createFutureOrRti(universe, baseType, key, normalize) { + var t1, rti; + if (normalize) { + t1 = baseType._kind; + if (A.isSoundTopType(baseType) || baseType === type$.Object || baseType === type$.legacy_Object) + return baseType; + else if (t1 === 1) + return A._Universe__lookupInterfaceRti(universe, "Future", [baseType]); + else if (baseType === type$.Null || baseType === type$.JSNull) + return type$.nullable_Future_Null; + } + rti = new A.Rti(null, null); + rti._kind = 8; + rti._primary = baseType; + rti._canonicalRecipe = key; + return A._Universe__installTypeTests(universe, rti); + }, + _Universe__lookupGenericFunctionParameterRti(universe, index) { + var rti, t1, + key = "" + index + "^", + probe = universe.eC.get(key); + if (probe != null) + return probe; + rti = new A.Rti(null, null); + rti._kind = 14; + rti._primary = index; + rti._canonicalRecipe = key; + t1 = A._Universe__installTypeTests(universe, rti); + universe.eC.set(key, t1); + return t1; + }, + _Universe__canonicalRecipeJoin($arguments) { + var s, sep, i, + $length = $arguments.length; + for (s = "", sep = "", i = 0; i < $length; ++i, sep = ",") + s += sep + $arguments[i]._canonicalRecipe; + return s; + }, + _Universe__canonicalRecipeJoinNamed($arguments) { + var s, sep, i, t1, nameSep, + $length = $arguments.length; + for (s = "", sep = "", i = 0; i < $length; i += 3, sep = ",") { + t1 = $arguments[i]; + nameSep = $arguments[i + 1] ? "!" : ":"; + s += sep + t1 + nameSep + $arguments[i + 2]._canonicalRecipe; + } + return s; + }, + _Universe__lookupInterfaceRti(universe, $name, $arguments) { + var probe, rti, t1, + s = $name; + if ($arguments.length > 0) + s += "<" + A._Universe__canonicalRecipeJoin($arguments) + ">"; + probe = universe.eC.get(s); + if (probe != null) + return probe; + rti = new A.Rti(null, null); + rti._kind = 9; + rti._primary = $name; + rti._rest = $arguments; + if ($arguments.length > 0) + rti._precomputed1 = $arguments[0]; + rti._canonicalRecipe = s; + t1 = A._Universe__installTypeTests(universe, rti); + universe.eC.set(s, t1); + return t1; + }, + _Universe__lookupBindingRti(universe, base, $arguments) { + var newBase, newArguments, key, probe, rti, t1; + if (base._kind === 10) { + newBase = base._primary; + newArguments = base._rest.concat($arguments); + } else { + newArguments = $arguments; + newBase = base; + } + key = newBase._canonicalRecipe + (";<" + A._Universe__canonicalRecipeJoin(newArguments) + ">"); + probe = universe.eC.get(key); + if (probe != null) + return probe; + rti = new A.Rti(null, null); + rti._kind = 10; + rti._primary = newBase; + rti._rest = newArguments; + rti._canonicalRecipe = key; + t1 = A._Universe__installTypeTests(universe, rti); + universe.eC.set(key, t1); + return t1; + }, + _Universe__lookupRecordRti(universe, partialShapeTag, fields) { + var rti, t1, + key = "+" + (partialShapeTag + "(" + A._Universe__canonicalRecipeJoin(fields) + ")"), + probe = universe.eC.get(key); + if (probe != null) + return probe; + rti = new A.Rti(null, null); + rti._kind = 11; + rti._primary = partialShapeTag; + rti._rest = fields; + rti._canonicalRecipe = key; + t1 = A._Universe__installTypeTests(universe, rti); + universe.eC.set(key, t1); + return t1; + }, + _Universe__lookupFunctionRti(universe, returnType, parameters) { + var sep, key, probe, rti, t1, + s = returnType._canonicalRecipe, + requiredPositional = parameters._requiredPositional, + requiredPositionalLength = requiredPositional.length, + optionalPositional = parameters._optionalPositional, + optionalPositionalLength = optionalPositional.length, + named = parameters._named, + namedLength = named.length, + recipe = "(" + A._Universe__canonicalRecipeJoin(requiredPositional); + if (optionalPositionalLength > 0) { + sep = requiredPositionalLength > 0 ? "," : ""; + recipe += sep + "[" + A._Universe__canonicalRecipeJoin(optionalPositional) + "]"; + } + if (namedLength > 0) { + sep = requiredPositionalLength > 0 ? "," : ""; + recipe += sep + "{" + A._Universe__canonicalRecipeJoinNamed(named) + "}"; + } + key = s + (recipe + ")"); + probe = universe.eC.get(key); + if (probe != null) + return probe; + rti = new A.Rti(null, null); + rti._kind = 12; + rti._primary = returnType; + rti._rest = parameters; + rti._canonicalRecipe = key; + t1 = A._Universe__installTypeTests(universe, rti); + universe.eC.set(key, t1); + return t1; + }, + _Universe__lookupGenericFunctionRti(universe, baseFunctionType, bounds, normalize) { + var t1, + key = baseFunctionType._canonicalRecipe + ("<" + A._Universe__canonicalRecipeJoin(bounds) + ">"), + probe = universe.eC.get(key); + if (probe != null) + return probe; + t1 = A._Universe__createGenericFunctionRti(universe, baseFunctionType, bounds, key, normalize); + universe.eC.set(key, t1); + return t1; + }, + _Universe__createGenericFunctionRti(universe, baseFunctionType, bounds, key, normalize) { + var $length, typeArguments, count, i, bound, substitutedBase, substitutedBounds, rti; + if (normalize) { + $length = bounds.length; + typeArguments = A._Utils_newArrayOrEmpty($length); + for (count = 0, i = 0; i < $length; ++i) { + bound = bounds[i]; + if (bound._kind === 1) { + typeArguments[i] = bound; + ++count; + } + } + if (count > 0) { + substitutedBase = A._substitute(universe, baseFunctionType, typeArguments, 0); + substitutedBounds = A._substituteArray(universe, bounds, typeArguments, 0); + return A._Universe__lookupGenericFunctionRti(universe, substitutedBase, substitutedBounds, bounds !== substitutedBounds); + } + } + rti = new A.Rti(null, null); + rti._kind = 13; + rti._primary = baseFunctionType; + rti._rest = bounds; + rti._canonicalRecipe = key; + return A._Universe__installTypeTests(universe, rti); + }, + _Parser_create(universe, environment, recipe, normalize) { + return {u: universe, e: environment, r: recipe, s: [], p: 0, n: normalize}; + }, + _Parser_parse(parser) { + var t2, i, ch, t3, array, end, item, + source = parser.r, + t1 = parser.s; + for (t2 = source.length, i = 0; i < t2;) { + ch = source.charCodeAt(i); + if (ch >= 48 && ch <= 57) + i = A._Parser_handleDigit(i + 1, ch, source, t1); + else if ((((ch | 32) >>> 0) - 97 & 65535) < 26 || ch === 95 || ch === 36 || ch === 124) + i = A._Parser_handleIdentifier(parser, i, source, t1, false); + else if (ch === 46) + i = A._Parser_handleIdentifier(parser, i, source, t1, true); + else { + ++i; + switch (ch) { + case 44: + break; + case 58: + t1.push(false); + break; + case 33: + t1.push(true); + break; + case 59: + t1.push(A._Parser_toType(parser.u, parser.e, t1.pop())); + break; + case 94: + t1.push(A._Universe__lookupGenericFunctionParameterRti(parser.u, t1.pop())); + break; + case 35: + t1.push(A._Universe__lookupTerminalRti(parser.u, 5, "#")); + break; + case 64: + t1.push(A._Universe__lookupTerminalRti(parser.u, 2, "@")); + break; + case 126: + t1.push(A._Universe__lookupTerminalRti(parser.u, 3, "~")); + break; + case 60: + t1.push(parser.p); + parser.p = t1.length; + break; + case 62: + A._Parser_handleTypeArguments(parser, t1); + break; + case 38: + A._Parser_handleExtendedOperations(parser, t1); + break; + case 42: + t3 = parser.u; + t1.push(A._Universe__lookupStarRti(t3, A._Parser_toType(t3, parser.e, t1.pop()), parser.n)); + break; + case 63: + t3 = parser.u; + t1.push(A._Universe__lookupQuestionRti(t3, A._Parser_toType(t3, parser.e, t1.pop()), parser.n)); + break; + case 47: + t3 = parser.u; + t1.push(A._Universe__lookupFutureOrRti(t3, A._Parser_toType(t3, parser.e, t1.pop()), parser.n)); + break; + case 40: + t1.push(-3); + t1.push(parser.p); + parser.p = t1.length; + break; + case 41: + A._Parser_handleArguments(parser, t1); + break; + case 91: + t1.push(parser.p); + parser.p = t1.length; + break; + case 93: + array = t1.splice(parser.p); + A._Parser_toTypes(parser.u, parser.e, array); + parser.p = t1.pop(); + t1.push(array); + t1.push(-1); + break; + case 123: + t1.push(parser.p); + parser.p = t1.length; + break; + case 125: + array = t1.splice(parser.p); + A._Parser_toTypesNamed(parser.u, parser.e, array); + parser.p = t1.pop(); + t1.push(array); + t1.push(-2); + break; + case 43: + end = source.indexOf("(", i); + t1.push(source.substring(i, end)); + t1.push(-4); + t1.push(parser.p); + parser.p = t1.length; + i = end + 1; + break; + default: + throw "Bad character " + ch; + } + } + } + item = t1.pop(); + return A._Parser_toType(parser.u, parser.e, item); + }, + _Parser_handleDigit(i, digit, source, stack) { + var t1, ch, + value = digit - 48; + for (t1 = source.length; i < t1; ++i) { + ch = source.charCodeAt(i); + if (!(ch >= 48 && ch <= 57)) + break; + value = value * 10 + (ch - 48); + } + stack.push(value); + return i; + }, + _Parser_handleIdentifier(parser, start, source, stack, hasPeriod) { + var t1, ch, t2, string, environment, recipe, + i = start + 1; + for (t1 = source.length; i < t1; ++i) { + ch = source.charCodeAt(i); + if (ch === 46) { + if (hasPeriod) + break; + hasPeriod = true; + } else { + if (!((((ch | 32) >>> 0) - 97 & 65535) < 26 || ch === 95 || ch === 36 || ch === 124)) + t2 = ch >= 48 && ch <= 57; + else + t2 = true; + if (!t2) + break; + } + } + string = source.substring(start, i); + if (hasPeriod) { + t1 = parser.u; + environment = parser.e; + if (environment._kind === 10) + environment = environment._primary; + recipe = A._Universe_findRule(t1, environment._primary)[string]; + if (recipe == null) + A.throwExpression('No "' + string + '" in "' + A.Rti__getCanonicalRecipe(environment) + '"'); + stack.push(A._Universe_evalInEnvironment(t1, environment, recipe)); + } else + stack.push(string); + return i; + }, + _Parser_handleTypeArguments(parser, stack) { + var base, + t1 = parser.u, + $arguments = A._Parser_collectArray(parser, stack), + head = stack.pop(); + if (typeof head == "string") + stack.push(A._Universe__lookupInterfaceRti(t1, head, $arguments)); + else { + base = A._Parser_toType(t1, parser.e, head); + switch (base._kind) { + case 12: + stack.push(A._Universe__lookupGenericFunctionRti(t1, base, $arguments, parser.n)); + break; + default: + stack.push(A._Universe__lookupBindingRti(t1, base, $arguments)); + break; + } + } + }, + _Parser_handleArguments(parser, stack) { + var requiredPositional, returnType, parameters, + t1 = parser.u, + head = stack.pop(), + optionalPositional = null, named = null; + if (typeof head == "number") + switch (head) { + case -1: + optionalPositional = stack.pop(); + break; + case -2: + named = stack.pop(); + break; + default: + stack.push(head); + break; + } + else + stack.push(head); + requiredPositional = A._Parser_collectArray(parser, stack); + head = stack.pop(); + switch (head) { + case -3: + head = stack.pop(); + if (optionalPositional == null) + optionalPositional = t1.sEA; + if (named == null) + named = t1.sEA; + returnType = A._Parser_toType(t1, parser.e, head); + parameters = new A._FunctionParameters(); + parameters._requiredPositional = requiredPositional; + parameters._optionalPositional = optionalPositional; + parameters._named = named; + stack.push(A._Universe__lookupFunctionRti(t1, returnType, parameters)); + return; + case -4: + stack.push(A._Universe__lookupRecordRti(t1, stack.pop(), requiredPositional)); + return; + default: + throw A.wrapException(A.AssertionError$("Unexpected state under `()`: " + A.S(head))); + } + }, + _Parser_handleExtendedOperations(parser, stack) { + var $top = stack.pop(); + if (0 === $top) { + stack.push(A._Universe__lookupTerminalRti(parser.u, 1, "0&")); + return; + } + if (1 === $top) { + stack.push(A._Universe__lookupTerminalRti(parser.u, 4, "1&")); + return; + } + throw A.wrapException(A.AssertionError$("Unexpected extended operation " + A.S($top))); + }, + _Parser_collectArray(parser, stack) { + var array = stack.splice(parser.p); + A._Parser_toTypes(parser.u, parser.e, array); + parser.p = stack.pop(); + return array; + }, + _Parser_toType(universe, environment, item) { + if (typeof item == "string") + return A._Universe__lookupInterfaceRti(universe, item, universe.sEA); + else if (typeof item == "number") { + environment.toString; + return A._Parser_indexToType(universe, environment, item); + } else + return item; + }, + _Parser_toTypes(universe, environment, items) { + var i, + $length = items.length; + for (i = 0; i < $length; ++i) + items[i] = A._Parser_toType(universe, environment, items[i]); + }, + _Parser_toTypesNamed(universe, environment, items) { + var i, + $length = items.length; + for (i = 2; i < $length; i += 3) + items[i] = A._Parser_toType(universe, environment, items[i]); + }, + _Parser_indexToType(universe, environment, index) { + var typeArguments, len, + kind = environment._kind; + if (kind === 10) { + if (index === 0) + return environment._primary; + typeArguments = environment._rest; + len = typeArguments.length; + if (index <= len) + return typeArguments[index - 1]; + index -= len; + environment = environment._primary; + kind = environment._kind; + } else if (index === 0) + return environment; + if (kind !== 9) + throw A.wrapException(A.AssertionError$("Indexed base must be an interface type")); + typeArguments = environment._rest; + if (index <= typeArguments.length) + return typeArguments[index - 1]; + throw A.wrapException(A.AssertionError$("Bad index " + index + " for " + environment.toString$0(0))); + }, + isSubtype(universe, s, t) { + var result, + sCache = s._isSubtypeCache; + if (sCache == null) + sCache = s._isSubtypeCache = new Map(); + result = sCache.get(t); + if (result == null) { + result = A._isSubtype(universe, s, null, t, null, false) ? 1 : 0; + sCache.set(t, result); + } + if (0 === result) + return false; + if (1 === result) + return true; + return true; + }, + _isSubtype(universe, s, sEnv, t, tEnv, isLegacy) { + var t1, sKind, leftTypeVariable, tKind, t2, sBounds, tBounds, sLength, i, sBound, tBound; + if (s === t) + return true; + if (!A.isSoundTopType(t)) + t1 = t === type$.legacy_Object; + else + t1 = true; + if (t1) + return true; + sKind = s._kind; + if (sKind === 4) + return true; + if (A.isSoundTopType(s)) + return false; + t1 = s._kind; + if (t1 === 1) + return true; + leftTypeVariable = sKind === 14; + if (leftTypeVariable) + if (A._isSubtype(universe, sEnv[s._primary], sEnv, t, tEnv, false)) + return true; + tKind = t._kind; + t1 = s === type$.Null || s === type$.JSNull; + if (t1) { + if (tKind === 8) + return A._isSubtype(universe, s, sEnv, t._primary, tEnv, false); + return t === type$.Null || t === type$.JSNull || tKind === 7 || tKind === 6; + } + if (t === type$.Object) { + if (sKind === 8) + return A._isSubtype(universe, s._primary, sEnv, t, tEnv, false); + if (sKind === 6) + return A._isSubtype(universe, s._primary, sEnv, t, tEnv, false); + return sKind !== 7; + } + if (sKind === 6) + return A._isSubtype(universe, s._primary, sEnv, t, tEnv, false); + if (tKind === 6) { + t1 = A.Rti__getQuestionFromStar(universe, t); + return A._isSubtype(universe, s, sEnv, t1, tEnv, false); + } + if (sKind === 8) { + if (!A._isSubtype(universe, s._primary, sEnv, t, tEnv, false)) + return false; + return A._isSubtype(universe, A.Rti__getFutureFromFutureOr(universe, s), sEnv, t, tEnv, false); + } + if (sKind === 7) { + t1 = A._isSubtype(universe, type$.Null, sEnv, t, tEnv, false); + return t1 && A._isSubtype(universe, s._primary, sEnv, t, tEnv, false); + } + if (tKind === 8) { + if (A._isSubtype(universe, s, sEnv, t._primary, tEnv, false)) + return true; + return A._isSubtype(universe, s, sEnv, A.Rti__getFutureFromFutureOr(universe, t), tEnv, false); + } + if (tKind === 7) { + t1 = A._isSubtype(universe, s, sEnv, type$.Null, tEnv, false); + return t1 || A._isSubtype(universe, s, sEnv, t._primary, tEnv, false); + } + if (leftTypeVariable) + return false; + t1 = sKind !== 12; + if ((!t1 || sKind === 13) && t === type$.Function) + return true; + t2 = sKind === 11; + if (t2 && t === type$.Record) + return true; + if (tKind === 13) { + if (s === type$.JavaScriptFunction) + return true; + if (sKind !== 13) + return false; + sBounds = s._rest; + tBounds = t._rest; + sLength = sBounds.length; + if (sLength !== tBounds.length) + return false; + sEnv = sEnv == null ? sBounds : sBounds.concat(sEnv); + tEnv = tEnv == null ? tBounds : tBounds.concat(tEnv); + for (i = 0; i < sLength; ++i) { + sBound = sBounds[i]; + tBound = tBounds[i]; + if (!A._isSubtype(universe, sBound, sEnv, tBound, tEnv, false) || !A._isSubtype(universe, tBound, tEnv, sBound, sEnv, false)) + return false; + } + return A._isFunctionSubtype(universe, s._primary, sEnv, t._primary, tEnv, false); + } + if (tKind === 12) { + if (s === type$.JavaScriptFunction) + return true; + if (t1) + return false; + return A._isFunctionSubtype(universe, s, sEnv, t, tEnv, false); + } + if (sKind === 9) { + if (tKind !== 9) + return false; + return A._isInterfaceSubtype(universe, s, sEnv, t, tEnv, false); + } + if (t2 && tKind === 11) + return A._isRecordSubtype(universe, s, sEnv, t, tEnv, false); + return false; + }, + _isFunctionSubtype(universe, s, sEnv, t, tEnv, isLegacy) { + var sParameters, tParameters, sRequiredPositional, tRequiredPositional, sRequiredPositionalLength, tRequiredPositionalLength, requiredPositionalDelta, sOptionalPositional, tOptionalPositional, sOptionalPositionalLength, tOptionalPositionalLength, i, t1, sNamed, tNamed, sNamedLength, tNamedLength, sIndex, tIndex, tName, sName, sIsRequired; + if (!A._isSubtype(universe, s._primary, sEnv, t._primary, tEnv, false)) + return false; + sParameters = s._rest; + tParameters = t._rest; + sRequiredPositional = sParameters._requiredPositional; + tRequiredPositional = tParameters._requiredPositional; + sRequiredPositionalLength = sRequiredPositional.length; + tRequiredPositionalLength = tRequiredPositional.length; + if (sRequiredPositionalLength > tRequiredPositionalLength) + return false; + requiredPositionalDelta = tRequiredPositionalLength - sRequiredPositionalLength; + sOptionalPositional = sParameters._optionalPositional; + tOptionalPositional = tParameters._optionalPositional; + sOptionalPositionalLength = sOptionalPositional.length; + tOptionalPositionalLength = tOptionalPositional.length; + if (sRequiredPositionalLength + sOptionalPositionalLength < tRequiredPositionalLength + tOptionalPositionalLength) + return false; + for (i = 0; i < sRequiredPositionalLength; ++i) { + t1 = sRequiredPositional[i]; + if (!A._isSubtype(universe, tRequiredPositional[i], tEnv, t1, sEnv, false)) + return false; + } + for (i = 0; i < requiredPositionalDelta; ++i) { + t1 = sOptionalPositional[i]; + if (!A._isSubtype(universe, tRequiredPositional[sRequiredPositionalLength + i], tEnv, t1, sEnv, false)) + return false; + } + for (i = 0; i < tOptionalPositionalLength; ++i) { + t1 = sOptionalPositional[requiredPositionalDelta + i]; + if (!A._isSubtype(universe, tOptionalPositional[i], tEnv, t1, sEnv, false)) + return false; + } + sNamed = sParameters._named; + tNamed = tParameters._named; + sNamedLength = sNamed.length; + tNamedLength = tNamed.length; + for (sIndex = 0, tIndex = 0; tIndex < tNamedLength; tIndex += 3) { + tName = tNamed[tIndex]; + for (; true;) { + if (sIndex >= sNamedLength) + return false; + sName = sNamed[sIndex]; + sIndex += 3; + if (tName < sName) + return false; + sIsRequired = sNamed[sIndex - 2]; + if (sName < tName) { + if (sIsRequired) + return false; + continue; + } + t1 = tNamed[tIndex + 1]; + if (sIsRequired && !t1) + return false; + t1 = sNamed[sIndex - 1]; + if (!A._isSubtype(universe, tNamed[tIndex + 2], tEnv, t1, sEnv, false)) + return false; + break; + } + } + for (; sIndex < sNamedLength;) { + if (sNamed[sIndex + 1]) + return false; + sIndex += 3; + } + return true; + }, + _isInterfaceSubtype(universe, s, sEnv, t, tEnv, isLegacy) { + var rule, recipes, $length, supertypeArgs, i, + sName = s._primary, + tName = t._primary; + for (; sName !== tName;) { + rule = universe.tR[sName]; + if (rule == null) + return false; + if (typeof rule == "string") { + sName = rule; + continue; + } + recipes = rule[tName]; + if (recipes == null) + return false; + $length = recipes.length; + supertypeArgs = $length > 0 ? new Array($length) : init.typeUniverse.sEA; + for (i = 0; i < $length; ++i) + supertypeArgs[i] = A._Universe_evalInEnvironment(universe, s, recipes[i]); + return A._areArgumentsSubtypes(universe, supertypeArgs, null, sEnv, t._rest, tEnv, false); + } + return A._areArgumentsSubtypes(universe, s._rest, null, sEnv, t._rest, tEnv, false); + }, + _areArgumentsSubtypes(universe, sArgs, sVariances, sEnv, tArgs, tEnv, isLegacy) { + var i, + $length = sArgs.length; + for (i = 0; i < $length; ++i) + if (!A._isSubtype(universe, sArgs[i], sEnv, tArgs[i], tEnv, false)) + return false; + return true; + }, + _isRecordSubtype(universe, s, sEnv, t, tEnv, isLegacy) { + var i, + sFields = s._rest, + tFields = t._rest, + sCount = sFields.length; + if (sCount !== tFields.length) + return false; + if (s._primary !== t._primary) + return false; + for (i = 0; i < sCount; ++i) + if (!A._isSubtype(universe, sFields[i], sEnv, tFields[i], tEnv, false)) + return false; + return true; + }, + isNullable(t) { + var kind = t._kind, + t1 = true; + if (!(t === type$.Null || t === type$.JSNull)) + if (!A.isSoundTopType(t)) + if (kind !== 7) + if (!(kind === 6 && A.isNullable(t._primary))) + t1 = kind === 8 && A.isNullable(t._primary); + return t1; + }, + isDefinitelyTopType(t) { + var t1; + if (!A.isSoundTopType(t)) + t1 = t === type$.legacy_Object; + else + t1 = true; + return t1; + }, + isSoundTopType(t) { + var kind = t._kind; + return kind === 2 || kind === 3 || kind === 4 || kind === 5 || t === type$.nullable_Object; + }, + _Utils_objectAssign(o, other) { + var i, key, + keys = Object.keys(other), + $length = keys.length; + for (i = 0; i < $length; ++i) { + key = keys[i]; + o[key] = other[key]; + } + }, + _Utils_newArrayOrEmpty($length) { + return $length > 0 ? new Array($length) : init.typeUniverse.sEA; + }, + Rti: function Rti(t0, t1) { + var _ = this; + _._as = t0; + _._is = t1; + _._cachedRuntimeType = _._specializedTestResource = _._isSubtypeCache = _._precomputed1 = null; + _._kind = 0; + _._canonicalRecipe = _._bindCache = _._evalCache = _._rest = _._primary = null; + }, + _FunctionParameters: function _FunctionParameters() { + this._named = this._optionalPositional = this._requiredPositional = null; + }, + _Type: function _Type(t0) { + this._rti = t0; + }, + _Error: function _Error() { + }, + _TypeError: function _TypeError(t0) { + this.__rti$_message = t0; + }, + _AsyncRun__initializeScheduleImmediate() { + var t1, div, span; + if (self.scheduleImmediate != null) + return A.async__AsyncRun__scheduleImmediateJsOverride$closure(); + if (self.MutationObserver != null && self.document != null) { + t1 = {}; + div = self.document.createElement("div"); + span = self.document.createElement("span"); + t1.storedCallback = null; + new self.MutationObserver(A.convertDartClosureToJS(new A._AsyncRun__initializeScheduleImmediate_internalCallback(t1), 1)).observe(div, {childList: true}); + return new A._AsyncRun__initializeScheduleImmediate_closure(t1, div, span); + } else if (self.setImmediate != null) + return A.async__AsyncRun__scheduleImmediateWithSetImmediate$closure(); + return A.async__AsyncRun__scheduleImmediateWithTimer$closure(); + }, + _AsyncRun__scheduleImmediateJsOverride(callback) { + self.scheduleImmediate(A.convertDartClosureToJS(new A._AsyncRun__scheduleImmediateJsOverride_internalCallback(callback), 0)); + }, + _AsyncRun__scheduleImmediateWithSetImmediate(callback) { + self.setImmediate(A.convertDartClosureToJS(new A._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback(callback), 0)); + }, + _AsyncRun__scheduleImmediateWithTimer(callback) { + A.Timer__createTimer(B.Duration_0, callback); + }, + Timer__createTimer(duration, callback) { + var milliseconds = B.JSInt_methods._tdivFast$1(duration._duration, 1000); + return A._TimerImpl$(milliseconds < 0 ? 0 : milliseconds, callback); + }, + _TimerImpl$(milliseconds, callback) { + var t1 = new A._TimerImpl(true); + t1._TimerImpl$2(milliseconds, callback); + return t1; + }, + _TimerImpl$periodic(milliseconds, callback) { + var t1 = new A._TimerImpl(false); + t1._TimerImpl$periodic$2(milliseconds, callback); + return t1; + }, + _makeAsyncAwaitCompleter($T) { + return new A._AsyncAwaitCompleter(new A._Future($.Zone__current, $T._eval$1("_Future<0>")), $T._eval$1("_AsyncAwaitCompleter<0>")); + }, + _asyncStartSync(bodyFunction, completer) { + bodyFunction.call$2(0, null); + completer.isSync = true; + return completer._future; + }, + _asyncAwait(object, bodyFunction) { + A._awaitOnObject(object, bodyFunction); + }, + _asyncReturn(object, completer) { + completer.complete$1(object); + }, + _asyncRethrow(object, completer) { + completer.completeError$2(A.unwrapException(object), A.getTraceFromException(object)); + }, + _awaitOnObject(object, bodyFunction) { + var t1, future, + thenCallback = new A._awaitOnObject_closure(bodyFunction), + errorCallback = new A._awaitOnObject_closure0(bodyFunction); + if (object instanceof A._Future) + object._thenAwait$1$2(thenCallback, errorCallback, type$.dynamic); + else { + t1 = type$.dynamic; + if (object instanceof A._Future) + object.then$1$2$onError(0, thenCallback, errorCallback, t1); + else { + future = new A._Future($.Zone__current, type$._Future_dynamic); + future._state = 8; + future._resultOrListeners = object; + future._thenAwait$1$2(thenCallback, errorCallback, t1); + } + } + }, + _wrapJsFunctionForAsync($function) { + var $protected = function(fn, ERROR) { + return function(errorCode, result) { + while (true) { + try { + fn(errorCode, result); + break; + } catch (error) { + result = error; + errorCode = ERROR; + } + } + }; + }($function, 1); + return $.Zone__current.registerBinaryCallback$3$1(new A._wrapJsFunctionForAsync_closure($protected), type$.void, type$.int, type$.dynamic); + }, + _SyncStarIterator__terminatedBody(_1, _2, _3) { + return 0; + }, + AsyncError_defaultStackTrace(error) { + var stackTrace; + if (type$.Error._is(error)) { + stackTrace = error.get$stackTrace(); + if (stackTrace != null) + return stackTrace; + } + return B._StringStackTrace_OdL; + }, + Future_Future$value(value, $T) { + var t1; + $T._as(value); + t1 = new A._Future($.Zone__current, $T._eval$1("_Future<0>")); + t1._asyncComplete$1(value); + return t1; + }, + Future_Future$error(error, stackTrace, $T) { + var _0_0 = A._interceptUserError(error, stackTrace), + t1 = new A._Future($.Zone__current, $T._eval$1("_Future<0>")); + t1._asyncCompleteError$2(_0_0.error, _0_0.stackTrace); + return t1; + }, + Future_wait(futures, eagerError, $T) { + var handleError, future, pos, e, st, t1, t2, exception, _box_0 = {}, cleanUp = null, + _future = new A._Future($.Zone__current, $T._eval$1("_Future>")); + _box_0.values = null; + _box_0.remaining = 0; + _box_0.stackTrace = _box_0.error = null; + handleError = new A.Future_wait_handleError(_box_0, cleanUp, eagerError, _future); + try { + for (t1 = J.get$iterator$ax(futures), t2 = type$.Null; t1.moveNext$0();) { + future = t1.get$current(t1); + pos = _box_0.remaining; + J.then$1$2$onError$x(future, new A.Future_wait_closure(_box_0, pos, _future, $T, cleanUp, eagerError), handleError, t2); + ++_box_0.remaining; + } + t1 = _box_0.remaining; + if (t1 === 0) { + t1 = _future; + t1._completeWithValue$1(A._setArrayType([], $T._eval$1("JSArray<0>"))); + return t1; + } + _box_0.values = A.List_List$filled(t1, null, false, $T._eval$1("0?")); + } catch (exception) { + e = A.unwrapException(exception); + st = A.getTraceFromException(exception); + if (_box_0.remaining === 0 || eagerError) + return A.Future_Future$error(e, st, $T._eval$1("List<0>")); + else { + _box_0.error = e; + _box_0.stackTrace = st; + } + } + return _future; + }, + _interceptError(error, stackTrace) { + var replacement, t1, t2, + zone = $.Zone__current; + if (zone === B.C__RootZone) + return null; + replacement = zone.errorCallback$2(error, stackTrace); + if (replacement == null) + return null; + t1 = replacement.error; + t2 = replacement.stackTrace; + if (type$.Error._is(t1)) + A.Primitives_trySetStackTrace(t1, t2); + return replacement; + }, + _interceptUserError(error, stackTrace) { + var replacement; + if ($.Zone__current !== B.C__RootZone) { + replacement = A._interceptError(error, stackTrace); + if (replacement != null) + return replacement; + } + if (stackTrace == null) + if (type$.Error._is(error)) { + stackTrace = error.get$stackTrace(); + if (stackTrace == null) { + A.Primitives_trySetStackTrace(error, B._StringStackTrace_OdL); + stackTrace = B._StringStackTrace_OdL; + } + } else + stackTrace = B._StringStackTrace_OdL; + else if (type$.Error._is(error)) + A.Primitives_trySetStackTrace(error, stackTrace); + return new A.AsyncError(error, stackTrace); + }, + _Future$zoneValue(value, _zone, $T) { + var t1 = new A._Future(_zone, $T._eval$1("_Future<0>")); + t1._state = 8; + t1._resultOrListeners = value; + return t1; + }, + _Future$value(value, $T) { + var t1 = new A._Future($.Zone__current, $T._eval$1("_Future<0>")); + t1._state = 8; + t1._resultOrListeners = value; + return t1; + }, + _Future__chainCoreFuture(source, target, sync) { + var t2, ignoreError, listeners, _box_0 = {}, + t1 = _box_0.source = source; + for (; t2 = t1._state, (t2 & 4) !== 0;) { + t1 = t1._resultOrListeners; + _box_0.source = t1; + } + if (t1 === target) { + target._asyncCompleteError$2(new A.ArgumentError(true, t1, null, "Cannot complete a future with itself"), A.StackTrace_current()); + return; + } + ignoreError = target._state & 1; + t2 = t1._state = t2 | ignoreError; + if ((t2 & 24) === 0) { + listeners = target._resultOrListeners; + target._state = target._state & 1 | 4; + target._resultOrListeners = t1; + t1._prependListeners$1(listeners); + return; + } + if (!sync) + if (target._resultOrListeners == null) + t1 = (t2 & 16) === 0 || ignoreError !== 0; + else + t1 = false; + else + t1 = true; + if (t1) { + listeners = target._removeListeners$0(); + target._cloneResult$1(_box_0.source); + A._Future__propagateToListeners(target, listeners); + return; + } + target._state ^= 2; + target._zone.scheduleMicrotask$1(new A._Future__chainCoreFuture_closure(_box_0, target)); + }, + _Future__propagateToListeners(source, listeners) { + var _box_0, t2, t3, hasError, nextListener, nextListener0, sourceResult, t4, zone, oldZone, result, current, _box_1 = {}, + t1 = _box_1.source = source; + for (; true;) { + _box_0 = {}; + t2 = t1._state; + t3 = (t2 & 16) === 0; + hasError = !t3; + if (listeners == null) { + if (hasError && (t2 & 1) === 0) { + t2 = t1._resultOrListeners; + t1._zone.handleUncaughtError$2(t2.error, t2.stackTrace); + } + return; + } + _box_0.listener = listeners; + nextListener = listeners._nextListener; + for (t1 = listeners; nextListener != null; t1 = nextListener, nextListener = nextListener0) { + t1._nextListener = null; + A._Future__propagateToListeners(_box_1.source, t1); + _box_0.listener = nextListener; + nextListener0 = nextListener._nextListener; + } + t2 = _box_1.source; + sourceResult = t2._resultOrListeners; + _box_0.listenerHasError = hasError; + _box_0.listenerValueOrError = sourceResult; + if (t3) { + t4 = t1.state; + t4 = (t4 & 1) !== 0 || (t4 & 15) === 8; + } else + t4 = true; + if (t4) { + zone = t1.result._zone; + if (hasError) { + t1 = t2._zone; + t1 = !(t1 === zone || t1.get$errorZone() === zone.get$errorZone()); + } else + t1 = false; + if (t1) { + t1 = _box_1.source; + t2 = t1._resultOrListeners; + t1._zone.handleUncaughtError$2(t2.error, t2.stackTrace); + return; + } + oldZone = $.Zone__current; + if (oldZone !== zone) + $.Zone__current = zone; + else + oldZone = null; + t1 = _box_0.listener.state; + if ((t1 & 15) === 8) + new A._Future__propagateToListeners_handleWhenCompleteCallback(_box_0, _box_1, hasError).call$0(); + else if (t3) { + if ((t1 & 1) !== 0) + new A._Future__propagateToListeners_handleValueCallback(_box_0, sourceResult).call$0(); + } else if ((t1 & 2) !== 0) + new A._Future__propagateToListeners_handleError(_box_1, _box_0).call$0(); + if (oldZone != null) + $.Zone__current = oldZone; + t1 = _box_0.listenerValueOrError; + if (t1 instanceof A._Future) { + t2 = _box_0.listener.$ti; + t2 = t2._eval$1("Future<2>")._is(t1) || !t2._rest[1]._is(t1); + } else + t2 = false; + if (t2) { + result = _box_0.listener.result; + if ((t1._state & 24) !== 0) { + current = result._resultOrListeners; + result._resultOrListeners = null; + listeners = result._reverseListeners$1(current); + result._state = t1._state & 30 | result._state & 1; + result._resultOrListeners = t1._resultOrListeners; + _box_1.source = t1; + continue; + } else + A._Future__chainCoreFuture(t1, result, true); + return; + } + } + result = _box_0.listener.result; + current = result._resultOrListeners; + result._resultOrListeners = null; + listeners = result._reverseListeners$1(current); + t1 = _box_0.listenerHasError; + t2 = _box_0.listenerValueOrError; + if (!t1) { + result._state = 8; + result._resultOrListeners = t2; + } else { + result._state = result._state & 1 | 16; + result._resultOrListeners = t2; + } + _box_1.source = result; + t1 = result; + } + }, + _registerErrorHandler(errorHandler, zone) { + if (type$.dynamic_Function_Object_StackTrace._is(errorHandler)) + return zone.registerBinaryCallback$3$1(errorHandler, type$.dynamic, type$.Object, type$.StackTrace); + if (type$.dynamic_Function_Object._is(errorHandler)) + return zone.registerUnaryCallback$2$1(errorHandler, type$.dynamic, type$.Object); + throw A.wrapException(A.ArgumentError$value(errorHandler, "onError", string$.Error_)); + }, + _microtaskLoop() { + var entry, next; + for (entry = $._nextCallback; entry != null; entry = $._nextCallback) { + $._lastPriorityCallback = null; + next = entry.next; + $._nextCallback = next; + if (next == null) + $._lastCallback = null; + entry.callback.call$0(); + } + }, + _startMicrotaskLoop() { + $._isInCallbackLoop = true; + try { + A._microtaskLoop(); + } finally { + $._lastPriorityCallback = null; + $._isInCallbackLoop = false; + if ($._nextCallback != null) + $.$get$_AsyncRun__scheduleImmediateClosure().call$1(A.async___startMicrotaskLoop$closure()); + } + }, + _scheduleAsyncCallback(callback) { + var newEntry = new A._AsyncCallbackEntry(callback), + lastCallback = $._lastCallback; + if (lastCallback == null) { + $._nextCallback = $._lastCallback = newEntry; + if (!$._isInCallbackLoop) + $.$get$_AsyncRun__scheduleImmediateClosure().call$1(A.async___startMicrotaskLoop$closure()); + } else + $._lastCallback = lastCallback.next = newEntry; + }, + _schedulePriorityAsyncCallback(callback) { + var entry, lastPriorityCallback, next, + t1 = $._nextCallback; + if (t1 == null) { + A._scheduleAsyncCallback(callback); + $._lastPriorityCallback = $._lastCallback; + return; + } + entry = new A._AsyncCallbackEntry(callback); + lastPriorityCallback = $._lastPriorityCallback; + if (lastPriorityCallback == null) { + entry.next = t1; + $._nextCallback = $._lastPriorityCallback = entry; + } else { + next = lastPriorityCallback.next; + entry.next = next; + $._lastPriorityCallback = lastPriorityCallback.next = entry; + if (next == null) + $._lastCallback = entry; + } + }, + scheduleMicrotask(callback) { + var t1, _null = null, + currentZone = $.Zone__current; + if (B.C__RootZone === currentZone) { + A._rootScheduleMicrotask(_null, _null, B.C__RootZone, callback); + return; + } + if (B.C__RootZone === currentZone.get$_scheduleMicrotask().zone) + t1 = B.C__RootZone.get$errorZone() === currentZone.get$errorZone(); + else + t1 = false; + if (t1) { + A._rootScheduleMicrotask(_null, _null, currentZone, currentZone.registerCallback$1$1(callback, type$.void)); + return; + } + t1 = $.Zone__current; + t1.scheduleMicrotask$1(t1.bindCallbackGuarded$1(callback)); + }, + Stream_Stream$fromFuture(future, $T) { + var _null = null, + t1 = $T._eval$1("_SyncStreamController<0>"), + controller = new A._SyncStreamController(_null, _null, _null, _null, t1); + future.then$1$2$onError(0, new A.Stream_Stream$fromFuture_closure(controller, $T), new A.Stream_Stream$fromFuture_closure0(controller), type$.Null); + return new A._ControllerStream(controller, t1._eval$1("_ControllerStream<1>")); + }, + StreamIterator_StreamIterator(stream) { + return new A._StreamIterator(A.checkNotNullable(stream, "stream", type$.Object)); + }, + StreamController_StreamController(onCancel, onListen, onPause, onResume, sync, $T) { + return sync ? new A._SyncStreamController(onListen, onPause, onResume, onCancel, $T._eval$1("_SyncStreamController<0>")) : new A._AsyncStreamController(onListen, onPause, onResume, onCancel, $T._eval$1("_AsyncStreamController<0>")); + }, + _runGuarded(notificationHandler) { + var e, s, exception; + if (notificationHandler == null) + return; + try { + notificationHandler.call$0(); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + $.Zone__current.handleUncaughtError$2(e, s); + } + }, + _ControllerSubscription$(_controller, onData, onError, onDone, cancelOnError, $T) { + var t1 = $.Zone__current, + t2 = cancelOnError ? 1 : 0, + t3 = onError != null ? 32 : 0, + t4 = A._BufferingStreamSubscription__registerDataHandler(t1, onData, $T), + t5 = A._BufferingStreamSubscription__registerErrorHandler(t1, onError), + t6 = onDone == null ? A.async___nullDoneHandler$closure() : onDone; + return new A._ControllerSubscription(_controller, t4, t5, t1.registerCallback$1$1(t6, type$.void), t1, t2 | t3, $T._eval$1("_ControllerSubscription<0>")); + }, + _AddStreamState_makeErrorHandler(controller) { + return new A._AddStreamState_makeErrorHandler_closure(controller); + }, + _BufferingStreamSubscription__registerDataHandler(zone, handleData, $T) { + var t1 = handleData == null ? A.async___nullDataHandler$closure() : handleData; + return zone.registerUnaryCallback$2$1(t1, type$.void, $T); + }, + _BufferingStreamSubscription__registerErrorHandler(zone, handleError) { + if (handleError == null) + handleError = A.async___nullErrorHandler$closure(); + if (type$.void_Function_Object_StackTrace._is(handleError)) + return zone.registerBinaryCallback$3$1(handleError, type$.dynamic, type$.Object, type$.StackTrace); + if (type$.void_Function_Object._is(handleError)) + return zone.registerUnaryCallback$2$1(handleError, type$.dynamic, type$.Object); + throw A.wrapException(A.ArgumentError$("handleError callback must take either an Object (the error), or both an Object (the error) and a StackTrace.", null)); + }, + _nullDataHandler(value) { + }, + _nullErrorHandler(error, stackTrace) { + $.Zone__current.handleUncaughtError$2(error, stackTrace); + }, + _nullDoneHandler() { + }, + Timer_Timer(duration, callback) { + var t1 = $.Zone__current; + if (t1 === B.C__RootZone) + return t1.createTimer$2(duration, callback); + return t1.createTimer$2(duration, t1.bindCallbackGuarded$1(callback)); + }, + _rootHandleUncaughtError($self, $parent, zone, error, stackTrace) { + A._rootHandleError(error, stackTrace); + }, + _rootHandleError(error, stackTrace) { + A._schedulePriorityAsyncCallback(new A._rootHandleError_closure(error, stackTrace)); + }, + _rootRun($self, $parent, zone, f) { + var old, + t1 = $.Zone__current; + if (t1 === zone) + return f.call$0(); + $.Zone__current = zone; + old = t1; + try { + t1 = f.call$0(); + return t1; + } finally { + $.Zone__current = old; + } + }, + _rootRunUnary($self, $parent, zone, f, arg) { + var old, + t1 = $.Zone__current; + if (t1 === zone) + return f.call$1(arg); + $.Zone__current = zone; + old = t1; + try { + t1 = f.call$1(arg); + return t1; + } finally { + $.Zone__current = old; + } + }, + _rootRunBinary($self, $parent, zone, f, arg1, arg2) { + var old, + t1 = $.Zone__current; + if (t1 === zone) + return f.call$2(arg1, arg2); + $.Zone__current = zone; + old = t1; + try { + t1 = f.call$2(arg1, arg2); + return t1; + } finally { + $.Zone__current = old; + } + }, + _rootRegisterCallback($self, $parent, zone, f) { + return f; + }, + _rootRegisterUnaryCallback($self, $parent, zone, f) { + return f; + }, + _rootRegisterBinaryCallback($self, $parent, zone, f) { + return f; + }, + _rootErrorCallback($self, $parent, zone, error, stackTrace) { + return null; + }, + _rootScheduleMicrotask($self, $parent, zone, f) { + var t1, t2; + if (B.C__RootZone !== zone) { + t1 = B.C__RootZone.get$errorZone(); + t2 = zone.get$errorZone(); + f = t1 !== t2 ? zone.bindCallbackGuarded$1(f) : zone.bindCallback$1$1(f, type$.void); + } + A._scheduleAsyncCallback(f); + }, + _rootCreateTimer($self, $parent, zone, duration, callback) { + return A.Timer__createTimer(duration, B.C__RootZone !== zone ? zone.bindCallback$1$1(callback, type$.void) : callback); + }, + _rootCreatePeriodicTimer($self, $parent, zone, duration, callback) { + var milliseconds; + if (B.C__RootZone !== zone) + callback = zone.bindUnaryCallback$2$1(callback, type$.void, type$.Timer); + milliseconds = B.JSInt_methods._tdivFast$1(duration._duration, 1000); + return A._TimerImpl$periodic(milliseconds < 0 ? 0 : milliseconds, callback); + }, + _rootPrint($self, $parent, zone, line) { + A.printString(line); + }, + _printToZone(line) { + $.Zone__current.print$1(line); + }, + _rootFork($self, $parent, zone, specification, zoneValues) { + var valueMap, t1, handleUncaughtError; + $.printToZone = A.async___printToZone$closure(); + if (specification == null) + specification = B._ZoneSpecification_Ipa; + if (zoneValues == null) + valueMap = zone.get$_async$_map(); + else { + t1 = type$.nullable_Object; + valueMap = A.HashMap_HashMap$from(zoneValues, t1, t1); + } + t1 = new A._CustomZone(zone.get$_run(), zone.get$_runUnary(), zone.get$_runBinary(), zone.get$_registerCallback(), zone.get$_registerUnaryCallback(), zone.get$_registerBinaryCallback(), zone.get$_errorCallback(), zone.get$_scheduleMicrotask(), zone.get$_createTimer(), zone.get$_createPeriodicTimer(), zone.get$_print(), zone.get$_fork(), zone.get$_handleUncaughtError(), zone, valueMap); + handleUncaughtError = specification.handleUncaughtError; + if (handleUncaughtError != null) + t1._handleUncaughtError = new A._ZoneFunction(t1, handleUncaughtError); + return t1; + }, + runZoned(body, zoneValues, $R) { + return A._runZoned(body, zoneValues, null, $R); + }, + _runZoned(body, zoneValues, specification, $R) { + return $.Zone__current.fork$2$specification$zoneValues(specification, zoneValues).run$1$1(0, body, $R); + }, + _AsyncRun__initializeScheduleImmediate_internalCallback: function _AsyncRun__initializeScheduleImmediate_internalCallback(t0) { + this._box_0 = t0; + }, + _AsyncRun__initializeScheduleImmediate_closure: function _AsyncRun__initializeScheduleImmediate_closure(t0, t1, t2) { + this._box_0 = t0; + this.div = t1; + this.span = t2; + }, + _AsyncRun__scheduleImmediateJsOverride_internalCallback: function _AsyncRun__scheduleImmediateJsOverride_internalCallback(t0) { + this.callback = t0; + }, + _AsyncRun__scheduleImmediateWithSetImmediate_internalCallback: function _AsyncRun__scheduleImmediateWithSetImmediate_internalCallback(t0) { + this.callback = t0; + }, + _TimerImpl: function _TimerImpl(t0) { + this._once = t0; + this._handle = null; + this._tick = 0; + }, + _TimerImpl_internalCallback: function _TimerImpl_internalCallback(t0, t1) { + this.$this = t0; + this.callback = t1; + }, + _TimerImpl$periodic_closure: function _TimerImpl$periodic_closure(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.milliseconds = t1; + _.start = t2; + _.callback = t3; + }, + _AsyncAwaitCompleter: function _AsyncAwaitCompleter(t0, t1) { + this._future = t0; + this.isSync = false; + this.$ti = t1; + }, + _awaitOnObject_closure: function _awaitOnObject_closure(t0) { + this.bodyFunction = t0; + }, + _awaitOnObject_closure0: function _awaitOnObject_closure0(t0) { + this.bodyFunction = t0; + }, + _wrapJsFunctionForAsync_closure: function _wrapJsFunctionForAsync_closure(t0) { + this.$protected = t0; + }, + _SyncStarIterator: function _SyncStarIterator(t0) { + var _ = this; + _._body = t0; + _._suspendedBodies = _._nestedIterator = _._datum = _._async$_current = null; + }, + _SyncStarIterable: function _SyncStarIterable(t0, t1) { + this._outerHelper = t0; + this.$ti = t1; + }, + AsyncError: function AsyncError(t0, t1) { + this.error = t0; + this.stackTrace = t1; + }, + Future_wait_handleError: function Future_wait_handleError(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.cleanUp = t1; + _.eagerError = t2; + _._future = t3; + }, + Future_wait_closure: function Future_wait_closure(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._box_0 = t0; + _.pos = t1; + _._future = t2; + _.T = t3; + _.cleanUp = t4; + _.eagerError = t5; + }, + _Completer: function _Completer() { + }, + _AsyncCompleter: function _AsyncCompleter(t0, t1) { + this.future = t0; + this.$ti = t1; + }, + _SyncCompleter: function _SyncCompleter(t0, t1) { + this.future = t0; + this.$ti = t1; + }, + _FutureListener: function _FutureListener(t0, t1, t2, t3, t4) { + var _ = this; + _._nextListener = null; + _.result = t0; + _.state = t1; + _.callback = t2; + _.errorCallback = t3; + _.$ti = t4; + }, + _Future: function _Future(t0, t1) { + var _ = this; + _._state = 0; + _._zone = t0; + _._resultOrListeners = null; + _.$ti = t1; + }, + _Future__addListener_closure: function _Future__addListener_closure(t0, t1) { + this.$this = t0; + this.listener = t1; + }, + _Future__prependListeners_closure: function _Future__prependListeners_closure(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + _Future__chainForeignFuture_closure: function _Future__chainForeignFuture_closure(t0) { + this.$this = t0; + }, + _Future__chainForeignFuture_closure0: function _Future__chainForeignFuture_closure0(t0) { + this.$this = t0; + }, + _Future__chainForeignFuture_closure1: function _Future__chainForeignFuture_closure1(t0, t1, t2) { + this.$this = t0; + this.e = t1; + this.s = t2; + }, + _Future__chainCoreFuture_closure: function _Future__chainCoreFuture_closure(t0, t1) { + this._box_0 = t0; + this.target = t1; + }, + _Future__asyncCompleteWithValue_closure: function _Future__asyncCompleteWithValue_closure(t0, t1) { + this.$this = t0; + this.value = t1; + }, + _Future__asyncCompleteError_closure: function _Future__asyncCompleteError_closure(t0, t1, t2) { + this.$this = t0; + this.error = t1; + this.stackTrace = t2; + }, + _Future__propagateToListeners_handleWhenCompleteCallback: function _Future__propagateToListeners_handleWhenCompleteCallback(t0, t1, t2) { + this._box_0 = t0; + this._box_1 = t1; + this.hasError = t2; + }, + _Future__propagateToListeners_handleWhenCompleteCallback_closure: function _Future__propagateToListeners_handleWhenCompleteCallback_closure(t0, t1) { + this.joinedResult = t0; + this.originalSource = t1; + }, + _Future__propagateToListeners_handleWhenCompleteCallback_closure0: function _Future__propagateToListeners_handleWhenCompleteCallback_closure0(t0) { + this.joinedResult = t0; + }, + _Future__propagateToListeners_handleValueCallback: function _Future__propagateToListeners_handleValueCallback(t0, t1) { + this._box_0 = t0; + this.sourceResult = t1; + }, + _Future__propagateToListeners_handleError: function _Future__propagateToListeners_handleError(t0, t1) { + this._box_1 = t0; + this._box_0 = t1; + }, + _AsyncCallbackEntry: function _AsyncCallbackEntry(t0) { + this.callback = t0; + this.next = null; + }, + Stream: function Stream() { + }, + Stream_Stream$fromFuture_closure: function Stream_Stream$fromFuture_closure(t0, t1) { + this.controller = t0; + this.T = t1; + }, + Stream_Stream$fromFuture_closure0: function Stream_Stream$fromFuture_closure0(t0) { + this.controller = t0; + }, + Stream_length_closure: function Stream_length_closure(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + Stream_length_closure0: function Stream_length_closure0(t0, t1) { + this._box_0 = t0; + this.future = t1; + }, + _StreamController: function _StreamController() { + }, + _StreamController__subscribe_closure: function _StreamController__subscribe_closure(t0) { + this.$this = t0; + }, + _StreamController__recordCancel_complete: function _StreamController__recordCancel_complete(t0) { + this.$this = t0; + }, + _SyncStreamControllerDispatch: function _SyncStreamControllerDispatch() { + }, + _AsyncStreamControllerDispatch: function _AsyncStreamControllerDispatch() { + }, + _AsyncStreamController: function _AsyncStreamController(t0, t1, t2, t3, t4) { + var _ = this; + _._varData = null; + _._state = 0; + _._doneFuture = null; + _.onListen = t0; + _.onPause = t1; + _.onResume = t2; + _.onCancel = t3; + _.$ti = t4; + }, + _SyncStreamController: function _SyncStreamController(t0, t1, t2, t3, t4) { + var _ = this; + _._varData = null; + _._state = 0; + _._doneFuture = null; + _.onListen = t0; + _.onPause = t1; + _.onResume = t2; + _.onCancel = t3; + _.$ti = t4; + }, + _ControllerStream: function _ControllerStream(t0, t1) { + this._controller = t0; + this.$ti = t1; + }, + _ControllerSubscription: function _ControllerSubscription(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._controller = t0; + _._onData = t1; + _._onError = t2; + _._onDone = t3; + _._zone = t4; + _._state = t5; + _._pending = _._cancelFuture = null; + _.$ti = t6; + }, + _AddStreamState: function _AddStreamState() { + }, + _AddStreamState_makeErrorHandler_closure: function _AddStreamState_makeErrorHandler_closure(t0) { + this.controller = t0; + }, + _AddStreamState_cancel_closure: function _AddStreamState_cancel_closure(t0) { + this.$this = t0; + }, + _StreamControllerAddStreamState: function _StreamControllerAddStreamState(t0, t1, t2) { + this._varData = t0; + this.addStreamFuture = t1; + this.addSubscription = t2; + }, + _BufferingStreamSubscription: function _BufferingStreamSubscription() { + }, + _BufferingStreamSubscription__sendError_sendError: function _BufferingStreamSubscription__sendError_sendError(t0, t1, t2) { + this.$this = t0; + this.error = t1; + this.stackTrace = t2; + }, + _BufferingStreamSubscription__sendDone_sendDone: function _BufferingStreamSubscription__sendDone_sendDone(t0) { + this.$this = t0; + }, + _StreamImpl: function _StreamImpl() { + }, + _DelayedEvent: function _DelayedEvent() { + }, + _DelayedData: function _DelayedData(t0) { + this.value = t0; + this.next = null; + }, + _DelayedError: function _DelayedError(t0, t1) { + this.error = t0; + this.stackTrace = t1; + this.next = null; + }, + _DelayedDone: function _DelayedDone() { + }, + _PendingEvents: function _PendingEvents() { + this._state = 0; + this.lastPendingEvent = this.firstPendingEvent = null; + }, + _PendingEvents_schedule_closure: function _PendingEvents_schedule_closure(t0, t1) { + this.$this = t0; + this.dispatch = t1; + }, + _StreamIterator: function _StreamIterator(t0) { + this._subscription = null; + this._stateData = t0; + this._async$_hasValue = false; + }, + _ForwardingStream: function _ForwardingStream() { + }, + _ForwardingStreamSubscription: function _ForwardingStreamSubscription(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._stream = t0; + _._subscription = null; + _._onData = t1; + _._onError = t2; + _._onDone = t3; + _._zone = t4; + _._state = t5; + _._pending = _._cancelFuture = null; + _.$ti = t6; + }, + _MapStream: function _MapStream(t0, t1, t2) { + this._transform = t0; + this._async$_source = t1; + this.$ti = t2; + }, + _ZoneFunction: function _ZoneFunction(t0, t1) { + this.zone = t0; + this.$function = t1; + }, + _ZoneSpecification: function _ZoneSpecification(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12) { + var _ = this; + _.handleUncaughtError = t0; + _.run = t1; + _.runUnary = t2; + _.runBinary = t3; + _.registerCallback = t4; + _.registerUnaryCallback = t5; + _.registerBinaryCallback = t6; + _.errorCallback = t7; + _.scheduleMicrotask = t8; + _.createTimer = t9; + _.createPeriodicTimer = t10; + _.print = t11; + _.fork = t12; + }, + _ZoneDelegate: function _ZoneDelegate(t0) { + this._delegationTarget = t0; + }, + _Zone: function _Zone() { + }, + _CustomZone: function _CustomZone(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14) { + var _ = this; + _._run = t0; + _._runUnary = t1; + _._runBinary = t2; + _._registerCallback = t3; + _._registerUnaryCallback = t4; + _._registerBinaryCallback = t5; + _._errorCallback = t6; + _._scheduleMicrotask = t7; + _._createTimer = t8; + _._createPeriodicTimer = t9; + _._print = t10; + _._fork = t11; + _._handleUncaughtError = t12; + _._delegateCache = null; + _.parent = t13; + _._async$_map = t14; + }, + _CustomZone_bindCallback_closure: function _CustomZone_bindCallback_closure(t0, t1, t2) { + this.$this = t0; + this.registered = t1; + this.R = t2; + }, + _CustomZone_bindUnaryCallback_closure: function _CustomZone_bindUnaryCallback_closure(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.registered = t1; + _.T = t2; + _.R = t3; + }, + _CustomZone_bindCallbackGuarded_closure: function _CustomZone_bindCallbackGuarded_closure(t0, t1) { + this.$this = t0; + this.registered = t1; + }, + _rootHandleError_closure: function _rootHandleError_closure(t0, t1) { + this.error = t0; + this.stackTrace = t1; + }, + _RootZone: function _RootZone() { + }, + _RootZone_bindCallback_closure: function _RootZone_bindCallback_closure(t0, t1, t2) { + this.$this = t0; + this.f = t1; + this.R = t2; + }, + _RootZone_bindUnaryCallback_closure: function _RootZone_bindUnaryCallback_closure(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.f = t1; + _.T = t2; + _.R = t3; + }, + _RootZone_bindCallbackGuarded_closure: function _RootZone_bindCallbackGuarded_closure(t0, t1) { + this.$this = t0; + this.f = t1; + }, + HashMap_HashMap($K, $V) { + return new A._HashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("_HashMap<1,2>")); + }, + _HashMap__getTableEntry(table, key) { + var entry = table[key]; + return entry === table ? null : entry; + }, + _HashMap__setTableEntry(table, key, value) { + if (value == null) + table[key] = table; + else + table[key] = value; + }, + _HashMap__newHashTable() { + var table = Object.create(null); + A._HashMap__setTableEntry(table, "", table); + delete table[""]; + return table; + }, + LinkedHashMap_LinkedHashMap(equals, hashCode, isValidKey, $K, $V) { + if (isValidKey == null) + if (hashCode == null) { + if (equals == null) + return new A.JsLinkedHashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("JsLinkedHashMap<1,2>")); + hashCode = A.collection___defaultHashCode$closure(); + } else { + if (A.core__identityHashCode$closure() === hashCode && A.core__identical$closure() === equals) + return new A.JsIdentityLinkedHashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("JsIdentityLinkedHashMap<1,2>")); + if (equals == null) + equals = A.collection___defaultEquals$closure(); + } + else { + if (hashCode == null) + hashCode = A.collection___defaultHashCode$closure(); + if (equals == null) + equals = A.collection___defaultEquals$closure(); + } + return A._LinkedCustomHashMap$(equals, hashCode, isValidKey, $K, $V); + }, + LinkedHashMap_LinkedHashMap$_literal(keyValuePairs, $K, $V) { + return A.fillLiteralMap(keyValuePairs, new A.JsLinkedHashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("JsLinkedHashMap<1,2>"))); + }, + LinkedHashMap_LinkedHashMap$_empty($K, $V) { + return new A.JsLinkedHashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("JsLinkedHashMap<1,2>")); + }, + _LinkedCustomHashMap$(_equals, _hashCode, validKey, $K, $V) { + var t1 = validKey != null ? validKey : new A._LinkedCustomHashMap_closure($K); + return new A._LinkedCustomHashMap(_equals, _hashCode, t1, $K._eval$1("@<0>")._bind$1($V)._eval$1("_LinkedCustomHashMap<1,2>")); + }, + LinkedHashSet_LinkedHashSet($E) { + return new A._LinkedHashSet($E._eval$1("_LinkedHashSet<0>")); + }, + LinkedHashSet_LinkedHashSet$_empty($E) { + return new A._LinkedHashSet($E._eval$1("_LinkedHashSet<0>")); + }, + LinkedHashSet_LinkedHashSet$_literal(values, $E) { + return A.fillLiteralSet(values, new A._LinkedHashSet($E._eval$1("_LinkedHashSet<0>"))); + }, + _LinkedHashSet__newHashTable() { + var table = Object.create(null); + table[""] = table; + delete table[""]; + return table; + }, + _LinkedHashSetIterator$(_set, _modifications, $E) { + var t1 = new A._LinkedHashSetIterator(_set, _modifications, $E._eval$1("_LinkedHashSetIterator<0>")); + t1._cell = _set._first; + return t1; + }, + UnmodifiableListView$(source, $E) { + return new A.UnmodifiableListView(source, $E._eval$1("UnmodifiableListView<0>")); + }, + _defaultEquals(a, b) { + return J.$eq$(a, b); + }, + _defaultHashCode(a) { + return J.get$hashCode$(a); + }, + HashMap_HashMap$from(other, $K, $V) { + var result = A.HashMap_HashMap($K, $V); + other.forEach$1(0, new A.HashMap_HashMap$from_closure(result, $K, $V)); + return result; + }, + IterableExtensions_get_firstOrNull(_this) { + var t2, + t1 = A._arrayInstanceType(_this), + iterator = new J.ArrayIterator(_this, _this.length, t1._eval$1("ArrayIterator<1>")); + if (iterator.moveNext$0()) { + t2 = iterator._current; + return t2 == null ? t1._precomputed1._as(t2) : t2; + } + return null; + }, + LinkedHashMap_LinkedHashMap$from(other, $K, $V) { + var result = A.LinkedHashMap_LinkedHashMap(null, null, null, $K, $V); + other.forEach$1(0, new A.LinkedHashMap_LinkedHashMap$from_closure(result, $K, $V)); + return result; + }, + LinkedHashMap_LinkedHashMap$of(other, $K, $V) { + var t1 = A.LinkedHashMap_LinkedHashMap(null, null, null, $K, $V); + t1.addAll$1(0, other); + return t1; + }, + LinkedHashSet_LinkedHashSet$from(elements, $E) { + var t1, _i, + result = A.LinkedHashSet_LinkedHashSet($E); + for (t1 = elements.length, _i = 0; _i < elements.length; elements.length === t1 || (0, A.throwConcurrentModificationError)(elements), ++_i) + result.add$1(0, $E._as(elements[_i])); + return result; + }, + LinkedHashSet_LinkedHashSet$of(elements, $E) { + var t1 = A.LinkedHashSet_LinkedHashSet($E); + t1.addAll$1(0, elements); + return t1; + }, + ListBase__compareAny(a, b) { + var t1 = type$.Comparable_dynamic; + return J.compareTo$1$ns(t1._as(a), t1._as(b)); + }, + MapBase_mapToString(m) { + var result, t1; + if (A.isToStringVisiting(m)) + return "{...}"; + result = new A.StringBuffer(""); + try { + t1 = {}; + $.toStringVisiting.push(m); + result._contents += "{"; + t1.first = true; + m.forEach$1(0, new A.MapBase_mapToString_closure(t1, result)); + result._contents += "}"; + } finally { + $.toStringVisiting.pop(); + } + t1 = result._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + MapBase__fillMapWithIterables(map, keys, values) { + var keyIterator = keys.get$iterator(keys), + valueIterator = values.get$iterator(values), + hasNextKey = keyIterator.moveNext$0(), + hasNextValue = valueIterator.moveNext$0(); + while (true) { + if (!(hasNextKey && hasNextValue)) + break; + map.$indexSet(0, keyIterator.get$current(keyIterator), valueIterator.get$current(valueIterator)); + hasNextKey = keyIterator.moveNext$0(); + hasNextValue = valueIterator.moveNext$0(); + } + if (hasNextKey || hasNextValue) + throw A.wrapException(A.ArgumentError$("Iterables do not have same length.", null)); + }, + ListQueue$($E) { + return new A.ListQueue(A.List_List$filled(A.ListQueue__calculateCapacity(null), null, false, $E._eval$1("0?")), $E._eval$1("ListQueue<0>")); + }, + ListQueue__calculateCapacity(initialCapacity) { + return 8; + }, + ListQueue__nextPowerOf2(number) { + var nextNumber; + number = (number << 1 >>> 0) - 1; + for (; true; number = nextNumber) { + nextNumber = (number & number - 1) >>> 0; + if (nextNumber === 0) + return number; + } + }, + _ListQueueIterator$(queue, $E) { + return new A._ListQueueIterator(queue, queue._tail, queue._modificationCount, queue._head, $E._eval$1("_ListQueueIterator<0>")); + }, + _UnmodifiableSetMixin__throwUnmodifiable() { + throw A.wrapException(A.UnsupportedError$("Cannot change an unmodifiable set")); + }, + _HashMap: function _HashMap(t0) { + var _ = this; + _._collection$_length = 0; + _._collection$_keys = _._collection$_rest = _._nums = _._strings = null; + _.$ti = t0; + }, + _HashMap_values_closure: function _HashMap_values_closure(t0) { + this.$this = t0; + }, + _HashMap_addAll_closure: function _HashMap_addAll_closure(t0) { + this.$this = t0; + }, + _IdentityHashMap: function _IdentityHashMap(t0) { + var _ = this; + _._collection$_length = 0; + _._collection$_keys = _._collection$_rest = _._nums = _._strings = null; + _.$ti = t0; + }, + _HashMapKeyIterable: function _HashMapKeyIterable(t0, t1) { + this._map = t0; + this.$ti = t1; + }, + _HashMapKeyIterator: function _HashMapKeyIterator(t0, t1, t2) { + var _ = this; + _._map = t0; + _._collection$_keys = t1; + _._offset = 0; + _._collection$_current = null; + _.$ti = t2; + }, + _LinkedCustomHashMap: function _LinkedCustomHashMap(t0, t1, t2, t3) { + var _ = this; + _._equals = t0; + _._hashCode = t1; + _._validKey = t2; + _.__js_helper$_length = 0; + _.__js_helper$_last = _.__js_helper$_first = _.__js_helper$_rest = _.__js_helper$_nums = _.__js_helper$_strings = null; + _.__js_helper$_modifications = 0; + _.$ti = t3; + }, + _LinkedCustomHashMap_closure: function _LinkedCustomHashMap_closure(t0) { + this.K = t0; + }, + _LinkedHashSet: function _LinkedHashSet(t0) { + var _ = this; + _._collection$_length = 0; + _._last = _._first = _._collection$_rest = _._nums = _._strings = null; + _._modifications = 0; + _.$ti = t0; + }, + _LinkedIdentityHashSet: function _LinkedIdentityHashSet(t0) { + var _ = this; + _._collection$_length = 0; + _._last = _._first = _._collection$_rest = _._nums = _._strings = null; + _._modifications = 0; + _.$ti = t0; + }, + _LinkedHashSetCell: function _LinkedHashSetCell(t0) { + this._element = t0; + this._previous = this._next = null; + }, + _LinkedHashSetIterator: function _LinkedHashSetIterator(t0, t1, t2) { + var _ = this; + _._set = t0; + _._modifications = t1; + _._collection$_current = _._cell = null; + _.$ti = t2; + }, + UnmodifiableListView: function UnmodifiableListView(t0, t1) { + this._collection$_source = t0; + this.$ti = t1; + }, + HashMap_HashMap$from_closure: function HashMap_HashMap$from_closure(t0, t1, t2) { + this.result = t0; + this.K = t1; + this.V = t2; + }, + LinkedHashMap_LinkedHashMap$from_closure: function LinkedHashMap_LinkedHashMap$from_closure(t0, t1, t2) { + this.result = t0; + this.K = t1; + this.V = t2; + }, + ListBase: function ListBase() { + }, + MapBase: function MapBase() { + }, + MapBase_addAll_closure: function MapBase_addAll_closure(t0) { + this.$this = t0; + }, + MapBase_entries_closure: function MapBase_entries_closure(t0) { + this.$this = t0; + }, + MapBase_mapToString_closure: function MapBase_mapToString_closure(t0, t1) { + this._box_0 = t0; + this.result = t1; + }, + UnmodifiableMapBase: function UnmodifiableMapBase() { + }, + _MapBaseValueIterable: function _MapBaseValueIterable(t0, t1) { + this._map = t0; + this.$ti = t1; + }, + _MapBaseValueIterator: function _MapBaseValueIterator(t0, t1, t2) { + var _ = this; + _._collection$_keys = t0; + _._map = t1; + _._collection$_current = null; + _.$ti = t2; + }, + _UnmodifiableMapMixin: function _UnmodifiableMapMixin() { + }, + MapView: function MapView() { + }, + UnmodifiableMapView: function UnmodifiableMapView(t0, t1) { + this._map = t0; + this.$ti = t1; + }, + ListQueue: function ListQueue(t0, t1) { + var _ = this; + _._table = t0; + _._modificationCount = _._tail = _._head = 0; + _.$ti = t1; + }, + _ListQueueIterator: function _ListQueueIterator(t0, t1, t2, t3, t4) { + var _ = this; + _._queue = t0; + _._collection$_end = t1; + _._modificationCount = t2; + _._collection$_position = t3; + _._collection$_current = null; + _.$ti = t4; + }, + SetBase: function SetBase() { + }, + _SetBase: function _SetBase() { + }, + _UnmodifiableSetMixin: function _UnmodifiableSetMixin() { + }, + UnmodifiableSetView: function UnmodifiableSetView(t0, t1) { + this._collection$_source = t0; + this.$ti = t1; + }, + _UnmodifiableMapView_MapView__UnmodifiableMapMixin: function _UnmodifiableMapView_MapView__UnmodifiableMapMixin() { + }, + _UnmodifiableSetView_SetBase__UnmodifiableSetMixin: function _UnmodifiableSetView_SetBase__UnmodifiableSetMixin() { + }, + _parseJson(source, reviver) { + var e, exception, t1, parsed = null; + try { + parsed = JSON.parse(source); + } catch (exception) { + e = A.unwrapException(exception); + t1 = A.FormatException$(String(e), null, null); + throw A.wrapException(t1); + } + t1 = A._convertJsonToDartLazy(parsed); + return t1; + }, + _convertJsonToDartLazy(object) { + var i; + if (object == null) + return null; + if (typeof object != "object") + return object; + if (!Array.isArray(object)) + return new A._JsonMap(object, Object.create(null)); + for (i = 0; i < object.length; ++i) + object[i] = A._convertJsonToDartLazy(object[i]); + return object; + }, + _Utf8Decoder__makeNativeUint8List(codeUnits, start, end) { + var bytes, t1, i, b, + $length = end - start; + if ($length <= 4096) + bytes = $.$get$_Utf8Decoder__reusableBuffer(); + else + bytes = new Uint8Array($length); + for (t1 = J.getInterceptor$asx(codeUnits), i = 0; i < $length; ++i) { + b = t1.$index(codeUnits, start + i); + if ((b & 255) !== b) + b = 255; + bytes[i] = b; + } + return bytes; + }, + _Utf8Decoder__convertInterceptedUint8List(allowMalformed, codeUnits, start, end) { + var decoder = allowMalformed ? $.$get$_Utf8Decoder__decoderNonfatal() : $.$get$_Utf8Decoder__decoder(); + if (decoder == null) + return null; + if (0 === start && end === codeUnits.length) + return A._Utf8Decoder__useTextDecoder(decoder, codeUnits); + return A._Utf8Decoder__useTextDecoder(decoder, codeUnits.subarray(start, end)); + }, + _Utf8Decoder__useTextDecoder(decoder, codeUnits) { + var t1, exception; + try { + t1 = decoder.decode(codeUnits); + return t1; + } catch (exception) { + } + return null; + }, + Base64Codec__checkPadding(source, sourceIndex, sourceEnd, firstPadding, paddingCount, $length) { + if (B.JSInt_methods.$mod($length, 4) !== 0) + throw A.wrapException(A.FormatException$("Invalid base64 padding, padded length must be multiple of four, is " + $length, source, sourceEnd)); + if (firstPadding + paddingCount !== $length) + throw A.wrapException(A.FormatException$("Invalid base64 padding, '=' not at the end", source, sourceIndex)); + if (paddingCount > 2) + throw A.wrapException(A.FormatException$("Invalid base64 padding, more than two '=' characters", source, sourceIndex)); + }, + _Base64Encoder_encodeChunk(alphabet, bytes, start, end, isLast, output, outputIndex, state) { + var t1, t2, i, byteOr, byte, outputIndex0, outputIndex1, + bits = state >>> 2, + expectedChars = 3 - (state & 3); + for (t1 = J.getInterceptor$asx(bytes), t2 = output.$flags | 0, i = start, byteOr = 0; i < end; ++i) { + byte = t1.$index(bytes, i); + byteOr = (byteOr | byte) >>> 0; + bits = (bits << 8 | byte) & 16777215; + --expectedChars; + if (expectedChars === 0) { + outputIndex0 = outputIndex + 1; + t2 & 2 && A.throwUnsupportedOperation(output); + output[outputIndex] = alphabet.charCodeAt(bits >>> 18 & 63); + outputIndex = outputIndex0 + 1; + output[outputIndex0] = alphabet.charCodeAt(bits >>> 12 & 63); + outputIndex0 = outputIndex + 1; + output[outputIndex] = alphabet.charCodeAt(bits >>> 6 & 63); + outputIndex = outputIndex0 + 1; + output[outputIndex0] = alphabet.charCodeAt(bits & 63); + bits = 0; + expectedChars = 3; + } + } + if (byteOr >= 0 && byteOr <= 255) { + if (isLast && expectedChars < 3) { + outputIndex0 = outputIndex + 1; + outputIndex1 = outputIndex0 + 1; + if (3 - expectedChars === 1) { + t2 & 2 && A.throwUnsupportedOperation(output); + output[outputIndex] = alphabet.charCodeAt(bits >>> 2 & 63); + output[outputIndex0] = alphabet.charCodeAt(bits << 4 & 63); + output[outputIndex1] = 61; + output[outputIndex1 + 1] = 61; + } else { + t2 & 2 && A.throwUnsupportedOperation(output); + output[outputIndex] = alphabet.charCodeAt(bits >>> 10 & 63); + output[outputIndex0] = alphabet.charCodeAt(bits >>> 4 & 63); + output[outputIndex1] = alphabet.charCodeAt(bits << 2 & 63); + output[outputIndex1 + 1] = 61; + } + return 0; + } + return (bits << 2 | 3 - expectedChars) >>> 0; + } + for (i = start; i < end;) { + byte = t1.$index(bytes, i); + if (byte < 0 || byte > 255) + break; + ++i; + } + throw A.wrapException(A.ArgumentError$value(bytes, "Not a byte value at index " + i + ": 0x" + B.JSInt_methods.toRadixString$1(t1.$index(bytes, i), 16), null)); + }, + JsonUnsupportedObjectError$(unsupportedObject, cause, partialResult) { + return new A.JsonUnsupportedObjectError(unsupportedObject, cause); + }, + _defaultToEncodable(object) { + return object.toJson$0(); + }, + _JsonStringStringifier$(_sink, _toEncodable) { + return new A._JsonStringStringifier(_sink, [], A.convert___defaultToEncodable$closure()); + }, + _JsonStringStringifier_stringify(object, toEncodable, indent) { + var t1, + output = new A.StringBuffer(""), + stringifier = A._JsonStringStringifier$(output, toEncodable); + stringifier.writeObject$1(object); + t1 = output._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _Utf8Decoder_errorDescription(state) { + switch (state) { + case 65: + return "Missing extension byte"; + case 67: + return "Unexpected extension byte"; + case 69: + return "Invalid UTF-8 byte"; + case 71: + return "Overlong encoding"; + case 73: + return "Out of unicode range"; + case 75: + return "Encoded surrogate"; + case 77: + return "Unfinished UTF-8 octet sequence"; + default: + return ""; + } + }, + _JsonMap: function _JsonMap(t0, t1) { + this._original = t0; + this._processed = t1; + this._data = null; + }, + _JsonMap_values_closure: function _JsonMap_values_closure(t0) { + this.$this = t0; + }, + _JsonMap_addAll_closure: function _JsonMap_addAll_closure(t0) { + this.$this = t0; + }, + _JsonMapKeyIterable: function _JsonMapKeyIterable(t0) { + this._convert$_parent = t0; + }, + _Utf8Decoder__decoder_closure: function _Utf8Decoder__decoder_closure() { + }, + _Utf8Decoder__decoderNonfatal_closure: function _Utf8Decoder__decoderNonfatal_closure() { + }, + AsciiCodec: function AsciiCodec() { + }, + _UnicodeSubsetEncoder: function _UnicodeSubsetEncoder() { + }, + AsciiEncoder: function AsciiEncoder(t0) { + this._subsetMask = t0; + }, + Base64Codec: function Base64Codec() { + }, + Base64Encoder: function Base64Encoder() { + }, + _Base64Encoder: function _Base64Encoder(t0) { + this._convert$_state = 0; + this._alphabet = t0; + }, + _Base64EncoderSink: function _Base64EncoderSink() { + }, + _Utf8Base64EncoderSink: function _Utf8Base64EncoderSink(t0, t1) { + this._sink = t0; + this._encoder = t1; + }, + ByteConversionSink: function ByteConversionSink() { + }, + Codec: function Codec() { + }, + Converter: function Converter() { + }, + Encoding: function Encoding() { + }, + JsonUnsupportedObjectError: function JsonUnsupportedObjectError(t0, t1) { + this.unsupportedObject = t0; + this.cause = t1; + }, + JsonCyclicError: function JsonCyclicError(t0, t1) { + this.unsupportedObject = t0; + this.cause = t1; + }, + JsonCodec: function JsonCodec() { + }, + JsonEncoder: function JsonEncoder(t0) { + this._toEncodable = t0; + }, + JsonDecoder: function JsonDecoder(t0) { + this._reviver = t0; + }, + _JsonStringifier: function _JsonStringifier() { + }, + _JsonStringifier_writeMap_closure: function _JsonStringifier_writeMap_closure(t0, t1) { + this._box_0 = t0; + this.keyValueList = t1; + }, + _JsonStringStringifier: function _JsonStringStringifier(t0, t1, t2) { + this._sink = t0; + this._seen = t1; + this._toEncodable = t2; + }, + StringConversionSink: function StringConversionSink() { + }, + _StringSinkConversionSink: function _StringSinkConversionSink(t0) { + this._stringSink = t0; + }, + _StringCallbackSink: function _StringCallbackSink(t0, t1) { + this._convert$_callback = t0; + this._stringSink = t1; + }, + _Utf8StringSinkAdapter: function _Utf8StringSinkAdapter(t0, t1, t2) { + this._decoder = t0; + this._sink = t1; + this._stringSink = t2; + }, + Utf8Codec: function Utf8Codec() { + }, + Utf8Encoder: function Utf8Encoder() { + }, + _Utf8Encoder: function _Utf8Encoder(t0) { + this._bufferIndex = 0; + this._buffer = t0; + }, + Utf8Decoder: function Utf8Decoder(t0) { + this._allowMalformed = t0; + }, + _Utf8Decoder: function _Utf8Decoder(t0) { + this.allowMalformed = t0; + this._convert$_state = 16; + this._charOrIndex = 0; + }, + identityHashCode(object) { + return A.objectHashCode(object); + }, + Function_apply($function, positionalArguments) { + return A.Primitives_applyFunction($function, positionalArguments, null); + }, + Expando$() { + return new A.Expando(new WeakMap()); + }, + Expando__checkType(object) { + if (A._isBool(object) || typeof object == "number" || typeof object == "string" || object instanceof A._Record) + A.Expando__badExpandoKey(object); + }, + Expando__badExpandoKey(object) { + throw A.wrapException(A.ArgumentError$value(object, "object", "Expandos are not allowed on strings, numbers, bools, records or null")); + }, + int_parse(source, radix) { + var value = A.Primitives_parseInt(source, radix); + if (value != null) + return value; + throw A.wrapException(A.FormatException$(source, null, null)); + }, + double_parse(source) { + var value = A.Primitives_parseDouble(source); + if (value != null) + return value; + throw A.wrapException(A.FormatException$("Invalid double", source, null)); + }, + Error__throw(error, stackTrace) { + error = A.wrapException(error); + error.stack = stackTrace.toString$0(0); + throw error; + throw A.wrapException("unreachable"); + }, + List_List$filled($length, fill, growable, $E) { + var i, + result = growable ? J.JSArray_JSArray$growable($length, $E) : J.JSArray_JSArray$fixed($length, $E); + if ($length !== 0 && fill != null) + for (i = 0; i < result.length; ++i) + result[i] = fill; + return result; + }, + List_List$from(elements, growable, $E) { + var t1, + list = A._setArrayType([], $E._eval$1("JSArray<0>")); + for (t1 = J.get$iterator$ax(elements); t1.moveNext$0();) + list.push(t1.get$current(t1)); + if (growable) + return list; + list.$flags = 1; + return list; + }, + List_List$of(elements, growable, $E) { + var t1; + if (growable) + return A.List_List$_of(elements, $E); + t1 = A.List_List$_of(elements, $E); + t1.$flags = 1; + return t1; + }, + List_List$_of(elements, $E) { + var list, t1; + if (Array.isArray(elements)) + return A._setArrayType(elements.slice(0), $E._eval$1("JSArray<0>")); + list = A._setArrayType([], $E._eval$1("JSArray<0>")); + for (t1 = J.get$iterator$ax(elements); t1.moveNext$0();) + list.push(t1.get$current(t1)); + return list; + }, + List_List$unmodifiable(elements, $E) { + var result = A.List_List$from(elements, false, $E); + result.$flags = 3; + return result; + }, + String_String$fromCharCodes(charCodes, start, end) { + var t1, t2, maxLength, array, len; + A.RangeError_checkNotNegative(start, "start"); + t1 = end == null; + t2 = !t1; + if (t2) { + maxLength = end - start; + if (maxLength < 0) + throw A.wrapException(A.RangeError$range(end, start, null, "end", null)); + if (maxLength === 0) + return ""; + } + if (Array.isArray(charCodes)) { + array = charCodes; + len = array.length; + if (t1) + end = len; + return A.Primitives_stringFromCharCodes(start > 0 || end < len ? array.slice(start, end) : array); + } + if (type$.NativeUint8List._is(charCodes)) + return A.String__stringFromUint8List(charCodes, start, end); + if (t2) + charCodes = J.take$1$ax(charCodes, end); + if (start > 0) + charCodes = J.skip$1$ax(charCodes, start); + return A.Primitives_stringFromCharCodes(A.List_List$of(charCodes, true, type$.int)); + }, + String_String$fromCharCode(charCode) { + return A.Primitives_stringFromCharCode(charCode); + }, + String__stringFromUint8List(charCodes, start, endOrNull) { + var len = charCodes.length; + if (start >= len) + return ""; + return A.Primitives_stringFromNativeUint8List(charCodes, start, endOrNull == null || endOrNull > len ? len : endOrNull); + }, + RegExp_RegExp(source, multiLine) { + return new A.JSSyntaxRegExp(source, A.JSSyntaxRegExp_makeNative(source, multiLine, true, false, false, false)); + }, + identical(a, b) { + return a == null ? b == null : a === b; + }, + StringBuffer__writeAll(string, objects, separator) { + var iterator = J.get$iterator$ax(objects); + if (!iterator.moveNext$0()) + return string; + if (separator.length === 0) { + do + string += A.S(iterator.get$current(iterator)); + while (iterator.moveNext$0()); + } else { + string += A.S(iterator.get$current(iterator)); + for (; iterator.moveNext$0();) + string = string + separator + A.S(iterator.get$current(iterator)); + } + return string; + }, + NoSuchMethodError_NoSuchMethodError$withInvocation(receiver, invocation) { + return new A.NoSuchMethodError(receiver, invocation.get$memberName(), invocation.get$positionalArguments(), invocation.get$namedArguments()); + }, + Uri_base() { + var cachedUri, uri, + current = A.Primitives_currentUri(); + if (current == null) + throw A.wrapException(A.UnsupportedError$("'Uri.base' is not supported")); + cachedUri = $.Uri__cachedBaseUri; + if (cachedUri != null && current === $.Uri__cachedBaseString) + return cachedUri; + uri = A.Uri_parse(current); + $.Uri__cachedBaseUri = uri; + $.Uri__cachedBaseString = current; + return uri; + }, + _Uri__uriEncode(canonicalMask, text, encoding, spaceToPlus) { + var t1, bytes, i, t2, byte, + _s16_ = "0123456789ABCDEF"; + if (encoding === B.C_Utf8Codec) { + t1 = $.$get$_Uri__needsNoEncoding(); + t1 = t1._nativeRegExp.test(text); + } else + t1 = false; + if (t1) + return text; + bytes = B.C_Utf8Encoder.convert$1(text); + for (t1 = bytes.length, i = 0, t2 = ""; i < t1; ++i) { + byte = bytes[i]; + if (byte < 128 && (string$.x00_____.charCodeAt(byte) & canonicalMask) !== 0) + t2 += A.Primitives_stringFromCharCode(byte); + else + t2 = spaceToPlus && byte === 32 ? t2 + "+" : t2 + "%" + _s16_[byte >>> 4 & 15] + _s16_[byte & 15]; + } + return t2.charCodeAt(0) == 0 ? t2 : t2; + }, + StackTrace_current() { + return A.getTraceFromException(new Error()); + }, + DateTime__fourDigits(n) { + var absN = Math.abs(n), + sign = n < 0 ? "-" : ""; + if (absN >= 1000) + return "" + n; + if (absN >= 100) + return sign + "0" + absN; + if (absN >= 10) + return sign + "00" + absN; + return sign + "000" + absN; + }, + DateTime__threeDigits(n) { + if (n >= 100) + return "" + n; + if (n >= 10) + return "0" + n; + return "00" + n; + }, + DateTime__twoDigits(n) { + if (n >= 10) + return "" + n; + return "0" + n; + }, + Duration$(microseconds, milliseconds) { + return new A.Duration(microseconds + 1000 * milliseconds); + }, + EnumByName_byName(_this, $name) { + var _i, value; + for (_i = 0; _i < 4; ++_i) { + value = _this[_i]; + if (value._name === $name) + return value; + } + throw A.wrapException(A.ArgumentError$value($name, "name", "No enum value with that name")); + }, + Error_safeToString(object) { + if (typeof object == "number" || A._isBool(object) || object == null) + return J.toString$0$(object); + if (typeof object == "string") + return JSON.stringify(object); + return A.Primitives_safeToString(object); + }, + Error_throwWithStackTrace(error, stackTrace) { + A.checkNotNullable(error, "error", type$.Object); + A.checkNotNullable(stackTrace, "stackTrace", type$.StackTrace); + A.Error__throw(error, stackTrace); + }, + AssertionError$(message) { + return new A.AssertionError(message); + }, + ArgumentError$(message, $name) { + return new A.ArgumentError(false, null, $name, message); + }, + ArgumentError$value(value, $name, message) { + return new A.ArgumentError(true, value, $name, message); + }, + ArgumentError_checkNotNull(argument, $name) { + return argument; + }, + RangeError$(message) { + var _null = null; + return new A.RangeError(_null, _null, false, _null, _null, message); + }, + RangeError$value(value, $name, message) { + return new A.RangeError(null, null, true, value, $name, message == null ? "Value not in range" : message); + }, + RangeError$range(invalidValue, minValue, maxValue, $name, message) { + return new A.RangeError(minValue, maxValue, true, invalidValue, $name, message == null ? "Invalid value" : message); + }, + RangeError_checkValueInInterval(value, minValue, maxValue, $name) { + if (value < minValue || value > maxValue) + throw A.wrapException(A.RangeError$range(value, minValue, maxValue, $name, null)); + return value; + }, + RangeError_checkValidRange(start, end, $length) { + if (0 > start || start > $length) + throw A.wrapException(A.RangeError$range(start, 0, $length, "start", null)); + if (end != null) { + if (start > end || end > $length) + throw A.wrapException(A.RangeError$range(end, start, $length, "end", null)); + return end; + } + return $length; + }, + RangeError_checkNotNegative(value, $name) { + if (value < 0) + throw A.wrapException(A.RangeError$range(value, 0, null, $name, null)); + return value; + }, + IndexError$withLength(invalidValue, $length, indexable, message, $name) { + return new A.IndexError($length, true, invalidValue, $name, "Index out of range"); + }, + IndexError_check(index, $length, indexable, message, $name) { + if (0 > index || index >= $length) + throw A.wrapException(A.IndexError$withLength(index, $length, indexable, message, $name == null ? "index" : $name)); + return index; + }, + UnsupportedError$(message) { + return new A.UnsupportedError(message); + }, + UnimplementedError$(message) { + return new A.UnimplementedError(message); + }, + StateError$(message) { + return new A.StateError(message); + }, + ConcurrentModificationError$(modifiedObject) { + return new A.ConcurrentModificationError(modifiedObject); + }, + FormatException$(message, source, offset) { + return new A.FormatException(message, source, offset); + }, + Iterable_Iterable$generate(count, generator, $E) { + if (count <= 0) + return new A.EmptyIterable($E._eval$1("EmptyIterable<0>")); + return new A._GeneratorIterable(count, generator, $E._eval$1("_GeneratorIterable<0>")); + }, + Iterable_iterableToShortString(iterable, leftDelimiter, rightDelimiter) { + var parts, t1; + if (A.isToStringVisiting(iterable)) { + if (leftDelimiter === "(" && rightDelimiter === ")") + return "(...)"; + return leftDelimiter + "..." + rightDelimiter; + } + parts = A._setArrayType([], type$.JSArray_String); + $.toStringVisiting.push(iterable); + try { + A._iterablePartsToStrings(iterable, parts); + } finally { + $.toStringVisiting.pop(); + } + t1 = A.StringBuffer__writeAll(leftDelimiter, parts, ", ") + rightDelimiter; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + Iterable_iterableToFullString(iterable, leftDelimiter, rightDelimiter) { + var buffer, t1; + if (A.isToStringVisiting(iterable)) + return leftDelimiter + "..." + rightDelimiter; + buffer = new A.StringBuffer(leftDelimiter); + $.toStringVisiting.push(iterable); + try { + t1 = buffer; + t1._contents = A.StringBuffer__writeAll(t1._contents, iterable, ", "); + } finally { + $.toStringVisiting.pop(); + } + buffer._contents += rightDelimiter; + t1 = buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _iterablePartsToStrings(iterable, parts) { + var next, ultimateString, penultimateString, penultimate, ultimate, ultimate0, elision, + it = iterable.get$iterator(iterable), + $length = 0, count = 0; + while (true) { + if (!($length < 80 || count < 3)) + break; + if (!it.moveNext$0()) + return; + next = A.S(it.get$current(it)); + parts.push(next); + $length += next.length + 2; + ++count; + } + if (!it.moveNext$0()) { + if (count <= 5) + return; + ultimateString = parts.pop(); + penultimateString = parts.pop(); + } else { + penultimate = it.get$current(it); + ++count; + if (!it.moveNext$0()) { + if (count <= 4) { + parts.push(A.S(penultimate)); + return; + } + ultimateString = A.S(penultimate); + penultimateString = parts.pop(); + $length += ultimateString.length + 2; + } else { + ultimate = it.get$current(it); + ++count; + for (; it.moveNext$0(); penultimate = ultimate, ultimate = ultimate0) { + ultimate0 = it.get$current(it); + ++count; + if (count > 100) { + while (true) { + if (!($length > 75 && count > 3)) + break; + $length -= parts.pop().length + 2; + --count; + } + parts.push("..."); + return; + } + } + penultimateString = A.S(penultimate); + ultimateString = A.S(ultimate); + $length += ultimateString.length + penultimateString.length + 4; + } + } + if (count > parts.length + 2) { + $length += 5; + elision = "..."; + } else + elision = null; + while (true) { + if (!($length > 80 && parts.length > 3)) + break; + $length -= parts.pop().length + 2; + if (elision == null) { + $length += 5; + elision = "..."; + } + } + if (elision != null) + parts.push(elision); + parts.push(penultimateString); + parts.push(ultimateString); + }, + Map_castFrom(source, $K, $V, K2, V2) { + return new A.CastMap(source, $K._eval$1("@<0>")._bind$1($V)._bind$1(K2)._bind$1(V2)._eval$1("CastMap<1,2,3,4>")); + }, + Object_hash(object1, object2, object3, object4) { + var t1; + if (B.C_SentinelValue === object3) { + t1 = J.get$hashCode$(object1); + object2 = J.get$hashCode$(object2); + return A.SystemHash_finish(A.SystemHash_combine(A.SystemHash_combine($.$get$_hashSeed(), t1), object2)); + } + if (B.C_SentinelValue === object4) { + t1 = J.get$hashCode$(object1); + object2 = J.get$hashCode$(object2); + object3 = J.get$hashCode$(object3); + return A.SystemHash_finish(A.SystemHash_combine(A.SystemHash_combine(A.SystemHash_combine($.$get$_hashSeed(), t1), object2), object3)); + } + t1 = J.get$hashCode$(object1); + object2 = J.get$hashCode$(object2); + object3 = J.get$hashCode$(object3); + object4 = J.get$hashCode$(object4); + object4 = A.SystemHash_finish(A.SystemHash_combine(A.SystemHash_combine(A.SystemHash_combine(A.SystemHash_combine($.$get$_hashSeed(), t1), object2), object3), object4)); + return object4; + }, + Object_hashAll(objects) { + var t1, _i, + hash = $.$get$_hashSeed(); + for (t1 = objects.length, _i = 0; _i < objects.length; objects.length === t1 || (0, A.throwConcurrentModificationError)(objects), ++_i) + hash = A.SystemHash_combine(hash, J.get$hashCode$(objects[_i])); + return A.SystemHash_finish(hash); + }, + print(object) { + var line = A.S(object), + toZone = $.printToZone; + if (toZone == null) + A.printString(line); + else + toZone.call$1(line); + }, + Set_Set$unmodifiable(elements, $E) { + return new A.UnmodifiableSetView(A.LinkedHashSet_LinkedHashSet$of(elements, $E), $E._eval$1("UnmodifiableSetView<0>")); + }, + Set_castFrom(source, newSet, $S, $T) { + return new A.CastSet(source, newSet, $S._eval$1("@<0>")._bind$1($T)._eval$1("CastSet<1,2>")); + }, + _combineSurrogatePair(start, end) { + return 65536 + ((start & 1023) << 10) + (end & 1023); + }, + Uri_Uri$dataFromString($content, encoding, mimeType) { + var encodingName, t1, + buffer = new A.StringBuffer(""), + indices = A._setArrayType([-1], type$.JSArray_int); + if (encoding == null) + encodingName = null; + else + encodingName = "utf-8"; + if (encoding == null) + encoding = B.C_AsciiCodec; + A.UriData__writeUri(mimeType, encodingName, null, buffer, indices); + indices.push(buffer._contents.length); + buffer._contents += ","; + A.UriData__uriEncodeBytes(256, encoding.encode$1($content), buffer); + t1 = buffer._contents; + return new A.UriData(t1.charCodeAt(0) == 0 ? t1 : t1, indices, null).get$uri(); + }, + Uri_parse(uri) { + var delta, indices, schemeEnd, hostStart, portStart, pathStart, queryStart, fragmentStart, isSimple, scheme, t1, t2, schemeAuth, queryStart0, pathStart0, port, userInfoStart, userInfo, host, portNumber, path, query, _null = null, + end = uri.length; + if (end >= 5) { + delta = ((uri.charCodeAt(4) ^ 58) * 3 | uri.charCodeAt(0) ^ 100 | uri.charCodeAt(1) ^ 97 | uri.charCodeAt(2) ^ 116 | uri.charCodeAt(3) ^ 97) >>> 0; + if (delta === 0) + return A.UriData__parse(end < end ? B.JSString_methods.substring$2(uri, 0, end) : uri, 5, _null).get$uri(); + else if (delta === 32) + return A.UriData__parse(B.JSString_methods.substring$2(uri, 5, end), 0, _null).get$uri(); + } + indices = A.List_List$filled(8, 0, false, type$.int); + indices[0] = 0; + indices[1] = -1; + indices[2] = -1; + indices[7] = -1; + indices[3] = 0; + indices[4] = 0; + indices[5] = end; + indices[6] = end; + if (A._scan(uri, 0, end, 0, indices) >= 14) + indices[7] = end; + schemeEnd = indices[1]; + if (schemeEnd >= 0) + if (A._scan(uri, 0, schemeEnd, 20, indices) === 20) + indices[7] = schemeEnd; + hostStart = indices[2] + 1; + portStart = indices[3]; + pathStart = indices[4]; + queryStart = indices[5]; + fragmentStart = indices[6]; + if (fragmentStart < queryStart) + queryStart = fragmentStart; + if (pathStart < hostStart) + pathStart = queryStart; + else if (pathStart <= schemeEnd) + pathStart = schemeEnd + 1; + if (portStart < hostStart) + portStart = pathStart; + isSimple = indices[7] < 0; + scheme = _null; + if (isSimple) { + isSimple = false; + if (!(hostStart > schemeEnd + 3)) { + t1 = portStart > 0; + if (!(t1 && portStart + 1 === pathStart)) { + if (!B.JSString_methods.startsWith$2(uri, "\\", pathStart)) + if (hostStart > 0) + t2 = B.JSString_methods.startsWith$2(uri, "\\", hostStart - 1) || B.JSString_methods.startsWith$2(uri, "\\", hostStart - 2); + else + t2 = false; + else + t2 = true; + if (!t2) { + if (!(queryStart < end && queryStart === pathStart + 2 && B.JSString_methods.startsWith$2(uri, "..", pathStart))) + t2 = queryStart > pathStart + 2 && B.JSString_methods.startsWith$2(uri, "/..", queryStart - 3); + else + t2 = true; + if (!t2) + if (schemeEnd === 4) { + if (B.JSString_methods.startsWith$2(uri, "file", 0)) { + if (hostStart <= 0) { + if (!B.JSString_methods.startsWith$2(uri, "/", pathStart)) { + schemeAuth = "file:///"; + delta = 3; + } else { + schemeAuth = "file://"; + delta = 2; + } + uri = schemeAuth + B.JSString_methods.substring$2(uri, pathStart, end); + queryStart += delta; + fragmentStart += delta; + end = uri.length; + hostStart = 7; + portStart = 7; + pathStart = 7; + } else if (pathStart === queryStart) { + ++fragmentStart; + queryStart0 = queryStart + 1; + uri = B.JSString_methods.replaceRange$3(uri, pathStart, queryStart, "/"); + ++end; + queryStart = queryStart0; + } + scheme = "file"; + } else if (B.JSString_methods.startsWith$2(uri, "http", 0)) { + if (t1 && portStart + 3 === pathStart && B.JSString_methods.startsWith$2(uri, "80", portStart + 1)) { + fragmentStart -= 3; + pathStart0 = pathStart - 3; + queryStart -= 3; + uri = B.JSString_methods.replaceRange$3(uri, portStart, pathStart, ""); + end -= 3; + pathStart = pathStart0; + } + scheme = "http"; + } + } else if (schemeEnd === 5 && B.JSString_methods.startsWith$2(uri, "https", 0)) { + if (t1 && portStart + 4 === pathStart && B.JSString_methods.startsWith$2(uri, "443", portStart + 1)) { + fragmentStart -= 4; + pathStart0 = pathStart - 4; + queryStart -= 4; + uri = B.JSString_methods.replaceRange$3(uri, portStart, pathStart, ""); + end -= 3; + pathStart = pathStart0; + } + scheme = "https"; + } + isSimple = !t2; + } + } + } + } + if (isSimple) + return new A._SimpleUri(end < uri.length ? B.JSString_methods.substring$2(uri, 0, end) : uri, schemeEnd, hostStart, portStart, pathStart, queryStart, fragmentStart, scheme); + if (scheme == null) + if (schemeEnd > 0) + scheme = A._Uri__makeScheme(uri, 0, schemeEnd); + else { + if (schemeEnd === 0) + A._Uri__fail(uri, 0, "Invalid empty scheme"); + scheme = ""; + } + port = _null; + if (hostStart > 0) { + userInfoStart = schemeEnd + 3; + userInfo = userInfoStart < hostStart ? A._Uri__makeUserInfo(uri, userInfoStart, hostStart - 1) : ""; + host = A._Uri__makeHost(uri, hostStart, portStart, false); + t1 = portStart + 1; + if (t1 < pathStart) { + portNumber = A.Primitives_parseInt(B.JSString_methods.substring$2(uri, t1, pathStart), _null); + port = A._Uri__makePort(portNumber == null ? A.throwExpression(A.FormatException$("Invalid port", uri, t1)) : portNumber, scheme); + } + } else { + host = _null; + userInfo = ""; + } + path = A._Uri__makePath(uri, pathStart, queryStart, _null, scheme, host != null); + query = queryStart < fragmentStart ? A._Uri__makeQuery(uri, queryStart + 1, fragmentStart, _null) : _null; + return A._Uri$_internal(scheme, userInfo, host, port, path, query, fragmentStart < end ? A._Uri__makeFragment(uri, fragmentStart + 1, end) : _null); + }, + Uri_decodeComponent(encodedComponent) { + return A._Uri__uriDecode(encodedComponent, 0, encodedComponent.length, B.C_Utf8Codec, false); + }, + Uri__parseIPv4Address(host, start, end) { + var i, partStart, partIndex, char, part, partIndex0, + _s43_ = "IPv4 address should contain exactly 4 parts", + _s37_ = "each part must be in the range 0..255", + error = new A.Uri__parseIPv4Address_error(host), + result = new Uint8Array(4); + for (i = start, partStart = i, partIndex = 0; i < end; ++i) { + char = host.charCodeAt(i); + if (char !== 46) { + if ((char ^ 48) > 9) + error.call$2("invalid character", i); + } else { + if (partIndex === 3) + error.call$2(_s43_, i); + part = A.int_parse(B.JSString_methods.substring$2(host, partStart, i), null); + if (part > 255) + error.call$2(_s37_, partStart); + partIndex0 = partIndex + 1; + result[partIndex] = part; + partStart = i + 1; + partIndex = partIndex0; + } + } + if (partIndex !== 3) + error.call$2(_s43_, end); + part = A.int_parse(B.JSString_methods.substring$2(host, partStart, end), null); + if (part > 255) + error.call$2(_s37_, partStart); + result[partIndex] = part; + return result; + }, + Uri_parseIPv6Address(host, start, end) { + var parts, i, partStart, wildcardSeen, seenDot, char, atEnd, t1, last, bytes, wildCardLength, index, value, j, _null = null, + error = new A.Uri_parseIPv6Address_error(host), + parseHex = new A.Uri_parseIPv6Address_parseHex(error, host); + if (host.length < 2) + error.call$2("address is too short", _null); + parts = A._setArrayType([], type$.JSArray_int); + for (i = start, partStart = i, wildcardSeen = false, seenDot = false; i < end; ++i) { + char = host.charCodeAt(i); + if (char === 58) { + if (i === start) { + ++i; + if (host.charCodeAt(i) !== 58) + error.call$2("invalid start colon.", i); + partStart = i; + } + if (i === partStart) { + if (wildcardSeen) + error.call$2("only one wildcard `::` is allowed", i); + parts.push(-1); + wildcardSeen = true; + } else + parts.push(parseHex.call$2(partStart, i)); + partStart = i + 1; + } else if (char === 46) + seenDot = true; + } + if (parts.length === 0) + error.call$2("too few parts", _null); + atEnd = partStart === end; + t1 = B.JSArray_methods.get$last(parts); + if (atEnd && t1 !== -1) + error.call$2("expected a part after last `:`", end); + if (!atEnd) + if (!seenDot) + parts.push(parseHex.call$2(partStart, end)); + else { + last = A.Uri__parseIPv4Address(host, partStart, end); + parts.push((last[0] << 8 | last[1]) >>> 0); + parts.push((last[2] << 8 | last[3]) >>> 0); + } + if (wildcardSeen) { + if (parts.length > 7) + error.call$2("an address with a wildcard must have less than 7 parts", _null); + } else if (parts.length !== 8) + error.call$2("an address without a wildcard must contain exactly 8 parts", _null); + bytes = new Uint8Array(16); + for (t1 = parts.length, wildCardLength = 9 - t1, i = 0, index = 0; i < t1; ++i) { + value = parts[i]; + if (value === -1) + for (j = 0; j < wildCardLength; ++j) { + bytes[index] = 0; + bytes[index + 1] = 0; + index += 2; + } + else { + bytes[index] = B.JSInt_methods._shrOtherPositive$1(value, 8); + bytes[index + 1] = value & 255; + index += 2; + } + } + return bytes; + }, + _Uri$_internal(scheme, _userInfo, _host, _port, path, _query, _fragment) { + return new A._Uri(scheme, _userInfo, _host, _port, path, _query, _fragment); + }, + _Uri__Uri(host, path, pathSegments, scheme) { + var userInfo, query, fragment, port, isFile, t1, hasAuthority, t2, _null = null; + scheme = scheme == null ? "" : A._Uri__makeScheme(scheme, 0, scheme.length); + userInfo = A._Uri__makeUserInfo(_null, 0, 0); + host = A._Uri__makeHost(host, 0, host == null ? 0 : host.length, false); + query = A._Uri__makeQuery(_null, 0, 0, _null); + fragment = A._Uri__makeFragment(_null, 0, 0); + port = A._Uri__makePort(_null, scheme); + isFile = scheme === "file"; + if (host == null) + t1 = userInfo.length !== 0 || port != null || isFile; + else + t1 = false; + if (t1) + host = ""; + t1 = host == null; + hasAuthority = !t1; + path = A._Uri__makePath(path, 0, path == null ? 0 : path.length, pathSegments, scheme, hasAuthority); + t2 = scheme.length === 0; + if (t2 && t1 && !B.JSString_methods.startsWith$1(path, "/")) + path = A._Uri__normalizeRelativePath(path, !t2 || hasAuthority); + else + path = A._Uri__removeDotSegments(path); + return A._Uri$_internal(scheme, userInfo, t1 && B.JSString_methods.startsWith$1(path, "//") ? "" : host, port, path, query, fragment); + }, + _Uri__defaultPort(scheme) { + if (scheme === "http") + return 80; + if (scheme === "https") + return 443; + return 0; + }, + _Uri__fail(uri, index, message) { + throw A.wrapException(A.FormatException$(message, uri, index)); + }, + _Uri__Uri$file(path, windows) { + return windows ? A._Uri__makeWindowsFileUrl(path, false) : A._Uri__makeFileUri(path, false); + }, + _Uri__checkNonWindowsPathReservedCharacters(segments, argumentError) { + var t1, _i, segment; + for (t1 = segments.length, _i = 0; _i < t1; ++_i) { + segment = segments[_i]; + if (A.stringContainsUnchecked(segment, "/", 0)) { + t1 = A.UnsupportedError$("Illegal path character " + segment); + throw A.wrapException(t1); + } + } + }, + _Uri__checkWindowsPathReservedCharacters(segments, argumentError, firstSegment) { + var t1, t2, t3, t4; + for (t1 = A.SubListIterable$(segments, firstSegment, null, A._arrayInstanceType(segments)._precomputed1), t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListIterable.E"); t1.moveNext$0();) { + t3 = t1.__internal$_current; + if (t3 == null) + t3 = t2._as(t3); + t4 = A.RegExp_RegExp('["*/:<>?\\\\|]', false); + if (A.stringContainsUnchecked(t3, t4, 0)) + if (argumentError) + throw A.wrapException(A.ArgumentError$("Illegal character in path", null)); + else + throw A.wrapException(A.UnsupportedError$("Illegal character in path: " + t3)); + } + }, + _Uri__checkWindowsDriveLetter(charCode, argumentError) { + var t1, + _s21_ = "Illegal drive letter "; + if (!(65 <= charCode && charCode <= 90)) + t1 = 97 <= charCode && charCode <= 122; + else + t1 = true; + if (t1) + return; + if (argumentError) + throw A.wrapException(A.ArgumentError$(_s21_ + A.String_String$fromCharCode(charCode), null)); + else + throw A.wrapException(A.UnsupportedError$(_s21_ + A.String_String$fromCharCode(charCode))); + }, + _Uri__makeFileUri(path, slashTerminated) { + var _null = null, + segments = A._setArrayType(path.split("/"), type$.JSArray_String); + if (B.JSString_methods.startsWith$1(path, "/")) + return A._Uri__Uri(_null, _null, segments, "file"); + else + return A._Uri__Uri(_null, _null, segments, _null); + }, + _Uri__makeWindowsFileUrl(path, slashTerminated) { + var t1, pathSegments, pathStart, hostPart, _s1_ = "\\", _null = null, _s4_ = "file"; + if (B.JSString_methods.startsWith$1(path, "\\\\?\\")) + if (B.JSString_methods.startsWith$2(path, "UNC\\", 4)) + path = B.JSString_methods.replaceRange$3(path, 0, 7, _s1_); + else { + path = B.JSString_methods.substring$1(path, 4); + if (path.length < 3 || path.charCodeAt(1) !== 58 || path.charCodeAt(2) !== 92) + throw A.wrapException(A.ArgumentError$value(path, "path", "Windows paths with \\\\?\\ prefix must be absolute")); + } + else + path = A.stringReplaceAllUnchecked(path, "/", _s1_); + t1 = path.length; + if (t1 > 1 && path.charCodeAt(1) === 58) { + A._Uri__checkWindowsDriveLetter(path.charCodeAt(0), true); + if (t1 === 2 || path.charCodeAt(2) !== 92) + throw A.wrapException(A.ArgumentError$value(path, "path", "Windows paths with drive letter must be absolute")); + pathSegments = A._setArrayType(path.split(_s1_), type$.JSArray_String); + A._Uri__checkWindowsPathReservedCharacters(pathSegments, true, 1); + return A._Uri__Uri(_null, _null, pathSegments, _s4_); + } + if (B.JSString_methods.startsWith$1(path, _s1_)) + if (B.JSString_methods.startsWith$2(path, _s1_, 1)) { + pathStart = B.JSString_methods.indexOf$2(path, _s1_, 2); + t1 = pathStart < 0; + hostPart = t1 ? B.JSString_methods.substring$1(path, 2) : B.JSString_methods.substring$2(path, 2, pathStart); + pathSegments = A._setArrayType((t1 ? "" : B.JSString_methods.substring$1(path, pathStart + 1)).split(_s1_), type$.JSArray_String); + A._Uri__checkWindowsPathReservedCharacters(pathSegments, true, 0); + return A._Uri__Uri(hostPart, _null, pathSegments, _s4_); + } else { + pathSegments = A._setArrayType(path.split(_s1_), type$.JSArray_String); + A._Uri__checkWindowsPathReservedCharacters(pathSegments, true, 0); + return A._Uri__Uri(_null, _null, pathSegments, _s4_); + } + else { + pathSegments = A._setArrayType(path.split(_s1_), type$.JSArray_String); + A._Uri__checkWindowsPathReservedCharacters(pathSegments, true, 0); + return A._Uri__Uri(_null, _null, pathSegments, _null); + } + }, + _Uri__makePort(port, scheme) { + if (port != null && port === A._Uri__defaultPort(scheme)) + return null; + return port; + }, + _Uri__makeHost(host, start, end, strictIPv6) { + var t1, t2, index, zoneIDstart, zoneID, i; + if (host == null) + return null; + if (start === end) + return ""; + if (host.charCodeAt(start) === 91) { + t1 = end - 1; + if (host.charCodeAt(t1) !== 93) + A._Uri__fail(host, start, "Missing end `]` to match `[` in host"); + t2 = start + 1; + index = A._Uri__checkZoneID(host, t2, t1); + if (index < t1) { + zoneIDstart = index + 1; + zoneID = A._Uri__normalizeZoneID(host, B.JSString_methods.startsWith$2(host, "25", zoneIDstart) ? index + 3 : zoneIDstart, t1, "%25"); + } else + zoneID = ""; + A.Uri_parseIPv6Address(host, t2, index); + return B.JSString_methods.substring$2(host, start, index).toLowerCase() + zoneID + "]"; + } + for (i = start; i < end; ++i) + if (host.charCodeAt(i) === 58) { + index = B.JSString_methods.indexOf$2(host, "%", start); + index = index >= start && index < end ? index : end; + if (index < end) { + zoneIDstart = index + 1; + zoneID = A._Uri__normalizeZoneID(host, B.JSString_methods.startsWith$2(host, "25", zoneIDstart) ? index + 3 : zoneIDstart, end, "%25"); + } else + zoneID = ""; + A.Uri_parseIPv6Address(host, start, index); + return "[" + B.JSString_methods.substring$2(host, start, index) + zoneID + "]"; + } + return A._Uri__normalizeRegName(host, start, end); + }, + _Uri__checkZoneID(host, start, end) { + var index = B.JSString_methods.indexOf$2(host, "%", start); + return index >= start && index < end ? index : end; + }, + _Uri__normalizeZoneID(host, start, end, prefix) { + var index, sectionStart, isNormalized, char, replacement, t1, t2, sourceLength, tail, slice, + buffer = prefix !== "" ? new A.StringBuffer(prefix) : null; + for (index = start, sectionStart = index, isNormalized = true; index < end;) { + char = host.charCodeAt(index); + if (char === 37) { + replacement = A._Uri__normalizeEscape(host, index, true); + t1 = replacement == null; + if (t1 && isNormalized) { + index += 3; + continue; + } + if (buffer == null) + buffer = new A.StringBuffer(""); + t2 = buffer._contents += B.JSString_methods.substring$2(host, sectionStart, index); + if (t1) + replacement = B.JSString_methods.substring$2(host, index, index + 3); + else if (replacement === "%") + A._Uri__fail(host, index, "ZoneID should not contain % anymore"); + buffer._contents = t2 + replacement; + index += 3; + sectionStart = index; + isNormalized = true; + } else if (char < 127 && (string$.x00_____.charCodeAt(char) & 1) !== 0) { + if (isNormalized && 65 <= char && 90 >= char) { + if (buffer == null) + buffer = new A.StringBuffer(""); + if (sectionStart < index) { + buffer._contents += B.JSString_methods.substring$2(host, sectionStart, index); + sectionStart = index; + } + isNormalized = false; + } + ++index; + } else { + sourceLength = 1; + if ((char & 64512) === 55296 && index + 1 < end) { + tail = host.charCodeAt(index + 1); + if ((tail & 64512) === 56320) { + char = 65536 + ((char & 1023) << 10) + (tail & 1023); + sourceLength = 2; + } + } + slice = B.JSString_methods.substring$2(host, sectionStart, index); + if (buffer == null) { + buffer = new A.StringBuffer(""); + t1 = buffer; + } else + t1 = buffer; + t1._contents += slice; + t2 = A._Uri__escapeChar(char); + t1._contents += t2; + index += sourceLength; + sectionStart = index; + } + } + if (buffer == null) + return B.JSString_methods.substring$2(host, start, end); + if (sectionStart < end) { + slice = B.JSString_methods.substring$2(host, sectionStart, end); + buffer._contents += slice; + } + t1 = buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _Uri__normalizeRegName(host, start, end) { + var index, sectionStart, buffer, isNormalized, char, replacement, t1, slice, t2, sourceLength, tail, + _s128_ = string$.x00_____; + for (index = start, sectionStart = index, buffer = null, isNormalized = true; index < end;) { + char = host.charCodeAt(index); + if (char === 37) { + replacement = A._Uri__normalizeEscape(host, index, true); + t1 = replacement == null; + if (t1 && isNormalized) { + index += 3; + continue; + } + if (buffer == null) + buffer = new A.StringBuffer(""); + slice = B.JSString_methods.substring$2(host, sectionStart, index); + if (!isNormalized) + slice = slice.toLowerCase(); + t2 = buffer._contents += slice; + sourceLength = 3; + if (t1) + replacement = B.JSString_methods.substring$2(host, index, index + 3); + else if (replacement === "%") { + replacement = "%25"; + sourceLength = 1; + } + buffer._contents = t2 + replacement; + index += sourceLength; + sectionStart = index; + isNormalized = true; + } else if (char < 127 && (_s128_.charCodeAt(char) & 32) !== 0) { + if (isNormalized && 65 <= char && 90 >= char) { + if (buffer == null) + buffer = new A.StringBuffer(""); + if (sectionStart < index) { + buffer._contents += B.JSString_methods.substring$2(host, sectionStart, index); + sectionStart = index; + } + isNormalized = false; + } + ++index; + } else if (char <= 93 && (_s128_.charCodeAt(char) & 1024) !== 0) + A._Uri__fail(host, index, "Invalid character"); + else { + sourceLength = 1; + if ((char & 64512) === 55296 && index + 1 < end) { + tail = host.charCodeAt(index + 1); + if ((tail & 64512) === 56320) { + char = 65536 + ((char & 1023) << 10) + (tail & 1023); + sourceLength = 2; + } + } + slice = B.JSString_methods.substring$2(host, sectionStart, index); + if (!isNormalized) + slice = slice.toLowerCase(); + if (buffer == null) { + buffer = new A.StringBuffer(""); + t1 = buffer; + } else + t1 = buffer; + t1._contents += slice; + t2 = A._Uri__escapeChar(char); + t1._contents += t2; + index += sourceLength; + sectionStart = index; + } + } + if (buffer == null) + return B.JSString_methods.substring$2(host, start, end); + if (sectionStart < end) { + slice = B.JSString_methods.substring$2(host, sectionStart, end); + if (!isNormalized) + slice = slice.toLowerCase(); + buffer._contents += slice; + } + t1 = buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _Uri__makeScheme(scheme, start, end) { + var i, containsUpperCase, codeUnit; + if (start === end) + return ""; + if (!A._Uri__isAlphabeticCharacter(scheme.charCodeAt(start))) + A._Uri__fail(scheme, start, "Scheme not starting with alphabetic character"); + for (i = start, containsUpperCase = false; i < end; ++i) { + codeUnit = scheme.charCodeAt(i); + if (!(codeUnit < 128 && (string$.x00_____.charCodeAt(codeUnit) & 8) !== 0)) + A._Uri__fail(scheme, i, "Illegal scheme character"); + if (65 <= codeUnit && codeUnit <= 90) + containsUpperCase = true; + } + scheme = B.JSString_methods.substring$2(scheme, start, end); + return A._Uri__canonicalizeScheme(containsUpperCase ? scheme.toLowerCase() : scheme); + }, + _Uri__canonicalizeScheme(scheme) { + if (scheme === "http") + return "http"; + if (scheme === "file") + return "file"; + if (scheme === "https") + return "https"; + if (scheme === "package") + return "package"; + return scheme; + }, + _Uri__makeUserInfo(userInfo, start, end) { + if (userInfo == null) + return ""; + return A._Uri__normalizeOrSubstring(userInfo, start, end, 16, false, false); + }, + _Uri__makePath(path, start, end, pathSegments, scheme, hasAuthority) { + var result, + isFile = scheme === "file", + ensureLeadingSlash = isFile || hasAuthority; + if (path == null) { + if (pathSegments == null) + return isFile ? "/" : ""; + result = new A.MappedListIterable(pathSegments, new A._Uri__makePath_closure(), A._arrayInstanceType(pathSegments)._eval$1("MappedListIterable<1,String>")).join$1(0, "/"); + } else if (pathSegments != null) + throw A.wrapException(A.ArgumentError$("Both path and pathSegments specified", null)); + else + result = A._Uri__normalizeOrSubstring(path, start, end, 128, true, true); + if (result.length === 0) { + if (isFile) + return "/"; + } else if (ensureLeadingSlash && !B.JSString_methods.startsWith$1(result, "/")) + result = "/" + result; + return A._Uri__normalizePath(result, scheme, hasAuthority); + }, + _Uri__normalizePath(path, scheme, hasAuthority) { + var t1 = scheme.length === 0; + if (t1 && !hasAuthority && !B.JSString_methods.startsWith$1(path, "/") && !B.JSString_methods.startsWith$1(path, "\\")) + return A._Uri__normalizeRelativePath(path, !t1 || hasAuthority); + return A._Uri__removeDotSegments(path); + }, + _Uri__makeQuery(query, start, end, queryParameters) { + if (query != null) + return A._Uri__normalizeOrSubstring(query, start, end, 256, true, false); + return null; + }, + _Uri__makeFragment(fragment, start, end) { + if (fragment == null) + return null; + return A._Uri__normalizeOrSubstring(fragment, start, end, 256, true, false); + }, + _Uri__normalizeEscape(source, index, lowerCase) { + var firstDigit, secondDigit, firstDigitValue, secondDigitValue, value, + t1 = index + 2; + if (t1 >= source.length) + return "%"; + firstDigit = source.charCodeAt(index + 1); + secondDigit = source.charCodeAt(t1); + firstDigitValue = A.hexDigitValue(firstDigit); + secondDigitValue = A.hexDigitValue(secondDigit); + if (firstDigitValue < 0 || secondDigitValue < 0) + return "%"; + value = firstDigitValue * 16 + secondDigitValue; + if (value < 127 && (string$.x00_____.charCodeAt(value) & 1) !== 0) + return A.Primitives_stringFromCharCode(lowerCase && 65 <= value && 90 >= value ? (value | 32) >>> 0 : value); + if (firstDigit >= 97 || secondDigit >= 97) + return B.JSString_methods.substring$2(source, index, index + 3).toUpperCase(); + return null; + }, + _Uri__escapeChar(char) { + var codeUnits, flag, encodedBytes, index, byte, + _s16_ = "0123456789ABCDEF"; + if (char <= 127) { + codeUnits = new Uint8Array(3); + codeUnits[0] = 37; + codeUnits[1] = _s16_.charCodeAt(char >>> 4); + codeUnits[2] = _s16_.charCodeAt(char & 15); + } else { + if (char > 2047) + if (char > 65535) { + flag = 240; + encodedBytes = 4; + } else { + flag = 224; + encodedBytes = 3; + } + else { + flag = 192; + encodedBytes = 2; + } + codeUnits = new Uint8Array(3 * encodedBytes); + for (index = 0; --encodedBytes, encodedBytes >= 0; flag = 128) { + byte = B.JSInt_methods._shrReceiverPositive$1(char, 6 * encodedBytes) & 63 | flag; + codeUnits[index] = 37; + codeUnits[index + 1] = _s16_.charCodeAt(byte >>> 4); + codeUnits[index + 2] = _s16_.charCodeAt(byte & 15); + index += 3; + } + } + return A.String_String$fromCharCodes(codeUnits, 0, null); + }, + _Uri__normalizeOrSubstring(component, start, end, charMask, escapeDelimiters, replaceBackslash) { + var t1 = A._Uri__normalize(component, start, end, charMask, escapeDelimiters, replaceBackslash); + return t1 == null ? B.JSString_methods.substring$2(component, start, end) : t1; + }, + _Uri__normalize(component, start, end, charMask, escapeDelimiters, replaceBackslash) { + var t1, index, sectionStart, buffer, char, sourceLength, replacement, t2, tail, t3, _null = null, + _s128_ = string$.x00_____; + for (t1 = !escapeDelimiters, index = start, sectionStart = index, buffer = _null; index < end;) { + char = component.charCodeAt(index); + if (char < 127 && (_s128_.charCodeAt(char) & charMask) !== 0) + ++index; + else { + sourceLength = 1; + if (char === 37) { + replacement = A._Uri__normalizeEscape(component, index, false); + if (replacement == null) { + index += 3; + continue; + } + if ("%" === replacement) + replacement = "%25"; + else + sourceLength = 3; + } else if (char === 92 && replaceBackslash) + replacement = "/"; + else if (t1 && char <= 93 && (_s128_.charCodeAt(char) & 1024) !== 0) { + A._Uri__fail(component, index, "Invalid character"); + sourceLength = _null; + replacement = sourceLength; + } else { + if ((char & 64512) === 55296) { + t2 = index + 1; + if (t2 < end) { + tail = component.charCodeAt(t2); + if ((tail & 64512) === 56320) { + char = 65536 + ((char & 1023) << 10) + (tail & 1023); + sourceLength = 2; + } + } + } + replacement = A._Uri__escapeChar(char); + } + if (buffer == null) { + buffer = new A.StringBuffer(""); + t2 = buffer; + } else + t2 = buffer; + t3 = t2._contents += B.JSString_methods.substring$2(component, sectionStart, index); + t2._contents = t3 + A.S(replacement); + index += sourceLength; + sectionStart = index; + } + } + if (buffer == null) + return _null; + if (sectionStart < end) { + t1 = B.JSString_methods.substring$2(component, sectionStart, end); + buffer._contents += t1; + } + t1 = buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _Uri__mayContainDotSegments(path) { + if (B.JSString_methods.startsWith$1(path, ".")) + return true; + return B.JSString_methods.indexOf$1(path, "/.") !== -1; + }, + _Uri__removeDotSegments(path) { + var output, t1, t2, appendSlash, _i, segment; + if (!A._Uri__mayContainDotSegments(path)) + return path; + output = A._setArrayType([], type$.JSArray_String); + for (t1 = path.split("/"), t2 = t1.length, appendSlash = false, _i = 0; _i < t2; ++_i) { + segment = t1[_i]; + if (segment === "..") { + if (output.length !== 0) { + output.pop(); + if (output.length === 0) + output.push(""); + } + appendSlash = true; + } else { + appendSlash = "." === segment; + if (!appendSlash) + output.push(segment); + } + } + if (appendSlash) + output.push(""); + return B.JSArray_methods.join$1(output, "/"); + }, + _Uri__normalizeRelativePath(path, allowScheme) { + var output, t1, t2, appendSlash, _i, segment; + if (!A._Uri__mayContainDotSegments(path)) + return !allowScheme ? A._Uri__escapeScheme(path) : path; + output = A._setArrayType([], type$.JSArray_String); + for (t1 = path.split("/"), t2 = t1.length, appendSlash = false, _i = 0; _i < t2; ++_i) { + segment = t1[_i]; + if (".." === segment) { + appendSlash = output.length !== 0 && B.JSArray_methods.get$last(output) !== ".."; + if (appendSlash) + output.pop(); + else + output.push(".."); + } else { + appendSlash = "." === segment; + if (!appendSlash) + output.push(segment); + } + } + t1 = output.length; + if (t1 !== 0) + t1 = t1 === 1 && output[0].length === 0; + else + t1 = true; + if (t1) + return "./"; + if (appendSlash || B.JSArray_methods.get$last(output) === "..") + output.push(""); + if (!allowScheme) + output[0] = A._Uri__escapeScheme(output[0]); + return B.JSArray_methods.join$1(output, "/"); + }, + _Uri__escapeScheme(path) { + var i, char, + t1 = path.length; + if (t1 >= 2 && A._Uri__isAlphabeticCharacter(path.charCodeAt(0))) + for (i = 1; i < t1; ++i) { + char = path.charCodeAt(i); + if (char === 58) + return B.JSString_methods.substring$2(path, 0, i) + "%3A" + B.JSString_methods.substring$1(path, i + 1); + if (char > 127 || (string$.x00_____.charCodeAt(char) & 8) === 0) + break; + } + return path; + }, + _Uri__packageNameEnd(uri, path) { + if (uri.isScheme$1("package") && uri._host == null) + return A._skipPackageNameChars(path, 0, path.length); + return -1; + }, + _Uri__toWindowsFilePath(uri) { + var t2, hasDriveLetter, host, + segments = uri.get$pathSegments(), + t1 = segments.length; + if (t1 > 0) { + t2 = segments[0]; + hasDriveLetter = t2.length === 2 && t2.charCodeAt(1) === 58; + } else + hasDriveLetter = false; + if (hasDriveLetter) { + A._Uri__checkWindowsDriveLetter(segments[0].charCodeAt(0), false); + A._Uri__checkWindowsPathReservedCharacters(segments, false, 1); + } else + A._Uri__checkWindowsPathReservedCharacters(segments, false, 0); + t2 = uri.get$hasAbsolutePath() && !hasDriveLetter ? "" + "\\" : ""; + if (uri.get$hasAuthority()) { + host = uri.get$host(); + if (host.length !== 0) + t2 = t2 + "\\" + host + "\\"; + } + t2 = A.StringBuffer__writeAll(t2, segments, "\\"); + t1 = hasDriveLetter && t1 === 1 ? t2 + "\\" : t2; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _Uri__hexCharPairToByte(s, pos) { + var byte, i, charCode; + for (byte = 0, i = 0; i < 2; ++i) { + charCode = s.charCodeAt(pos + i); + if (48 <= charCode && charCode <= 57) + byte = byte * 16 + charCode - 48; + else { + charCode |= 32; + if (97 <= charCode && charCode <= 102) + byte = byte * 16 + charCode - 87; + else + throw A.wrapException(A.ArgumentError$("Invalid URL encoding", null)); + } + } + return byte; + }, + _Uri__uriDecode(text, start, end, encoding, plusToSpace) { + var simple, codeUnit, t1, bytes, + i = start; + while (true) { + if (!(i < end)) { + simple = true; + break; + } + codeUnit = text.charCodeAt(i); + if (codeUnit <= 127) + t1 = codeUnit === 37; + else + t1 = true; + if (t1) { + simple = false; + break; + } + ++i; + } + if (simple) + if (B.C_Utf8Codec === encoding) + return B.JSString_methods.substring$2(text, start, end); + else + bytes = new A.CodeUnits(B.JSString_methods.substring$2(text, start, end)); + else { + bytes = A._setArrayType([], type$.JSArray_int); + for (t1 = text.length, i = start; i < end; ++i) { + codeUnit = text.charCodeAt(i); + if (codeUnit > 127) + throw A.wrapException(A.ArgumentError$("Illegal percent encoding in URI", null)); + if (codeUnit === 37) { + if (i + 3 > t1) + throw A.wrapException(A.ArgumentError$("Truncated URI", null)); + bytes.push(A._Uri__hexCharPairToByte(text, i + 1)); + i += 2; + } else + bytes.push(codeUnit); + } + } + return B.Utf8Decoder_false.convert$1(bytes); + }, + _Uri__isAlphabeticCharacter(codeUnit) { + var lowerCase = codeUnit | 32; + return 97 <= lowerCase && lowerCase <= 122; + }, + UriData__writeUri(mimeType, charsetName, parameters, buffer, indices) { + var t1, slashIndex; + if (mimeType != null) + t1 = 10 === mimeType.length && A._caseInsensitiveCompareStart("text/plain", mimeType, 0) >= 0; + else + t1 = true; + if (t1) + mimeType = ""; + if (mimeType.length === 0 || mimeType === "application/octet-stream") + t1 = buffer._contents += mimeType; + else { + slashIndex = A.UriData__validateMimeType(mimeType); + if (slashIndex < 0) + throw A.wrapException(A.ArgumentError$value(mimeType, "mimeType", "Invalid MIME type")); + t1 = A._Uri__uriEncode(512, B.JSString_methods.substring$2(mimeType, 0, slashIndex), B.C_Utf8Codec, false); + t1 = buffer._contents += t1; + buffer._contents = t1 + "/"; + t1 = A._Uri__uriEncode(512, B.JSString_methods.substring$1(mimeType, slashIndex + 1), B.C_Utf8Codec, false); + t1 = buffer._contents += t1; + } + if (charsetName != null) { + indices.push(t1.length); + indices.push(buffer._contents.length + 8); + buffer._contents += ";charset="; + t1 = A._Uri__uriEncode(512, charsetName, B.C_Utf8Codec, false); + buffer._contents += t1; + } + }, + UriData__validateMimeType(mimeType) { + var t1, slashIndex, i; + for (t1 = mimeType.length, slashIndex = -1, i = 0; i < t1; ++i) { + if (mimeType.charCodeAt(i) !== 47) + continue; + if (slashIndex < 0) { + slashIndex = i; + continue; + } + return -1; + } + return slashIndex; + }, + UriData__parse(text, start, sourceUri) { + var t1, i, slashIndex, char, equalsIndex, lastSeparator, t2, data, + _s17_ = "Invalid MIME type", + indices = A._setArrayType([start - 1], type$.JSArray_int); + for (t1 = text.length, i = start, slashIndex = -1, char = null; i < t1; ++i) { + char = text.charCodeAt(i); + if (char === 44 || char === 59) + break; + if (char === 47) { + if (slashIndex < 0) { + slashIndex = i; + continue; + } + throw A.wrapException(A.FormatException$(_s17_, text, i)); + } + } + if (slashIndex < 0 && i > start) + throw A.wrapException(A.FormatException$(_s17_, text, i)); + for (; char !== 44;) { + indices.push(i); + ++i; + for (equalsIndex = -1; i < t1; ++i) { + char = text.charCodeAt(i); + if (char === 61) { + if (equalsIndex < 0) + equalsIndex = i; + } else if (char === 59 || char === 44) + break; + } + if (equalsIndex >= 0) + indices.push(equalsIndex); + else { + lastSeparator = B.JSArray_methods.get$last(indices); + if (char !== 44 || i !== lastSeparator + 7 || !B.JSString_methods.startsWith$2(text, "base64", lastSeparator + 1)) + throw A.wrapException(A.FormatException$("Expecting '='", text, i)); + break; + } + } + indices.push(i); + t2 = i + 1; + if ((indices.length & 1) === 1) + text = B.C_Base64Codec.normalize$3(text, t2, t1); + else { + data = A._Uri__normalize(text, t2, t1, 256, true, false); + if (data != null) + text = B.JSString_methods.replaceRange$3(text, t2, t1, data); + } + return new A.UriData(text, indices, sourceUri); + }, + UriData__uriEncodeBytes(canonicalMask, bytes, buffer) { + var t1, byteOr, i, byte, t2, + _s16_ = "0123456789ABCDEF"; + for (t1 = bytes.length, byteOr = 0, i = 0; i < t1; ++i) { + byte = bytes[i]; + byteOr |= byte; + if (byte < 128 && (string$.x00_____.charCodeAt(byte) & canonicalMask) !== 0) { + t2 = A.Primitives_stringFromCharCode(byte); + buffer._contents += t2; + } else { + t2 = A.Primitives_stringFromCharCode(37); + buffer._contents += t2; + t2 = A.Primitives_stringFromCharCode(_s16_.charCodeAt(byte >>> 4)); + buffer._contents += t2; + t2 = A.Primitives_stringFromCharCode(_s16_.charCodeAt(byte & 15)); + buffer._contents += t2; + } + } + if ((byteOr & 4294967040) !== 0) + for (i = 0; i < t1; ++i) { + byte = bytes[i]; + if (byte > 255) + throw A.wrapException(A.ArgumentError$value(byte, "non-byte value", null)); + } + }, + _scan(uri, start, end, state, indices) { + var i, char, transition; + for (i = start; i < end; ++i) { + char = uri.charCodeAt(i) ^ 96; + if (char > 95) + char = 31; + transition = '\xe1\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\xe1\xe1\xe1\x01\xe1\xe1\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\xe1\xe3\xe1\xe1\x01\xe1\x01\xe1\xcd\x01\xe1\x01\x01\x01\x01\x01\x01\x01\x01\x0e\x03\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"\x01\xe1\x01\xe1\xac\xe1\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\xe1\xe1\xe1\x01\xe1\xe1\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\xe1\xea\xe1\xe1\x01\xe1\x01\xe1\xcd\x01\xe1\x01\x01\x01\x01\x01\x01\x01\x01\x01\n\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"\x01\xe1\x01\xe1\xac\xeb\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\xeb\xeb\xeb\x8b\xeb\xeb\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\xeb\x83\xeb\xeb\x8b\xeb\x8b\xeb\xcd\x8b\xeb\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x92\x83\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\x8b\xeb\x8b\xeb\x8b\xeb\xac\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xeb\xeb\xeb\v\xeb\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xebD\xeb\xeb\v\xeb\v\xeb\xcd\v\xeb\v\v\v\v\v\v\v\v\x12D\v\v\v\v\v\v\v\v\v\v\xeb\v\xeb\v\xeb\xac\xe5\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\xe5\xe5\xe5\x05\xe5D\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe8\x8a\xe5\xe5\x05\xe5\x05\xe5\xcd\x05\xe5\x05\x05\x05\x05\x05\x05\x05\x05\x05\x8a\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05f\x05\xe5\x05\xe5\xac\xe5\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\xe5\xe5\xe5\x05\xe5D\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\xe5\x8a\xe5\xe5\x05\xe5\x05\xe5\xcd\x05\xe5\x05\x05\x05\x05\x05\x05\x05\x05\x05\x8a\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05f\x05\xe5\x05\xe5\xac\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7D\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\x8a\xe7\xe7\xe7\xe7\xe7\xe7\xcd\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\x8a\xe7\x07\x07\x07\x07\x07\x07\x07\x07\x07\xe7\xe7\xe7\xe7\xe7\xac\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7D\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\x8a\xe7\xe7\xe7\xe7\xe7\xe7\xcd\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\xe7\x8a\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\xe7\xe7\xe7\xe7\xe7\xac\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\x05\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xeb\xeb\xeb\v\xeb\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xeb\xea\xeb\xeb\v\xeb\v\xeb\xcd\v\xeb\v\v\v\v\v\v\v\v\x10\xea\v\v\v\v\v\v\v\v\v\v\xeb\v\xeb\v\xeb\xac\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xeb\xeb\xeb\v\xeb\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xeb\xea\xeb\xeb\v\xeb\v\xeb\xcd\v\xeb\v\v\v\v\v\v\v\v\x12\n\v\v\v\v\v\v\v\v\v\v\xeb\v\xeb\v\xeb\xac\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xeb\xeb\xeb\v\xeb\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xeb\xea\xeb\xeb\v\xeb\v\xeb\xcd\v\xeb\v\v\v\v\v\v\v\v\v\n\v\v\v\v\v\v\v\v\v\v\xeb\v\xeb\v\xeb\xac\xec\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\xec\xec\xec\f\xec\xec\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\f\xec\xec\xec\xec\f\xec\f\xec\xcd\f\xec\f\f\f\f\f\f\f\f\f\xec\f\f\f\f\f\f\f\f\f\f\xec\f\xec\f\xec\f\xed\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\xed\xed\xed\r\xed\xed\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\xed\xed\xed\xed\r\xed\r\xed\xed\r\xed\r\r\r\r\r\r\r\r\r\xed\r\r\r\r\r\r\r\r\r\r\xed\r\xed\r\xed\r\xe1\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\xe1\xe1\xe1\x01\xe1\xe1\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\xe1\xea\xe1\xe1\x01\xe1\x01\xe1\xcd\x01\xe1\x01\x01\x01\x01\x01\x01\x01\x01\x0f\xea\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"\x01\xe1\x01\xe1\xac\xe1\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\xe1\xe1\xe1\x01\xe1\xe1\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\xe1\xe9\xe1\xe1\x01\xe1\x01\xe1\xcd\x01\xe1\x01\x01\x01\x01\x01\x01\x01\x01\x01\t\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"\x01\xe1\x01\xe1\xac\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xeb\xeb\xeb\v\xeb\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xeb\xea\xeb\xeb\v\xeb\v\xeb\xcd\v\xeb\v\v\v\v\v\v\v\v\x11\xea\v\v\v\v\v\v\v\v\v\v\xeb\v\xeb\v\xeb\xac\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xeb\xeb\xeb\v\xeb\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xeb\xe9\xeb\xeb\v\xeb\v\xeb\xcd\v\xeb\v\v\v\v\v\v\v\v\v\t\v\v\v\v\v\v\v\v\v\v\xeb\v\xeb\v\xeb\xac\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xeb\xeb\xeb\v\xeb\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xeb\xea\xeb\xeb\v\xeb\v\xeb\xcd\v\xeb\v\v\v\v\v\v\v\v\x13\xea\v\v\v\v\v\v\v\v\v\v\xeb\v\xeb\v\xeb\xac\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xeb\xeb\xeb\v\xeb\xeb\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\xeb\xea\xeb\xeb\v\xeb\v\xeb\xcd\v\xeb\v\v\v\v\v\v\v\v\v\xea\v\v\v\v\v\v\v\v\v\v\xeb\v\xeb\v\xeb\xac\xf5\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\xf5\x15\xf5\x15\x15\xf5\x15\x15\x15\x15\x15\x15\x15\x15\x15\x15\xf5\xf5\xf5\xf5\xf5\xf5'.charCodeAt(state * 96 + char); + state = transition & 31; + indices[transition >>> 5] = i; + } + return state; + }, + _SimpleUri__packageNameEnd(uri) { + if (uri._schemeEnd === 7 && B.JSString_methods.startsWith$1(uri._uri, "package") && uri._hostStart <= 0) + return A._skipPackageNameChars(uri._uri, uri._pathStart, uri._queryStart); + return -1; + }, + _skipPackageNameChars(source, start, end) { + var i, dots, char; + for (i = start, dots = 0; i < end; ++i) { + char = source.charCodeAt(i); + if (char === 47) + return dots !== 0 ? i : -1; + if (char === 37 || char === 58) + return -1; + dots |= char ^ 46; + } + return -1; + }, + _caseInsensitiveCompareStart(prefix, string, start) { + var t1, result, i, stringChar, delta, lowerChar; + for (t1 = prefix.length, result = 0, i = 0; i < t1; ++i) { + stringChar = string.charCodeAt(start + i); + delta = prefix.charCodeAt(i) ^ stringChar; + if (delta !== 0) { + if (delta === 32) { + lowerChar = stringChar | delta; + if (97 <= lowerChar && lowerChar <= 122) { + result = 32; + continue; + } + } + return -1; + } + } + return result; + }, + NoSuchMethodError_toString_closure: function NoSuchMethodError_toString_closure(t0, t1) { + this._box_0 = t0; + this.sb = t1; + }, + DateTime: function DateTime(t0, t1, t2) { + this._value = t0; + this._microsecond = t1; + this.isUtc = t2; + }, + Duration: function Duration(t0) { + this._duration = t0; + }, + _Enum: function _Enum() { + }, + Error: function Error() { + }, + AssertionError: function AssertionError(t0) { + this.message = t0; + }, + TypeError: function TypeError() { + }, + ArgumentError: function ArgumentError(t0, t1, t2, t3) { + var _ = this; + _._hasValue = t0; + _.invalidValue = t1; + _.name = t2; + _.message = t3; + }, + RangeError: function RangeError(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.start = t0; + _.end = t1; + _._hasValue = t2; + _.invalidValue = t3; + _.name = t4; + _.message = t5; + }, + IndexError: function IndexError(t0, t1, t2, t3, t4) { + var _ = this; + _.length = t0; + _._hasValue = t1; + _.invalidValue = t2; + _.name = t3; + _.message = t4; + }, + NoSuchMethodError: function NoSuchMethodError(t0, t1, t2, t3) { + var _ = this; + _._core$_receiver = t0; + _._memberName = t1; + _._core$_arguments = t2; + _._namedArguments = t3; + }, + UnsupportedError: function UnsupportedError(t0) { + this.message = t0; + }, + UnimplementedError: function UnimplementedError(t0) { + this.message = t0; + }, + StateError: function StateError(t0) { + this.message = t0; + }, + ConcurrentModificationError: function ConcurrentModificationError(t0) { + this.modifiedObject = t0; + }, + OutOfMemoryError: function OutOfMemoryError() { + }, + StackOverflowError: function StackOverflowError() { + }, + _Exception: function _Exception(t0) { + this.message = t0; + }, + FormatException: function FormatException(t0, t1, t2) { + this.message = t0; + this.source = t1; + this.offset = t2; + }, + Iterable: function Iterable() { + }, + _GeneratorIterable: function _GeneratorIterable(t0, t1, t2) { + this.length = t0; + this._generator = t1; + this.$ti = t2; + }, + MapEntry: function MapEntry(t0, t1, t2) { + this.key = t0; + this.value = t1; + this.$ti = t2; + }, + Null: function Null() { + }, + Object: function Object() { + }, + _StringStackTrace: function _StringStackTrace(t0) { + this._stackTrace = t0; + }, + Runes: function Runes(t0) { + this.string = t0; + }, + RuneIterator: function RuneIterator(t0) { + var _ = this; + _.string = t0; + _._nextPosition = _._position = 0; + _._currentCodePoint = -1; + }, + StringBuffer: function StringBuffer(t0) { + this._contents = t0; + }, + Uri__parseIPv4Address_error: function Uri__parseIPv4Address_error(t0) { + this.host = t0; + }, + Uri_parseIPv6Address_error: function Uri_parseIPv6Address_error(t0) { + this.host = t0; + }, + Uri_parseIPv6Address_parseHex: function Uri_parseIPv6Address_parseHex(t0, t1) { + this.error = t0; + this.host = t1; + }, + _Uri: function _Uri(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.scheme = t0; + _._userInfo = t1; + _._host = t2; + _._port = t3; + _.path = t4; + _._query = t5; + _._fragment = t6; + _.___Uri_hashCode_FI = _.___Uri_pathSegments_FI = _.___Uri__text_FI = $; + }, + _Uri__makePath_closure: function _Uri__makePath_closure() { + }, + UriData: function UriData(t0, t1, t2) { + this._text = t0; + this._separatorIndices = t1; + this._uriCache = t2; + }, + _SimpleUri: function _SimpleUri(t0, t1, t2, t3, t4, t5, t6, t7) { + var _ = this; + _._uri = t0; + _._schemeEnd = t1; + _._hostStart = t2; + _._portStart = t3; + _._pathStart = t4; + _._queryStart = t5; + _._fragmentStart = t6; + _._schemeCache = t7; + _._hashCodeCache = null; + }, + _DataUri: function _DataUri(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.scheme = t0; + _._userInfo = t1; + _._host = t2; + _._port = t3; + _.path = t4; + _._query = t5; + _._fragment = t6; + _.___Uri_hashCode_FI = _.___Uri_pathSegments_FI = _.___Uri__text_FI = $; + }, + Expando: function Expando(t0) { + this._jsWeakMap = t0; + }, + _convertDartFunctionFast(f) { + var ret, + existing = f.$dart_jsFunction; + if (existing != null) + return existing; + ret = function(_call, f) { + return function() { + return _call(f, Array.prototype.slice.apply(arguments)); + }; + }(A._callDartFunctionFast, f); + ret[$.$get$DART_CLOSURE_PROPERTY_NAME()] = f; + f.$dart_jsFunction = ret; + return ret; + }, + _convertDartFunctionFastCaptureThis(f) { + var ret, + existing = f._$dart_jsFunctionCaptureThis; + if (existing != null) + return existing; + ret = function(_call, f) { + return function() { + return _call(f, this, Array.prototype.slice.apply(arguments)); + }; + }(A._callDartFunctionFastCaptureThis, f); + ret[$.$get$DART_CLOSURE_PROPERTY_NAME()] = f; + f._$dart_jsFunctionCaptureThis = ret; + return ret; + }, + _callDartFunctionFast(callback, $arguments) { + return A.Function_apply(callback, $arguments); + }, + _callDartFunctionFastCaptureThis(callback, $self, $arguments) { + var t1 = [$self]; + B.JSArray_methods.addAll$1(t1, $arguments); + return A.Function_apply(callback, t1); + }, + allowInterop(f) { + if (typeof f == "function") + return f; + else + return A._convertDartFunctionFast(f); + }, + allowInteropCaptureThis(f) { + if (typeof f == "function") + throw A.wrapException(A.ArgumentError$("Function is already a JS function so cannot capture this.", null)); + else + return A._convertDartFunctionFastCaptureThis(f); + }, + _callDartFunctionFast2(callback, arg1, arg2, $length) { + if ($length >= 2) + return callback.call$2(arg1, arg2); + if ($length === 1) + return callback.call$1(arg1); + return callback.call$0(); + }, + _noJsifyRequired(o) { + return o == null || A._isBool(o) || typeof o == "number" || typeof o == "string" || type$.Int8List._is(o) || type$.Uint8List._is(o) || type$.Uint8ClampedList._is(o) || type$.Int16List._is(o) || type$.Uint16List._is(o) || type$.Int32List._is(o) || type$.Uint32List._is(o) || type$.Float32List._is(o) || type$.Float64List._is(o) || type$.ByteBuffer._is(o) || type$.ByteData._is(o); + }, + jsify(object) { + if (A._noJsifyRequired(object)) + return object; + return new A.jsify__convert(new A._IdentityHashMap(type$._IdentityHashMap_of_nullable_Object_and_nullable_Object)).call$1(object); + }, + _callMethodUnchecked0(o, method) { + return o[method](); + }, + callConstructor(constr, $arguments) { + var args, factoryFunction; + if ($arguments instanceof Array) + switch ($arguments.length) { + case 0: + return new constr(); + case 1: + return new constr($arguments[0]); + case 2: + return new constr($arguments[0], $arguments[1]); + case 3: + return new constr($arguments[0], $arguments[1], $arguments[2]); + case 4: + return new constr($arguments[0], $arguments[1], $arguments[2], $arguments[3]); + } + args = [null]; + B.JSArray_methods.addAll$1(args, $arguments); + factoryFunction = constr.bind.apply(constr, args); + String(factoryFunction); + return new factoryFunction(); + }, + promiseToFuture(jsPromise, $T) { + var t1 = new A._Future($.Zone__current, $T._eval$1("_Future<0>")), + completer = new A._AsyncCompleter(t1, $T._eval$1("_AsyncCompleter<0>")); + jsPromise.then(A.convertDartClosureToJS(new A.promiseToFuture_closure(completer), 1), A.convertDartClosureToJS(new A.promiseToFuture_closure0(completer), 1)); + return t1; + }, + jsify__convert: function jsify__convert(t0) { + this._convertedObjects = t0; + }, + promiseToFuture_closure: function promiseToFuture_closure(t0) { + this.completer = t0; + }, + promiseToFuture_closure0: function promiseToFuture_closure0(t0) { + this.completer = t0; + }, + NullRejectionException: function NullRejectionException(t0) { + this.isUndefined = t0; + }, + max(a, b) { + return Math.max(a, b); + }, + pow(x, exponent) { + return Math.pow(x, exponent); + }, + Random_Random() { + return B.C__JSRandom; + }, + _JSRandom: function _JSRandom() { + }, + ArgParser: function ArgParser(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._arg_parser$_options = t0; + _._aliases = t1; + _.options = t2; + _.commands = t3; + _._optionsAndSeparators = t4; + _.allowTrailingOptions = t5; + _.usageLineLength = t6; + }, + ArgParser__addOption_closure: function ArgParser__addOption_closure(t0) { + this.$this = t0; + }, + ArgParserException$(message, commands, argumentName, source, offset) { + return new A.ArgParserException(commands == null ? B.List_empty : A.List_List$unmodifiable(commands, type$.String), argumentName, message, source, offset); + }, + ArgParserException: function ArgParserException(t0, t1, t2, t3, t4) { + var _ = this; + _.commands = t0; + _.argumentName = t1; + _.message = t2; + _.source = t3; + _.offset = t4; + }, + ArgResults: function ArgResults(t0, t1, t2, t3) { + var _ = this; + _._parser = t0; + _._parsed = t1; + _.name = t2; + _.rest = t3; + }, + Option: function Option(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13) { + var _ = this; + _.name = t0; + _.abbr = t1; + _.help = t2; + _.valueHelp = t3; + _.allowed = t4; + _.allowedHelp = t5; + _.defaultsTo = t6; + _.negatable = t7; + _.hideNegatedUsage = t8; + _.callback = t9; + _.type = t10; + _.splitCommas = t11; + _.mandatory = t12; + _.hide = t13; + }, + OptionType: function OptionType(t0) { + this.name = t0; + }, + Parser$(_commandName, _grammar, _args, _parent, rest) { + var t1 = A._setArrayType([], type$.JSArray_String); + if (rest != null) + B.JSArray_methods.addAll$1(t1, rest); + return new A.Parser0(_commandName, _parent, _grammar, _args, t1, A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.dynamic)); + }, + _isLetterOrDigit(codeUnit) { + var t1 = true; + if (!(codeUnit >= 65 && codeUnit <= 90)) + if (!(codeUnit >= 97 && codeUnit <= 122)) + t1 = codeUnit >= 48 && codeUnit <= 57; + return t1; + }, + Parser0: function Parser0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._commandName = t0; + _._parser$_parent = t1; + _._grammar = t2; + _._args = t3; + _._parser$_rest = t4; + _._results = t5; + }, + Parser_parse_closure: function Parser_parse_closure(t0) { + this.$this = t0; + }, + Parser__setOption_closure: function Parser__setOption_closure() { + }, + _Usage: function _Usage(t0, t1, t2) { + var _ = this; + _._usage$_optionsAndSeparators = t0; + _._usage$_buffer = t1; + _._currentColumn = 0; + _.___Usage__columnWidths_FI = $; + _._newlinesNeeded = 0; + _.lineLength = t2; + }, + _Usage__writeOption_closure: function _Usage__writeOption_closure() { + }, + _Usage__buildAllowedList_closure: function _Usage__buildAllowedList_closure(t0) { + this.option = t0; + }, + FutureGroup: function FutureGroup(t0, t1, t2) { + var _ = this; + _._future_group$_pending = 0; + _._future_group$_closed = false; + _._future_group$_completer = t0; + _._future_group$_values = t1; + _.$ti = t2; + }, + FutureGroup_add_closure: function FutureGroup_add_closure(t0, t1) { + this.$this = t0; + this.index = t1; + }, + FutureGroup_add_closure0: function FutureGroup_add_closure0(t0) { + this.$this = t0; + }, + ErrorResult: function ErrorResult(t0, t1) { + this.error = t0; + this.stackTrace = t1; + }, + ValueResult: function ValueResult(t0, t1) { + this.value = t0; + this.$ti = t1; + }, + StreamCompleter: function StreamCompleter(t0, t1) { + this._stream_completer$_stream = t0; + this.$ti = t1; + }, + _CompleterStream: function _CompleterStream(t0) { + this._sourceStream = this._stream_completer$_controller = null; + this.$ti = t0; + }, + StreamGroup: function StreamGroup(t0, t1, t2) { + var _ = this; + _.__StreamGroup__controller_A = $; + _._closed = false; + _._stream_group$_state = t0; + _._subscriptions = t1; + _.$ti = t2; + }, + StreamGroup_add_closure: function StreamGroup_add_closure() { + }, + StreamGroup_add_closure0: function StreamGroup_add_closure0(t0, t1) { + this.$this = t0; + this.stream = t1; + }, + StreamGroup__onListen_closure: function StreamGroup__onListen_closure() { + }, + StreamGroup__onCancel_closure: function StreamGroup__onCancel_closure(t0) { + this.$this = t0; + }, + StreamGroup__listenToStream_closure: function StreamGroup__listenToStream_closure(t0, t1) { + this.$this = t0; + this.stream = t1; + }, + _StreamGroupState: function _StreamGroupState(t0) { + this.name = t0; + }, + StreamQueue: function StreamQueue(t0, t1, t2, t3) { + var _ = this; + _._stream_queue$_source = t0; + _._stream_queue$_subscription = null; + _._isDone = false; + _._eventsReceived = 0; + _._eventQueue = t1; + _._requestQueue = t2; + _.$ti = t3; + }, + StreamQueue__ensureListening_closure: function StreamQueue__ensureListening_closure(t0) { + this.$this = t0; + }, + StreamQueue__ensureListening_closure1: function StreamQueue__ensureListening_closure1(t0) { + this.$this = t0; + }, + StreamQueue__ensureListening_closure0: function StreamQueue__ensureListening_closure0(t0) { + this.$this = t0; + }, + _NextRequest: function _NextRequest(t0, t1) { + this._completer = t0; + this.$ti = t1; + }, + isNodeJs() { + var t1 = self.process; + if (t1 == null) + t1 = null; + else { + t1 = J.get$release$x(t1); + t1 = t1 == null ? null : J.get$name$x(t1); + } + return J.$eq$(t1, "node"); + }, + isBrowser() { + return !A.isNodeJs() && self.document != null && typeof self.document.querySelector == "function"; + }, + wrapJSExceptions(callback) { + var error, error0, error1, error2, t1, exception; + if (!$.$get$_isStrictMode()) + return callback.call$0(); + try { + t1 = callback.call$0(); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (typeof t1 == "string") { + error = t1; + throw A.wrapException(error); + } else if (A._isBool(t1)) { + error0 = t1; + throw A.wrapException(error0); + } else if (typeof t1 == "number") { + error1 = t1; + throw A.wrapException(error1); + } else { + error2 = t1; + if (typeof error2 == "symbol" || typeof error2 == "bigint" || error2 == null) + throw A.wrapException(A._callMethodUnchecked0(error2, "toString")); + throw exception; + } + } + }, + _isStrictMode_closure: function _isStrictMode_closure() { + }, + Repl: function Repl(t0, t1, t2, t3) { + var _ = this; + _.prompt = t0; + _.continuation = t1; + _.validator = t2; + _.__Repl__adapter_A = $; + _.history = t3; + }, + alwaysValid_closure: function alwaysValid_closure() { + }, + ReplAdapter: function ReplAdapter(t0) { + this.repl = t0; + this.rl = null; + }, + ReplAdapter_runAsync_closure: function ReplAdapter_runAsync_closure(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.rl = t2; + _.runController = t3; + }, + ReplAdapter_runAsync__closure: function ReplAdapter_runAsync__closure(t0) { + this.lineController = t0; + }, + Stdin: function Stdin() { + }, + Stdout: function Stdout() { + }, + ReadlineModule: function ReadlineModule() { + }, + ReadlineOptions: function ReadlineOptions() { + }, + ReadlineInterface: function ReadlineInterface() { + }, + EmptyUnmodifiableSet: function EmptyUnmodifiableSet(t0) { + this.$ti = t0; + }, + _EmptyUnmodifiableSet_IterableBase_UnmodifiableSetMixin: function _EmptyUnmodifiableSet_IterableBase_UnmodifiableSetMixin() { + }, + DefaultEquality: function DefaultEquality() { + }, + IterableEquality: function IterableEquality() { + }, + ListEquality: function ListEquality() { + }, + _MapEntry: function _MapEntry(t0, t1, t2) { + this.equality = t0; + this.key = t1; + this.value = t2; + }, + MapEquality: function MapEquality(t0) { + this.$ti = t0; + }, + QueueList$(initialCapacity, $E) { + return new A.QueueList(A.List_List$filled(A.QueueList__computeInitialCapacity(initialCapacity), null, false, $E._eval$1("0?")), 0, 0, $E._eval$1("QueueList<0>")); + }, + QueueList_QueueList$from(source, $E) { + var $length, queue, t1; + if (type$.List_dynamic._is(source)) { + $length = J.get$length$asx(source); + queue = A.QueueList$($length + 1, $E); + J.setRange$4$ax(queue._queue_list$_table, 0, $length, source, 0); + queue._queue_list$_tail = $length; + return queue; + } else { + t1 = A.QueueList$(null, $E); + t1.addAll$1(0, source); + return t1; + } + }, + QueueList__computeInitialCapacity(initialCapacity) { + if (initialCapacity == null || initialCapacity < 8) + return 8; + ++initialCapacity; + if ((initialCapacity & initialCapacity - 1) >>> 0 === 0) + return initialCapacity; + return A.QueueList__nextPowerOf2(initialCapacity); + }, + QueueList__nextPowerOf2(number) { + var nextNumber; + number = (number << 1 >>> 0) - 1; + for (; true; number = nextNumber) { + nextNumber = (number & number - 1) >>> 0; + if (nextNumber === 0) + return number; + } + }, + QueueList: function QueueList(t0, t1, t2, t3) { + var _ = this; + _._queue_list$_table = t0; + _._queue_list$_head = t1; + _._queue_list$_tail = t2; + _.$ti = t3; + }, + _CastQueueList: function _CastQueueList(t0, t1, t2, t3, t4) { + var _ = this; + _._queue_list$_delegate = t0; + _._queue_list$_table = t1; + _._queue_list$_head = t2; + _._queue_list$_tail = t3; + _.$ti = t4; + }, + _QueueList_Object_ListMixin: function _QueueList_Object_ListMixin() { + }, + UnionSet: function UnionSet(t0, t1) { + this._sets = t0; + this.$ti = t1; + }, + UnionSet__iterable_closure: function UnionSet__iterable_closure(t0) { + this.$this = t0; + }, + UnionSet_contains_closure: function UnionSet_contains_closure(t0, t1) { + this.$this = t0; + this.element = t1; + }, + _UnionSet_SetBase_UnmodifiableSetMixin: function _UnionSet_SetBase_UnmodifiableSetMixin() { + }, + UnmodifiableSetMixin__throw() { + throw A.wrapException(A.UnsupportedError$("Cannot modify an unmodifiable Set")); + }, + UnmodifiableSetView0: function UnmodifiableSetView0(t0, t1) { + this._base = t0; + this.$ti = t1; + }, + UnmodifiableSetMixin: function UnmodifiableSetMixin() { + }, + _UnmodifiableSetView_DelegatingSet_UnmodifiableSetMixin: function _UnmodifiableSetView_DelegatingSet_UnmodifiableSetMixin() { + }, + _DelegatingIterableBase: function _DelegatingIterableBase() { + }, + DelegatingSet: function DelegatingSet(t0, t1) { + this._base = t0; + this.$ti = t1; + }, + MapKeySet: function MapKeySet(t0, t1) { + this._baseMap = t0; + this.$ti = t1; + }, + MapKeySet_difference_closure: function MapKeySet_difference_closure(t0, t1) { + this.$this = t0; + this.other = t1; + }, + _MapKeySet__DelegatingIterableBase_UnmodifiableSetMixin: function _MapKeySet__DelegatingIterableBase_UnmodifiableSetMixin() { + }, + BufferModule: function BufferModule() { + }, + BufferConstants: function BufferConstants() { + }, + Buffer: function Buffer() { + }, + ConsoleModule: function ConsoleModule() { + }, + Console: function Console() { + }, + EventEmitter: function EventEmitter() { + }, + fs() { + var t1 = $._fs; + return t1 == null ? $._fs = self.fs : t1; + }, + FS: function FS() { + }, + FSConstants: function FSConstants() { + }, + Realpath: function Realpath() { + }, + RealpathSync: function RealpathSync() { + }, + FSWatcher: function FSWatcher() { + }, + ReadStream: function ReadStream() { + }, + ReadStreamOptions: function ReadStreamOptions() { + }, + WriteStream: function WriteStream() { + }, + WriteStreamOptions: function WriteStreamOptions() { + }, + FileOptions: function FileOptions() { + }, + StatOptions: function StatOptions() { + }, + MkdirOptions: function MkdirOptions() { + }, + RmdirOptions: function RmdirOptions() { + }, + WatchOptions: function WatchOptions() { + }, + WatchFileOptions: function WatchFileOptions() { + }, + Stats: function Stats() { + }, + Promise: function Promise() { + }, + Date: function Date() { + }, + JsError: function JsError() { + }, + Atomics: function Atomics() { + }, + Modules: function Modules() { + }, + Module: function Module() { + }, + Net: function Net() { + }, + Socket: function Socket() { + }, + NetAddress: function NetAddress() { + }, + NetServer: function NetServer() { + }, + NodeJsError: function NodeJsError() { + }, + JsAssertionError: function JsAssertionError() { + }, + JsRangeError: function JsRangeError() { + }, + JsReferenceError: function JsReferenceError() { + }, + JsSyntaxError: function JsSyntaxError() { + }, + JsTypeError: function JsTypeError() { + }, + JsSystemError: function JsSystemError() { + }, + Process: function Process() { + }, + CPUUsage: function CPUUsage() { + }, + Release: function Release() { + }, + StreamModule: function StreamModule() { + }, + Readable: function Readable() { + }, + Writable: function Writable() { + }, + Duplex: function Duplex() { + }, + Transform: function Transform() { + }, + WritableOptions: function WritableOptions() { + }, + ReadableOptions: function ReadableOptions() { + }, + Immediate: function Immediate() { + }, + Timeout: function Timeout() { + }, + TTY: function TTY() { + }, + TTYReadStream: function TTYReadStream() { + }, + TTYWriteStream: function TTYWriteStream() { + }, + jsify0(dartObject) { + if (A._isBasicType(dartObject)) + return dartObject; + return A.jsify(dartObject); + }, + _isBasicType(value) { + return false; + }, + promiseToFuture0(promise, $T) { + var t1 = new A._Future($.Zone__current, $T._eval$1("_Future<0>")), + completer = new A._SyncCompleter(t1, $T._eval$1("_SyncCompleter<0>")); + J.then$2$x(promise, A.allowInterop(new A.promiseToFuture_closure1(completer)), A.allowInterop(new A.promiseToFuture_closure2(completer))); + return t1; + }, + futureToPromise(future, $T) { + return new self.Promise(A.allowInterop(new A.futureToPromise_closure(future, $T))); + }, + Util: function Util() { + }, + promiseToFuture_closure1: function promiseToFuture_closure1(t0) { + this.completer = t0; + }, + promiseToFuture_closure2: function promiseToFuture_closure2(t0) { + this.completer = t0; + }, + futureToPromise_closure: function futureToPromise_closure(t0, t1) { + this.future = t0; + this.T = t1; + }, + futureToPromise__closure: function futureToPromise__closure(t0, t1) { + this.resolve = t0; + this.T = t1; + }, + Context_Context(style) { + return new A.Context(style, "."); + }, + _parseUri(uri) { + if (typeof uri == "string") + return A.Uri_parse(uri); + if (type$.Uri._is(uri)) + return uri; + throw A.wrapException(A.ArgumentError$value(uri, "uri", "Value must be a String or a Uri")); + }, + _validateArgList(method, args) { + var numArgs, i, numArgs0, message, t1, t2, t3, t4; + for (numArgs = args.length, i = 1; i < numArgs; ++i) { + if (args[i] == null || args[i - 1] != null) + continue; + for (; numArgs >= 1; numArgs = numArgs0) { + numArgs0 = numArgs - 1; + if (args[numArgs0] != null) + break; + } + message = new A.StringBuffer(""); + t1 = "" + (method + "("); + message._contents = t1; + t2 = A._arrayInstanceType(args); + t3 = t2._eval$1("SubListIterable<1>"); + t4 = new A.SubListIterable(args, 0, numArgs, t3); + t4.SubListIterable$3(args, 0, numArgs, t2._precomputed1); + t3 = t1 + new A.MappedListIterable(t4, new A._validateArgList_closure(), t3._eval$1("MappedListIterable")).join$1(0, ", "); + message._contents = t3; + message._contents = t3 + ("): part " + (i - 1) + " was null, but part " + i + " was not."); + throw A.wrapException(A.ArgumentError$(message.toString$0(0), null)); + } + }, + Context: function Context(t0, t1) { + this.style = t0; + this._context$_current = t1; + }, + Context_joinAll_closure: function Context_joinAll_closure() { + }, + Context_split_closure: function Context_split_closure() { + }, + _validateArgList_closure: function _validateArgList_closure() { + }, + _PathDirection: function _PathDirection(t0) { + this.name = t0; + }, + _PathRelation: function _PathRelation(t0) { + this.name = t0; + }, + InternalStyle: function InternalStyle() { + }, + ParsedPath_ParsedPath$parse(path, style) { + var t1, parts, separators, start, i, + root = style.getRoot$1(path), + isRootRelative = style.isRootRelative$1(path); + if (root != null) + path = B.JSString_methods.substring$1(path, root.length); + t1 = type$.JSArray_String; + parts = A._setArrayType([], t1); + separators = A._setArrayType([], t1); + t1 = path.length; + if (t1 !== 0 && style.isSeparator$1(path.charCodeAt(0))) { + separators.push(path[0]); + start = 1; + } else { + separators.push(""); + start = 0; + } + for (i = start; i < t1; ++i) + if (style.isSeparator$1(path.charCodeAt(i))) { + parts.push(B.JSString_methods.substring$2(path, start, i)); + separators.push(path[i]); + start = i + 1; + } + if (start < t1) { + parts.push(B.JSString_methods.substring$1(path, start)); + separators.push(""); + } + return new A.ParsedPath(style, root, isRootRelative, parts, separators); + }, + ParsedPath: function ParsedPath(t0, t1, t2, t3, t4) { + var _ = this; + _.style = t0; + _.root = t1; + _.isRootRelative = t2; + _.parts = t3; + _.separators = t4; + }, + ParsedPath__splitExtension_closure: function ParsedPath__splitExtension_closure() { + }, + ParsedPath__splitExtension_closure0: function ParsedPath__splitExtension_closure0() { + }, + PathException$(message) { + return new A.PathException(message); + }, + PathException: function PathException(t0) { + this.message = t0; + }, + PathMap__create(context, $V) { + var t1 = {}; + t1.context = context; + t1.context = $.$get$context(); + return A.LinkedHashMap_LinkedHashMap(new A.PathMap__create_closure(t1), new A.PathMap__create_closure0(t1), new A.PathMap__create_closure1(), type$.nullable_String, $V); + }, + PathMap: function PathMap(t0, t1) { + this._map = t0; + this.$ti = t1; + }, + PathMap__create_closure: function PathMap__create_closure(t0) { + this._box_0 = t0; + }, + PathMap__create_closure0: function PathMap__create_closure0(t0) { + this._box_0 = t0; + }, + PathMap__create_closure1: function PathMap__create_closure1() { + }, + Style__getPlatformStyle() { + if (A.Uri_base().get$scheme() !== "file") + return $.$get$Style_url(); + var t1 = A.Uri_base(); + if (!B.JSString_methods.endsWith$1(t1.get$path(t1), "/")) + return $.$get$Style_url(); + if (A._Uri__Uri(null, "a/b", null, null).toFilePath$0() === "a\\b") + return $.$get$Style_windows(); + return $.$get$Style_posix(); + }, + Style: function Style() { + }, + PosixStyle: function PosixStyle(t0, t1, t2) { + this.separatorPattern = t0; + this.needsSeparatorPattern = t1; + this.rootPattern = t2; + }, + UrlStyle: function UrlStyle(t0, t1, t2, t3) { + var _ = this; + _.separatorPattern = t0; + _.needsSeparatorPattern = t1; + _.rootPattern = t2; + _.relativeRootPattern = t3; + }, + WindowsStyle: function WindowsStyle(t0, t1, t2, t3) { + var _ = this; + _.separatorPattern = t0; + _.needsSeparatorPattern = t1; + _.rootPattern = t2; + _.relativeRootPattern = t3; + }, + WindowsStyle_absolutePathToUri_closure: function WindowsStyle_absolutePathToUri_closure() { + }, + Version$_(major, minor, patch, preRelease, build, _text) { + var t1 = preRelease == null || preRelease.length === 0 ? A._setArrayType([], type$.JSArray_Object) : A.Version__splitParts(preRelease), + t2 = build == null || build.length === 0 ? A._setArrayType([], type$.JSArray_Object) : A.Version__splitParts(build); + if (major < 0) + A.throwExpression(A.ArgumentError$("Major version must be non-negative.", null)); + if (minor < 0) + A.throwExpression(A.ArgumentError$("Minor version must be non-negative.", null)); + if (patch < 0) + A.throwExpression(A.ArgumentError$("Patch version must be non-negative.", null)); + return new A.Version(major, minor, patch, t1, t2, _text); + }, + Version_Version(major, minor, patch, pre) { + var text = "" + major + "." + minor + "." + patch; + if (pre != null) + text += "-" + pre; + return A.Version$_(major, minor, patch, pre, null, text); + }, + Version___parse_tearOff(text) { + return A.Version_Version$parse(text); + }, + Version_Version$parse(text) { + var major, minor, patch, preRelease, build, t1, exception, _null = null, + _s17_ = 'Could not parse "', + match = $.$get$completeVersion().firstMatch$1(text); + if (match == null) + throw A.wrapException(A.FormatException$(_s17_ + text + '".', _null, _null)); + try { + t1 = match._match[1]; + t1.toString; + major = A.int_parse(t1, _null); + t1 = match._match[2]; + t1.toString; + minor = A.int_parse(t1, _null); + t1 = match._match[3]; + t1.toString; + patch = A.int_parse(t1, _null); + preRelease = match._match[5]; + build = match._match[8]; + t1 = A.Version$_(major, minor, patch, preRelease, build, text); + return t1; + } catch (exception) { + if (type$.FormatException._is(A.unwrapException(exception))) + throw A.wrapException(A.FormatException$(_s17_ + text + '".', _null, _null)); + else + throw exception; + } + }, + Version__splitParts(text) { + var t1 = type$.MappedListIterable_String_Object; + return A.List_List$of(new A.MappedListIterable(A._setArrayType(text.split("."), type$.JSArray_String), new A.Version__splitParts_closure(), t1), true, t1._eval$1("ListIterable.E")); + }, + Version: function Version(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.major = t0; + _.minor = t1; + _.patch = t2; + _.preRelease = t3; + _.build = t4; + _._version$_text = t5; + }, + Version__splitParts_closure: function Version__splitParts_closure() { + }, + VersionRange_VersionRange(includeMax, max) { + return new A.VersionRange(null, max, false, true); + }, + VersionRange: function VersionRange(t0, t1, t2, t3) { + var _ = this; + _.min = t0; + _.max = t1; + _.includeMin = t2; + _.includeMax = t3; + }, + CssMediaQuery$type(type, conditions, modifier) { + return new A.CssMediaQuery(modifier, type, true, conditions == null ? B.List_empty : A.List_List$unmodifiable(conditions, type$.String)); + }, + CssMediaQuery$condition(conditions, conjunction) { + var t1 = A.List_List$unmodifiable(conditions, type$.String); + if (t1.length > 1 && conjunction == null) + A.throwExpression(A.ArgumentError$(string$.If_con, null)); + return new A.CssMediaQuery(null, null, conjunction !== false, t1); + }, + CssMediaQuery: function CssMediaQuery(t0, t1, t2, t3) { + var _ = this; + _.modifier = t0; + _.type = t1; + _.conjunction = t2; + _.conditions = t3; + }, + _SingletonCssMediaQueryMergeResult: function _SingletonCssMediaQueryMergeResult(t0) { + this._name = t0; + }, + MediaQuerySuccessfulMergeResult: function MediaQuerySuccessfulMergeResult(t0) { + this.query = t0; + }, + ModifiableCssAtRule$($name, span, childless, value) { + var t1 = A._setArrayType([], type$.JSArray_ModifiableCssNode); + return new A.ModifiableCssAtRule($name, value, childless, span, new A.UnmodifiableListView(t1, type$.UnmodifiableListView_ModifiableCssNode), t1); + }, + ModifiableCssAtRule: function ModifiableCssAtRule(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.name = t0; + _.value = t1; + _.isChildless = t2; + _.span = t3; + _.children = t4; + _._children = t5; + _._indexInParent = _._parent = null; + _.isGroupEnd = false; + }, + ModifiableCssComment: function ModifiableCssComment(t0, t1) { + var _ = this; + _.text = t0; + _.span = t1; + _._indexInParent = _._parent = null; + _.isGroupEnd = false; + }, + ModifiableCssDeclaration$($name, value, span, interleavedRules, parsedAsCustomProperty, trace, valueSpanForMap) { + var t3, + t1 = interleavedRules == null ? B.List_empty11 : A.List_List$unmodifiable(interleavedRules, type$.CssStyleRule), + t2 = valueSpanForMap == null ? value.span : valueSpanForMap; + if (parsedAsCustomProperty) + if (!J.startsWith$1$s($name.value, "--")) + A.throwExpression(A.ArgumentError$(string$.parsed, null)); + else { + t3 = value.value; + if (!(t3 instanceof A.SassString)) + A.throwExpression(A.ArgumentError$(string$.If_par + value.toString$0(0) + "` of type " + A.getRuntimeTypeOfDartObject(t3).toString$0(0) + ").", null)); + } + return new A.ModifiableCssDeclaration($name, value, parsedAsCustomProperty, t1, trace, t2, span); + }, + ModifiableCssDeclaration: function ModifiableCssDeclaration(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.name = t0; + _.value = t1; + _.parsedAsCustomProperty = t2; + _.interleavedRules = t3; + _.trace = t4; + _.valueSpanForMap = t5; + _.span = t6; + _._indexInParent = _._parent = null; + _.isGroupEnd = false; + }, + ModifiableCssImport: function ModifiableCssImport(t0, t1, t2) { + var _ = this; + _.url = t0; + _.modifiers = t1; + _.span = t2; + _._indexInParent = _._parent = null; + _.isGroupEnd = false; + }, + ModifiableCssKeyframeBlock$(selector, span) { + var t1 = A._setArrayType([], type$.JSArray_ModifiableCssNode); + return new A.ModifiableCssKeyframeBlock(selector, span, new A.UnmodifiableListView(t1, type$.UnmodifiableListView_ModifiableCssNode), t1); + }, + ModifiableCssKeyframeBlock: function ModifiableCssKeyframeBlock(t0, t1, t2, t3) { + var _ = this; + _.selector = t0; + _.span = t1; + _.children = t2; + _._children = t3; + _._indexInParent = _._parent = null; + _.isGroupEnd = false; + }, + ModifiableCssMediaRule$(queries, span) { + var t1 = A.List_List$unmodifiable(queries, type$.CssMediaQuery), + t2 = A._setArrayType([], type$.JSArray_ModifiableCssNode); + if (J.get$isEmpty$asx(queries)) + A.throwExpression(A.ArgumentError$value(queries, "queries", "may not be empty.")); + return new A.ModifiableCssMediaRule(t1, span, new A.UnmodifiableListView(t2, type$.UnmodifiableListView_ModifiableCssNode), t2); + }, + ModifiableCssMediaRule: function ModifiableCssMediaRule(t0, t1, t2, t3) { + var _ = this; + _.queries = t0; + _.span = t1; + _.children = t2; + _._children = t3; + _._indexInParent = _._parent = null; + _.isGroupEnd = false; + }, + ModifiableCssNode: function ModifiableCssNode() { + }, + ModifiableCssNode_hasFollowingSibling_closure: function ModifiableCssNode_hasFollowingSibling_closure() { + }, + ModifiableCssParentNode: function ModifiableCssParentNode() { + }, + ModifiableCssStyleRule$(_selector, span, fromPlainCss, originalSelector) { + var t1 = A._setArrayType([], type$.JSArray_ModifiableCssNode); + return new A.ModifiableCssStyleRule(_selector, originalSelector, span, fromPlainCss, new A.UnmodifiableListView(t1, type$.UnmodifiableListView_ModifiableCssNode), t1); + }, + ModifiableCssStyleRule: function ModifiableCssStyleRule(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._style_rule$_selector = t0; + _.originalSelector = t1; + _.span = t2; + _.fromPlainCss = t3; + _.children = t4; + _._children = t5; + _._indexInParent = _._parent = null; + _.isGroupEnd = false; + }, + ModifiableCssStylesheet$(span) { + var t1 = A._setArrayType([], type$.JSArray_ModifiableCssNode); + return new A.ModifiableCssStylesheet(span, new A.UnmodifiableListView(t1, type$.UnmodifiableListView_ModifiableCssNode), t1); + }, + ModifiableCssStylesheet: function ModifiableCssStylesheet(t0, t1, t2) { + var _ = this; + _.span = t0; + _.children = t1; + _._children = t2; + _._indexInParent = _._parent = null; + _.isGroupEnd = false; + }, + ModifiableCssSupportsRule$(condition, span) { + var t1 = A._setArrayType([], type$.JSArray_ModifiableCssNode); + return new A.ModifiableCssSupportsRule(condition, span, new A.UnmodifiableListView(t1, type$.UnmodifiableListView_ModifiableCssNode), t1); + }, + ModifiableCssSupportsRule: function ModifiableCssSupportsRule(t0, t1, t2, t3) { + var _ = this; + _.condition = t0; + _.span = t1; + _.children = t2; + _._children = t3; + _._indexInParent = _._parent = null; + _.isGroupEnd = false; + }, + CssNode: function CssNode() { + }, + CssParentNode: function CssParentNode() { + }, + _IsInvisibleVisitor: function _IsInvisibleVisitor(t0, t1) { + this.includeBogus = t0; + this.includeComments = t1; + }, + __IsInvisibleVisitor_Object_EveryCssVisitor: function __IsInvisibleVisitor_Object_EveryCssVisitor() { + }, + CssStylesheet: function CssStylesheet(t0, t1) { + this.children = t0; + this.span = t1; + }, + CssValue: function CssValue(t0, t1, t2) { + this.value = t0; + this.span = t1; + this.$ti = t2; + }, + _FakeAstNode: function _FakeAstNode(t0) { + this._callback = t0; + }, + ArgumentList$empty(span) { + return new A.ArgumentList(B.List_empty9, B.Map_empty5, null, null, span); + }, + ArgumentList: function ArgumentList(t0, t1, t2, t3, t4) { + var _ = this; + _.positional = t0; + _.named = t1; + _.rest = t2; + _.keywordRest = t3; + _.span = t4; + }, + AtRootQuery: function AtRootQuery(t0, t1, t2, t3) { + var _ = this; + _.include = t0; + _.names = t1; + _._all = t2; + _._at_root_query$_rule = t3; + }, + ConfiguredVariable: function ConfiguredVariable(t0, t1, t2, t3) { + var _ = this; + _.name = t0; + _.expression = t1; + _.isGuarded = t2; + _.span = t3; + }, + Expression: function Expression() { + }, + BinaryOperationExpression: function BinaryOperationExpression(t0, t1, t2, t3) { + var _ = this; + _.operator = t0; + _.left = t1; + _.right = t2; + _.allowsSlash = t3; + }, + BinaryOperator: function BinaryOperator(t0, t1, t2, t3, t4) { + var _ = this; + _.name = t0; + _.operator = t1; + _.precedence = t2; + _.isAssociative = t3; + _._name = t4; + }, + BooleanExpression: function BooleanExpression(t0, t1) { + this.value = t0; + this.span = t1; + }, + ColorExpression: function ColorExpression(t0, t1) { + this.value = t0; + this.span = t1; + }, + FunctionExpression: function FunctionExpression(t0, t1, t2, t3, t4) { + var _ = this; + _.namespace = t0; + _.name = t1; + _.originalName = t2; + _.$arguments = t3; + _.span = t4; + }, + IfExpression: function IfExpression(t0, t1) { + this.$arguments = t0; + this.span = t1; + }, + InterpolatedFunctionExpression: function InterpolatedFunctionExpression(t0, t1, t2) { + this.name = t0; + this.$arguments = t1; + this.span = t2; + }, + ListExpression: function ListExpression(t0, t1, t2, t3) { + var _ = this; + _.contents = t0; + _.separator = t1; + _.hasBrackets = t2; + _.span = t3; + }, + ListExpression_toString_closure: function ListExpression_toString_closure(t0) { + this.$this = t0; + }, + MapExpression: function MapExpression(t0, t1) { + this.pairs = t0; + this.span = t1; + }, + NullExpression: function NullExpression(t0) { + this.span = t0; + }, + NumberExpression: function NumberExpression(t0, t1, t2) { + this.value = t0; + this.unit = t1; + this.span = t2; + }, + ParenthesizedExpression: function ParenthesizedExpression(t0, t1) { + this.expression = t0; + this.span = t1; + }, + SelectorExpression: function SelectorExpression(t0) { + this.span = t0; + }, + StringExpression_quoteText(text) { + var t1, + quote = A.StringExpression__bestQuote(A._setArrayType([text], type$.JSArray_String)), + buffer = new A.StringBuffer(""); + buffer._contents = "" + A.Primitives_stringFromCharCode(quote); + A.StringExpression__quoteInnerText(text, quote, buffer, true); + t1 = A.Primitives_stringFromCharCode(quote); + t1 = buffer._contents += t1; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + StringExpression__quoteInnerText(text, quote, buffer, $static) { + var t1, t2, i, _1_0, _0_0, t3, t4, t5, t0; + for (t1 = text.length, t2 = t1 - 1, i = 0; i < t1; ++i) { + _1_0 = text.charCodeAt(i); + if (_1_0 === 10 || _1_0 === 13 || _1_0 === 12) { + buffer.writeCharCode$1(92); + buffer.writeCharCode$1(97); + if (i !== t2) { + _0_0 = text.charCodeAt(i + 1); + t3 = true; + if (!(_0_0 === 32 || _0_0 === 9 || _0_0 === 10 || _0_0 === 13 || _0_0 === 12)) + if (!(_0_0 >= 48 && _0_0 <= 57)) + if (!(_0_0 >= 97 && _0_0 <= 102)) + t3 = _0_0 >= 65 && _0_0 <= 70; + if (t3) + buffer.writeCharCode$1(32); + } + continue; + } + t3 = 92 === _1_0; + if (t3) + t4 = _1_0; + else + t4 = null; + if (!t3) { + t3 = false; + t5 = _1_0 === quote; + if (t5) + t4 = _1_0; + if (!t5) + if (35 === _1_0) + if ($static) + if (i < t2) { + t3 = text.charCodeAt(i + 1) === 123; + if (t3) + t4 = _1_0; + t0 = t4; + t4 = t3; + t3 = t0; + } else { + t0 = t4; + t4 = t3; + t3 = t0; + } + else { + t0 = t4; + t4 = t3; + t3 = t0; + } + else { + t0 = t4; + t4 = t3; + t3 = t0; + } + else { + t3 = t4; + t4 = true; + } + } else { + t3 = t4; + t4 = true; + } + if (t4) { + buffer.writeCharCode$1(92); + buffer.writeCharCode$1(t3); + continue; + } + buffer.writeCharCode$1(_1_0); + } + }, + StringExpression__bestQuote(strings) { + var t1, t2, t3, containsDoubleQuote, t4, t5; + for (t1 = J.get$iterator$ax(strings), t2 = type$.CodeUnits, t3 = t2._eval$1("ListIterator"), t2 = t2._eval$1("ListBase.E"), containsDoubleQuote = false; t1.moveNext$0();) + for (t4 = new A.CodeUnits(t1.get$current(t1)), t4 = new A.ListIterator(t4, t4.get$length(0), t3); t4.moveNext$0();) { + t5 = t4.__internal$_current; + if (t5 == null) + t5 = t2._as(t5); + if (t5 === 39) + return 34; + if (t5 === 34) + containsDoubleQuote = true; + } + return containsDoubleQuote ? 39 : 34; + }, + StringExpression: function StringExpression(t0, t1) { + this.text = t0; + this.hasQuotes = t1; + }, + SupportsExpression: function SupportsExpression(t0) { + this.condition = t0; + }, + UnaryOperationExpression: function UnaryOperationExpression(t0, t1, t2) { + this.operator = t0; + this.operand = t1; + this.span = t2; + }, + UnaryOperator: function UnaryOperator(t0, t1, t2) { + this.name = t0; + this.operator = t1; + this._name = t2; + }, + ValueExpression: function ValueExpression(t0, t1) { + this.value = t0; + this.span = t1; + }, + VariableExpression: function VariableExpression(t0, t1, t2) { + this.namespace = t0; + this.name = t1; + this.span = t2; + }, + DynamicImport: function DynamicImport(t0, t1) { + this.urlString = t0; + this.span = t1; + }, + StaticImport: function StaticImport(t0, t1, t2) { + this.url = t0; + this.modifiers = t1; + this.span = t2; + }, + Interpolation$(contents, spans, span) { + var t1 = new A.Interpolation(A.List_List$unmodifiable(contents, type$.Object), A.List_List$unmodifiable(spans, type$.nullable_FileSpan), span); + t1.Interpolation$3(contents, spans, span); + return t1; + }, + Interpolation: function Interpolation(t0, t1, t2) { + this.contents = t0; + this.spans = t1; + this.span = t2; + }, + Interpolation_toString_closure: function Interpolation_toString_closure() { + }, + Parameter: function Parameter(t0, t1, t2) { + this.name = t0; + this.defaultValue = t1; + this.span = t2; + }, + ParameterList_ParameterList$parse(contents, url) { + return A.ScssParser$(contents, url).parseParameterList$0(); + }, + ParameterList: function ParameterList(t0, t1, t2) { + this.parameters = t0; + this.restParameter = t1; + this.span = t2; + }, + ParameterList_verify_closure: function ParameterList_verify_closure() { + }, + ParameterList_verify_closure0: function ParameterList_verify_closure0() { + }, + Statement: function Statement() { + }, + AtRootRule$(children, span, query) { + var t1 = A.List_List$unmodifiable(children, type$.Statement), + t2 = B.JSArray_methods.any$1(t1, new A.ParentStatement_closure()); + return new A.AtRootRule(query, span, t1, t2); + }, + AtRootRule: function AtRootRule(t0, t1, t2, t3) { + var _ = this; + _.query = t0; + _.span = t1; + _.children = t2; + _.hasDeclarations = t3; + }, + AtRule$($name, span, children, value) { + var t1 = children == null ? null : A.List_List$unmodifiable(children, type$.Statement), + t2 = t1 == null ? null : B.JSArray_methods.any$1(t1, new A.ParentStatement_closure()); + return new A.AtRule($name, value, span, t1, t2 === true); + }, + AtRule: function AtRule(t0, t1, t2, t3, t4) { + var _ = this; + _.name = t0; + _.value = t1; + _.span = t2; + _.children = t3; + _.hasDeclarations = t4; + }, + CallableDeclaration: function CallableDeclaration() { + }, + ContentBlock$(parameters, children, span) { + var _s8_ = "@content", + t1 = A.stringReplaceAllUnchecked(_s8_, "_", "-"), + t2 = A.List_List$unmodifiable(children, type$.Statement), + t3 = B.JSArray_methods.any$1(t2, new A.ParentStatement_closure()); + return new A.ContentBlock(t1, _s8_, parameters, span, t2, t3); + }, + ContentBlock: function ContentBlock(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.name = t0; + _.originalName = t1; + _.parameters = t2; + _.span = t3; + _.children = t4; + _.hasDeclarations = t5; + }, + ContentRule: function ContentRule(t0, t1) { + this.$arguments = t0; + this.span = t1; + }, + DebugRule: function DebugRule(t0, t1) { + this.expression = t0; + this.span = t1; + }, + Declaration$($name, value, span) { + return new A.Declaration($name, value, span, null, false); + }, + Declaration$nested($name, children, span, value) { + var t1 = A.List_List$unmodifiable(children, type$.Statement), + t2 = B.JSArray_methods.any$1(t1, new A.ParentStatement_closure()); + return new A.Declaration($name, value, span, t1, t2); + }, + Declaration: function Declaration(t0, t1, t2, t3, t4) { + var _ = this; + _.name = t0; + _.value = t1; + _.span = t2; + _.children = t3; + _.hasDeclarations = t4; + }, + EachRule$(variables, list, children, span) { + var t1 = A.List_List$unmodifiable(variables, type$.String), + t2 = A.List_List$unmodifiable(children, type$.Statement), + t3 = B.JSArray_methods.any$1(t2, new A.ParentStatement_closure()); + return new A.EachRule(t1, list, span, t2, t3); + }, + EachRule: function EachRule(t0, t1, t2, t3, t4) { + var _ = this; + _.variables = t0; + _.list = t1; + _.span = t2; + _.children = t3; + _.hasDeclarations = t4; + }, + EachRule_toString_closure: function EachRule_toString_closure() { + }, + ErrorRule: function ErrorRule(t0, t1) { + this.expression = t0; + this.span = t1; + }, + ExtendRule: function ExtendRule(t0, t1, t2) { + this.selector = t0; + this.isOptional = t1; + this.span = t2; + }, + ForRule$(variable, from, to, children, span, exclusive) { + var t1 = A.List_List$unmodifiable(children, type$.Statement), + t2 = B.JSArray_methods.any$1(t1, new A.ParentStatement_closure()); + return new A.ForRule(variable, from, to, exclusive, span, t1, t2); + }, + ForRule: function ForRule(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.variable = t0; + _.from = t1; + _.to = t2; + _.isExclusive = t3; + _.span = t4; + _.children = t5; + _.hasDeclarations = t6; + }, + ForwardRule: function ForwardRule(t0, t1, t2, t3, t4, t5, t6, t7) { + var _ = this; + _.url = t0; + _.shownMixinsAndFunctions = t1; + _.shownVariables = t2; + _.hiddenMixinsAndFunctions = t3; + _.hiddenVariables = t4; + _.prefix = t5; + _.configuration = t6; + _.span = t7; + }, + FunctionRule$($name, parameters, children, span, comment) { + var t1 = A.stringReplaceAllUnchecked($name, "_", "-"), + t2 = A.List_List$unmodifiable(children, type$.Statement), + t3 = B.JSArray_methods.any$1(t2, new A.ParentStatement_closure()); + return new A.FunctionRule(t1, $name, parameters, span, t2, t3); + }, + FunctionRule: function FunctionRule(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.name = t0; + _.originalName = t1; + _.parameters = t2; + _.span = t3; + _.children = t4; + _.hasDeclarations = t5; + }, + IfClause$(expression, children) { + var t1 = A.List_List$unmodifiable(children, type$.Statement); + return new A.IfClause(expression, t1, B.JSArray_methods.any$1(t1, new A.IfRuleClause$__closure())); + }, + ElseClause$(children) { + var t1 = A.List_List$unmodifiable(children, type$.Statement); + return new A.ElseClause(t1, B.JSArray_methods.any$1(t1, new A.IfRuleClause$__closure())); + }, + IfRule: function IfRule(t0, t1, t2) { + this.clauses = t0; + this.lastClause = t1; + this.span = t2; + }, + IfRule_toString_closure: function IfRule_toString_closure() { + }, + IfRuleClause: function IfRuleClause() { + }, + IfRuleClause$__closure: function IfRuleClause$__closure() { + }, + IfRuleClause$___closure: function IfRuleClause$___closure() { + }, + IfClause: function IfClause(t0, t1, t2) { + this.expression = t0; + this.children = t1; + this.hasDeclarations = t2; + }, + ElseClause: function ElseClause(t0, t1) { + this.children = t0; + this.hasDeclarations = t1; + }, + ImportRule: function ImportRule(t0, t1) { + this.imports = t0; + this.span = t1; + }, + IncludeRule: function IncludeRule(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.namespace = t0; + _.name = t1; + _.originalName = t2; + _.$arguments = t3; + _.content = t4; + _.span = t5; + }, + LoudComment: function LoudComment(t0) { + this.text = t0; + }, + MediaRule$(query, children, span) { + var t1 = A.List_List$unmodifiable(children, type$.Statement), + t2 = B.JSArray_methods.any$1(t1, new A.ParentStatement_closure()); + return new A.MediaRule(query, span, t1, t2); + }, + MediaRule: function MediaRule(t0, t1, t2, t3) { + var _ = this; + _.query = t0; + _.span = t1; + _.children = t2; + _.hasDeclarations = t3; + }, + MixinRule$($name, parameters, children, span, comment) { + var t1 = A.stringReplaceAllUnchecked($name, "_", "-"), + t2 = A.List_List$unmodifiable(children, type$.Statement), + t3 = B.JSArray_methods.any$1(t2, new A.ParentStatement_closure()); + return new A.MixinRule(t1, $name, parameters, span, t2, t3); + }, + MixinRule: function MixinRule(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.__MixinRule_hasContent_FI = $; + _.name = t0; + _.originalName = t1; + _.parameters = t2; + _.span = t3; + _.children = t4; + _.hasDeclarations = t5; + }, + _HasContentVisitor: function _HasContentVisitor() { + }, + __HasContentVisitor_Object_StatementSearchVisitor: function __HasContentVisitor_Object_StatementSearchVisitor() { + }, + ParentStatement: function ParentStatement() { + }, + ParentStatement_closure: function ParentStatement_closure() { + }, + ParentStatement__closure: function ParentStatement__closure() { + }, + ReturnRule: function ReturnRule(t0, t1) { + this.expression = t0; + this.span = t1; + }, + SilentComment: function SilentComment(t0, t1) { + this.text = t0; + this.span = t1; + }, + StyleRule$(selector, children, span) { + var t1 = A.List_List$unmodifiable(children, type$.Statement), + t2 = B.JSArray_methods.any$1(t1, new A.ParentStatement_closure()); + return new A.StyleRule(selector, span, t1, t2); + }, + StyleRule: function StyleRule(t0, t1, t2, t3) { + var _ = this; + _.selector = t0; + _.span = t1; + _.children = t2; + _.hasDeclarations = t3; + }, + Stylesheet$(children, span) { + var t1 = A._setArrayType([], type$.JSArray_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span), + t2 = A._setArrayType([], type$.JSArray_UseRule), + t3 = A._setArrayType([], type$.JSArray_ForwardRule), + t4 = A.List_List$unmodifiable(children, type$.Statement), + t5 = B.JSArray_methods.any$1(t4, new A.ParentStatement_closure()); + t2 = new A.Stylesheet(span, false, t2, t3, new A.UnmodifiableListView(t1, type$.UnmodifiableListView_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span), B.Map_empty7, t4, t5); + t2.Stylesheet$internal$5$globalVariables$plainCss(children, span, t1, null, false); + return t2; + }, + Stylesheet$internal(children, span, parseTimeWarnings, globalVariables, plainCss) { + var t1 = A._setArrayType([], type$.JSArray_UseRule), + t2 = A._setArrayType([], type$.JSArray_ForwardRule), + t3 = globalVariables == null ? B.Map_empty7 : A.ConstantMap_ConstantMap$from(globalVariables, type$.String, type$.FileSpan), + t4 = A.List_List$unmodifiable(children, type$.Statement), + t5 = B.JSArray_methods.any$1(t4, new A.ParentStatement_closure()); + t1 = new A.Stylesheet(span, plainCss, t1, t2, new A.UnmodifiableListView(parseTimeWarnings, type$.UnmodifiableListView_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span), t3, t4, t5); + t1.Stylesheet$internal$5$globalVariables$plainCss(children, span, parseTimeWarnings, globalVariables, plainCss); + return t1; + }, + Stylesheet_Stylesheet$parse(contents, syntax, url) { + var error, stackTrace, url0, t1, exception, t2; + try { + switch (syntax) { + case B.Syntax_Sass_sass: + t1 = new A.SassParser(A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.FileSpan), A._setArrayType([], type$.JSArray_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span), A.SpanScanner$(contents, url), null).parse$0(0); + return t1; + case B.Syntax_SCSS_scss: + t1 = A.ScssParser$(contents, url).parse$0(0); + return t1; + case B.Syntax_CSS_css: + t1 = new A.CssParser(A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.FileSpan), A._setArrayType([], type$.JSArray_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span), A.SpanScanner$(contents, url), null).parse$0(0); + return t1; + } + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = error; + t2 = J.getInterceptor$z(t1); + t1 = A.SourceSpanException.prototype.get$span.call(t2, t1); + url0 = t1.get$sourceUrl(t1); + if (url0 == null || J.toString$0$(url0) === "stdin") + throw exception; + t1 = type$.Uri; + throw A.wrapException(A.throwWithTrace(error.withLoadedUrls$1(A.Set_Set$unmodifiable(A.LinkedHashSet_LinkedHashSet$_literal([url0], t1), t1)), error, stackTrace)); + } else + throw exception; + } + }, + Stylesheet: function Stylesheet(t0, t1, t2, t3, t4, t5, t6, t7) { + var _ = this; + _.span = t0; + _.plainCss = t1; + _._uses = t2; + _._forwards = t3; + _.parseTimeWarnings = t4; + _.globalVariables = t5; + _.children = t6; + _.hasDeclarations = t7; + }, + SupportsRule$(condition, children, span) { + var t1 = A.List_List$unmodifiable(children, type$.Statement), + t2 = B.JSArray_methods.any$1(t1, new A.ParentStatement_closure()); + return new A.SupportsRule(condition, span, t1, t2); + }, + SupportsRule: function SupportsRule(t0, t1, t2, t3) { + var _ = this; + _.condition = t0; + _.span = t1; + _.children = t2; + _.hasDeclarations = t3; + }, + UseRule: function UseRule(t0, t1, t2, t3) { + var _ = this; + _.url = t0; + _.namespace = t1; + _.configuration = t2; + _.span = t3; + }, + VariableDeclaration$($name, expression, span, comment, global, guarded, namespace) { + if (namespace != null && global) + A.throwExpression(A.ArgumentError$(string$.Other_, null)); + return new A.VariableDeclaration(namespace, $name, expression, guarded, global, span); + }, + VariableDeclaration: function VariableDeclaration(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.namespace = t0; + _.name = t1; + _.expression = t2; + _.isGuarded = t3; + _.isGlobal = t4; + _.span = t5; + }, + WarnRule: function WarnRule(t0, t1) { + this.expression = t0; + this.span = t1; + }, + WhileRule$(condition, children, span) { + var t1 = A.List_List$unmodifiable(children, type$.Statement), + t2 = B.JSArray_methods.any$1(t1, new A.ParentStatement_closure()); + return new A.WhileRule(condition, span, t1, t2); + }, + WhileRule: function WhileRule(t0, t1, t2, t3) { + var _ = this; + _.condition = t0; + _.span = t1; + _.children = t2; + _.hasDeclarations = t3; + }, + SupportsAnything: function SupportsAnything(t0, t1) { + this.contents = t0; + this.span = t1; + }, + SupportsDeclaration: function SupportsDeclaration(t0, t1, t2) { + this.name = t0; + this.value = t1; + this.span = t2; + }, + SupportsFunction: function SupportsFunction(t0, t1, t2) { + this.name = t0; + this.$arguments = t1; + this.span = t2; + }, + SupportsInterpolation: function SupportsInterpolation(t0, t1) { + this.expression = t0; + this.span = t1; + }, + SupportsNegation: function SupportsNegation(t0, t1) { + this.condition = t0; + this.span = t1; + }, + SupportsOperation$(left, right, operator, span) { + var lowerOperator = operator.toLowerCase(); + if (lowerOperator !== "and" && lowerOperator !== "or") + A.throwExpression(A.ArgumentError$value(operator, "operator", 'may only be "and" or "or".')); + return new A.SupportsOperation(left, right, operator, span); + }, + SupportsOperation: function SupportsOperation(t0, t1, t2, t3) { + var _ = this; + _.left = t0; + _.right = t1; + _.operator = t2; + _.span = t3; + }, + Selector: function Selector() { + }, + _IsInvisibleVisitor0: function _IsInvisibleVisitor0(t0) { + this.includeBogus = t0; + }, + _IsBogusVisitor: function _IsBogusVisitor(t0) { + this.includeLeadingCombinator = t0; + }, + _IsBogusVisitor_visitComplexSelector_closure: function _IsBogusVisitor_visitComplexSelector_closure(t0) { + this.$this = t0; + }, + _IsUselessVisitor: function _IsUselessVisitor() { + }, + _IsUselessVisitor_visitComplexSelector_closure: function _IsUselessVisitor_visitComplexSelector_closure(t0) { + this.$this = t0; + }, + __IsBogusVisitor_Object_AnySelectorVisitor: function __IsBogusVisitor_Object_AnySelectorVisitor() { + }, + __IsInvisibleVisitor_Object_AnySelectorVisitor: function __IsInvisibleVisitor_Object_AnySelectorVisitor() { + }, + __IsUselessVisitor_Object_AnySelectorVisitor: function __IsUselessVisitor_Object_AnySelectorVisitor() { + }, + AttributeSelector: function AttributeSelector(t0, t1, t2, t3, t4) { + var _ = this; + _.name = t0; + _.op = t1; + _.value = t2; + _.modifier = t3; + _.span = t4; + }, + AttributeOperator: function AttributeOperator(t0, t1) { + this._attribute$_text = t0; + this._name = t1; + }, + ClassSelector: function ClassSelector(t0, t1) { + this.name = t0; + this.span = t1; + }, + Combinator: function Combinator(t0, t1) { + this._combinator$_text = t0; + this._name = t1; + }, + ComplexSelector$(leadingCombinators, components, span, lineBreak) { + var t1 = A.List_List$unmodifiable(leadingCombinators, type$.CssValue_Combinator), + t2 = A.List_List$unmodifiable(components, type$.ComplexSelectorComponent); + if (t1.length === 0 && t2.length === 0) + A.throwExpression(A.ArgumentError$(string$.leadin, null)); + return new A.ComplexSelector(t1, t2, lineBreak, span); + }, + ComplexSelector: function ComplexSelector(t0, t1, t2, t3) { + var _ = this; + _.leadingCombinators = t0; + _.components = t1; + _.lineBreak = t2; + _.__ComplexSelector_specificity_FI = $; + _.span = t3; + }, + ComplexSelector_specificity_closure: function ComplexSelector_specificity_closure() { + }, + ComplexSelectorComponent: function ComplexSelectorComponent(t0, t1, t2) { + this.selector = t0; + this.combinators = t1; + this.span = t2; + }, + ComplexSelectorComponent_toString_closure: function ComplexSelectorComponent_toString_closure() { + }, + CompoundSelector$(components, span) { + var t1 = A.List_List$unmodifiable(components, type$.SimpleSelector); + if (t1.length === 0) + A.throwExpression(A.ArgumentError$("components may not be empty.", null)); + return new A.CompoundSelector(t1, span); + }, + CompoundSelector: function CompoundSelector(t0, t1) { + var _ = this; + _.components = t0; + _.__CompoundSelector_hasComplicatedSuperselectorSemantics_FI = _.__CompoundSelector_specificity_FI = $; + _.span = t1; + }, + CompoundSelector_specificity_closure: function CompoundSelector_specificity_closure() { + }, + CompoundSelector_hasComplicatedSuperselectorSemantics_closure: function CompoundSelector_hasComplicatedSuperselectorSemantics_closure() { + }, + IDSelector: function IDSelector(t0, t1) { + this.name = t0; + this.span = t1; + }, + IDSelector_unify_closure: function IDSelector_unify_closure(t0) { + this.$this = t0; + }, + SelectorList$(components, span) { + var t1 = A.List_List$unmodifiable(components, type$.ComplexSelector); + if (t1.length === 0) + A.throwExpression(A.ArgumentError$("components may not be empty.", null)); + return new A.SelectorList(t1, span); + }, + SelectorList_SelectorList$parse(contents, allowParent, interpolationMap, plainCss) { + return new A.SelectorParser(allowParent, plainCss, A.SpanScanner$(contents, null), interpolationMap).parse$0(0); + }, + SelectorList: function SelectorList(t0, t1) { + this.components = t0; + this.span = t1; + }, + SelectorList_asSassList_closure: function SelectorList_asSassList_closure() { + }, + SelectorList_nestWithin_closure: function SelectorList_nestWithin_closure(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.preserveParentSelectors = t1; + _.implicitParent = t2; + _.parent = t3; + }, + SelectorList_nestWithin__closure: function SelectorList_nestWithin__closure(t0) { + this.complex = t0; + }, + SelectorList_nestWithin__closure0: function SelectorList_nestWithin__closure0(t0) { + this.complex = t0; + }, + SelectorList__nestWithinCompound_closure: function SelectorList__nestWithinCompound_closure() { + }, + SelectorList__nestWithinCompound_closure0: function SelectorList__nestWithinCompound_closure0(t0) { + this.parent = t0; + }, + SelectorList__nestWithinCompound_closure1: function SelectorList__nestWithinCompound_closure1(t0, t1, t2) { + this.parentSelector = t0; + this.resolvedSimples = t1; + this.component = t2; + }, + SelectorList_withAdditionalCombinators_closure: function SelectorList_withAdditionalCombinators_closure(t0) { + this.combinators = t0; + }, + _ParentSelectorVisitor: function _ParentSelectorVisitor() { + }, + __ParentSelectorVisitor_Object_SelectorSearchVisitor: function __ParentSelectorVisitor_Object_SelectorSearchVisitor() { + }, + ParentSelector: function ParentSelector(t0, t1) { + this.suffix = t0; + this.span = t1; + }, + PlaceholderSelector: function PlaceholderSelector(t0, t1) { + this.name = t0; + this.span = t1; + }, + PseudoSelector$($name, span, argument, element, selector) { + var t1 = !element, + t2 = t1 && !A.PseudoSelector__isFakePseudoElement($name); + return new A.PseudoSelector($name, A.unvendor($name), t2, t1, argument, selector, span); + }, + PseudoSelector__isFakePseudoElement($name) { + switch ($name.charCodeAt(0)) { + case 97: + case 65: + return A.equalsIgnoreCase($name, "after"); + case 98: + case 66: + return A.equalsIgnoreCase($name, "before"); + case 102: + case 70: + return A.equalsIgnoreCase($name, "first-line") || A.equalsIgnoreCase($name, "first-letter"); + default: + return false; + } + }, + PseudoSelector: function PseudoSelector(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.name = t0; + _.normalizedName = t1; + _.isClass = t2; + _.isSyntacticClass = t3; + _.argument = t4; + _.selector = t5; + _.__PseudoSelector_specificity_FI = $; + _.span = t6; + }, + PseudoSelector_specificity_closure: function PseudoSelector_specificity_closure(t0) { + this.$this = t0; + }, + PseudoSelector_specificity__closure: function PseudoSelector_specificity__closure() { + }, + PseudoSelector_specificity__closure0: function PseudoSelector_specificity__closure0() { + }, + PseudoSelector_unify_closure: function PseudoSelector_unify_closure() { + }, + QualifiedName: function QualifiedName(t0, t1) { + this.name = t0; + this.namespace = t1; + }, + SimpleSelector: function SimpleSelector() { + }, + SimpleSelector_isSuperselector_closure: function SimpleSelector_isSuperselector_closure(t0) { + this.$this = t0; + }, + SimpleSelector_isSuperselector__closure: function SimpleSelector_isSuperselector__closure(t0) { + this.$this = t0; + }, + TypeSelector: function TypeSelector(t0, t1) { + this.name = t0; + this.span = t1; + }, + UniversalSelector: function UniversalSelector(t0, t1) { + this.namespace = t0; + this.span = t1; + }, + compileAsync(path, charset, fatalDeprecations, futureDeprecations, importCache, logger, quietDeps, silenceDeprecations, sourceMap, style, syntax, verbose) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.CompileResult), + $async$returnValue, t3, t4, t0, stylesheet, result, t1, t2; + var $async$compileAsync = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = type$.Deprecation; + t2 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + t2.addAll$1(0, silenceDeprecations); + t3 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + t3.addAll$1(0, fatalDeprecations); + t4 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + t4.addAll$1(0, futureDeprecations); + logger = new A.DeprecationProcessingLogger(A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.int), logger, t2, t3, t4, !verbose); + logger.validate$0(); + t1 = syntax === A.Syntax_forPath(path); + $async$goto = t1 ? 3 : 5; + break; + case 3: + // then + t1 = $.$get$FilesystemImporter_cwd(); + t2 = A.isNodeJs() ? self.process : null; + if (!J.$eq$(t2 == null ? null : J.get$platform$x(t2), "win32")) { + t2 = A.isNodeJs() ? self.process : null; + t2 = J.$eq$(t2 == null ? null : J.get$platform$x(t2), "darwin"); + } else + t2 = true; + if (t2) { + t2 = A.absolute(path, null, null, null, null, null, null, null, null, null, null, null, null, null, null); + t3 = $.$get$context(); + t2 = A._realCasePath(t3.normalize$1(t2)); + } else { + t2 = $.$get$context(); + t3 = t2.canonicalize$1(0, path); + t0 = t3; + t3 = t2; + t2 = t0; + } + $async$goto = 6; + return A._asyncAwait(importCache.importCanonical$3$originalUrl(t1, t3.toUri$1(t2), t3.toUri$1(path)), $async$compileAsync); + case 6: + // returning from await. + t3 = $async$result; + t3.toString; + stylesheet = t3; + // goto join + $async$goto = 4; + break; + case 5: + // else + t1 = A.readFile(path); + stylesheet = A.Stylesheet_Stylesheet$parse(t1, syntax, $.$get$context().toUri$1(path)); + case 4: + // join + $async$goto = 7; + return A._asyncAwait(A._compileStylesheet0(stylesheet, logger, importCache, null, $.$get$FilesystemImporter_cwd(), null, style, true, null, null, quietDeps, sourceMap, charset), $async$compileAsync); + case 7: + // returning from await. + result = $async$result; + logger.summarize$1$js(false); + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$compileAsync, $async$completer); + }, + compileStringAsync(source, charset, fatalDeprecations, futureDeprecations, importCache, importer, logger, quietDeps, silenceDeprecations, sourceMap, style, syntax, verbose) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.CompileResult), + $async$returnValue, t3, t4, stylesheet, result, t1, t2; + var $async$compileStringAsync = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = type$.Deprecation; + t2 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + t2.addAll$1(0, silenceDeprecations); + t3 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + t3.addAll$1(0, fatalDeprecations); + t4 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + t4.addAll$1(0, futureDeprecations); + logger = new A.DeprecationProcessingLogger(A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.int), logger, t2, t3, t4, !verbose); + logger.validate$0(); + stylesheet = A.Stylesheet_Stylesheet$parse(source, syntax, null); + $async$goto = 3; + return A._asyncAwait(A._compileStylesheet0(stylesheet, logger, importCache, null, importer, null, style, true, null, null, quietDeps, sourceMap, charset), $async$compileStringAsync); + case 3: + // returning from await. + result = $async$result; + logger.summarize$1$js(false); + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$compileStringAsync, $async$completer); + }, + _compileStylesheet0(stylesheet, logger, importCache, nodeImporter, importer, functions, style, useSpaces, indentWidth, lineFeed, quietDeps, sourceMap, charset) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.CompileResult), + $async$returnValue, serializeResult, resultSourceMap, $async$temp1; + var $async$_compileStylesheet0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$temp1 = A; + $async$goto = 3; + return A._asyncAwait(A._EvaluateVisitor$0(functions, importCache, logger, nodeImporter, quietDeps, sourceMap).run$2(0, importer, stylesheet), $async$_compileStylesheet0); + case 3: + // returning from await. + serializeResult = $async$temp1.serialize($async$result._1, charset, indentWidth, false, lineFeed, logger, sourceMap, style, true); + resultSourceMap = serializeResult._1; + if (resultSourceMap != null) + A.mapInPlace(resultSourceMap.urls, new A._compileStylesheet_closure0(stylesheet, importCache)); + $async$returnValue = new A.CompileResult(serializeResult); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_compileStylesheet0, $async$completer); + }, + _compileStylesheet_closure0: function _compileStylesheet_closure0(t0, t1) { + this.stylesheet = t0; + this.importCache = t1; + }, + AsyncEnvironment$() { + var t1 = type$.String, + t2 = type$.Module_AsyncCallable, + t3 = type$.AstNode, + t4 = type$.int, + t5 = type$.AsyncCallable, + t6 = type$.JSArray_Map_String_AsyncCallable; + return new A.AsyncEnvironment(A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), A.LinkedHashMap_LinkedHashMap$_empty(t1, t3), A.LinkedHashMap_LinkedHashMap$_empty(t2, t3), A.LinkedHashMap_LinkedHashMap$_empty(t2, t3), null, null, A._setArrayType([], type$.JSArray_Module_AsyncCallable), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Value)], type$.JSArray_Map_String_Value), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, t3)], type$.JSArray_Map_String_AstNode), A.LinkedHashMap_LinkedHashMap$_empty(t1, t4), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, t5)], t6), A.LinkedHashMap_LinkedHashMap$_empty(t1, t4), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, t5)], t6), A.LinkedHashMap_LinkedHashMap$_empty(t1, t4), null); + }, + AsyncEnvironment$_(_modules, _namespaceNodes, _globalModules, _importedModules, _forwardedModules, _nestedForwardedModules, _allModules, _variables, _variableNodes, _functions, _mixins, _content) { + var t1 = type$.String, + t2 = type$.int; + return new A.AsyncEnvironment(_modules, _namespaceNodes, _globalModules, _importedModules, _forwardedModules, _nestedForwardedModules, _allModules, _variables, _variableNodes, A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), _functions, A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), _mixins, A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), _content); + }, + _EnvironmentModule__EnvironmentModule0(environment, css, preModuleComments, extensionStore, forwarded) { + var t1, t2, t3, t4, t5, t6, module, result, t7; + if (forwarded == null) + forwarded = B.Set_empty2; + t1 = type$.dynamic; + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t2 = type$.Module_AsyncCallable, t3 = type$.List_CssComment, t4 = A.MapExtensions_get_pairs(preModuleComments, t2, t3), t4 = t4.get$iterator(t4), t5 = type$.CssComment; t4.moveNext$0();) { + t6 = t4.get$current(t4); + module = t6._0; + result = A.List_List$from(t6._1, false, t5); + result.$flags = 3; + t1.$indexSet(0, module, result); + } + t1 = A.ConstantMap_ConstantMap$from(t1, t2, t3); + t2 = A._EnvironmentModule__makeModulesByVariable0(forwarded); + t3 = A._EnvironmentModule__memberMap0(B.JSArray_methods.get$first(environment._async_environment$_variables), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure5(), type$.Map_String_Value), type$.Value); + t4 = A._EnvironmentModule__memberMap0(B.JSArray_methods.get$first(environment._async_environment$_variableNodes), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure6(), type$.Map_String_AstNode), type$.AstNode); + t5 = type$.Map_String_AsyncCallable; + t6 = type$.AsyncCallable; + t7 = A._EnvironmentModule__memberMap0(B.JSArray_methods.get$first(environment._async_environment$_functions), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure7(), t5), t6); + t6 = A._EnvironmentModule__memberMap0(B.JSArray_methods.get$first(environment._async_environment$_mixins), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure8(), t5), t6); + t5 = J.get$isNotEmpty$asx(css.get$children(css)) || preModuleComments.get$isNotEmpty(preModuleComments) || B.JSArray_methods.any$1(environment._async_environment$_allModules, new A._EnvironmentModule__EnvironmentModule_closure9()); + return A._EnvironmentModule$_0(environment, css, t1, extensionStore, t2, t3, t4, t7, t6, t5, !extensionStore.get$isEmpty(extensionStore) || B.JSArray_methods.any$1(environment._async_environment$_allModules, new A._EnvironmentModule__EnvironmentModule_closure10())); + }, + _EnvironmentModule__makeModulesByVariable0(forwarded) { + var modulesByVariable, t1, t2, t3, t4, t5; + if (forwarded.get$isEmpty(forwarded)) + return B.Map_empty9; + modulesByVariable = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.Module_AsyncCallable); + for (t1 = forwarded.get$iterator(forwarded); t1.moveNext$0();) { + t2 = t1.get$current(t1); + if (t2 instanceof A._EnvironmentModule0) { + for (t3 = t2._async_environment$_modulesByVariable, t3 = t3.get$values(t3), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t5 = t4.get$variables(); + A.setAll(modulesByVariable, t5.get$keys(t5), t4); + } + A.setAll(modulesByVariable, J.get$keys$z(B.JSArray_methods.get$first(t2._async_environment$_environment._async_environment$_variables)), t2); + } else { + t3 = t2.get$variables(); + A.setAll(modulesByVariable, t3.get$keys(t3), t2); + } + } + return modulesByVariable; + }, + _EnvironmentModule__memberMap0(localMap, otherMaps, $V) { + var t1, t2, t3; + localMap = new A.PublicMemberMapView(localMap, $V._eval$1("PublicMemberMapView<0>")); + if (otherMaps.get$isEmpty(otherMaps)) + return localMap; + t1 = A._setArrayType([], $V._eval$1("JSArray>")); + for (t2 = otherMaps.get$iterator(otherMaps); t2.moveNext$0();) { + t3 = t2.get$current(t2); + if (t3.get$isNotEmpty(t3)) + t1.push(t3); + } + t1.push(localMap); + if (t1.length === 1) + return localMap; + return A.MergedMapView$(t1, type$.String, $V); + }, + _EnvironmentModule$_0(_environment, css, preModuleComments, extensionStore, _modulesByVariable, variables, variableNodes, functions, mixins, transitivelyContainsCss, transitivelyContainsExtensions) { + return new A._EnvironmentModule0(_environment._async_environment$_allModules, variables, variableNodes, functions, mixins, extensionStore, css, preModuleComments, transitivelyContainsCss, transitivelyContainsExtensions, _environment, _modulesByVariable); + }, + AsyncEnvironment: function AsyncEnvironment(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14) { + var _ = this; + _._async_environment$_modules = t0; + _._async_environment$_namespaceNodes = t1; + _._async_environment$_globalModules = t2; + _._async_environment$_importedModules = t3; + _._async_environment$_forwardedModules = t4; + _._async_environment$_nestedForwardedModules = t5; + _._async_environment$_allModules = t6; + _._async_environment$_variables = t7; + _._async_environment$_variableNodes = t8; + _._async_environment$_variableIndices = t9; + _._async_environment$_functions = t10; + _._async_environment$_functionIndices = t11; + _._async_environment$_mixins = t12; + _._async_environment$_mixinIndices = t13; + _._async_environment$_content = t14; + _._async_environment$_inMixin = false; + _._async_environment$_inSemiGlobalScope = true; + _._async_environment$_lastVariableIndex = _._async_environment$_lastVariableName = null; + }, + AsyncEnvironment__getVariableFromGlobalModule_closure: function AsyncEnvironment__getVariableFromGlobalModule_closure(t0) { + this.name = t0; + }, + AsyncEnvironment_setVariable_closure: function AsyncEnvironment_setVariable_closure(t0, t1) { + this.$this = t0; + this.name = t1; + }, + AsyncEnvironment_setVariable_closure0: function AsyncEnvironment_setVariable_closure0(t0) { + this.name = t0; + }, + AsyncEnvironment_setVariable_closure1: function AsyncEnvironment_setVariable_closure1(t0, t1) { + this.$this = t0; + this.name = t1; + }, + AsyncEnvironment__getFunctionFromGlobalModule_closure: function AsyncEnvironment__getFunctionFromGlobalModule_closure(t0) { + this.name = t0; + }, + AsyncEnvironment__getMixinFromGlobalModule_closure: function AsyncEnvironment__getMixinFromGlobalModule_closure(t0) { + this.name = t0; + }, + AsyncEnvironment_toModule_closure: function AsyncEnvironment_toModule_closure() { + }, + AsyncEnvironment_toDummyModule_closure: function AsyncEnvironment_toDummyModule_closure() { + }, + _EnvironmentModule0: function _EnvironmentModule0(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11) { + var _ = this; + _.upstream = t0; + _.variables = t1; + _.variableNodes = t2; + _.functions = t3; + _.mixins = t4; + _.extensionStore = t5; + _.css = t6; + _.preModuleComments = t7; + _.transitivelyContainsCss = t8; + _.transitivelyContainsExtensions = t9; + _._async_environment$_environment = t10; + _._async_environment$_modulesByVariable = t11; + }, + _EnvironmentModule__EnvironmentModule_closure5: function _EnvironmentModule__EnvironmentModule_closure5() { + }, + _EnvironmentModule__EnvironmentModule_closure6: function _EnvironmentModule__EnvironmentModule_closure6() { + }, + _EnvironmentModule__EnvironmentModule_closure7: function _EnvironmentModule__EnvironmentModule_closure7() { + }, + _EnvironmentModule__EnvironmentModule_closure8: function _EnvironmentModule__EnvironmentModule_closure8() { + }, + _EnvironmentModule__EnvironmentModule_closure9: function _EnvironmentModule__EnvironmentModule_closure9() { + }, + _EnvironmentModule__EnvironmentModule_closure10: function _EnvironmentModule__EnvironmentModule_closure10() { + }, + AsyncImportCache__toImporters(importers, loadPaths, packageConfig) { + var t1, t2, t3, t4, _i, path, _null = null, + sassPath = A.getEnvironmentVariable("SASS_PATH"); + if (A.isBrowser()) { + t1 = A._setArrayType([], type$.JSArray_AsyncImporter_2); + B.JSArray_methods.addAll$1(t1, importers); + return t1; + } + t1 = A._setArrayType([], type$.JSArray_AsyncImporter_2); + B.JSArray_methods.addAll$1(t1, importers); + for (t2 = J.get$iterator$ax(loadPaths); t2.moveNext$0();) { + t3 = t2.get$current(t2); + t1.push(new A.FilesystemImporter($.$get$context().absolute$15(t3, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null), false)); + } + if (sassPath != null) { + t2 = A.isNodeJs() ? self.process : _null; + t3 = sassPath.split(J.$eq$(t2 == null ? _null : J.get$platform$x(t2), "win32") ? ";" : ":"); + t4 = t3.length; + _i = 0; + for (; _i < t4; ++_i) { + path = t3[_i]; + t1.push(new A.FilesystemImporter($.$get$context().absolute$15(path, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null), false)); + } + } + return t1; + }, + AsyncImportCache: function AsyncImportCache(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._async_import_cache$_importers = t0; + _._async_import_cache$_canonicalizeCache = t1; + _._async_import_cache$_perImporterCanonicalizeCache = t2; + _._async_import_cache$_nonCanonicalRelativeUrls = t3; + _._async_import_cache$_importCache = t4; + _._async_import_cache$_resultsCache = t5; + _._async_import_cache$_loadTimes = t6; + }, + AsyncImportCache_canonicalize_closure: function AsyncImportCache_canonicalize_closure(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.$this = t0; + _.baseImporter = t1; + _.resolvedUrl = t2; + _.baseUrl = t3; + _.forImport = t4; + _.key = t5; + _.url = t6; + }, + AsyncImportCache__canonicalize_closure: function AsyncImportCache__canonicalize_closure(t0, t1) { + this.importer = t0; + this.url = t1; + }, + AsyncImportCache_importCanonical_closure: function AsyncImportCache_importCanonical_closure(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.importer = t1; + _.canonicalUrl = t2; + _.originalUrl = t3; + }, + AsyncImportCache_humanize_closure: function AsyncImportCache_humanize_closure(t0) { + this.canonicalUrl = t0; + }, + AsyncImportCache_humanize_closure0: function AsyncImportCache_humanize_closure0() { + }, + AsyncImportCache_humanize_closure1: function AsyncImportCache_humanize_closure1() { + }, + AsyncImportCache_humanize_closure2: function AsyncImportCache_humanize_closure2(t0) { + this.canonicalUrl = t0; + }, + AsyncBuiltInCallable$mixin($name, parameters, callback, acceptsContent, url) { + return new A.AsyncBuiltInCallable($name, A.ScssParser$("@mixin " + $name + "(" + parameters + ") {", url).parseParameterList$0(), new A.AsyncBuiltInCallable$mixin_closure(callback), false); + }, + AsyncBuiltInCallable: function AsyncBuiltInCallable(t0, t1, t2, t3) { + var _ = this; + _.name = t0; + _._parameters = t1; + _._async_built_in$_callback = t2; + _.acceptsContent = t3; + }, + AsyncBuiltInCallable$mixin_closure: function AsyncBuiltInCallable$mixin_closure(t0) { + this.callback = t0; + }, + AsyncBuiltInCallable_withDeprecationWarning_closure: function AsyncBuiltInCallable_withDeprecationWarning_closure(t0, t1, t2) { + this.$this = t0; + this.module = t1; + this.newName = t2; + }, + BuiltInCallable$function($name, parameters, callback, url) { + return new A.BuiltInCallable($name, A._setArrayType([new A._Record_2(A.ScssParser$("@function " + $name + "(" + parameters + ") {", url).parseParameterList$0(), callback)], type$.JSArray_Record_2_ParameterList_and_Value_Function_List_Value), false); + }, + BuiltInCallable$mixin($name, parameters, callback, acceptsContent, url) { + return new A.BuiltInCallable($name, A._setArrayType([new A._Record_2(A.ScssParser$("@mixin " + $name + "(" + parameters + ") {", url).parseParameterList$0(), new A.BuiltInCallable$mixin_closure(callback))], type$.JSArray_Record_2_ParameterList_and_Value_Function_List_Value), acceptsContent); + }, + BuiltInCallable$overloadedFunction($name, overloads) { + var t2, t3, t4, t5, t6, t7, args, callback, + t1 = A._setArrayType([], type$.JSArray_Record_2_ParameterList_and_Value_Function_List_Value); + for (t2 = type$.String, t3 = A.MapExtensions_get_pairs(overloads, t2, type$.Value_Function_List_Value), t3 = t3.get$iterator(t3), t4 = "@function " + $name + "(", t5 = type$.FileSpan, t6 = type$.JSArray_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span; t3.moveNext$0();) { + t7 = t3.get$current(t3); + args = t7._0; + callback = t7._1; + t1.push(new A._Record_2(new A.ScssParser(A.LinkedHashMap_LinkedHashMap$_empty(t2, t5), A._setArrayType([], t6), A.SpanScanner$(t4 + args + ") {", null), null).parseParameterList$0(), callback)); + } + return new A.BuiltInCallable($name, t1, false); + }, + BuiltInCallable: function BuiltInCallable(t0, t1, t2) { + this.name = t0; + this._overloads = t1; + this.acceptsContent = t2; + }, + BuiltInCallable$mixin_closure: function BuiltInCallable$mixin_closure(t0) { + this.callback = t0; + }, + BuiltInCallable_withDeprecationWarning_closure: function BuiltInCallable_withDeprecationWarning_closure(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.module = t2; + _.newName = t3; + }, + PlainCssCallable: function PlainCssCallable(t0) { + this.name = t0; + }, + UserDefinedCallable: function UserDefinedCallable(t0, t1, t2, t3) { + var _ = this; + _.declaration = t0; + _.environment = t1; + _.inDependency = t2; + _.$ti = t3; + }, + _compileStylesheet(stylesheet, logger, importCache, nodeImporter, importer, functions, style, useSpaces, indentWidth, lineFeed, quietDeps, sourceMap, charset) { + var serializeResult = A.serialize(A._EvaluateVisitor$(functions, importCache, logger, nodeImporter, quietDeps, sourceMap).run$2(0, importer, stylesheet)._1, charset, indentWidth, false, lineFeed, logger, sourceMap, style, true), + resultSourceMap = serializeResult._1; + if (resultSourceMap != null) + A.mapInPlace(resultSourceMap.urls, new A._compileStylesheet_closure(stylesheet, importCache)); + return new A.CompileResult(serializeResult); + }, + _compileStylesheet_closure: function _compileStylesheet_closure(t0, t1) { + this.stylesheet = t0; + this.importCache = t1; + }, + CompileResult: function CompileResult(t0) { + this._serialize = t0; + }, + Configuration: function Configuration(t0, t1) { + this._configuration$_values = t0; + this.__originalConfiguration = t1; + }, + ExplicitConfiguration: function ExplicitConfiguration(t0, t1, t2) { + this.nodeWithSpan = t0; + this._configuration$_values = t1; + this.__originalConfiguration = t2; + }, + ConfiguredValue: function ConfiguredValue(t0, t1, t2) { + this.value = t0; + this.configurationSpan = t1; + this.assignmentNode = t2; + }, + Deprecation_fromId(id) { + return A.IterableExtension_firstWhereOrNull(B.List_dCD, new A.Deprecation_fromId_closure(id)); + }, + Deprecation_forVersion(version) { + var t2, _i, deprecation, $self, t3, + t1 = A.LinkedHashSet_LinkedHashSet$_empty(type$.Deprecation); + for (t2 = A.VersionRange_VersionRange(true, version).get$allows(), _i = 0; _i < 25; ++_i) { + deprecation = B.List_dCD[_i]; + $self = deprecation._deprecatedIn; + t3 = $self == null ? null : A.Version___parse_tearOff($self); + t3 = t3 == null ? null : t2.call$1(t3); + if (t3 == null ? false : t3) + t1.add$1(0, deprecation); + } + return t1; + }, + Deprecation: function Deprecation(t0, t1, t2) { + this.id = t0; + this._deprecatedIn = t1; + this._name = t2; + }, + Deprecation_fromId_closure: function Deprecation_fromId_closure(t0) { + this.id = t0; + }, + Environment$() { + var t1 = type$.String, + t2 = type$.Module_Callable, + t3 = type$.AstNode, + t4 = type$.int, + t5 = type$.Callable, + t6 = type$.JSArray_Map_String_Callable; + return new A.Environment(A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), A.LinkedHashMap_LinkedHashMap$_empty(t1, t3), A.LinkedHashMap_LinkedHashMap$_empty(t2, t3), A.LinkedHashMap_LinkedHashMap$_empty(t2, t3), null, null, A._setArrayType([], type$.JSArray_Module_Callable), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Value)], type$.JSArray_Map_String_Value), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, t3)], type$.JSArray_Map_String_AstNode), A.LinkedHashMap_LinkedHashMap$_empty(t1, t4), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, t5)], t6), A.LinkedHashMap_LinkedHashMap$_empty(t1, t4), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, t5)], t6), A.LinkedHashMap_LinkedHashMap$_empty(t1, t4), null); + }, + Environment$_(_modules, _namespaceNodes, _globalModules, _importedModules, _forwardedModules, _nestedForwardedModules, _allModules, _variables, _variableNodes, _functions, _mixins, _content) { + var t1 = type$.String, + t2 = type$.int; + return new A.Environment(_modules, _namespaceNodes, _globalModules, _importedModules, _forwardedModules, _nestedForwardedModules, _allModules, _variables, _variableNodes, A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), _functions, A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), _mixins, A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), _content); + }, + _EnvironmentModule__EnvironmentModule(environment, css, preModuleComments, extensionStore, forwarded) { + var t1, t2, t3, t4, t5, t6, module, result, t7; + if (forwarded == null) + forwarded = B.Set_empty0; + t1 = type$.dynamic; + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t2 = type$.Module_Callable, t3 = type$.List_CssComment, t4 = A.MapExtensions_get_pairs(preModuleComments, t2, t3), t4 = t4.get$iterator(t4), t5 = type$.CssComment; t4.moveNext$0();) { + t6 = t4.get$current(t4); + module = t6._0; + result = A.List_List$from(t6._1, false, t5); + result.$flags = 3; + t1.$indexSet(0, module, result); + } + t1 = A.ConstantMap_ConstantMap$from(t1, t2, t3); + t2 = A._EnvironmentModule__makeModulesByVariable(forwarded); + t3 = A._EnvironmentModule__memberMap(B.JSArray_methods.get$first(environment._variables), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure(), type$.Map_String_Value), type$.Value); + t4 = A._EnvironmentModule__memberMap(B.JSArray_methods.get$first(environment._variableNodes), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure0(), type$.Map_String_AstNode), type$.AstNode); + t5 = type$.Map_String_Callable; + t6 = type$.Callable; + t7 = A._EnvironmentModule__memberMap(B.JSArray_methods.get$first(environment._functions), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure1(), t5), t6); + t6 = A._EnvironmentModule__memberMap(B.JSArray_methods.get$first(environment._mixins), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure2(), t5), t6); + t5 = J.get$isNotEmpty$asx(css.get$children(css)) || preModuleComments.get$isNotEmpty(preModuleComments) || B.JSArray_methods.any$1(environment._allModules, new A._EnvironmentModule__EnvironmentModule_closure3()); + return A._EnvironmentModule$_(environment, css, t1, extensionStore, t2, t3, t4, t7, t6, t5, !extensionStore.get$isEmpty(extensionStore) || B.JSArray_methods.any$1(environment._allModules, new A._EnvironmentModule__EnvironmentModule_closure4())); + }, + _EnvironmentModule__makeModulesByVariable(forwarded) { + var modulesByVariable, t1, t2, t3, t4, t5; + if (forwarded.get$isEmpty(forwarded)) + return B.Map_empty1; + modulesByVariable = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.Module_Callable); + for (t1 = forwarded.get$iterator(forwarded); t1.moveNext$0();) { + t2 = t1.get$current(t1); + if (t2 instanceof A._EnvironmentModule) { + for (t3 = t2._modulesByVariable, t3 = t3.get$values(t3), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t5 = t4.get$variables(); + A.setAll(modulesByVariable, t5.get$keys(t5), t4); + } + A.setAll(modulesByVariable, J.get$keys$z(B.JSArray_methods.get$first(t2._environment$_environment._variables)), t2); + } else { + t3 = t2.get$variables(); + A.setAll(modulesByVariable, t3.get$keys(t3), t2); + } + } + return modulesByVariable; + }, + _EnvironmentModule__memberMap(localMap, otherMaps, $V) { + var t1, t2, t3; + localMap = new A.PublicMemberMapView(localMap, $V._eval$1("PublicMemberMapView<0>")); + if (otherMaps.get$isEmpty(otherMaps)) + return localMap; + t1 = A._setArrayType([], $V._eval$1("JSArray>")); + for (t2 = otherMaps.get$iterator(otherMaps); t2.moveNext$0();) { + t3 = t2.get$current(t2); + if (t3.get$isNotEmpty(t3)) + t1.push(t3); + } + t1.push(localMap); + if (t1.length === 1) + return localMap; + return A.MergedMapView$(t1, type$.String, $V); + }, + _EnvironmentModule$_(_environment, css, preModuleComments, extensionStore, _modulesByVariable, variables, variableNodes, functions, mixins, transitivelyContainsCss, transitivelyContainsExtensions) { + return new A._EnvironmentModule(_environment._allModules, variables, variableNodes, functions, mixins, extensionStore, css, preModuleComments, transitivelyContainsCss, transitivelyContainsExtensions, _environment, _modulesByVariable); + }, + Environment: function Environment(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14) { + var _ = this; + _._environment$_modules = t0; + _._namespaceNodes = t1; + _._globalModules = t2; + _._importedModules = t3; + _._forwardedModules = t4; + _._nestedForwardedModules = t5; + _._allModules = t6; + _._variables = t7; + _._variableNodes = t8; + _._variableIndices = t9; + _._functions = t10; + _._functionIndices = t11; + _._mixins = t12; + _._mixinIndices = t13; + _._content = t14; + _._inMixin = false; + _._inSemiGlobalScope = true; + _._lastVariableIndex = _._lastVariableName = null; + }, + Environment__getVariableFromGlobalModule_closure: function Environment__getVariableFromGlobalModule_closure(t0) { + this.name = t0; + }, + Environment_setVariable_closure: function Environment_setVariable_closure(t0, t1) { + this.$this = t0; + this.name = t1; + }, + Environment_setVariable_closure0: function Environment_setVariable_closure0(t0) { + this.name = t0; + }, + Environment_setVariable_closure1: function Environment_setVariable_closure1(t0, t1) { + this.$this = t0; + this.name = t1; + }, + Environment__getFunctionFromGlobalModule_closure: function Environment__getFunctionFromGlobalModule_closure(t0) { + this.name = t0; + }, + Environment__getMixinFromGlobalModule_closure: function Environment__getMixinFromGlobalModule_closure(t0) { + this.name = t0; + }, + Environment_toModule_closure: function Environment_toModule_closure() { + }, + Environment_toDummyModule_closure: function Environment_toDummyModule_closure() { + }, + _EnvironmentModule: function _EnvironmentModule(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11) { + var _ = this; + _.upstream = t0; + _.variables = t1; + _.variableNodes = t2; + _.functions = t3; + _.mixins = t4; + _.extensionStore = t5; + _.css = t6; + _.preModuleComments = t7; + _.transitivelyContainsCss = t8; + _.transitivelyContainsExtensions = t9; + _._environment$_environment = t10; + _._modulesByVariable = t11; + }, + _EnvironmentModule__EnvironmentModule_closure: function _EnvironmentModule__EnvironmentModule_closure() { + }, + _EnvironmentModule__EnvironmentModule_closure0: function _EnvironmentModule__EnvironmentModule_closure0() { + }, + _EnvironmentModule__EnvironmentModule_closure1: function _EnvironmentModule__EnvironmentModule_closure1() { + }, + _EnvironmentModule__EnvironmentModule_closure2: function _EnvironmentModule__EnvironmentModule_closure2() { + }, + _EnvironmentModule__EnvironmentModule_closure3: function _EnvironmentModule__EnvironmentModule_closure3() { + }, + _EnvironmentModule__EnvironmentModule_closure4: function _EnvironmentModule__EnvironmentModule_closure4() { + }, + SassException$(message, span, loadedUrls) { + return new A.SassException(loadedUrls == null ? B.Set_empty : A.Set_Set$unmodifiable(loadedUrls, type$.Uri), message, span); + }, + MultiSpanSassException$(message, span, primaryLabel, secondarySpans, loadedUrls) { + var t1 = A.ConstantMap_ConstantMap$from(secondarySpans, type$.FileSpan, type$.String); + return new A.MultiSpanSassException(primaryLabel, t1, loadedUrls == null ? B.Set_empty : A.Set_Set$unmodifiable(loadedUrls, type$.Uri), message, span); + }, + SassRuntimeException$(message, span, trace, loadedUrls) { + return new A.SassRuntimeException(trace, loadedUrls == null ? B.Set_empty : A.Set_Set$unmodifiable(loadedUrls, type$.Uri), message, span); + }, + MultiSpanSassRuntimeException$(message, span, primaryLabel, secondarySpans, trace, loadedUrls) { + var t1 = A.ConstantMap_ConstantMap$from(secondarySpans, type$.FileSpan, type$.String); + return new A.MultiSpanSassRuntimeException(trace, primaryLabel, t1, loadedUrls == null ? B.Set_empty : A.Set_Set$unmodifiable(loadedUrls, type$.Uri), message, span); + }, + SassFormatException$(message, span, loadedUrls) { + return new A.SassFormatException(loadedUrls == null ? B.Set_empty : A.Set_Set$unmodifiable(loadedUrls, type$.Uri), message, span); + }, + MultiSpanSassFormatException$(message, span, primaryLabel, secondarySpans, loadedUrls) { + var t1 = A.ConstantMap_ConstantMap$from(secondarySpans, type$.FileSpan, type$.String); + return new A.MultiSpanSassFormatException(primaryLabel, t1, loadedUrls == null ? B.Set_empty : A.Set_Set$unmodifiable(loadedUrls, type$.Uri), message, span); + }, + SassScriptException$(message, argumentName) { + return new A.SassScriptException(argumentName == null ? message : "$" + argumentName + ": " + message); + }, + MultiSpanSassScriptException$(message, primaryLabel, secondarySpans) { + var t1 = A.ConstantMap_ConstantMap$from(secondarySpans, type$.FileSpan, type$.String); + return new A.MultiSpanSassScriptException(primaryLabel, t1, message); + }, + SassException: function SassException(t0, t1, t2) { + this.loadedUrls = t0; + this._span_exception$_message = t1; + this._span = t2; + }, + MultiSpanSassException: function MultiSpanSassException(t0, t1, t2, t3, t4) { + var _ = this; + _.primaryLabel = t0; + _.secondarySpans = t1; + _.loadedUrls = t2; + _._span_exception$_message = t3; + _._span = t4; + }, + SassRuntimeException: function SassRuntimeException(t0, t1, t2, t3) { + var _ = this; + _.trace = t0; + _.loadedUrls = t1; + _._span_exception$_message = t2; + _._span = t3; + }, + MultiSpanSassRuntimeException: function MultiSpanSassRuntimeException(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.trace = t0; + _.primaryLabel = t1; + _.secondarySpans = t2; + _.loadedUrls = t3; + _._span_exception$_message = t4; + _._span = t5; + }, + SassFormatException: function SassFormatException(t0, t1, t2) { + this.loadedUrls = t0; + this._span_exception$_message = t1; + this._span = t2; + }, + MultiSpanSassFormatException: function MultiSpanSassFormatException(t0, t1, t2, t3, t4) { + var _ = this; + _.primaryLabel = t0; + _.secondarySpans = t1; + _.loadedUrls = t2; + _._span_exception$_message = t3; + _._span = t4; + }, + SassScriptException: function SassScriptException(t0) { + this.message = t0; + }, + MultiSpanSassScriptException: function MultiSpanSassScriptException(t0, t1, t2) { + this.primaryLabel = t0; + this.secondarySpans = t1; + this.message = t2; + }, + compileStylesheet(options, graph, source, destination, ifModified) { + return A.compileStylesheet$body(options, graph, source, destination, ifModified); + }, + compileStylesheet$body(options, graph, source, destination, ifModified) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Record_3_int_and_String_and_nullable_String), + $async$returnValue, $async$handler = 2, $async$errorStack = [], error, stackTrace, message, error0, stackTrace0, path, message0, exception, t1, $async$exception; + var $async$compileStylesheet = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$handler = 4; + $async$goto = 7; + return A._asyncAwait(A._compileStylesheetWithoutErrorHandling(options, graph, source, destination, ifModified), $async$compileStylesheet); + case 7: + // returning from await. + $async$handler = 2; + // goto after finally + $async$goto = 6; + break; + case 4: + // catch + $async$handler = 3; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (t1 instanceof A.SassException) { + error = t1; + stackTrace = A.getTraceFromException($async$exception); + if (destination != null && !options.get$emitErrorCss()) + A._tryDelete(destination); + message = J.toString$1$color$(error, options.get$color()); + if (A._asBool(options._options.$index(0, "trace"))) { + t1 = A.getTrace(error); + if (t1 == null) + t1 = stackTrace; + } else + t1 = null; + $async$returnValue = A._getErrorWithStackTrace(65, message, t1); + // goto return + $async$goto = 1; + break; + } else if (t1 instanceof A.FileSystemException) { + error0 = t1; + stackTrace0 = A.getTraceFromException($async$exception); + path = error0.path; + message0 = path == null ? error0.message : "Error reading " + $.$get$context().relative$2$from(path, null) + ": " + error0.message + "."; + if (A._asBool(options._options.$index(0, "trace"))) { + t1 = A.getTrace(error0); + if (t1 == null) + t1 = stackTrace0; + } else + t1 = null; + $async$returnValue = A._getErrorWithStackTrace(66, message0, t1); + // goto return + $async$goto = 1; + break; + } else + throw $async$exception; + // goto after finally + $async$goto = 6; + break; + case 3: + // uncaught + // goto rethrow + $async$goto = 2; + break; + case 6: + // after finally + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$compileStylesheet, $async$completer); + }, + _compileStylesheetWithoutErrorHandling(options, graph, source, destination, ifModified) { + return A._compileStylesheetWithoutErrorHandling$body(options, graph, source, destination, ifModified); + }, + _compileStylesheetWithoutErrorHandling$body(options, graph, source, destination, ifModified) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$returnValue, $async$handler = 2, $async$errorStack = [], syntax, result, importCache, error, t1, exception, t2, t3, t4, t5, t6, t7, t8, t9, t10, result0, t11, t12, t13, t14, logger, stylesheet, t0, css, buffer, sourceName, destinationName, nowStr, timestamp, importer, $async$exception; + var $async$_compileStylesheetWithoutErrorHandling = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + importer = $.$get$FilesystemImporter_cwd(); + if (ifModified) + try { + t1 = false; + if (source != null) + if (destination != null) { + t1 = A.absolute(source, null, null, null, null, null, null, null, null, null, null, null, null, null, null); + t1 = !graph.modifiedSince$3($.$get$context().toUri$1(t1), A.modificationTime(destination), importer); + } + if (t1) { + // goto return + $async$goto = 1; + break; + } + } catch (exception) { + if (!(A.unwrapException(exception) instanceof A.FileSystemException)) + throw exception; + } + syntax = null; + if (A._asBoolQ(options._ifParsed$1("indented")) === true) + syntax = B.Syntax_Sass_sass; + else if (source != null) + syntax = A.Syntax_forPath(source); + else + syntax = B.Syntax_SCSS_scss; + result = null; + $async$handler = 4; + t1 = options._options; + $async$goto = A._asBool(t1.$index(0, "async")) ? 7 : 9; + break; + case 7: + // then + t2 = type$.nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl; + t3 = type$.Record_3_AsyncImporter_and_Uri_and_bool_forImport; + t4 = type$.Uri; + importCache = new A.AsyncImportCache(A.AsyncImportCache__toImporters(options.get$pkgImporters(), type$.List_String._as(t1.$index(0, "load-path")), null), A.LinkedHashMap_LinkedHashMap$_empty(type$.Record_2_Uri_and_bool_forImport, t2), A.LinkedHashMap_LinkedHashMap$_empty(t3, t2), A.LinkedHashMap_LinkedHashMap$_empty(t3, t4), A.LinkedHashMap_LinkedHashMap$_empty(t4, type$.nullable_Stylesheet), A.LinkedHashMap_LinkedHashMap$_empty(t4, type$.ImporterResult), A.LinkedHashMap_LinkedHashMap$_empty(t4, type$.DateTime)); + $async$goto = source == null ? 10 : 12; + break; + case 10: + // then + $async$goto = 13; + return A._asyncAwait(A.readStdin(), $async$_compileStylesheetWithoutErrorHandling); + case 13: + // returning from await. + t2 = $async$result; + t3 = syntax; + t4 = A._asBool(t1.$index(0, "quiet")) ? $.$get$Logger_quiet() : new A.StderrLogger(options.get$color()); + t5 = $.$get$FilesystemImporter_cwd(); + t6 = J.$eq$(t1.$index(0, "style"), "compressed") ? B.OutputStyle_1 : B.OutputStyle_0; + t7 = A._asBool(t1.$index(0, "quiet-deps")); + t8 = A._asBool(t1.$index(0, "verbose")); + t9 = options.get$emitSourceMap(); + t1 = A._asBool(t1.$index(0, "charset")); + t10 = options.get$silenceDeprecations(0); + $async$goto = 14; + return A._asyncAwait(A.compileStringAsync(t2, t1, options.get$fatalDeprecations(0), options.get$futureDeprecations(0), importCache, t5, t4, t7, t10, t9, t6, t3, t8), $async$_compileStylesheetWithoutErrorHandling); + case 14: + // returning from await. + result0 = $async$result; + // goto join + $async$goto = 11; + break; + case 12: + // else + t2 = syntax; + t3 = A._asBool(t1.$index(0, "quiet")) ? $.$get$Logger_quiet() : new A.StderrLogger(options.get$color()); + t4 = J.$eq$(t1.$index(0, "style"), "compressed") ? B.OutputStyle_1 : B.OutputStyle_0; + t5 = A._asBool(t1.$index(0, "quiet-deps")); + t6 = A._asBool(t1.$index(0, "verbose")); + t7 = options.get$emitSourceMap(); + t1 = A._asBool(t1.$index(0, "charset")); + t8 = options.get$silenceDeprecations(0); + $async$goto = 15; + return A._asyncAwait(A.compileAsync(source, t1, options.get$fatalDeprecations(0), options.get$futureDeprecations(0), importCache, t3, t5, t8, t7, t4, t2, t6), $async$_compileStylesheetWithoutErrorHandling); + case 15: + // returning from await. + result0 = $async$result; + case 11: + // join + result = result0; + // goto join + $async$goto = 8; + break; + case 9: + // else + graph.reloadAllModified$0(); + $async$goto = source == null ? 16 : 18; + break; + case 16: + // then + $async$goto = 19; + return A._asyncAwait(A.readStdin(), $async$_compileStylesheetWithoutErrorHandling); + case 19: + // returning from await. + t2 = $async$result; + t3 = syntax; + t4 = A._asBool(t1.$index(0, "quiet")) ? $.$get$Logger_quiet() : new A.StderrLogger(options.get$color()); + t5 = $.$get$FilesystemImporter_cwd(); + t6 = J.$eq$(t1.$index(0, "style"), "compressed") ? B.OutputStyle_1 : B.OutputStyle_0; + t7 = A._asBool(t1.$index(0, "quiet-deps")); + t8 = A._asBool(t1.$index(0, "verbose")); + t9 = options.get$emitSourceMap(); + t1 = A._asBool(t1.$index(0, "charset")); + t10 = options.get$silenceDeprecations(0); + t11 = options.get$fatalDeprecations(0); + t12 = options.get$futureDeprecations(0); + t13 = type$.Deprecation; + t14 = A.LinkedHashSet_LinkedHashSet$_empty(t13); + t14.addAll$1(0, t10); + t10 = A.LinkedHashSet_LinkedHashSet$_empty(t13); + t10.addAll$1(0, t11); + t11 = A.LinkedHashSet_LinkedHashSet$_empty(t13); + t11.addAll$1(0, t12); + logger = new A.DeprecationProcessingLogger(A.LinkedHashMap_LinkedHashMap$_empty(t13, type$.int), t4, t14, t10, t11, !t8); + logger.validate$0(); + stylesheet = A.Stylesheet_Stylesheet$parse(t2, t3 == null ? B.Syntax_SCSS_scss : t3, null); + result0 = A._compileStylesheet(stylesheet, logger, graph.importCache, null, t5, null, t6, true, null, null, t7, t9, t1); + logger.summarize$1$js(false); + // goto join + $async$goto = 17; + break; + case 18: + // else + t2 = syntax; + t3 = A._asBool(t1.$index(0, "quiet")) ? $.$get$Logger_quiet() : new A.StderrLogger(options.get$color()); + importCache = graph.importCache; + t4 = J.$eq$(t1.$index(0, "style"), "compressed") ? B.OutputStyle_1 : B.OutputStyle_0; + t5 = A._asBool(t1.$index(0, "quiet-deps")); + t6 = A._asBool(t1.$index(0, "verbose")); + t7 = options.get$emitSourceMap(); + t1 = A._asBool(t1.$index(0, "charset")); + t8 = options.get$silenceDeprecations(0); + t9 = options.get$fatalDeprecations(0); + t10 = options.get$futureDeprecations(0); + t11 = type$.Deprecation; + t12 = A.LinkedHashSet_LinkedHashSet$_empty(t11); + t12.addAll$1(0, t8); + t8 = A.LinkedHashSet_LinkedHashSet$_empty(t11); + t8.addAll$1(0, t9); + t9 = A.LinkedHashSet_LinkedHashSet$_empty(t11); + t9.addAll$1(0, t10); + logger = new A.DeprecationProcessingLogger(A.LinkedHashMap_LinkedHashMap$_empty(t11, type$.int), t3, t12, t8, t9, !t6); + logger.validate$0(); + t3 = t2 == null || t2 === A.Syntax_forPath(source); + if (t3) { + t2 = $.$get$FilesystemImporter_cwd(); + t3 = A.isNodeJs() ? self.process : null; + if (!J.$eq$(t3 == null ? null : J.get$platform$x(t3), "win32")) { + t3 = A.isNodeJs() ? self.process : null; + t3 = J.$eq$(t3 == null ? null : J.get$platform$x(t3), "darwin"); + } else + t3 = true; + if (t3) { + t3 = A.absolute(source, null, null, null, null, null, null, null, null, null, null, null, null, null, null); + t6 = $.$get$context(); + t3 = A._realCasePath(t6.normalize$1(t3)); + } else { + t3 = $.$get$context(); + t6 = t3.canonicalize$1(0, source); + t0 = t6; + t6 = t3; + t3 = t0; + } + t6 = importCache.importCanonical$3$originalUrl(t2, t6.toUri$1(t3), t6.toUri$1(source)); + t6.toString; + stylesheet = t6; + } else { + t3 = A.readFile(source); + if (t2 == null) + t2 = A.Syntax_forPath(source); + stylesheet = A.Stylesheet_Stylesheet$parse(t3, t2, $.$get$context().toUri$1(source)); + } + result0 = A._compileStylesheet(stylesheet, logger, importCache, null, $.$get$FilesystemImporter_cwd(), null, t4, true, null, null, t5, t7, t1); + logger.summarize$1$js(false); + case 17: + // join + result = result0; + case 8: + // join + $async$handler = 2; + // goto after finally + $async$goto = 6; + break; + case 4: + // catch + $async$handler = 3; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (t1 instanceof A.SassException) { + error = t1; + if (options.get$emitErrorCss()) + if (destination == null) + A.print(error.toCssString$0()); + else { + A.ensureDir($.$get$context().dirname$1(destination)); + A.writeFile(destination, error.toCssString$0() + "\n"); + } + throw $async$exception; + } else + throw $async$exception; + // goto after finally + $async$goto = 6; + break; + case 3: + // uncaught + // goto rethrow + $async$goto = 2; + break; + case 6: + // after finally + css = result._serialize._0 + A._writeSourceMap(options, result._serialize._1, destination); + if (destination == null) { + if (css.length !== 0) + A.print(css); + } else { + A.ensureDir($.$get$context().dirname$1(destination)); + A.writeFile(destination, css + "\n"); + } + t1 = options._options; + if (!A._asBool(t1.$index(0, "quiet"))) + t1 = !A._asBool(t1.$index(0, "update")) && !A._asBool(t1.$index(0, "watch")); + else + t1 = true; + if (t1) { + // goto return + $async$goto = 1; + break; + } + buffer = new A.StringBuffer(""); + if (source == null) + sourceName = "stdin"; + else { + t1 = $.$get$context(); + sourceName = t1.prettyUri$1(t1.toUri$1(source)); + } + destination.toString; + t1 = $.$get$context(); + destinationName = t1.prettyUri$1(t1.toUri$1(destination)); + nowStr = new A.DateTime(Date.now(), 0, false).toString$0(0); + timestamp = B.JSString_methods.substring$2(nowStr, 0, nowStr.length - 7); + t1 = options.get$color() ? buffer._contents = "" + "\x1b[90m" : ""; + t1 = buffer._contents = t1 + ("[" + timestamp + "] "); + if (options.get$color()) + t1 = buffer._contents = t1 + "\x1b[32m"; + t1 += "Compiled " + sourceName + " to " + destinationName + "."; + buffer._contents = t1; + if (options.get$color()) + buffer._contents = t1 + "\x1b[0m"; + t1 = A.isNodeJs() ? self.process : null; + if (t1 != null) { + t1 = J.get$stdout$x(t1); + J.write$1$x(t1, buffer.toString$0(0) + "\n"); + } else { + t1 = self.console; + J.log$1$x(t1, buffer); + } + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$_compileStylesheetWithoutErrorHandling, $async$completer); + }, + _writeSourceMap(options, sourceMap, destination) { + var t1, sourceMapText, url, sourceMapPath, t2, escapedUrl; + if (sourceMap == null) + return ""; + if (destination != null) { + t1 = $.$get$context(); + sourceMap.targetUrl = t1.toUri$1(A.ParsedPath_ParsedPath$parse(destination, t1.style).get$basename()).toString$0(0); + } + A.mapInPlace(sourceMap.urls, new A._writeSourceMap_closure(options, destination)); + t1 = options._options; + sourceMapText = B.C_JsonCodec.encode$2$toEncodable(sourceMap.toJson$1$includeSourceContents(A._asBool(t1.$index(0, "embed-sources"))), null); + if (A._asBool(t1.$index(0, "embed-source-map"))) + url = A.Uri_Uri$dataFromString(sourceMapText, B.C_Utf8Codec, "application/json"); + else { + destination.toString; + sourceMapPath = destination + ".map"; + t2 = $.$get$context(); + A.ensureDir(t2.dirname$1(sourceMapPath)); + A.writeFile(sourceMapPath, sourceMapText); + url = t2.toUri$1(t2.relative$2$from(sourceMapPath, t2.dirname$1(destination))); + } + t2 = url.toString$0(0); + escapedUrl = A.stringReplaceAllUnchecked(t2, "*/", "%2A/"); + t1 = (J.$eq$(t1.$index(0, "style"), "compressed") ? B.OutputStyle_1 : B.OutputStyle_0) === B.OutputStyle_1 ? "" : "\n\n"; + return t1 + ("/*# sourceMappingURL=" + escapedUrl + " */"); + }, + _tryDelete(path) { + var exception; + try { + A.deleteFile(path); + } catch (exception) { + if (!(A.unwrapException(exception) instanceof A.FileSystemException)) + throw exception; + } + }, + _getErrorWithStackTrace(exitCode, error, stackTrace) { + return new A._Record_3(exitCode, error, stackTrace != null ? B.JSString_methods.trimRight$0(A.Trace_Trace$from(stackTrace).get$terse().toString$0(0)) : null); + }, + _writeSourceMap_closure: function _writeSourceMap_closure(t0, t1) { + this.options = t0; + this.destination = t1; + }, + ExecutableOptions__separator(text) { + var t1 = $.$get$ExecutableOptions__separatorBar(), + t2 = B.JSString_methods.$mul(t1, 3), + t3 = A.hasTerminal() ? "\x1b[1m" : "", + t4 = A.hasTerminal() ? "\x1b[0m" : ""; + return t2 + " " + t3 + text + t4 + " " + B.JSString_methods.$mul(t1, 35 - text.length); + }, + ExecutableOptions__fail(message) { + return A.throwExpression(A.UsageException$(message)); + }, + ExecutableOptions_ExecutableOptions$parse(args) { + var options, error, t1, t2, exception; + try { + t1 = $.$get$ExecutableOptions__parser(); + t2 = A.ListQueue$(type$.String); + t2.addAll$1(0, args); + t2 = A.Parser$(null, t1, t2, null, null).parse$0(0); + if (t2.wasParsed$1("poll") && !A._asBool(t2.$index(0, "watch"))) + A.ExecutableOptions__fail("--poll may not be passed without --watch."); + options = new A.ExecutableOptions(t2); + if (A._asBool(options._options.$index(0, "help"))) + A.ExecutableOptions__fail("Compile Sass to CSS."); + return options; + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.FormatException._is(t1)) { + error = t1; + A.ExecutableOptions__fail(J.get$message$x(error)); + } else + throw exception; + } + }, + UsageException$(message) { + return new A.UsageException(message); + }, + ExecutableOptions: function ExecutableOptions(t0) { + var _ = this; + _._options = t0; + _.__ExecutableOptions_interactive_FI = $; + _._sourcesToDestinations = null; + _.__ExecutableOptions__sourceDirectoriesToDestinations_F = $; + _._fatalDeprecations = null; + }, + ExecutableOptions__parser_closure: function ExecutableOptions__parser_closure() { + }, + ExecutableOptions_interactive_closure: function ExecutableOptions_interactive_closure(t0) { + this.$this = t0; + }, + ExecutableOptions_emitErrorCss_closure: function ExecutableOptions_emitErrorCss_closure() { + }, + ExecutableOptions_fatalDeprecations_closure: function ExecutableOptions_fatalDeprecations_closure(t0) { + this.$this = t0; + }, + UsageException: function UsageException(t0) { + this.message = t0; + }, + repl(options) { + return A.repl$body(options); + }, + repl$body(options) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$handler = 1, $async$errorStack = [], $async$next = [], repl, trackingLogger, warn, evaluator, line, node, warnings, _1_0, node0, warnings0, _2_0, node1, warnings1, _3_0, error, stackTrace, logger, t4, t5, t6, t7, t8, t9, line0, toZone, exception, t1, t2, t3, repl0; + var $async$repl = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = A._setArrayType([], type$.JSArray_String); + t2 = B.JSString_methods.$mul(" ", 3); + t3 = $.$get$alwaysValid(); + repl0 = new A.Repl(">> ", t2, t3, t1); + repl0.__Repl__adapter_A = new A.ReplAdapter(repl0); + repl = repl0; + t1 = options._options; + trackingLogger = new A.TrackingLogger(A._asBool(t1.$index(0, "quiet")) ? $.$get$Logger_quiet() : new A.StderrLogger(options.get$color())); + logger = new A.DeprecationProcessingLogger(A.LinkedHashMap_LinkedHashMap$_empty(type$.Deprecation, type$.int), trackingLogger, options.get$silenceDeprecations(0), options.get$fatalDeprecations(0), options.get$futureDeprecations(0), !A._asBool(t1.$index(0, "verbose"))); + logger.validate$0(); + warn = new A.repl_warn(logger); + t2 = $.$get$FilesystemImporter_cwd(); + evaluator = new A.Evaluator(A._EvaluateVisitor$(null, A.ImportCache$(options.get$pkgImporters(), type$.List_String._as(t1.$index(0, "load-path"))), logger, null, false, false), t2); + t2 = repl.__Repl__adapter_A; + t2 === $ && A.throwUnnamedLateFieldNI(); + t2 = new A._StreamIterator(A.checkNotNullable(t2.runAsync$0(), "stream", type$.Object)); + $async$handler = 2; + t1 = type$.String, t3 = type$.FileSpan, t4 = type$.JSArray_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span, t5 = type$.Expression; + case 5: + // for condition + $async$goto = 7; + return A._asyncAwait(t2.moveNext$0(), $async$repl); + case 7: + // returning from await. + if (!$async$result) { + // goto after for + $async$goto = 6; + break; + } + line = t2.get$current(0); + if (J.trim$0$s(line).length === 0) { + // goto for condition + $async$goto = 5; + break; + } + try { + if (J.startsWith$1$s(line, "@")) { + node = null; + warnings = null; + _1_0 = new A.ScssParser(A.LinkedHashMap_LinkedHashMap$_empty(t1, t3), A._setArrayType([], t4), A.SpanScanner$(line, null), null).parseUseRule$0(); + node = _1_0._0; + warnings = _1_0._1; + J.forEach$1$ax(warnings, warn); + t6 = evaluator; + t7 = node; + t6._visitor.runStatement$2(t6._importer, t7); + // goto for condition + $async$goto = 5; + break; + } + if (new A.Parser(A.SpanScanner$(line, null), null)._isVariableDeclarationLike$0()) { + node0 = null; + warnings0 = null; + _2_0 = new A.ScssParser(A.LinkedHashMap_LinkedHashMap$_empty(t1, t3), A._setArrayType([], t4), A.SpanScanner$(line, null), null).parseVariableDeclaration$0(); + node0 = _2_0._0; + warnings0 = _2_0._1; + J.forEach$1$ax(warnings0, warn); + t6 = evaluator; + t7 = node0; + t6._visitor.runStatement$2(t6._importer, t7); + t7 = evaluator; + t6 = node0.name; + t8 = node0.span; + t9 = node0.namespace; + line0 = t7._visitor.runExpression$2(t7._importer, new A.VariableExpression(t9, t6, t8)).toString$0(0); + toZone = $.printToZone; + if (toZone == null) + A.printString(line0); + else + toZone.call$1(line0); + } else { + node1 = null; + warnings1 = null; + t6 = A._setArrayType([], t4); + t7 = new A.ScssParser(A.LinkedHashMap_LinkedHashMap$_empty(t1, t3), t6, A.SpanScanner$(line, null), null); + _3_0 = new A._Record_2(t7._parseSingleProduction$1$1(t7.get$_expression(), t5), t6); + node1 = _3_0._0; + warnings1 = _3_0._1; + J.forEach$1$ax(warnings1, warn); + t6 = evaluator; + t7 = node1; + line0 = t6._visitor.runExpression$2(t6._importer, t7).toString$0(0); + toZone = $.printToZone; + if (toZone == null) + A.printString(line0); + else + toZone.call$1(line0); + } + } catch (exception) { + t6 = A.unwrapException(exception); + if (t6 instanceof A.SassException) { + error = t6; + stackTrace = A.getTraceFromException(exception); + t6 = error; + t7 = typeof t6 != "string"; + if (!t7 || typeof t6 == "number" || A._isBool(t6)) + t6 = null; + else { + t8 = $.$get$_traces(); + if (A._isBool(t6) || typeof t6 == "number" || !t7 || t6 instanceof A._Record) + A.Expando__badExpandoKey(t6); + t6 = t8._jsWeakMap.get(t6); + } + if (t6 == null) + t6 = stackTrace; + A._logError(error, t6, line, repl, options, trackingLogger); + } else + throw exception; + } + // goto for condition + $async$goto = 5; + break; + case 6: + // after for + $async$next.push(4); + // goto finally + $async$goto = 3; + break; + case 2: + // uncaught + $async$next = [1]; + case 3: + // finally + $async$handler = 1; + $async$goto = 8; + return A._asyncAwait(t2.cancel$0(), $async$repl); + case 8: + // returning from await. + // goto the next finally handler + $async$goto = $async$next.pop(); + break; + case 4: + // after finally + // implicit return + return A._asyncReturn(null, $async$completer); + case 1: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$repl, $async$completer); + }, + _logError(error, stackTrace, line, repl, options, logger) { + var t2, spacesBeforeError, t3, + t1 = A.SourceSpanException.prototype.get$span.call(error, 0); + if (t1.get$sourceUrl(t1) == null) + if (!A._asBool(options._options.$index(0, "quiet"))) + t1 = logger._emittedDebug || logger._emittedWarning; + else + t1 = false; + else + t1 = true; + if (t1) { + A.print(error.toString$1$color(0, options.get$color())); + return; + } + t1 = options.get$color() ? "" + "\x1b[31m" : ""; + t2 = A.SourceSpanException.prototype.get$span.call(error, 0); + t2 = t2.get$start(t2); + spacesBeforeError = repl.prompt.length + t2.file.getColumn$1(t2.offset); + if (options.get$color()) { + t2 = A.SourceSpanException.prototype.get$span.call(error, 0); + t2 = t2.get$start(t2); + t2 = t2.file.getColumn$1(t2.offset) < line.length; + } else + t2 = false; + if (t2) + t1 = t1 + ("\x1b[1F\x1b[" + spacesBeforeError + "C") + (A.SourceSpanException.prototype.get$span.call(error, 0).get$text() + "\n"); + t2 = B.JSString_methods.$mul(" ", spacesBeforeError); + t3 = A.SourceSpanException.prototype.get$span.call(error, 0); + t3 = t1 + t2 + (B.JSString_methods.$mul("^", Math.max(1, t3.get$length(t3))) + "\n"); + t1 = options.get$color() ? t3 + "\x1b[0m" : t3; + t1 += "Error: " + error._span_exception$_message + "\n"; + if (A._asBool(options._options.$index(0, "trace"))) + t1 += A.Trace_Trace$from(stackTrace).get$terse().toString$0(0); + A.print(B.JSString_methods.trimRight$0(t1.charCodeAt(0) == 0 ? t1 : t1)); + }, + repl_warn: function repl_warn(t0) { + this.logger = t0; + }, + watch(options, graph) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$returnValue, t1, t2, t3, t4, t5, t6, dirWatcher, sourcesToDestinations, t7, t0; + var $async$watch = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + options._ensureSources$0(); + t1 = options.__ExecutableOptions__sourceDirectoriesToDestinations_F; + t1 === $ && A.throwUnnamedLateFieldNI(); + t2 = type$.String; + t1 = t1.cast$2$0(0, t2, t2); + t1 = A.List_List$of(t1.get$keys(t1), true, t2); + for (options._ensureSources$0(), t3 = options._sourcesToDestinations.cast$2$0(0, t2, t2), t3 = J.get$iterator$ax(t3.get$keys(t3)); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t1.push($.$get$context().dirname$1(t4)); + } + t3 = options._options; + B.JSArray_methods.addAll$1(t1, type$.List_String._as(t3.$index(0, "load-path"))); + t4 = A._asBool(t3.$index(0, "poll")); + t5 = type$.Stream_WatchEvent; + t6 = A.PathMap__create(null, t5); + t5 = new A.StreamGroup(B._StreamGroupState_dormant, A.LinkedHashMap_LinkedHashMap$_empty(t5, type$.nullable_StreamSubscription_WatchEvent), type$.StreamGroup_WatchEvent); + t5.__StreamGroup__controller_A = A.StreamController_StreamController(t5.get$_onCancel(), t5.get$_onListen(), t5.get$_onPause(), t5.get$_onResume(), true, type$.WatchEvent); + dirWatcher = new A.MultiDirWatcher(new A.PathMap(t6, type$.PathMap_Stream_WatchEvent), t5, t4); + $async$goto = 3; + return A._asyncAwait(A.Future_wait(new A.MappedListIterable(t1, new A.watch_closure(dirWatcher), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Future<~>>")), false, type$.void), $async$watch); + case 3: + // returning from await. + options._ensureSources$0(); + sourcesToDestinations = options._sourcesToDestinations.cast$2$0(0, t2, t2); + for (t1 = J.get$iterator$ax(sourcesToDestinations.get$keys(sourcesToDestinations)); t1.moveNext$0();) { + t4 = t1.get$current(t1); + t5 = $.$get$FilesystemImporter_cwd(); + t6 = self.process; + if (t6 == null) + t6 = null; + else { + t6 = J.get$release$x(t6); + t6 = t6 == null ? null : J.get$name$x(t6); + } + t6 = J.$eq$(t6, "node") ? self.process : null; + if (!J.$eq$(t6 == null ? null : J.get$platform$x(t6), "win32")) { + t6 = self.process; + if (t6 == null) + t6 = null; + else { + t6 = J.get$release$x(t6); + t6 = t6 == null ? null : J.get$name$x(t6); + } + t6 = J.$eq$(t6, "node") ? self.process : null; + t6 = J.$eq$(t6 == null ? null : J.get$platform$x(t6), "darwin"); + } else + t6 = true; + if (t6) { + t6 = $.$get$context(); + t7 = A._realCasePath(t6.normalize$1(t6.absolute$15(t4, null, null, null, null, null, null, null, null, null, null, null, null, null, null))); + t0 = t7; + t7 = t6; + t6 = t0; + } else { + t6 = $.$get$context(); + t7 = t6.canonicalize$1(0, t4); + t0 = t7; + t7 = t6; + t6 = t0; + } + graph.addCanonical$4$recanonicalize(t5, t7.toUri$1(t6), t7.toUri$1(t4), false); + } + $async$goto = 4; + return A._asyncAwait(A.compileStylesheets(options, graph, sourcesToDestinations, true), $async$watch); + case 4: + // returning from await. + if (!$async$result && A._asBool(t3.$index(0, "stop-on-error"))) { + t1 = dirWatcher._group.__StreamGroup__controller_A; + t1 === $ && A.throwUnnamedLateFieldNI(); + new A._ControllerStream(t1, A._instanceType(t1)._eval$1("_ControllerStream<1>")).listen$1(0, null).cancel$0(); + // goto return + $async$goto = 1; + break; + } + A.print("Sass is watching for changes. Press Ctrl-C to stop.\n"); + $async$goto = 5; + return A._asyncAwait(new A._Watcher(options, graph, A.LinkedHashMap_LinkedHashMap$_empty(t2, t2)).watch$1(0, dirWatcher), $async$watch); + case 5: + // returning from await. + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$watch, $async$completer); + }, + watch_closure: function watch_closure(t0) { + this.dirWatcher = t0; + }, + _Watcher: function _Watcher(t0, t1, t2) { + this._watch$_options = t0; + this._graph = t1; + this._toRecompile = t2; + }, + _Watcher__debounceEvents_closure: function _Watcher__debounceEvents_closure() { + }, + EmptyExtensionStore: function EmptyExtensionStore() { + }, + Extension: function Extension(t0, t1, t2, t3, t4) { + var _ = this; + _.extender = t0; + _.target = t1; + _.mediaContext = t2; + _.isOptional = t3; + _.span = t4; + }, + Extender: function Extender(t0, t1) { + this.selector = t0; + this.isOriginal = t1; + this._extension = null; + }, + ExtensionStore__extendOrReplace(selector, source, targets, mode, span) { + var t1, t2, t3, t4, t5, t6, t7, t8, _i, complex, compound, t9, t10, t11, _i0, simple, t12, _i1, t13, t14, + extender = A.ExtensionStore$_mode(mode); + if (!selector.accept$1(B._IsInvisibleVisitor_true)) + extender._originals.addAll$1(0, selector.components); + for (t1 = targets.components, t2 = t1.length, t3 = source.components, t4 = t3.length, t5 = type$.ComplexSelector, t6 = type$.Extension, t7 = type$.SimpleSelector, t8 = type$.Map_ComplexSelector_Extension, _i = 0; _i < t2; ++_i) { + complex = t1[_i]; + compound = complex.get$singleCompound(); + if (compound == null) + throw A.wrapException(A.SassScriptException$("Can't extend complex selector " + complex.toString$0(0) + ".", null)); + t9 = A.LinkedHashMap_LinkedHashMap$_empty(t7, t8); + for (t10 = compound.components, t11 = t10.length, _i0 = 0; _i0 < t11; ++_i0) { + simple = t10[_i0]; + t12 = A.LinkedHashMap_LinkedHashMap$_empty(t5, t6); + for (_i1 = 0; _i1 < t4; ++_i1) { + complex = t3[_i1]; + complex.get$specificity(); + t13 = new A.Extender(complex, false); + t14 = new A.Extension(t13, simple, null, true, span); + t13._extension = t14; + t12.$indexSet(0, complex, t14); + } + t9.$indexSet(0, simple, t12); + } + selector = extender._extendList$2(selector, t9); + } + return selector; + }, + ExtensionStore$() { + var t1 = type$.SimpleSelector; + return new A.ExtensionStore(A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Set_ModifiableBox_SelectorList), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Map_ComplexSelector_Extension), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.List_Extension), A.LinkedHashMap_LinkedHashMap$_empty(type$.ModifiableBox_SelectorList, type$.List_CssMediaQuery), new A.JsIdentityLinkedHashMap(type$.JsIdentityLinkedHashMap_SimpleSelector_int), new A._LinkedIdentityHashSet(type$._LinkedIdentityHashSet_ComplexSelector), B.ExtendMode_normal_normal); + }, + ExtensionStore$_mode(_mode) { + var t1 = type$.SimpleSelector; + return new A.ExtensionStore(A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Set_ModifiableBox_SelectorList), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Map_ComplexSelector_Extension), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.List_Extension), A.LinkedHashMap_LinkedHashMap$_empty(type$.ModifiableBox_SelectorList, type$.List_CssMediaQuery), new A.JsIdentityLinkedHashMap(type$.JsIdentityLinkedHashMap_SimpleSelector_int), new A._LinkedIdentityHashSet(type$._LinkedIdentityHashSet_ComplexSelector), _mode); + }, + ExtensionStore: function ExtensionStore(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._selectors = t0; + _._extensions = t1; + _._extensionsByExtender = t2; + _._mediaContexts = t3; + _._sourceSpecificity = t4; + _._originals = t5; + _._mode = t6; + }, + ExtensionStore_extensionsWhereTarget_closure: function ExtensionStore_extensionsWhereTarget_closure() { + }, + ExtensionStore__registerSelector_closure: function ExtensionStore__registerSelector_closure() { + }, + ExtensionStore_addExtension_closure: function ExtensionStore_addExtension_closure() { + }, + ExtensionStore_addExtension_closure0: function ExtensionStore_addExtension_closure0() { + }, + ExtensionStore_addExtension_closure1: function ExtensionStore_addExtension_closure1(t0) { + this.complex = t0; + }, + ExtensionStore__extendExistingExtensions_closure: function ExtensionStore__extendExistingExtensions_closure() { + }, + ExtensionStore__extendExistingExtensions_closure0: function ExtensionStore__extendExistingExtensions_closure0() { + }, + ExtensionStore_addExtensions_closure: function ExtensionStore_addExtensions_closure() { + }, + ExtensionStore__extendComplex_closure: function ExtensionStore__extendComplex_closure(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.complex = t2; + }, + ExtensionStore__extendComplex__closure: function ExtensionStore__extendComplex__closure(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.complex = t2; + }, + ExtensionStore__extendCompound_closure: function ExtensionStore__extendCompound_closure() { + }, + ExtensionStore__extendCompound_closure0: function ExtensionStore__extendCompound_closure0() { + }, + ExtensionStore__extendCompound_closure1: function ExtensionStore__extendCompound_closure1(t0) { + this.original = t0; + }, + ExtensionStore__extendSimple_withoutPseudo: function ExtensionStore__extendSimple_withoutPseudo(t0, t1, t2) { + this.$this = t0; + this.extensions = t1; + this.targetsUsed = t2; + }, + ExtensionStore__extendSimple_closure: function ExtensionStore__extendSimple_closure(t0, t1) { + this.$this = t0; + this.withoutPseudo = t1; + }, + ExtensionStore__extendSimple_closure0: function ExtensionStore__extendSimple_closure0() { + }, + ExtensionStore__extendPseudo_closure: function ExtensionStore__extendPseudo_closure() { + }, + ExtensionStore__extendPseudo_closure0: function ExtensionStore__extendPseudo_closure0() { + }, + ExtensionStore__extendPseudo_closure1: function ExtensionStore__extendPseudo_closure1() { + }, + ExtensionStore__extendPseudo_closure2: function ExtensionStore__extendPseudo_closure2(t0) { + this.pseudo = t0; + }, + ExtensionStore__extendPseudo_closure3: function ExtensionStore__extendPseudo_closure3(t0, t1) { + this.pseudo = t0; + this.selector = t1; + }, + ExtensionStore__trim_closure: function ExtensionStore__trim_closure(t0, t1) { + this._box_0 = t0; + this.complex1 = t1; + }, + ExtensionStore__trim_closure0: function ExtensionStore__trim_closure0(t0, t1) { + this._box_0 = t0; + this.complex1 = t1; + }, + ExtensionStore_clone_closure: function ExtensionStore_clone_closure(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.newSelectors = t1; + _.oldToNewSelectors = t2; + _.newMediaContexts = t3; + }, + unifyComplex(complexes, span) { + var t2, trailingCombinator, leadingCombinator, unifiedBase, t3, t4, _0_6_isSet, _0_6, t5, newLeadingCombinator, base, _1_1, newTrailingCombinator, unifiedBase0, t6, t7, t8, _null = null, + t1 = J.getInterceptor$asx(complexes); + if (t1.get$length(complexes) === 1) + return complexes; + for (t2 = t1.get$iterator(complexes), trailingCombinator = _null, leadingCombinator = trailingCombinator, unifiedBase = leadingCombinator; t2.moveNext$0();) { + t3 = t2.get$current(t2); + if (t3.accept$1(B.C__IsUselessVisitor)) + return _null; + t4 = t3.components; + _0_6_isSet = t4.length === 1; + if (_0_6_isSet) { + _0_6 = t3.leadingCombinators; + t5 = _0_6.length === 1; + } else { + _0_6 = _null; + t5 = false; + } + if (t5) { + newLeadingCombinator = (_0_6_isSet ? _0_6 : t3.leadingCombinators)[0]; + if (leadingCombinator == null) + leadingCombinator = newLeadingCombinator; + else if (!(leadingCombinator.$ti._is(newLeadingCombinator) && J.$eq$(newLeadingCombinator.value, leadingCombinator.value))) + return _null; + } + base = B.JSArray_methods.get$last(t4); + _1_1 = base.combinators; + if (_1_1.length === 1) { + newTrailingCombinator = _1_1[0]; + if (trailingCombinator != null) + t3 = !(trailingCombinator.$ti._is(newTrailingCombinator) && J.$eq$(newTrailingCombinator.value, trailingCombinator.value)); + else + t3 = false; + if (t3) + return _null; + trailingCombinator = newTrailingCombinator; + } + unifiedBase0 = base.selector; + if (unifiedBase == null) + unifiedBase = unifiedBase0; + else { + unifiedBase = A.unifyCompound(unifiedBase, unifiedBase0); + if (unifiedBase == null) + return _null; + } + } + t2 = type$.JSArray_ComplexSelector; + t3 = A._setArrayType([], t2); + for (t4 = t1.get$iterator(complexes); t4.moveNext$0();) { + t5 = t4.get$current(t4); + t6 = t5.components; + t7 = t6.length; + if (t7 > 1) { + t8 = t5.leadingCombinators; + t3.push(A.ComplexSelector$(t8, B.JSArray_methods.take$1(t6, t7 - 1), t5.span, t5.lineBreak)); + } + } + t4 = leadingCombinator == null ? B.List_empty0 : A._setArrayType([leadingCombinator], type$.JSArray_CssValue_Combinator); + unifiedBase.toString; + t5 = trailingCombinator == null ? B.List_empty0 : A._setArrayType([trailingCombinator], type$.JSArray_CssValue_Combinator); + base = A.ComplexSelector$(t4, A._setArrayType([new A.ComplexSelectorComponent(unifiedBase, A.List_List$unmodifiable(t5, type$.CssValue_Combinator), span)], type$.JSArray_ComplexSelectorComponent), span, t1.any$1(complexes, new A.unifyComplex_closure())); + if (t3.length === 0) + t1 = A._setArrayType([base], t2); + else { + t1 = A.List_List$of(A.IterableExtension_get_exceptLast(t3), true, type$.ComplexSelector); + t1.push(B.JSArray_methods.get$last(t3).concatenate$2(base, span)); + } + return A.weave(t1, span, false); + }, + unifyCompound(compound1, compound2) { + var t1, t2, pseudoElementFound, _i, simple, unified, + result = compound1.components, + pseudoResult = A._setArrayType([], type$.JSArray_SimpleSelector); + for (t1 = compound2.components, t2 = t1.length, pseudoElementFound = false, _i = 0; _i < t2; ++_i) { + simple = t1[_i]; + if (pseudoElementFound && simple instanceof A.PseudoSelector) { + unified = simple.unify$1(pseudoResult); + if (unified == null) + return null; + pseudoResult = unified; + } else { + pseudoElementFound = B.JSBool_methods.$or(pseudoElementFound, simple instanceof A.PseudoSelector && !simple.isClass); + unified = simple.unify$1(result); + if (unified == null) + return null; + result = unified; + } + } + t1 = A.List_List$of(result, true, type$.SimpleSelector); + B.JSArray_methods.addAll$1(t1, pseudoResult); + return A.CompoundSelector$(t1, compound1.span); + }, + unifyUniversalAndElement(selector1, selector2) { + var namespace, $name, t1, + _0_0 = A._namespaceAndName(selector1, "selector1"), + namespace1 = _0_0._0, + name1 = _0_0._1, + _1_0 = A._namespaceAndName(selector2, "selector2"), + namespace2 = _1_0._0, + name2 = _1_0._1; + if (namespace1 == namespace2 || namespace2 === "*") + namespace = namespace1; + else { + if (namespace1 !== "*") + return null; + namespace = namespace2; + } + if (name1 == name2 || name2 == null) + $name = name1; + else { + if (!(name1 == null || name1 === "*")) + return null; + $name = name2; + } + t1 = selector1.span; + return $name == null ? new A.UniversalSelector(namespace, t1) : new A.TypeSelector(new A.QualifiedName($name, namespace), t1); + }, + _namespaceAndName(selector, $name) { + var t1, _0_4; + $label0$0: { + if (selector instanceof A.UniversalSelector) { + t1 = new A._Record_2(selector.namespace, null); + break $label0$0; + } + if (selector instanceof A.TypeSelector) { + _0_4 = selector.name; + t1 = new A._Record_2(_0_4.namespace, _0_4.name); + break $label0$0; + } + t1 = A.throwExpression(A.ArgumentError$value(selector, $name, string$.must_b)); + } + return t1; + }, + weave(complexes, span, forceLineBreak) { + var complex, t2, prefixes, t3, t4, t5, t6, i, t7, t8, _i, t9, t10, _i0, parentPrefix, t11, t12, + t1 = J.getInterceptor$asx(complexes); + if (t1.get$length(complexes) === 1) { + complex = t1.$index(complexes, 0); + if (!forceLineBreak || complex.lineBreak) + return complexes; + return A._setArrayType([A.ComplexSelector$(complex.leadingCombinators, complex.components, complex.span, true)], type$.JSArray_ComplexSelector); + } + t2 = type$.JSArray_ComplexSelector; + prefixes = A._setArrayType([t1.get$first(complexes)], t2); + for (t1 = t1.skip$1(complexes, 1), t3 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t3._eval$1("ListIterator")), t4 = type$.ComplexSelectorComponent, t3 = t3._eval$1("ListIterable.E"); t1.moveNext$0();) { + t5 = t1.__internal$_current; + if (t5 == null) + t5 = t3._as(t5); + t6 = t5.components; + if (t6.length === 1) { + for (i = 0; i < prefixes.length; ++i) + prefixes[i] = prefixes[i].concatenate$3$forceLineBreak(t5, span, forceLineBreak); + continue; + } + t7 = A._setArrayType([], t2); + for (t8 = prefixes.length, _i = 0; _i < prefixes.length; prefixes.length === t8 || (0, A.throwConcurrentModificationError)(prefixes), ++_i) { + t9 = A._weaveParents(prefixes[_i], t5, span); + if (t9 == null) + t9 = B.List_empty1; + t10 = t9.length; + _i0 = 0; + for (; _i0 < t9.length; t9.length === t10 || (0, A.throwConcurrentModificationError)(t9), ++_i0) { + parentPrefix = t9[_i0]; + t11 = B.JSArray_methods.get$last(t6); + t12 = A.List_List$of(parentPrefix.components, true, t4); + t12.push(t11); + t11 = parentPrefix.lineBreak || forceLineBreak; + t7.push(A.ComplexSelector$(parentPrefix.leadingCombinators, t12, span, t11)); + } + } + prefixes = t7; + } + return prefixes; + }, + _weaveParents(prefix, base, span) { + var t1, queue1, queue2, trailingCombinators, _0_1, _0_3, _0_3_isSet, _0_30, rootish2, t2, rootish1, rootish, t3, rootish_case_0, t0, rootish_case_1, groups1, groups2, lcs, choices, t4, _i, group, t5, t6, t7, _i0, chunk, t8, t9, _null = null, + leadingCombinators = A._mergeLeadingCombinators(prefix.leadingCombinators, base.leadingCombinators); + if (leadingCombinators == null) + return _null; + t1 = type$.ComplexSelectorComponent; + queue1 = A.QueueList_QueueList$from(prefix.components, t1); + queue2 = A.QueueList_QueueList$from(A.IterableExtension_get_exceptLast(base.components), t1); + trailingCombinators = A._mergeTrailingCombinators(queue1, queue2, span, _null); + if (trailingCombinators == null) + return _null; + $label0$0: { + _0_1 = A._firstIfRootish(queue1); + _0_3 = A._firstIfRootish(queue2); + _0_3_isSet = _0_1 != null; + _0_30 = _null; + rootish2 = _null; + t2 = false; + if (_0_3_isSet) { + rootish1 = _0_1 == null ? t1._as(_0_1) : _0_1; + t2 = _0_3 != null; + if (t2) + rootish2 = _0_3 == null ? t1._as(_0_3) : _0_3; + _0_30 = _0_3; + } else + rootish1 = _null; + if (t2) { + rootish = A.unifyCompound(rootish1.selector, rootish2.selector); + if (rootish == null) + return _null; + t1 = rootish1.combinators; + t2 = rootish1.span; + t3 = type$.CssValue_Combinator; + queue1.addFirst$1(new A.ComplexSelectorComponent(rootish, A.List_List$unmodifiable(t1, t3), t2)); + queue2.addFirst$1(new A.ComplexSelectorComponent(rootish, A.List_List$unmodifiable(rootish2.combinators, t3), t2)); + break $label0$0; + } + t2 = _null; + t3 = false; + if (_0_1 != null) { + rootish_case_0 = _0_1; + if (_0_3_isSet) + t2 = _0_30; + else { + t2 = _0_3; + _0_30 = t2; + _0_3_isSet = true; + } + t2 = t2 == null; + t3 = t2 ? rootish_case_0 : _null; + t0 = t3; + t3 = t2; + t2 = t0; + } + if (!t3) + if (_0_1 == null) { + if (_0_3_isSet) + t3 = _0_30; + else { + t3 = _0_3; + _0_30 = t3; + _0_3_isSet = true; + } + t3 = t3 != null; + if (t3) { + rootish_case_1 = _0_3_isSet ? _0_30 : _0_3; + if (rootish_case_1 == null) + rootish_case_1 = t1._as(rootish_case_1); + t1 = rootish_case_1; + } else + t1 = t2; + t2 = t3; + } else { + t1 = t2; + t2 = false; + } + else { + t1 = t2; + t2 = true; + } + if (t2) { + queue1.addFirst$1(t1); + queue2.addFirst$1(t1); + } + } + groups1 = A._groupSelectors(queue1); + groups2 = A._groupSelectors(queue2); + t1 = type$.List_ComplexSelectorComponent; + lcs = A.longestCommonSubsequence(groups2, groups1, new A._weaveParents_closure(span), t1); + choices = A._setArrayType([], type$.JSArray_List_Iterable_ComplexSelectorComponent); + for (t2 = lcs.length, t3 = type$.JSArray_Iterable_ComplexSelectorComponent, t4 = type$.JSArray_ComplexSelectorComponent, _i = 0; _i < lcs.length; lcs.length === t2 || (0, A.throwConcurrentModificationError)(lcs), ++_i) { + group = lcs[_i]; + t5 = A._setArrayType([], t3); + for (t6 = A._chunks(groups1, groups2, new A._weaveParents_closure0(group), t1), t7 = t6.length, _i0 = 0; _i0 < t6.length; t6.length === t7 || (0, A.throwConcurrentModificationError)(t6), ++_i0) { + chunk = t6[_i0]; + t8 = A._setArrayType([], t4); + for (t9 = B.JSArray_methods.get$iterator(chunk); t9.moveNext$0();) + B.JSArray_methods.addAll$1(t8, t9.get$current(0)); + t5.push(t8); + } + choices.push(t5); + choices.push(A._setArrayType([group], t3)); + groups1.removeFirst$0(); + groups2.removeFirst$0(); + } + t2 = A._setArrayType([], t3); + for (t1 = A._chunks(groups1, groups2, new A._weaveParents_closure1(), t1), t3 = t1.length, _i = 0; _i < t1.length; t1.length === t3 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + chunk = t1[_i]; + t5 = A._setArrayType([], t4); + for (t6 = B.JSArray_methods.get$iterator(chunk); t6.moveNext$0();) + B.JSArray_methods.addAll$1(t5, t6.get$current(0)); + t2.push(t5); + } + choices.push(t2); + B.JSArray_methods.addAll$1(choices, trailingCombinators); + t1 = A._setArrayType([], type$.JSArray_ComplexSelector); + for (t2 = J.get$iterator$ax(A.paths(new A.WhereIterable(choices, new A._weaveParents_closure2(), type$.WhereIterable_List_Iterable_ComplexSelectorComponent), type$.Iterable_ComplexSelectorComponent)), t3 = !prefix.lineBreak, t5 = base.lineBreak; t2.moveNext$0();) { + t6 = t2.get$current(t2); + t7 = A._setArrayType([], t4); + for (t6 = J.get$iterator$ax(t6); t6.moveNext$0();) + B.JSArray_methods.addAll$1(t7, t6.get$current(t6)); + t1.push(A.ComplexSelector$(leadingCombinators, t7, span, !t3 || t5)); + } + return t1; + }, + _firstIfRootish(queue) { + var first, t1, t2, _i, simple, t3; + if (queue.get$length(0) >= 1) { + first = queue.$index(0, 0); + for (t1 = first.selector.components, t2 = t1.length, _i = 0; _i < t2; ++_i) { + simple = t1[_i]; + t3 = false; + if (simple instanceof A.PseudoSelector) + if (simple.isClass) + t3 = $._rootishPseudoClasses.contains$1(0, simple.normalizedName); + if (t3) { + queue.removeFirst$0(); + return first; + } + } + } + return null; + }, + _mergeLeadingCombinators(combinators1, combinators2) { + var _0_4, t1, t2, _0_7_isSet, _0_7, t3, _0_4_isSet, _0_11, _0_11_isSet, combinators, _null = null; + $label0$0: { + _0_4 = combinators2; + t1 = _null; + t2 = type$.List_CssValue_Combinator; + _0_7_isSet = t2._is(combinators1); + _0_7 = _null; + if (_0_7_isSet) { + _0_7 = combinators1.length; + t3 = _0_7; + t3 = t3 > 1; + } else + t3 = false; + _0_4_isSet = true; + _0_11 = _null; + if (!t3) { + t3 = _0_4; + _0_11_isSet = t2._is(t3); + if (_0_11_isSet) { + t3 = _0_4; + _0_11 = (t3 == null ? t2._as(t3) : t3).length; + t3 = _0_11; + t3 = t3 > 1; + } else + t3 = false; + } else { + _0_11_isSet = false; + t3 = true; + } + if (t3) + break $label0$0; + if (t2._is(combinators1)) { + if (_0_7_isSet) + t3 = _0_7; + else { + _0_7 = combinators1.length; + t3 = _0_7; + } + t3 = t3 <= 0; + if (t3) + if (_0_4_isSet) + combinators = _0_4; + else { + combinators = combinators2; + _0_4 = combinators; + _0_4_isSet = true; + } + else + combinators = t1; + t1 = t3; + } else { + combinators = t1; + t1 = false; + } + if (!t1) { + t1 = false; + if (_0_4_isSet) + t3 = _0_4; + else { + t3 = combinators2; + _0_4 = t3; + _0_4_isSet = true; + } + if (t2._is(t3)) { + if (_0_11_isSet) + t1 = _0_11; + else { + t1 = _0_4_isSet ? _0_4 : combinators2; + _0_11 = (t1 == null ? t2._as(t1) : t1).length; + t1 = _0_11; + } + t1 = t1 <= 0; + } + combinators = combinators1; + } else + t1 = true; + if (t1) { + t1 = combinators; + break $label0$0; + } + t1 = B.C_ListEquality.equals$2(0, combinators1, combinators2) ? combinators1 : _null; + break $label0$0; + } + return t1; + }, + _mergeTrailingCombinators(components1, components2, span, result) { + var _0_1, t1, _1_1, t2, t3, _4_1, _4_3, _4_4_isSet, _4_5, _4_4, component1, component2, t4, t5, choices, _2_0, _4_9, _4_6, _4_7, followingComponents, nextComponents, _4_4_isSet0, _4_6_isSet, _4_7_isSet, _4_10_isSet, _4_10, _4_5_isSet, next, following, _3_0, siblingComponents_case_0, siblingComponents_case_1, combinator1, t6, combinator2, unified, t7, combinator_case_0, combinatorComponents_case_0, descendantComponents_case_0, t0, combinator_case_1, descendantComponents_case_1, combinatorComponents_case_1, _null = null; + if (result == null) + result = A.QueueList$(_null, type$.List_List_ComplexSelectorComponent); + $label0$0: { + _0_1 = components1.get$length(0); + if (_0_1 >= 1) { + t1 = components1.$index(0, _0_1 - 1).combinators; + break $label0$0; + } + t1 = B.List_empty0; + break $label0$0; + } + $label1$1: { + _1_1 = components2.get$length(0); + if (_1_1 >= 1) { + t2 = components2.$index(0, _1_1 - 1).combinators; + break $label1$1; + } + t2 = B.List_empty0; + break $label1$1; + } + t3 = t1.length; + if (t3 === 0 && t2.length === 0) + return result; + if (t3 > 1 || t2.length > 1) + return _null; + $label2$2: { + t3 = A.IterableExtension_get_firstOrNull(t1); + t3 = t3 == null ? _null : t3.value; + t2 = A.IterableExtension_get_firstOrNull(t2); + t2 = [t3, t2 == null ? _null : t2.value, components1, components2]; + _4_1 = t2[0]; + _4_3 = B.Combinator_55N === _4_1; + _4_4_isSet = _4_3; + _4_5 = _null; + _4_4 = _null; + if (_4_4_isSet) { + _4_4 = t2[1]; + _4_5 = B.Combinator_55N === _4_4; + t3 = _4_5; + } else + t3 = false; + if (t3) { + component1 = components1.removeLast$0(0); + component2 = components2.removeLast$0(0); + t2 = component1.selector; + t3 = component2.selector; + if (A.compoundIsSuperselector(t2, t3, _null)) + result.addFirst$1(A._setArrayType([A._setArrayType([component2], type$.JSArray_ComplexSelectorComponent)], type$.JSArray_List_ComplexSelectorComponent)); + else { + t4 = type$.JSArray_ComplexSelectorComponent; + t5 = type$.JSArray_List_ComplexSelectorComponent; + if (A.compoundIsSuperselector(t3, t2, _null)) + result.addFirst$1(A._setArrayType([A._setArrayType([component1], t4)], t5)); + else { + choices = A._setArrayType([A._setArrayType([component1, component2], t4), A._setArrayType([component2, component1], t4)], t5); + _2_0 = A.unifyCompound(t2, t3); + if (_2_0 != null) + choices.push(A._setArrayType([new A.ComplexSelectorComponent(_2_0, A.List_List$unmodifiable(A._setArrayType([B.JSArray_methods.get$first(t1)], type$.JSArray_CssValue_Combinator), type$.CssValue_Combinator), span)], t4)); + result.addFirst$1(choices); + } + } + break $label2$2; + } + _4_9 = _null; + _4_6 = _null; + _4_7 = _null; + followingComponents = _null; + nextComponents = _null; + if (_4_3) { + if (_4_4_isSet) { + t3 = _4_4; + _4_4_isSet0 = _4_4_isSet; + } else { + _4_4 = t2[1]; + t3 = _4_4; + _4_4_isSet0 = true; + } + _4_9 = B.Combinator_bOP === t3; + _4_6_isSet = _4_9; + if (_4_6_isSet) { + _4_6 = t2[2]; + _4_7 = t2[3]; + nextComponents = _4_7; + followingComponents = _4_6; + } + t3 = _4_6_isSet; + _4_7_isSet = t3; + } else { + _4_4_isSet0 = _4_4_isSet; + _4_6_isSet = false; + _4_7_isSet = false; + t3 = false; + } + _4_10_isSet = !t3; + _4_10 = _null; + if (_4_10_isSet) { + _4_10 = B.Combinator_bOP === _4_1; + t3 = _4_10; + if (t3) { + if (_4_4_isSet) { + t3 = _4_5; + _4_5_isSet = _4_4_isSet; + _4_4_isSet = _4_4_isSet0; + } else { + if (_4_4_isSet0) { + t3 = _4_4; + _4_4_isSet = _4_4_isSet0; + } else { + _4_4 = t2[1]; + t3 = _4_4; + _4_4_isSet = true; + } + _4_5 = B.Combinator_55N === t3; + t3 = _4_5; + _4_5_isSet = true; + } + if (t3) { + if (_4_6_isSet) + nextComponents = _4_6; + else { + _4_6 = t2[2]; + nextComponents = _4_6; + _4_6_isSet = true; + } + if (_4_7_isSet) + followingComponents = _4_7; + else { + _4_7 = t2[3]; + followingComponents = _4_7; + _4_7_isSet = true; + } + } + } else { + _4_5_isSet = _4_4_isSet; + _4_4_isSet = _4_4_isSet0; + t3 = false; + } + } else { + _4_5_isSet = _4_4_isSet; + _4_4_isSet = _4_4_isSet0; + t3 = true; + } + if (t3) { + next = nextComponents.removeLast$0(0); + following = followingComponents.removeLast$0(0); + t1 = following.selector; + t2 = next.selector; + t3 = type$.JSArray_ComplexSelectorComponent; + t4 = type$.JSArray_List_ComplexSelectorComponent; + if (A.compoundIsSuperselector(t1, t2, _null)) + result.addFirst$1(A._setArrayType([A._setArrayType([next], t3)], t4)); + else { + t4 = A._setArrayType([A._setArrayType([following, next], t3)], t4); + _3_0 = A.unifyCompound(t1, t2); + if (_3_0 != null) + t4.push(A._setArrayType([new A.ComplexSelectorComponent(_3_0, A.List_List$unmodifiable(next.combinators, type$.CssValue_Combinator), span)], t3)); + result.addFirst$1(t4); + } + break $label2$2; + } + t3 = _null; + if (B.Combinator_0mp === _4_1) { + _4_4_isSet0 = true; + if (_4_3) + t4 = _4_9; + else { + if (_4_4_isSet) + t4 = _4_4; + else { + _4_4 = t2[1]; + t4 = _4_4; + _4_4_isSet = _4_4_isSet0; + } + _4_9 = B.Combinator_bOP === t4; + t4 = _4_9; + } + if (!t4) + if (_4_5_isSet) + t4 = _4_5; + else { + if (_4_4_isSet) + t4 = _4_4; + else { + _4_4 = t2[1]; + t4 = _4_4; + _4_4_isSet = _4_4_isSet0; + } + _4_5 = B.Combinator_55N === t4; + t4 = _4_5; + } + else + t4 = true; + if (t4) { + if (_4_7_isSet) + siblingComponents_case_0 = _4_7; + else { + _4_7 = t2[3]; + siblingComponents_case_0 = _4_7; + _4_7_isSet = true; + } + t3 = siblingComponents_case_0; + } + } else + t4 = false; + if (!t4) { + if (_4_10_isSet) + t4 = _4_10; + else { + _4_10 = B.Combinator_bOP === _4_1; + t4 = _4_10; + } + if (!t4) + t4 = _4_3; + else + t4 = true; + if (t4) { + if (_4_4_isSet) + t4 = _4_4; + else { + _4_4 = t2[1]; + t4 = _4_4; + _4_4_isSet = true; + } + t4 = B.Combinator_0mp === t4; + if (t4) { + if (_4_6_isSet) + siblingComponents_case_1 = _4_6; + else { + _4_6 = t2[2]; + siblingComponents_case_1 = _4_6; + _4_6_isSet = true; + } + t3 = siblingComponents_case_1; + } + } else + t4 = false; + } else + t4 = true; + if (t4) { + result.addFirst$1(A._setArrayType([A._setArrayType([t3.removeLast$0(0)], type$.JSArray_ComplexSelectorComponent)], type$.JSArray_List_ComplexSelectorComponent)); + break $label2$2; + } + t3 = _4_1 == null; + t4 = !t3; + t5 = false; + if (t4) { + _4_4_isSet0 = true; + combinator1 = _4_1; + if (_4_4_isSet) + t6 = _4_4; + else { + _4_4 = t2[1]; + t6 = _4_4; + _4_4_isSet = _4_4_isSet0; + } + if (t6 != null) { + if (_4_4_isSet) + combinator2 = _4_4; + else { + _4_4 = t2[1]; + combinator2 = _4_4; + _4_4_isSet = _4_4_isSet0; + } + t5 = combinator1 === (combinator2 == null ? type$.Combinator._as(combinator2) : combinator2); + } + } + if (t5) { + unified = A.unifyCompound(components1.removeLast$0(0).selector, components2.removeLast$0(0).selector); + if (unified == null) + return _null; + result.addFirst$1(A._setArrayType([A._setArrayType([new A.ComplexSelectorComponent(unified, A.List_List$unmodifiable(A._setArrayType([B.JSArray_methods.get$first(t1)], type$.JSArray_CssValue_Combinator), type$.CssValue_Combinator), span)], type$.JSArray_ComplexSelectorComponent)], type$.JSArray_List_ComplexSelectorComponent)); + break $label2$2; + } + t1 = _null; + t5 = _null; + t6 = _null; + t7 = false; + if (t4) { + combinator_case_0 = _4_1; + if (_4_4_isSet) + t4 = _4_4; + else { + _4_4 = t2[1]; + t4 = _4_4; + _4_4_isSet = true; + } + t4 = t4 == null; + if (t4) { + if (_4_6_isSet) + combinatorComponents_case_0 = _4_6; + else { + _4_6 = t2[2]; + combinatorComponents_case_0 = _4_6; + _4_6_isSet = true; + } + if (_4_7_isSet) + descendantComponents_case_0 = _4_7; + else { + _4_7 = t2[3]; + descendantComponents_case_0 = _4_7; + _4_7_isSet = true; + } + t1 = descendantComponents_case_0; + t6 = t1; + t1 = combinator_case_0; + t5 = combinatorComponents_case_0; + } + t0 = t6; + t6 = t4; + t4 = t5; + t5 = t0; + } else { + t4 = t5; + t5 = t6; + t6 = t7; + } + if (!t6) + if (t3) { + if (_4_4_isSet) + t3 = _4_4; + else { + _4_4 = t2[1]; + t3 = _4_4; + _4_4_isSet = true; + } + t3 = t3 != null; + if (t3) { + combinator_case_1 = _4_4_isSet ? _4_4 : t2[1]; + if (combinator_case_1 == null) + combinator_case_1 = type$.Combinator._as(combinator_case_1); + descendantComponents_case_1 = _4_6_isSet ? _4_6 : t2[2]; + combinatorComponents_case_1 = _4_7_isSet ? _4_7 : t2[3]; + t1 = combinatorComponents_case_1; + t2 = descendantComponents_case_1; + t4 = t2; + t2 = t1; + t1 = combinator_case_1; + } else { + t2 = t4; + t4 = t5; + } + t0 = t4; + t4 = t3; + t3 = t0; + } else { + t3 = t5; + t2 = t4; + t4 = false; + } + else { + t3 = t5; + t2 = t4; + t4 = true; + } + if (t4) { + if (t1 === B.Combinator_0mp) { + t1 = A.IterableExtension_get_lastOrNull(t3); + t1 = t1 == null ? _null : A.compoundIsSuperselector(t1.selector, t2.get$last(t2).selector, _null); + t1 = t1 === true; + } else + t1 = false; + if (t1) + t3.removeLast$0(0); + result.addFirst$1(A._setArrayType([A._setArrayType([t2.removeLast$0(0)], type$.JSArray_ComplexSelectorComponent)], type$.JSArray_List_ComplexSelectorComponent)); + break $label2$2; + } + return _null; + } + return A._mergeTrailingCombinators(components1, components2, span, result); + }, + _mustUnify(complex1, complex2) { + var t2, t3, t4, + t1 = A.LinkedHashSet_LinkedHashSet$_empty(type$.SimpleSelector); + for (t2 = J.get$iterator$ax(complex1); t2.moveNext$0();) + for (t3 = B.JSArray_methods.get$iterator(t2.get$current(t2).selector.components), t4 = new A.WhereIterator(t3, A.functions___isUnique$closure()); t4.moveNext$0();) + t1.add$1(0, t3.get$current(0)); + if (t1._collection$_length === 0) + return false; + return J.any$1$ax(complex2, new A._mustUnify_closure(t1)); + }, + _isUnique(simple) { + var t1; + if (!(simple instanceof A.IDSelector)) + t1 = simple instanceof A.PseudoSelector && !simple.isClass; + else + t1 = true; + return t1; + }, + _chunks(queue1, queue2, done, $T) { + var chunk2, _0_4, _0_5_isSet, _0_1, _0_7, _0_5, chunk, _0_5_isSet0, t2, _null = null, + t1 = $T._eval$1("JSArray<0>"), + chunk1 = A._setArrayType([], t1); + for (; !done.call$1(queue1);) + chunk1.push(queue1.removeFirst$0()); + chunk2 = A._setArrayType([], t1); + for (; !done.call$1(queue2);) + chunk2.push(queue2.removeFirst$0()); + $label0$0: { + _0_4 = chunk1.length <= 0; + _0_5_isSet = _0_4; + _0_1 = chunk1; + _0_7 = _null; + _0_5 = _null; + if (_0_5_isSet) { + _0_7 = chunk2.length <= 0; + t1 = _0_7; + _0_5 = chunk2; + } else + t1 = false; + if (t1) { + t1 = A._setArrayType([], $T._eval$1("JSArray>")); + break $label0$0; + } + if (_0_4) + if (_0_5_isSet) { + chunk = _0_5; + _0_5_isSet0 = _0_5_isSet; + } else { + chunk = chunk2; + _0_5 = chunk; + _0_5_isSet0 = true; + } + else { + chunk = _null; + _0_5_isSet0 = _0_5_isSet; + } + if (!_0_4) { + if (_0_5_isSet) + t1 = _0_7; + else { + _0_7 = (_0_5_isSet0 ? _0_5 : chunk2).length <= 0; + t1 = _0_7; + } + chunk = _0_1; + } else + t1 = true; + if (t1) { + t1 = A._setArrayType([chunk], $T._eval$1("JSArray>")); + break $label0$0; + } + t1 = A.List_List$of(chunk1, true, $T); + B.JSArray_methods.addAll$1(t1, chunk2); + t2 = A.List_List$of(chunk2, true, $T); + B.JSArray_methods.addAll$1(t2, chunk1); + t2 = A._setArrayType([t1, t2], $T._eval$1("JSArray>")); + t1 = t2; + break $label0$0; + } + return t1; + }, + paths(choices, $T) { + return J.fold$2$ax(choices, A._setArrayType([A._setArrayType([], $T._eval$1("JSArray<0>"))], $T._eval$1("JSArray>")), new A.paths_closure($T)); + }, + _groupSelectors(complex) { + var t2, t3, t4, + groups = A.QueueList$(null, type$.List_ComplexSelectorComponent), + t1 = type$.JSArray_ComplexSelectorComponent, + group = A._setArrayType([], t1); + for (t2 = complex.$ti, t3 = new A.ListIterator(complex, complex.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"); t3.moveNext$0();) { + t4 = t3.__internal$_current; + if (t4 == null) + t4 = t2._as(t4); + group.push(t4); + if (t4.combinators.length === 0) { + groups._queue_list$_add$1(group); + group = A._setArrayType([], t1); + } + } + if (group.length !== 0) + groups._queue_list$_add$1(group); + return groups; + }, + listIsSuperselector(list1, list2) { + return B.JSArray_methods.every$1(list2, new A.listIsSuperselector_closure(list1)); + }, + _complexIsParentSuperselector(complex1, complex2) { + var t1, base, t2; + if (J.get$length$asx(complex1) > J.get$length$asx(complex2)) + return false; + t1 = $.$get$bogusSpan(); + base = new A.ComplexSelectorComponent(A.CompoundSelector$(A._setArrayType([new A.PlaceholderSelector("", t1)], type$.JSArray_SimpleSelector), t1), A.List_List$unmodifiable(B.List_empty0, type$.CssValue_Combinator), t1); + t1 = type$.ComplexSelectorComponent; + t2 = A.List_List$of(complex1, true, t1); + t2.push(base); + t1 = A.List_List$of(complex2, true, t1); + t1.push(base); + return A.complexIsSuperselector(t2, t1); + }, + complexIsSuperselector(complex1, complex2) { + var t1, t2, previousCombinator, i1, i2, remaining1, remaining2, component1, t3, t4, endOfSubselector, component2, t5, combinator1, _null = null; + if (B.JSArray_methods.get$last(complex1).combinators.length !== 0) + return false; + if (B.JSArray_methods.get$last(complex2).combinators.length !== 0) + return false; + for (t1 = A._arrayInstanceType(complex2), t2 = t1._precomputed1, t1 = t1._eval$1("SubListIterable<1>"), previousCombinator = _null, i1 = 0, i2 = 0; true; previousCombinator = combinator1) { + remaining1 = complex1.length - i1; + remaining2 = complex2.length - i2; + if (remaining1 === 0 || remaining2 === 0) + return false; + if (remaining1 > remaining2) + return false; + component1 = complex1[i1]; + t3 = component1.combinators; + if (t3.length > 1) + return false; + if (remaining1 === 1) + if (B.JSArray_methods.any$1(complex2, new A.complexIsSuperselector_closure())) + return false; + else { + t1 = component1.selector; + t2 = B.JSArray_methods.get$last(complex2).selector; + return A.compoundIsSuperselector(t1, t2, t1.get$hasComplicatedSuperselectorSemantics() ? B.JSArray_methods.sublist$2(complex2, i2, complex2.length - 1) : _null); + } + for (t4 = component1.selector, endOfSubselector = i2; true;) { + component2 = complex2[endOfSubselector]; + if (component2.combinators.length > 1) + return false; + t5 = t4.get$hasComplicatedSuperselectorSemantics() ? B.JSArray_methods.sublist$2(complex2, i2, endOfSubselector) : _null; + if (A.compoundIsSuperselector(t4, component2.selector, t5)) + break; + ++endOfSubselector; + if (endOfSubselector === complex2.length - 1) + return false; + } + t4 = new A.SubListIterable(complex2, 0, endOfSubselector, t1); + t4.SubListIterable$3(complex2, 0, endOfSubselector, t2); + if (!A._compatibleWithPreviousCombinator(previousCombinator, t4.skip$1(0, i2))) + return false; + component2 = complex2[endOfSubselector]; + combinator1 = A.IterableExtension_get_firstOrNull(t3); + if (!A._isSupercombinator(combinator1, A.IterableExtension_get_firstOrNull(component2.combinators))) + return false; + ++i1; + i2 = endOfSubselector + 1; + if (complex1.length - i1 === 1) { + t3 = combinator1 == null; + if (J.$eq$(t3 ? _null : combinator1.value, B.Combinator_55N)) { + t3 = complex2.length - 1; + t4 = new A.SubListIterable(complex2, 0, t3, t1); + t4.SubListIterable$3(complex2, 0, t3, t2); + if (!t4.skip$1(0, i2).every$1(0, new A.complexIsSuperselector_closure0(combinator1))) + return false; + } else if (!t3) + if (complex2.length - i2 > 1) + return false; + } + } + }, + _compatibleWithPreviousCombinator(previous, parents) { + if (parents.get$isEmpty(parents)) + return true; + if (previous == null) + return true; + if (previous.value !== B.Combinator_55N) + return false; + return parents.every$1(0, new A._compatibleWithPreviousCombinator_closure()); + }, + _isSupercombinator(combinator1, combinator2) { + var t2, t3, + t1 = true; + if (!J.$eq$(combinator1, combinator2)) { + t2 = combinator1 == null; + if (t2) + t3 = J.$eq$(combinator2 == null ? null : combinator2.value, B.Combinator_0mp); + else + t3 = false; + if (!t3) + if (J.$eq$(t2 ? null : combinator1.value, B.Combinator_55N)) + t1 = J.$eq$(combinator2 == null ? null : combinator2.value, B.Combinator_bOP); + else + t1 = false; + } + return t1; + }, + compoundIsSuperselector(compound1, compound2, parents) { + var t1, _0_1, _0_5, _0_5_isSet, _0_50, index1, pseudo2, index2, t2, t3, pseudo1, t4, t5, _i, simple1, _null = null; + if (!compound1.get$hasComplicatedSuperselectorSemantics() && !compound2.get$hasComplicatedSuperselectorSemantics()) { + t1 = compound1.components; + if (t1.length > compound2.components.length) + return false; + return B.JSArray_methods.every$1(t1, new A.compoundIsSuperselector_closure(compound2)); + } + _0_1 = A._findPseudoElementIndexed(compound1); + _0_5 = A._findPseudoElementIndexed(compound2); + t1 = type$.Record_2_nullable_Object_and_nullable_Object; + _0_5_isSet = t1._is(_0_1); + _0_50 = _null; + index1 = _null; + pseudo2 = _null; + index2 = _null; + t2 = false; + if (_0_5_isSet) { + t3 = _0_1 == null; + pseudo1 = (t3 ? t1._as(_0_1) : _0_1)._0; + index1 = (t3 ? t1._as(_0_1) : _0_1)._1; + t2 = t1._is(_0_5); + if (t2) { + t3 = _0_5 == null; + pseudo2 = (t3 ? t1._as(_0_5) : _0_5)._0; + index2 = (t3 ? t1._as(_0_5) : _0_5)._1; + } + t1 = t2; + _0_50 = _0_5; + } else { + t1 = t2; + pseudo1 = _null; + } + if (t1) { + if (pseudo1.isSuperselector$1(pseudo2)) { + t1 = compound1.components; + t2 = type$.int; + t3 = A._arrayInstanceType(t1)._precomputed1; + t4 = compound2.components; + t5 = A._arrayInstanceType(t4)._precomputed1; + t1 = A._compoundComponentsIsSuperselector(A.SubListIterable$(t1, 0, A.checkNotNullable(index1, "count", t2), t3), A.SubListIterable$(t4, 0, A.checkNotNullable(index2, "count", t2), t5), parents) && A._compoundComponentsIsSuperselector(A.SubListIterable$(t1, index1 + 1, _null, t3), A.SubListIterable$(t4, index2 + 1, _null, t5), parents); + } else + t1 = false; + return t1; + } + if (_0_1 == null) + t1 = (_0_5_isSet ? _0_50 : _0_5) != null; + else + t1 = true; + if (t1) + return false; + for (t1 = compound1.components, t2 = t1.length, t3 = compound2.components, _i = 0; _i < t2; ++_i) { + simple1 = t1[_i]; + if (simple1 instanceof A.PseudoSelector) + t4 = simple1.selector != null; + else + t4 = false; + if (t4) { + if (!A._selectorPseudoIsSuperselector(simple1, compound2, parents)) + return false; + } else if (!B.JSArray_methods.any$1(t3, simple1.get$isSuperselector())) + return false; + } + return true; + }, + _findPseudoElementIndexed(compound) { + var t1, t2, i, simple; + for (t1 = compound.components, t2 = t1.length, i = 0; i < t2; ++i) { + simple = t1[i]; + if (simple instanceof A.PseudoSelector && !simple.isClass) + return new A._Record_2(simple, i); + } + return null; + }, + _compoundComponentsIsSuperselector(compound1, compound2, parents) { + var t1; + if (compound1.get$length(0) === 0) + return true; + if (compound2.get$length(0) === 0) + compound2 = A._setArrayType([new A.UniversalSelector("*", $.$get$bogusSpan())], type$.JSArray_SimpleSelector); + t1 = $.$get$bogusSpan(); + return A.compoundIsSuperselector(A.CompoundSelector$(compound1, t1), A.CompoundSelector$(compound2, t1), parents); + }, + _selectorPseudoIsSuperselector(pseudo1, compound2, parents) { + var selector1 = pseudo1.selector; + if (selector1 == null) + throw A.wrapException(A.ArgumentError$("Selector " + pseudo1.toString$0(0) + " must have a selector argument.", null)); + switch (pseudo1.normalizedName) { + case "is": + case "matches": + case "any": + case "where": + return A._selectorPseudoArgs(compound2, pseudo1.name, true).any$1(0, new A._selectorPseudoIsSuperselector_closure(selector1)) || B.JSArray_methods.any$1(selector1.components, new A._selectorPseudoIsSuperselector_closure0(parents, compound2)); + case "has": + case "host": + case "host-context": + return A._selectorPseudoArgs(compound2, pseudo1.name, true).any$1(0, new A._selectorPseudoIsSuperselector_closure1(selector1)); + case "slotted": + return A._selectorPseudoArgs(compound2, pseudo1.name, false).any$1(0, new A._selectorPseudoIsSuperselector_closure2(selector1)); + case "not": + return B.JSArray_methods.every$1(selector1.components, new A._selectorPseudoIsSuperselector_closure3(compound2, pseudo1)); + case "current": + return A._selectorPseudoArgs(compound2, pseudo1.name, true).any$1(0, new A._selectorPseudoIsSuperselector_closure4(selector1)); + case "nth-child": + case "nth-last-child": + return B.JSArray_methods.any$1(compound2.components, new A._selectorPseudoIsSuperselector_closure5(pseudo1, selector1)); + default: + throw A.wrapException("unreachable"); + } + }, + _selectorPseudoArgs(compound, $name, isClass) { + var t1 = type$.WhereTypeIterable_PseudoSelector; + return new A.NonNullsIterable(new A.MappedIterable(new A.WhereIterable(new A.WhereTypeIterable(compound.components, t1), new A._selectorPseudoArgs_closure(isClass, $name), t1._eval$1("WhereIterable")), new A._selectorPseudoArgs_closure0(), t1._eval$1("MappedIterable")), type$.NonNullsIterable_SelectorList); + }, + unifyComplex_closure: function unifyComplex_closure() { + }, + _weaveParents_closure: function _weaveParents_closure(t0) { + this.span = t0; + }, + _weaveParents_closure0: function _weaveParents_closure0(t0) { + this.group = t0; + }, + _weaveParents_closure1: function _weaveParents_closure1() { + }, + _weaveParents_closure2: function _weaveParents_closure2() { + }, + _mustUnify_closure: function _mustUnify_closure(t0) { + this.uniqueSelectors = t0; + }, + _mustUnify__closure: function _mustUnify__closure(t0) { + this.uniqueSelectors = t0; + }, + paths_closure: function paths_closure(t0) { + this.T = t0; + }, + paths__closure: function paths__closure(t0, t1) { + this.paths = t0; + this.T = t1; + }, + paths___closure: function paths___closure(t0, t1) { + this.option = t0; + this.T = t1; + }, + listIsSuperselector_closure: function listIsSuperselector_closure(t0) { + this.list1 = t0; + }, + listIsSuperselector__closure: function listIsSuperselector__closure(t0) { + this.complex1 = t0; + }, + complexIsSuperselector_closure: function complexIsSuperselector_closure() { + }, + complexIsSuperselector_closure0: function complexIsSuperselector_closure0(t0) { + this.combinator1 = t0; + }, + _compatibleWithPreviousCombinator_closure: function _compatibleWithPreviousCombinator_closure() { + }, + compoundIsSuperselector_closure: function compoundIsSuperselector_closure(t0) { + this.compound2 = t0; + }, + _selectorPseudoIsSuperselector_closure: function _selectorPseudoIsSuperselector_closure(t0) { + this.selector1 = t0; + }, + _selectorPseudoIsSuperselector_closure0: function _selectorPseudoIsSuperselector_closure0(t0, t1) { + this.parents = t0; + this.compound2 = t1; + }, + _selectorPseudoIsSuperselector_closure1: function _selectorPseudoIsSuperselector_closure1(t0) { + this.selector1 = t0; + }, + _selectorPseudoIsSuperselector_closure2: function _selectorPseudoIsSuperselector_closure2(t0) { + this.selector1 = t0; + }, + _selectorPseudoIsSuperselector_closure3: function _selectorPseudoIsSuperselector_closure3(t0, t1) { + this.compound2 = t0; + this.pseudo1 = t1; + }, + _selectorPseudoIsSuperselector__closure: function _selectorPseudoIsSuperselector__closure(t0, t1) { + this.complex = t0; + this.pseudo1 = t1; + }, + _selectorPseudoIsSuperselector___closure: function _selectorPseudoIsSuperselector___closure(t0) { + this.simple2 = t0; + }, + _selectorPseudoIsSuperselector___closure0: function _selectorPseudoIsSuperselector___closure0(t0) { + this.simple2 = t0; + }, + _selectorPseudoIsSuperselector_closure4: function _selectorPseudoIsSuperselector_closure4(t0) { + this.selector1 = t0; + }, + _selectorPseudoIsSuperselector_closure5: function _selectorPseudoIsSuperselector_closure5(t0, t1) { + this.pseudo1 = t0; + this.selector1 = t1; + }, + _selectorPseudoArgs_closure: function _selectorPseudoArgs_closure(t0, t1) { + this.isClass = t0; + this.name = t1; + }, + _selectorPseudoArgs_closure0: function _selectorPseudoArgs_closure0() { + }, + MergedExtension_merge(left, right) { + var t2, t3, t4, + t1 = left.extender.selector; + if (!t1.$eq(0, right.extender.selector) || !left.target.$eq(0, right.target)) + throw A.wrapException(A.ArgumentError$(left.toString$0(0) + " and " + right.toString$0(0) + " aren't the same extension.", null)); + t2 = left.mediaContext; + t3 = t2 == null; + if (!t3) { + t4 = right.mediaContext; + t4 = t4 != null && !B.C_ListEquality.equals$2(0, t2, t4); + } else + t4 = false; + if (t4) + throw A.wrapException(A.SassException$("From " + left.span.message$1(0, "") + string$.x0aYou_m, right.span, null)); + if (right.isOptional && right.mediaContext == null) + return left; + if (left.isOptional && t3) + return right; + if (t3) + t2 = right.mediaContext; + t1.get$specificity(); + t1 = new A.Extender(t1, false); + return t1._extension = new A.MergedExtension(left, right, t1, left.target, t2, true, left.span); + }, + MergedExtension: function MergedExtension(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.left = t0; + _.right = t1; + _.extender = t2; + _.target = t3; + _.mediaContext = t4; + _.isOptional = t5; + _.span = t6; + }, + ExtendMode: function ExtendMode(t0, t1) { + this.name = t0; + this._name = t1; + }, + globalFunctions_closure: function globalFunctions_closure() { + }, + _invert($arguments, global) { + var t2, color, rgb, channel2, space, weight, inSpace, t3, _1_9, channel0, channel1, t4, _s6_ = "weight", _s5_ = "space", + t1 = J.getInterceptor$asx($arguments), + weightNumber = t1.$index($arguments, 1).assertNumber$1(_s6_); + if (!(t1.$index($arguments, 0) instanceof A.SassNumber)) + t2 = global && t1.$index($arguments, 0).get$isSpecialNumber(); + else + t2 = true; + if (t2) { + if (weightNumber._number$_value !== 100 || !weightNumber.hasUnit$1("%")) + throw A.wrapException(string$.Only_oa); + return A._functionString("invert", t1.take$1($arguments, 1)); + } + color = t1.$index($arguments, 0).assertColor$1("color"); + if (t1.$index($arguments, 2).$eq(0, B.C__SassNull)) { + t1 = color._space; + if (!t1.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$(string$.To_usei + color.toString$0(0) + ", you must provide a $space.", "color")); + A._checkPercent(weightNumber, _s6_); + rgb = color.toSpace$1(B.RgbColorSpace_i0P); + channel2 = B.LinearChannel_vJ3; + return A._mixLegacy(A.SassColor_SassColor$rgbInternal(A._invertChannel(rgb, B.LinearChannel_qXC, rgb.channel0OrNull), A._invertChannel(rgb, B.LinearChannel_Z5r, rgb.channel1OrNull), A._invertChannel(rgb, channel2, rgb.channel2OrNull), color.alphaOrNull, null), color, weightNumber).toSpace$1(t1); + } + t1 = t1.$index($arguments, 2).assertString$1(_s5_); + t1.assertUnquoted$1(_s5_); + space = A.ColorSpace_fromName(t1._string$_text, _s5_); + weight = weightNumber.valueInRangeWithUnit$4(0, 100, _s6_, "%") / 100; + if (A.fuzzyEquals(weight, 0)) + return color; + inSpace = color.toSpace$1(space); + $label0$0: { + if (B.HwbColorSpace_guQ === space) { + t1 = A._invertChannel(inSpace, space._channels[0], inSpace.channel0OrNull); + t2 = inSpace.alphaOrNull; + if (t2 == null) + t2 = 0; + t2 = A.SassColor_SassColor$hwb(t1, inSpace.channel2OrNull, inSpace.channel1OrNull, t2); + t1 = t2; + break $label0$0; + } + if (B.HslColorSpace_JQ2 === space || B.LchColorSpace_Bpv === space || B.OklchColorSpace_9Gj === space) { + t1 = space._channels; + t2 = A._invertChannel(inSpace, t1[0], inSpace.channel0OrNull); + t1 = A._invertChannel(inSpace, t1[2], inSpace.channel2OrNull); + t3 = inSpace.alphaOrNull; + if (t3 == null) + t3 = 0; + t3 = A.SassColor_SassColor$forSpaceInternal(space, t2, inSpace.channel1OrNull, t1, t3); + t1 = t3; + break $label0$0; + } + _1_9 = space._channels; + channel0 = _1_9[0]; + channel1 = _1_9[1]; + channel2 = _1_9[2]; + t1 = A._invertChannel(inSpace, channel0, inSpace.channel0OrNull); + t2 = A._invertChannel(inSpace, channel1, inSpace.channel1OrNull); + t3 = A._invertChannel(inSpace, channel2, inSpace.channel2OrNull); + t4 = inSpace.alphaOrNull; + t1 = A.SassColor_SassColor$forSpaceInternal(space, t1, t2, t3, t4 == null ? 0 : t4); + break $label0$0; + } + return A.fuzzyEquals(weight, 1) ? t1.toSpace$2$legacyMissing(color._space, false) : color.interpolate$4$legacyMissing$weight(t1, A.InterpolationMethod$(space, null), false, 1 - weight); + }, + _invertChannel(color, channel, value) { + var _0_2_isSet, _0_2, t1; + if (value == null) + A._missingChannelError(color, channel.name); + $label0$0: { + _0_2_isSet = channel instanceof A.LinearChannel; + if (_0_2_isSet) { + _0_2 = channel.min; + t1 = _0_2 < 0; + } else { + _0_2 = null; + t1 = false; + } + if (t1) { + t1 = -value; + break $label0$0; + } + if (_0_2_isSet) + t1 = 0 === _0_2; + else + t1 = false; + if (t1) { + t1 = channel.max - value; + break $label0$0; + } + if (channel.isPolarAngle) { + t1 = B.JSNumber_methods.$mod(value + 180, 360); + break $label0$0; + } + t1 = A.throwExpression(A.UnsupportedError$("Unknown channel " + channel.toString$0(0) + ".")); + } + return t1; + }, + _grayscale(colorArg) { + var hsl, t2, oklch, + color = colorArg.assertColor$1("color"), + t1 = color._space; + if (t1.get$isLegacyInternal()) { + hsl = color.toSpace$1(B.HslColorSpace_JQ2); + t2 = hsl.alphaOrNull; + if (t2 == null) + t2 = 0; + return A.SassColor_SassColor$hsl(hsl.channel0OrNull, 0, hsl.channel2OrNull, t2).toSpace$2$legacyMissing(t1, false); + } else { + oklch = color.toSpace$1(B.OklchColorSpace_9Gj); + t2 = oklch.alphaOrNull; + if (t2 == null) + t2 = 0; + return A.SassColor_SassColor$forSpaceInternal(B.OklchColorSpace_9Gj, oklch.channel0OrNull, 0, oklch.channel2OrNull, t2).toSpace$1(t1); + } + }, + _updateComponents($arguments, adjust, change, scale) { + var t2, t3, keywords, originalColor, spaceKeyword, alphaArg, color, channelArgs, channelInfo, t4, value, channelIndex, result, i, alphaNumber, _null = null, _s5_ = "space", + t1 = J.getInterceptor$asx($arguments), + argumentList = type$.SassArgumentList._as(t1.$index($arguments, 1)); + if (argumentList._list$_contents.length !== 0) + throw A.wrapException(A.SassScriptException$(string$.Only_op, _null)); + argumentList._wereKeywordsAccessed = true; + t2 = type$.String; + t3 = type$.Value; + keywords = A.LinkedHashMap_LinkedHashMap$of(argumentList._keywords, t2, t3); + originalColor = t1.$index($arguments, 0).assertColor$1("color"); + t1 = keywords.remove$1(0, _s5_); + spaceKeyword = t1 == null ? _null : t1.assertString$1(_s5_); + if (spaceKeyword == null) + spaceKeyword = _null; + else + spaceKeyword.assertUnquoted$1(_s5_); + alphaArg = keywords.remove$1(0, "alpha"); + t1 = spaceKeyword == null; + if (t1 && originalColor._space.get$isLegacyInternal() && keywords.__js_helper$_length !== 0) { + t1 = A.NullableExtension_andThen(A._sniffLegacyColorSpace(keywords), new A._updateComponents_closure(originalColor)); + color = t1 == null ? originalColor : t1; + } else + color = A._colorInSpace(originalColor, t1 ? B.C__SassNull : spaceKeyword, true); + channelArgs = A.List_List$filled(color.get$channels().length, _null, false, type$.nullable_Value); + t1 = color._space; + channelInfo = t1._channels; + for (t2 = A.MapExtensions_get_pairs(keywords, t2, t3), t2 = t2.get$iterator(t2); t2.moveNext$0();) { + t3 = {}; + t4 = t2.get$current(t2); + t3.name = null; + t3.name = t4._0; + value = t4._1; + channelIndex = B.JSArray_methods.indexWhere$1(channelInfo, new A._updateComponents_closure0(t3)); + if (channelIndex === -1) + throw A.wrapException(A.SassScriptException$("Color space " + t1.toString$0(0) + " doesn't have a channel with this name.", t3.name)); + channelArgs[channelIndex] = value; + } + if (change) + result = A._changeColor(color, channelArgs, alphaArg); + else { + t2 = A._setArrayType([], type$.JSArray_nullable_SassNumber); + for (i = 0; i < 3; ++i) { + t3 = channelArgs[i]; + t2.push(t3 == null ? _null : t3.assertNumber$1(channelInfo[i].name)); + } + alphaNumber = alphaArg == null ? _null : alphaArg.assertNumber$1("alpha"); + result = scale ? A.SassColor_SassColor$forSpaceInternal(t1, A._scaleChannel(color, channelInfo[0], color.channel0OrNull, t2[0]), A._scaleChannel(color, channelInfo[1], color.channel1OrNull, t2[1]), A._scaleChannel(color, channelInfo[2], color.channel2OrNull, t2[2]), A._scaleChannel(color, B.LinearChannel_XL8, color.alphaOrNull, alphaNumber)) : A._adjustColor(color, t2, alphaNumber); + } + return result.toSpace$2$legacyMissing(originalColor._space, false); + }, + _changeColor(color, channelArgs, alphaArg) { + var t4, _s5_ = "alpha", + t1 = A._channelForChange(channelArgs[0], color, 0), + t2 = A._channelForChange(channelArgs[1], color, 1), + t3 = A._channelForChange(channelArgs[2], color, 2); + $label0$0: { + if (alphaArg == null) { + t4 = color.alphaOrNull; + if (t4 == null) + t4 = 0; + break $label0$0; + } + t4 = A._isNone(alphaArg); + if (t4) { + t4 = null; + break $label0$0; + } + t4 = alphaArg instanceof A.SassNumber; + if (t4 && !alphaArg.get$hasUnits()) { + t4 = alphaArg.valueInRange$3(0, 1, _s5_); + break $label0$0; + } + if (t4 && alphaArg.hasUnit$1("%")) { + t4 = alphaArg.valueInRangeWithUnit$4(0, 100, _s5_, "%") / 100; + break $label0$0; + } + if (t4) { + t4 = new A._changeColor_closure(alphaArg).call$0(); + break $label0$0; + } + t4 = A.throwExpression(A.SassScriptException$(alphaArg.toString$0(0) + ' is not a number or unquoted "none".', _s5_)); + } + return A._colorFromChannels(color._space, t1, t2, t3, t4, false, false); + }, + _channelForChange(channelArg, color, channel) { + var _0_0, t1, t2; + if (channelArg == null) { + _0_0 = color.get$channelsOrNull()[channel]; + $label0$0: { + if (_0_0 != null) { + t1 = color._space; + t2 = A.SassNumber_SassNumber(_0_0, (t1 === B.HslColorSpace_JQ2 || t1 === B.HwbColorSpace_guQ) && channel > 0 ? "%" : null); + t1 = t2; + break $label0$0; + } + t1 = null; + break $label0$0; + } + return t1; + } + if (A._isNone(channelArg)) + return null; + if (channelArg instanceof A.SassNumber) + return channelArg; + throw A.wrapException(A.SassScriptException$(channelArg.toString$0(0) + ' is not a number or unquoted "none".', color._space._channels[channel].name)); + }, + _scaleChannel(color, channel, oldValue, factorArg) { + var t1, factor; + if (factorArg == null) + return oldValue; + if (!(channel instanceof A.LinearChannel)) + throw A.wrapException(A.SassScriptException$("Channel isn't scalable.", channel.name)); + if (oldValue == null) + A._missingChannelError(color, channel.name); + t1 = channel.name; + factorArg.assertUnit$2("%", t1); + factor = factorArg.valueInRangeWithUnit$4(-100, 100, t1, "%") / 100; + $label0$0: { + if (0 === factor) { + t1 = oldValue; + break $label0$0; + } + if (factor > 0) { + t1 = channel.max; + t1 = oldValue >= t1 ? oldValue : oldValue + (t1 - oldValue) * factor; + break $label0$0; + } + t1 = channel.min; + t1 = oldValue <= t1 ? oldValue : oldValue + (oldValue - t1) * factor; + break $label0$0; + } + return t1; + }, + _adjustColor(color, channelArgs, alphaArg) { + var t1 = color._space, + t2 = t1._channels; + return A.SassColor_SassColor$forSpaceInternal(t1, A._adjustChannel(color, t2[0], color.channel0OrNull, channelArgs[0]), A._adjustChannel(color, t2[1], color.channel1OrNull, channelArgs[1]), A._adjustChannel(color, t2[2], color.channel2OrNull, channelArgs[2]), A.NullableExtension_andThen(A._adjustChannel(color, B.LinearChannel_XL8, color.alphaOrNull, alphaArg), new A._adjustColor_closure())); + }, + _adjustChannel(color, channel, oldValue, adjustmentArg) { + var _0_1, _0_3, t1, _0_6_isSet, _0_6, _0_6_isSet0, t2, _0_11, result, min, max, _null = null; + if (adjustmentArg == null) + return oldValue; + if (oldValue == null) + A._missingChannelError(color, channel.name); + $label0$0: { + _0_1 = color._space; + _0_3 = B.HslColorSpace_JQ2 === _0_1; + t1 = _0_3; + if (!t1) + _0_6_isSet = B.HwbColorSpace_guQ === _0_1; + else + _0_6_isSet = true; + if (_0_6_isSet) { + t1 = channel.isPolarAngle; + _0_6 = channel; + } else { + _0_6 = _null; + t1 = false; + } + if (t1) { + adjustmentArg = A.SassNumber_SassNumber(A._angleValue(adjustmentArg, "hue"), _null); + break $label0$0; + } + t1 = false; + if (_0_3) { + _0_6_isSet0 = true; + if (_0_6_isSet) + t2 = _0_6; + else { + t2 = channel; + _0_6_isSet = _0_6_isSet0; + _0_6 = t2; + } + if (t2 instanceof A.LinearChannel) { + if (_0_6_isSet) + t1 = _0_6; + else { + t1 = channel; + _0_6_isSet = _0_6_isSet0; + _0_6 = t1; + } + _0_11 = type$.LinearChannel._as(t1).name; + t1 = _0_11; + if ("saturation" !== t1) + t1 = "lightness" === _0_11; + else + t1 = true; + } + } + if (t1) { + A._checkPercent(adjustmentArg, channel.name); + adjustmentArg = A.SassNumber_SassNumber(adjustmentArg._number$_value, "%"); + break $label0$0; + } + if (B.LinearChannel_XL8 === (_0_6_isSet ? _0_6 : channel) && adjustmentArg.get$hasUnits()) { + A.warnForDeprecation("$alpha: Passing a number with unit " + adjustmentArg.get$unitString() + string$.x20is_de + adjustmentArg.unitSuggestion$1("alpha") + string$.x0a_Morex3af, B.Deprecation_jG1); + adjustmentArg = A.SassNumber_SassNumber(adjustmentArg._number$_value, _null); + } + } + t1 = A._channelFromValue(channel, adjustmentArg, false); + t1.toString; + result = oldValue + t1; + $label1$1: { + t1 = channel instanceof A.LinearChannel; + min = _null; + t2 = false; + if (t1) + if (channel.lowerClamped) { + min = channel.min; + t2 = result < min; + } + if (t2) { + t1 = oldValue < min ? Math.max(oldValue, result) : min; + break $label1$1; + } + max = _null; + t2 = false; + if (t1) + if (channel.upperClamped) { + max = channel.max; + t1 = result > max; + } else + t1 = t2; + else + t1 = t2; + if (t1) { + t1 = oldValue > max ? Math.min(oldValue, result) : max; + break $label1$1; + } + t1 = result; + break $label1$1; + } + return t1; + }, + _sniffLegacyColorSpace(keywords) { + var t1, t2; + for (t1 = new A.LinkedHashMapKeyIterator(keywords, keywords.__js_helper$_modifications, keywords.__js_helper$_first); t1.moveNext$0();) { + t2 = t1.__js_helper$_current; + if ("red" === t2 || "green" === t2 || "blue" === t2) + return B.RgbColorSpace_i0P; + if ("saturation" === t2 || "lightness" === t2) + return B.HslColorSpace_JQ2; + if ("whiteness" === t2 || "blackness" === t2) + return B.HwbColorSpace_guQ; + } + return keywords.containsKey$1("hue") ? B.HslColorSpace_JQ2 : null; + }, + _functionString($name, $arguments) { + return new A.SassString($name + "(" + J.map$1$1$ax($arguments, new A._functionString_closure(), type$.String).join$1(0, ", ") + ")", false); + }, + _removedColorFunction($name, argument, negative) { + return A.BuiltInCallable$function($name, "$color, $amount", new A._removedColorFunction_closure($name, argument, negative), "sass:color"); + }, + _rgb($name, $arguments) { + var t3, t4, + t1 = J.getInterceptor$asx($arguments), + alpha = t1.get$length($arguments) > 3 ? t1.$index($arguments, 3) : null, + t2 = true; + if (!t1.$index($arguments, 0).get$isSpecialNumber()) + if (!t1.$index($arguments, 1).get$isSpecialNumber()) + if (!t1.$index($arguments, 2).get$isSpecialNumber()) { + t2 = alpha == null ? null : alpha.get$isSpecialNumber(); + t2 = t2 === true; + } + if (t2) + return A._functionString($name, $arguments); + t2 = t1.$index($arguments, 0).assertNumber$1("red"); + t3 = t1.$index($arguments, 1).assertNumber$1("green"); + t1 = t1.$index($arguments, 2).assertNumber$1("blue"); + t4 = A.NullableExtension_andThen(alpha, new A._rgb_closure()); + return A._colorFromChannels(B.RgbColorSpace_i0P, t2, t3, t1, t4 == null ? 1 : t4, true, true); + }, + _rgbTwoArg($name, $arguments) { + var t2, color, + t1 = J.getInterceptor$asx($arguments), + first = t1.$index($arguments, 0), + second = t1.$index($arguments, 1); + if (!first.get$isVar()) + t2 = !(first instanceof A.SassColor) && second.get$isVar(); + else + t2 = true; + if (t2) + return A._functionString($name, $arguments); + color = first.assertColor$1("color"); + if (!color._space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$("Expected " + color.toString$0(0) + string$.x20to_be_ + color.toString$0(0) + ", $alpha: " + second.toString$0(0) + ")", $name)); + color.assertLegacy$1("color"); + color = color.toSpace$1(B.RgbColorSpace_i0P); + if (second.get$isSpecialNumber()) + return A._functionString($name, A._setArrayType([A.SassNumber_SassNumber(color.channel$1(0, "red"), null), A.SassNumber_SassNumber(color.channel$1(0, "green"), null), A.SassNumber_SassNumber(color.channel$1(0, "blue"), null), t1.$index($arguments, 1)], type$.JSArray_Value)); + t1 = A._percentageOrUnitless(t1.$index($arguments, 1).assertNumber$1("alpha"), 1, "alpha"); + return color.changeAlpha$1(isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 1)); + }, + _hsl($name, $arguments) { + var t3, t4, + t1 = J.getInterceptor$asx($arguments), + alpha = t1.get$length($arguments) > 3 ? t1.$index($arguments, 3) : null, + t2 = true; + if (!t1.$index($arguments, 0).get$isSpecialNumber()) + if (!t1.$index($arguments, 1).get$isSpecialNumber()) + if (!t1.$index($arguments, 2).get$isSpecialNumber()) { + t2 = alpha == null ? null : alpha.get$isSpecialNumber(); + t2 = t2 === true; + } + if (t2) + return A._functionString($name, $arguments); + t2 = t1.$index($arguments, 0).assertNumber$1("hue"); + t3 = t1.$index($arguments, 1).assertNumber$1("saturation"); + t1 = t1.$index($arguments, 2).assertNumber$1("lightness"); + t4 = A.NullableExtension_andThen(alpha, new A._hsl_closure()); + return A._colorFromChannels(B.HslColorSpace_JQ2, t2, t3, t1, t4 == null ? 1 : t4, true, false); + }, + _angleValue(angleValue, $name) { + var angle = angleValue.assertNumber$1($name); + if (angle.compatibleWithUnit$1("deg")) + return angle.coerceValueToUnit$1("deg"); + A.warnForDeprecation("$" + $name + ": Passing a unit other than deg (" + angle.toString$0(0) + string$.x29x20is_d + angle.unitSuggestion$1($name) + string$.x0a_See_, B.Deprecation_jG1); + return angle._number$_value; + }, + _checkPercent(number, $name) { + if (number.hasUnit$1("%")) + return; + A.warnForDeprecation("$" + $name + ": Passing a number without unit % (" + number.toString$0(0) + string$.x29x20is_d + number.unitSuggestion$2($name, "%") + string$.x0a_Morex3af, B.Deprecation_jG1); + }, + _percentageOrUnitless(number, max, $name) { + var value; + if (!number.get$hasUnits()) + value = number._number$_value; + else if (number.hasUnit$1("%")) + value = max * number._number$_value / 100; + else + throw A.wrapException(A.SassScriptException$("Expected " + number.toString$0(0) + ' to have unit "%" or no units.', $name)); + return value; + }, + _mixLegacy(color1, color2, weight) { + var t2, alphaDistance, weight1, weight2, t3, t4, t5, t6, t7, t8, + rgb1 = color1.toSpace$1(B.RgbColorSpace_i0P), + rgb2 = color2.toSpace$1(B.RgbColorSpace_i0P), + weightScale = weight.valueInRange$3(0, 100, "weight") / 100, + normalizedWeight = weightScale * 2 - 1, + t1 = color1.alphaOrNull; + if (t1 == null) + t1 = 0; + t2 = color2.alphaOrNull; + alphaDistance = t1 - (t2 == null ? 0 : t2); + t1 = normalizedWeight * alphaDistance; + weight1 = ((t1 === -1 ? normalizedWeight : (normalizedWeight + alphaDistance) / (1 + t1)) + 1) / 2; + weight2 = 1 - weight1; + t1 = rgb1.channel0OrNull; + if (t1 == null) + t1 = 0; + t2 = rgb2.channel0OrNull; + if (t2 == null) + t2 = 0; + t3 = rgb1.channel1OrNull; + if (t3 == null) + t3 = 0; + t4 = rgb2.channel1OrNull; + if (t4 == null) + t4 = 0; + t5 = rgb1.channel2OrNull; + if (t5 == null) + t5 = 0; + t6 = rgb2.channel2OrNull; + if (t6 == null) + t6 = 0; + t7 = rgb1.alphaOrNull; + if (t7 == null) + t7 = 0; + t8 = rgb2.alphaOrNull; + if (t8 == null) + t8 = 0; + return A.SassColor_SassColor$rgbInternal(t1 * weight1 + t2 * weight2, t3 * weight1 + t4 * weight2, t5 * weight1 + t6 * weight2, t7 * weightScale + t8 * (1 - weightScale), null); + }, + _opacify($name, $arguments) { + var result, + t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + amount = t1.$index($arguments, 1).assertNumber$1("amount"); + if (!color._space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$($name + string$.x28__is_oa, null)); + t1 = color.alphaOrNull; + if (t1 == null) + t1 = 0; + t1 += amount.valueInRangeWithUnit$4(0, 1, "amount", ""); + result = color.changeAlpha$1(isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 1)); + A.warnForDeprecation($name + "() is deprecated. " + A._suggestScaleAndAdjust(color, amount._number$_value, "alpha") + string$.x0a_Morex3ac, B.Deprecation_cyE); + return result; + }, + _transparentize($name, $arguments) { + var result, + t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + amount = t1.$index($arguments, 1).assertNumber$1("amount"); + if (!color._space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$($name + string$.x28__is_oa, null)); + t1 = color.alphaOrNull; + if (t1 == null) + t1 = 0; + t1 -= amount.valueInRangeWithUnit$4(0, 1, "amount", ""); + result = color.changeAlpha$1(isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 1)); + A.warnForDeprecation($name + "() is deprecated. " + A._suggestScaleAndAdjust(color, -amount._number$_value, "alpha") + string$.x0a_Morex3ac, B.Deprecation_cyE); + return result; + }, + _colorInSpace(colorUntyped, spaceUntyped, legacyMissing) { + var t1, _s5_ = "space", + color = colorUntyped.assertColor$1("color"); + if (spaceUntyped.$eq(0, B.C__SassNull)) + return color; + t1 = spaceUntyped.assertString$1(_s5_); + t1.assertUnquoted$1(_s5_); + return color.toSpace$2$legacyMissing(A.ColorSpace_fromName(t1._string$_text, _s5_), legacyMissing); + }, + _parseChannels(functionName, input, $name, space) { + var parsedSlash, components, alphaValue, _2_0, _2_1, _2_5, t1, t2, _2_6, channels, first, rest, componentList, spaceName, i, channel, channelName, t3, t4, _null = null; + if (input.get$isVar()) + return A._functionString(functionName, A._setArrayType([input], type$.JSArray_Value)); + parsedSlash = A._parseSlashChannels(input, $name); + if (parsedSlash == null) + return A._functionString(functionName, A._setArrayType([input], type$.JSArray_Value)); + components = parsedSlash._0; + alphaValue = parsedSlash._1; + $label0$0: { + _2_0 = components.assertCommonListStyle$2$allowSlash($name, false); + _2_1 = _2_0.length; + if (_2_1 <= 0) + throw A.wrapException(A.SassScriptException$("Color component list may not be empty.", $name)); + _2_5 = _2_1 >= 1; + t1 = _2_5; + t2 = false; + if (t1) { + _2_6 = _2_0[0]; + if (_2_6 instanceof A.SassString) { + type$.SassString._as(_2_6); + t2 = !_2_6._hasQuotes && _2_6._string$_text.toLowerCase() === "from"; + } + } else + _2_6 = _null; + if (t2) + return A._functionString(functionName, A._setArrayType([input], type$.JSArray_Value)); + t2 = components.get$isVar(); + if (t2) { + channels = A._setArrayType([components], type$.JSArray_Value); + break $label0$0; + } + channels = _null; + if (_2_5) { + first = t1 ? _2_6 : _2_0[0]; + rest = B.JSArray_methods.sublist$1(_2_0, 1); + componentList = _2_0; + } else { + componentList = channels; + rest = componentList; + first = _null; + } + if (_2_5) { + if (space == null) { + spaceName = first.assertString$1($name); + spaceName.assertUnquoted$1($name); + space = spaceName.get$isVar() ? _null : A.ColorSpace_fromName(spaceName._string$_text, $name); + if (B.RgbColorSpace_i0P === space || B.HslColorSpace_JQ2 === space || B.HwbColorSpace_guQ === space || B.LabColorSpace_2nT === space || B.LchColorSpace_Bpv === space || B.OklabColorSpace_540 === space || B.OklchColorSpace_9Gj === space) + throw A.wrapException(A.SassScriptException$(string$.The_co + A.S(space) + ". Use the " + A.S(space) + "() function instead.", $name)); + channels = rest; + } else + channels = componentList; + for (i = 0; i < channels.length; ++i) { + channel = channels[i]; + t1 = false; + if (!channel.get$isSpecialNumber()) + if (!(channel instanceof A.SassNumber)) + t1 = !(channel instanceof A.SassString && !channel._hasQuotes && channel._string$_text.toLowerCase() === "none"); + if (t1) { + t1 = _null; + if (space == null) + channelName = t1; + else { + t2 = space._channels; + t2 = i < 3 ? t2[i] : _null; + if (!(t2 == null)) + t1 = new A._parseChannels_closure().call$1(t2.name); + channelName = t1; + } + if (channelName == null) + channelName = "channel " + (i + 1); + throw A.wrapException(A.SassScriptException$("Expected " + channelName + " to be a number, was " + channel.toString$0(0) + ".", $name)); + } + } + break $label0$0; + } + throw A.wrapException("unreachable"); + } + t1 = alphaValue == null; + t2 = t1 ? _null : alphaValue.get$isSpecialNumber(); + if (t2 === true) { + if (channels.length === 3 && B.Set_9FDyj.contains$1(0, space)) { + t1 = A.List_List$of(channels, true, type$.Value); + alphaValue.toString; + t1.push(alphaValue); + t1 = A._functionString(functionName, t1); + } else + t1 = A._functionString(functionName, A._setArrayType([input], type$.JSArray_Value)); + return t1; + } + $label1$1: { + if (t1) { + t2 = 1; + break $label1$1; + } + if (alphaValue instanceof A.SassString && !alphaValue._hasQuotes && "none" === alphaValue._string$_text) { + t2 = _null; + break $label1$1; + } + t2 = A._percentageOrUnitless(alphaValue.assertNumber$1($name), 1, "alpha"); + t2 = isNaN(t2) ? 0 : B.JSNumber_methods.clamp$2(t2, 0, 1); + break $label1$1; + } + if (space == null) + return A._functionString(functionName, A._setArrayType([input], type$.JSArray_Value)); + if (B.JSArray_methods.any$1(channels, new A._parseChannels_closure0())) { + if (channels.length === 3 && B.Set_9FDyj.contains$1(0, space)) { + t2 = A.List_List$of(channels, true, type$.Value); + if (!t1) + t2.push(alphaValue); + t1 = A._functionString(functionName, t2); + } else + t1 = A._functionString(functionName, A._setArrayType([input], type$.JSArray_Value)); + return t1; + } + if (channels.length !== 3) + throw A.wrapException(A.SassScriptException$("The " + space.toString$0(0) + " color space has 3 channels but " + input.toString$0(0) + " has " + channels.length + ".", $name)); + t1 = channels[0]; + t1 = t1 instanceof A.SassNumber ? t1 : _null; + t3 = channels[1]; + t3 = t3 instanceof A.SassNumber ? t3 : _null; + t4 = channels[2]; + t4 = t4 instanceof A.SassNumber ? t4 : _null; + return A._colorFromChannels(space, t1, t3, t4, t2, true, space === B.RgbColorSpace_i0P); + }, + _parseSlashChannels(input, $name) { + var _1_1, alphaValue, t1, components, _1_7, _1_9_isSet, _1_8, _1_9, initial, t2, _0_0, _0_1, channel3, alpha, _1_16, _1_16_isSet, _1_9_isSet0, t3, _null = null, + _1_0 = input.assertCommonListStyle$2$allowSlash($name, true); + $label0$0: { + _1_1 = _1_0.length; + alphaValue = _null; + t1 = false; + if (_1_1 === 2) { + components = _1_0[0]; + alphaValue = _1_0[1]; + t1 = input.get$separator(input) === B.ListSeparator_bRz; + } else + components = _null; + if (t1) { + t1 = new A._Record_2(components, alphaValue); + break $label0$0; + } + t1 = input.get$separator(input); + if (t1 === B.ListSeparator_bRz) { + t1 = _1_0.length; + A.throwExpression(A.SassScriptException$(string$.Only_2 + t1 + " " + A.pluralize("was", t1, "were") + " passed.", $name)); + } + _1_7 = _1_1 >= 1; + _1_9_isSet = _1_7; + _1_8 = _null; + _1_9 = _null; + initial = _null; + t1 = false; + if (_1_9_isSet) { + _1_8 = B.JSArray_methods.sublist$2(_1_0, 0, _1_1 - 1); + initial = _1_8; + _1_9 = _1_0[_1_1 - 1]; + t2 = _1_9; + if (t2 instanceof A.SassString) { + type$.SassString._as(_1_9); + t1 = !_1_9._hasQuotes; + } + } + if (t1) { + if (_1_9_isSet) + t1 = _1_9; + else { + _1_9 = _1_0[_1_1 - 1]; + t1 = _1_9; + } + _0_0 = type$.SassString._as(t1)._string$_text.split("/"); + $label1$1: { + _0_1 = _0_0.length; + if (_0_1 === 1) { + t1 = new A._Record_2(input, _null); + break $label1$1; + } + if (_0_1 === 2) { + channel3 = _0_0[0]; + alpha = _0_0[1]; + t1 = A.List_List$of(initial, true, type$.Value); + t1.push(A._parseNumberOrString(channel3)); + t1 = new A._Record_2(A.SassList$(t1, B.ListSeparator_qSL, false), A._parseNumberOrString(alpha)); + break $label1$1; + } + t1 = _null; + break $label1$1; + } + break $label0$0; + } + _1_16 = _null; + _1_16_isSet = false; + t1 = false; + if (_1_7) { + _1_9_isSet0 = true; + if (_1_9_isSet) + initial = _1_8; + else { + _1_8 = B.JSArray_methods.sublist$2(_1_0, 0, _1_1 - 1); + initial = _1_8; + } + if (_1_9_isSet) + t2 = _1_9; + else { + _1_9 = _1_0[_1_1 - 1]; + t2 = _1_9; + _1_9_isSet = _1_9_isSet0; + } + _1_16_isSet = t2 instanceof A.SassNumber; + if (_1_16_isSet) { + if (_1_9_isSet) + t1 = _1_9; + else { + _1_9 = _1_0[_1_1 - 1]; + t1 = _1_9; + _1_9_isSet = _1_9_isSet0; + } + _1_16 = type$.SassNumber._as(t1).asSlash; + t1 = _1_16; + t1 = type$.Record_2_nullable_Object_and_nullable_Object._is(t1); + } + } else + initial = _null; + if (t1) { + if (_1_16_isSet) + t1 = _1_16; + else { + if (_1_9_isSet) + t1 = _1_9; + else { + _1_9 = _1_0[_1_1 - 1]; + t1 = _1_9; + _1_9_isSet = true; + } + _1_16 = type$.SassNumber._as(t1).asSlash; + t1 = _1_16; + _1_16_isSet = true; + } + if (t1 == null) + t1 = type$.Record_2_nullable_Object_and_nullable_Object._as(t1); + if (_1_16_isSet) + t2 = _1_16; + else { + if (_1_9_isSet) + t2 = _1_9; + else { + _1_9 = _1_0[_1_1 - 1]; + t2 = _1_9; + } + _1_16 = type$.SassNumber._as(t2).asSlash; + t2 = _1_16; + } + if (t2 == null) + t2 = type$.Record_2_nullable_Object_and_nullable_Object._as(t2); + t3 = A.List_List$of(initial, true, type$.Value); + t3.push(t1._0); + t2 = new A._Record_2(A.SassList$(t3, B.ListSeparator_qSL, false), t2._1); + t1 = t2; + break $label0$0; + } + t1 = new A._Record_2(input, _null); + break $label0$0; + } + return t1; + }, + _parseNumberOrString(text) { + var t1, expression, exception; + try { + t1 = A.ScssParser$(text, null); + expression = t1._parseSingleProduction$1$1(t1.get$_number(), type$.NumberExpression); + t1 = A.SassNumber_SassNumber(expression.value, expression.unit); + return t1; + } catch (exception) { + if (type$.SassFormatException._is(A.unwrapException(exception))) + return new A.SassString(text, false); + else + throw exception; + } + }, + _colorFromChannels(space, channel0, channel1, channel2, alpha, clamp, fromRgbFunction) { + var t1, t2, whiteness, blackness, t3; + switch (space) { + case B.HslColorSpace_JQ2: + if (channel1 != null) + A._checkPercent(channel1, "saturation"); + if (channel2 != null) + A._checkPercent(channel2, "lightness"); + t1 = space._channels; + return A.SassColor_SassColor$hsl(A.NullableExtension_andThen(channel0, new A._colorFromChannels_closure()), A._channelFromValue(t1[1], A._forcePercent(channel1), clamp), A._channelFromValue(t1[2], A._forcePercent(channel2), clamp), alpha); + case B.HwbColorSpace_guQ: + t1 = channel1 == null; + if (!t1) + channel1.assertUnit$2("%", "whiteness"); + t2 = channel2 == null; + if (!t2) + channel2.assertUnit$2("%", "blackness"); + whiteness = t1 ? null : channel1._number$_value; + blackness = t2 ? null : channel2._number$_value; + if (whiteness != null && blackness != null && whiteness + blackness > 100) { + t1 = whiteness + blackness; + whiteness = whiteness / t1 * 100; + blackness = blackness / t1 * 100; + } + return A.SassColor_SassColor$hwb(A.NullableExtension_andThen(channel0, new A._colorFromChannels_closure0()), whiteness, blackness, alpha); + case B.RgbColorSpace_i0P: + t1 = space._channels; + t2 = A._channelFromValue(t1[0], channel0, clamp); + t3 = A._channelFromValue(t1[1], channel1, clamp); + t1 = A._channelFromValue(t1[2], channel2, clamp); + return A.SassColor_SassColor$rgbInternal(t2, t3, t1, alpha, fromRgbFunction ? B.C__ColorFormatEnum : null); + default: + t1 = space._channels; + return A.SassColor_SassColor$forSpaceInternal(space, A._channelFromValue(t1[0], channel0, clamp), A._channelFromValue(t1[1], channel1, clamp), A._channelFromValue(t1[2], channel2, clamp), alpha); + } + }, + _forcePercent(number) { + var t1, _0_3; + $label0$0: { + if (number == null) { + t1 = null; + break $label0$0; + } + _0_3 = number.get$numeratorUnits(number); + if (_0_3.length === 1) + t1 = "%" === _0_3[0] && number.get$denominatorUnits(number).length <= 0; + else + t1 = false; + if (t1) { + t1 = number; + break $label0$0; + } + t1 = A.SassNumber_SassNumber(number._number$_value, "%"); + break $label0$0; + } + return t1; + }, + _channelFromValue(channel, value, clamp) { + return A.NullableExtension_andThen(value, new A._channelFromValue_closure(channel, clamp)); + }, + _isNone(value) { + return value instanceof A.SassString && !value._hasQuotes && value._string$_text.toLowerCase() === "none"; + }, + _channelFunction($name, space, getter, global, unit) { + return A.BuiltInCallable$function($name, "$color", new A._channelFunction_closure(getter, unit, global, $name, space), "sass:color"); + }, + _suggestScaleAndAdjust(original, adjustment, channelName) { + var t2, oldValue, newValue, factor, t3, suggestion, + channel = channelName === "alpha" ? B.LinearChannel_XL8 : type$.LinearChannel._as(B.JSArray_methods.firstWhere$1(B.List_oAL, new A._suggestScaleAndAdjust_closure(channelName))), + t1 = channel === B.LinearChannel_XL8; + if (t1) { + t2 = original.alphaOrNull; + oldValue = t2 == null ? 0 : t2; + } else + oldValue = original.toSpace$1(B.HslColorSpace_JQ2).channel$1(0, channelName); + newValue = oldValue + adjustment; + if (adjustment !== 0) { + factor = A._Cell$(); + t2 = channel.max; + if (newValue > t2) + factor.__late_helper$_value = 1; + else { + t3 = channel.min; + if (newValue < t3) + factor.__late_helper$_value = -1; + else if (adjustment > 0) + factor.__late_helper$_value = adjustment / (t2 - oldValue); + else + factor.__late_helper$_value = (newValue - oldValue) / (oldValue - t3); + } + suggestion = "Suggestion" + ("s:\n\ncolor.scale($color, $" + channelName + ": " + A.SassNumber_SassNumber(factor._readLocal$0() * 100, "%").toString$0(0) + ")\n"); + } else + suggestion = "Suggestion:\n\n"; + return suggestion + ("color.adjust($color, $" + channelName + ": " + A.SassNumber_SassNumber(adjustment, t1 ? null : "%").toString$0(0) + ")"); + }, + _missingChannelError(color, channel) { + return A.throwExpression(A.SassScriptException$(string$.Becaus + color.toString$0(0) + ").", channel)); + }, + _channelName(value) { + var t1 = value.assertString$1("channel"); + t1.assertQuoted$1("channel"); + return t1._string$_text; + }, + _function5($name, $arguments, callback) { + return A.BuiltInCallable$function($name, $arguments, callback, "sass:color"); + }, + global_closure0: function global_closure0() { + }, + global_closure1: function global_closure1() { + }, + global_closure2: function global_closure2() { + }, + global_closure3: function global_closure3() { + }, + global_closure4: function global_closure4() { + }, + global_closure5: function global_closure5() { + }, + global_closure6: function global_closure6() { + }, + global_closure7: function global_closure7() { + }, + global_closure8: function global_closure8() { + }, + global_closure9: function global_closure9() { + }, + global_closure10: function global_closure10() { + }, + global_closure11: function global_closure11() { + }, + global_closure12: function global_closure12() { + }, + global_closure13: function global_closure13() { + }, + global_closure14: function global_closure14() { + }, + global_closure15: function global_closure15() { + }, + global_closure16: function global_closure16() { + }, + global_closure17: function global_closure17() { + }, + global_closure18: function global_closure18() { + }, + global_closure19: function global_closure19() { + }, + global_closure20: function global_closure20() { + }, + global_closure21: function global_closure21() { + }, + global_closure22: function global_closure22() { + }, + global_closure23: function global_closure23() { + }, + global_closure24: function global_closure24() { + }, + global_closure25: function global_closure25() { + }, + global_closure26: function global_closure26() { + }, + global_closure27: function global_closure27() { + }, + global_closure28: function global_closure28() { + }, + global_closure29: function global_closure29() { + }, + global_closure30: function global_closure30() { + }, + global_closure31: function global_closure31() { + }, + global_closure32: function global_closure32() { + }, + global_closure33: function global_closure33() { + }, + global_closure34: function global_closure34() { + }, + global_closure35: function global_closure35() { + }, + global__closure: function global__closure() { + }, + global_closure36: function global_closure36() { + }, + global_closure37: function global_closure37() { + }, + global_closure38: function global_closure38() { + }, + global_closure39: function global_closure39() { + }, + global_closure40: function global_closure40() { + }, + global_closure41: function global_closure41() { + }, + global_closure42: function global_closure42() { + }, + module_closure1: function module_closure1() { + }, + module_closure2: function module_closure2() { + }, + module_closure3: function module_closure3() { + }, + module_closure4: function module_closure4() { + }, + module_closure5: function module_closure5() { + }, + module_closure6: function module_closure6() { + }, + module_closure7: function module_closure7() { + }, + module_closure8: function module_closure8() { + }, + module_closure9: function module_closure9() { + }, + module_closure10: function module_closure10() { + }, + module_closure11: function module_closure11() { + }, + module_closure12: function module_closure12() { + }, + module_closure13: function module_closure13() { + }, + module_closure14: function module_closure14() { + }, + module__closure2: function module__closure2() { + }, + module_closure15: function module_closure15() { + }, + module_closure16: function module_closure16() { + }, + module_closure17: function module_closure17() { + }, + module_closure18: function module_closure18() { + }, + module_closure19: function module_closure19() { + }, + module_closure20: function module_closure20() { + }, + module_closure21: function module_closure21() { + }, + module_closure22: function module_closure22() { + }, + module__closure1: function module__closure1(t0) { + this.channelName = t0; + }, + module_closure23: function module_closure23() { + }, + module_closure_toXyzNoMissing: function module_closure_toXyzNoMissing() { + }, + module_closure24: function module_closure24() { + }, + _mix_closure: function _mix_closure() { + }, + _complement_closure: function _complement_closure() { + }, + _adjust_closure: function _adjust_closure() { + }, + _scale_closure: function _scale_closure() { + }, + _change_closure: function _change_closure() { + }, + _ieHexStr_closure: function _ieHexStr_closure() { + }, + _ieHexStr_closure_hexString: function _ieHexStr_closure_hexString() { + }, + _updateComponents_closure: function _updateComponents_closure(t0) { + this.originalColor = t0; + }, + _updateComponents_closure0: function _updateComponents_closure0(t0) { + this._box_0 = t0; + }, + _changeColor_closure: function _changeColor_closure(t0) { + this.alphaArg = t0; + }, + _adjustColor_closure: function _adjustColor_closure() { + }, + _functionString_closure: function _functionString_closure() { + }, + _removedColorFunction_closure: function _removedColorFunction_closure(t0, t1, t2) { + this.name = t0; + this.argument = t1; + this.negative = t2; + }, + _rgb_closure: function _rgb_closure() { + }, + _hsl_closure: function _hsl_closure() { + }, + _parseChannels_closure: function _parseChannels_closure() { + }, + _parseChannels_closure0: function _parseChannels_closure0() { + }, + _colorFromChannels_closure: function _colorFromChannels_closure() { + }, + _colorFromChannels_closure0: function _colorFromChannels_closure0() { + }, + _channelFromValue_closure: function _channelFromValue_closure(t0, t1) { + this.channel = t0; + this.clamp = t1; + }, + _channelFunction_closure: function _channelFunction_closure(t0, t1, t2, t3, t4) { + var _ = this; + _.getter = t0; + _.unit = t1; + _.global = t2; + _.name = t3; + _.space = t4; + }, + _suggestScaleAndAdjust_closure: function _suggestScaleAndAdjust_closure(t0) { + this.channelName = t0; + }, + _function4($name, $arguments, callback) { + return A.BuiltInCallable$function($name, $arguments, callback, "sass:list"); + }, + _length_closure0: function _length_closure0() { + }, + _nth_closure: function _nth_closure() { + }, + _setNth_closure: function _setNth_closure() { + }, + _join_closure: function _join_closure() { + }, + _append_closure0: function _append_closure0() { + }, + _zip_closure: function _zip_closure() { + }, + _zip__closure: function _zip__closure() { + }, + _zip__closure0: function _zip__closure0(t0) { + this._box_0 = t0; + }, + _zip__closure1: function _zip__closure1(t0) { + this._box_0 = t0; + }, + _index_closure0: function _index_closure0() { + }, + _separator_closure: function _separator_closure() { + }, + _isBracketed_closure: function _isBracketed_closure() { + }, + _slash_closure: function _slash_closure() { + }, + _modify(map, keys, modify, addNesting) { + var keyIterator = J.get$iterator$ax(keys); + return keyIterator.moveNext$0() ? new A._modify_modifyNestedMap(keyIterator, modify, addNesting).call$1(map) : modify.call$1(map); + }, + _deepMergeImpl(map1, map2) { + var t2, t3, result, t4, key, value, _1_1, _1_3, _1_3_isSet, _1_30, resultMap, valueMap, merged, + t1 = map1._map$_contents; + if (t1.get$isEmpty(t1)) + return map2; + t2 = map2._map$_contents; + if (t2.get$isEmpty(t2)) + return map1; + t3 = type$.Value; + result = A.LinkedHashMap_LinkedHashMap$of(t1, t3, t3); + for (t1 = A.MapExtensions_get_pairs(t2, t3, t3), t1 = t1.get$iterator(t1), t2 = type$.SassMap; t1.moveNext$0();) { + t4 = t1.get$current(t1); + key = t4._0; + value = t4._1; + t4 = result.$index(0, key); + _1_1 = t4 == null ? null : t4.tryMap$0(); + _1_3 = value.tryMap$0(); + _1_3_isSet = _1_1 != null; + _1_30 = null; + t4 = false; + if (_1_3_isSet) { + resultMap = _1_1 == null ? t2._as(_1_1) : _1_1; + t4 = _1_3 != null; + _1_30 = _1_3; + } else + resultMap = null; + if (t4) { + valueMap = _1_3_isSet ? _1_30 : _1_3; + merged = A._deepMergeImpl(resultMap, valueMap == null ? t2._as(valueMap) : valueMap); + if (merged === resultMap) + continue; + result.$indexSet(0, key, merged); + } else + result.$indexSet(0, key, value); + } + return new A.SassMap(A.ConstantMap_ConstantMap$from(result, t3, t3)); + }, + _function3($name, $arguments, callback) { + return A.BuiltInCallable$function($name, $arguments, callback, "sass:map"); + }, + _get_closure: function _get_closure() { + }, + _set_closure: function _set_closure() { + }, + _set__closure0: function _set__closure0(t0) { + this.$arguments = t0; + }, + _set_closure0: function _set_closure0() { + }, + _set__closure: function _set__closure(t0) { + this._box_0 = t0; + }, + _merge_closure: function _merge_closure() { + }, + _merge_closure0: function _merge_closure0() { + }, + _merge__closure: function _merge__closure(t0) { + this.map2 = t0; + }, + _deepMerge_closure: function _deepMerge_closure() { + }, + _deepRemove_closure: function _deepRemove_closure() { + }, + _deepRemove__closure: function _deepRemove__closure(t0) { + this.keys = t0; + }, + _remove_closure: function _remove_closure() { + }, + _remove_closure0: function _remove_closure0() { + }, + _keys_closure: function _keys_closure() { + }, + _values_closure: function _values_closure() { + }, + _hasKey_closure: function _hasKey_closure() { + }, + _modify_modifyNestedMap: function _modify_modifyNestedMap(t0, t1, t2) { + this.keyIterator = t0; + this.modify = t1; + this.addNesting = t2; + }, + _singleArgumentMathFunc($name, mathFunc) { + return A.BuiltInCallable$function($name, "$number", new A._singleArgumentMathFunc_closure(mathFunc), "sass:math"); + }, + _numberFunction($name, transform) { + return A.BuiltInCallable$function($name, "$number", new A._numberFunction_closure(transform), "sass:math"); + }, + _function2($name, $arguments, callback) { + return A.BuiltInCallable$function($name, $arguments, callback, "sass:math"); + }, + global_closure: function global_closure() { + }, + module_closure0: function module_closure0() { + }, + _ceil_closure: function _ceil_closure() { + }, + _clamp_closure: function _clamp_closure() { + }, + _floor_closure: function _floor_closure() { + }, + _max_closure: function _max_closure() { + }, + _min_closure: function _min_closure() { + }, + _round_closure: function _round_closure() { + }, + _hypot_closure: function _hypot_closure() { + }, + _hypot__closure: function _hypot__closure() { + }, + _log_closure: function _log_closure() { + }, + _pow_closure: function _pow_closure() { + }, + _atan2_closure: function _atan2_closure() { + }, + _compatible_closure: function _compatible_closure() { + }, + _isUnitless_closure: function _isUnitless_closure() { + }, + _unit_closure: function _unit_closure() { + }, + _percentage_closure: function _percentage_closure() { + }, + _randomFunction_closure: function _randomFunction_closure() { + }, + _div_closure: function _div_closure() { + }, + _singleArgumentMathFunc_closure: function _singleArgumentMathFunc_closure(t0) { + this.mathFunc = t0; + }, + _numberFunction_closure: function _numberFunction_closure(t0) { + this.transform = t0; + }, + _function($name, $arguments, callback) { + return A.BuiltInCallable$function($name, $arguments, callback, "sass:meta"); + }, + _shared_closure: function _shared_closure() { + }, + _shared_closure0: function _shared_closure0() { + }, + _shared_closure1: function _shared_closure1() { + }, + _shared_closure2: function _shared_closure2() { + }, + moduleFunctions_closure: function moduleFunctions_closure() { + }, + moduleFunctions_closure0: function moduleFunctions_closure0() { + }, + moduleFunctions__closure: function moduleFunctions__closure() { + }, + moduleFunctions_closure1: function moduleFunctions_closure1() { + }, + _prependParent(compound) { + var _0_3, _0_4, t2, _0_4_isSet, t3, rest, + t1 = A.EvaluationContext_currentOrNull(), + span = (t1 == null ? A.throwExpression(A.StateError$(string$.No_Sass)) : t1).get$currentCallableSpan(), + _0_0 = compound.components; + $label0$0: { + _0_3 = _0_0.length >= 1; + if (_0_3) { + _0_4 = _0_0[0]; + t1 = _0_4 instanceof A.UniversalSelector; + } else { + _0_4 = null; + t1 = false; + } + t2 = null; + if (t1) { + t1 = t2; + break $label0$0; + } + t1 = false; + if (_0_3) { + _0_4_isSet = true; + t3 = _0_4; + if (t3 instanceof A.TypeSelector) { + t1 = _0_4; + t1 = type$.TypeSelector._as(t1).name.namespace != null; + } + } else + _0_4_isSet = _0_3; + if (t1) { + t1 = t2; + break $label0$0; + } + if (_0_3) { + if (_0_4_isSet) + t1 = _0_4; + else { + _0_4 = _0_0[0]; + t1 = _0_4; + _0_4_isSet = true; + } + t1 = t1 instanceof A.TypeSelector; + } else + t1 = false; + if (t1) { + t1 = _0_4_isSet ? _0_4 : _0_0[0]; + type$.TypeSelector._as(t1); + rest = B.JSArray_methods.sublist$1(_0_0, 1); + t1 = A._setArrayType([new A.ParentSelector(t1.name.name, span)], type$.JSArray_SimpleSelector); + B.JSArray_methods.addAll$1(t1, rest); + t1 = A.CompoundSelector$(t1, span); + break $label0$0; + } + t1 = A._setArrayType([new A.ParentSelector(null, span)], type$.JSArray_SimpleSelector); + B.JSArray_methods.addAll$1(t1, _0_0); + t1 = A.CompoundSelector$(t1, span); + break $label0$0; + } + return t1; + }, + _function1($name, $arguments, callback) { + return A.BuiltInCallable$function($name, $arguments, callback, "sass:selector"); + }, + _nest_closure: function _nest_closure() { + }, + _nest__closure: function _nest__closure(t0) { + this._box_0 = t0; + }, + _nest__closure0: function _nest__closure0() { + }, + _append_closure: function _append_closure() { + }, + _append__closure: function _append__closure() { + }, + _append__closure0: function _append__closure0(t0) { + this.span = t0; + }, + _append___closure: function _append___closure(t0, t1) { + this.parent = t0; + this.span = t1; + }, + _extend_closure: function _extend_closure() { + }, + _replace_closure: function _replace_closure() { + }, + _unify_closure: function _unify_closure() { + }, + _isSuperselector_closure: function _isSuperselector_closure() { + }, + _simpleSelectors_closure: function _simpleSelectors_closure() { + }, + _simpleSelectors__closure: function _simpleSelectors__closure() { + }, + _parse_closure: function _parse_closure() { + }, + _codepointForIndex(index, lengthInCodepoints, allowNegative) { + var result; + if (index === 0) + return 0; + if (index > 0) + return Math.min(index - 1, lengthInCodepoints); + result = lengthInCodepoints + index; + if (result < 0 && !allowNegative) + return 0; + return result; + }, + _function0($name, $arguments, callback) { + return A.BuiltInCallable$function($name, $arguments, callback, "sass:string"); + }, + module_closure: function module_closure() { + }, + module__closure: function module__closure(t0) { + this.string = t0; + }, + module__closure0: function module__closure0(t0) { + this.string = t0; + }, + _unquote_closure: function _unquote_closure() { + }, + _quote_closure: function _quote_closure() { + }, + _length_closure: function _length_closure() { + }, + _insert_closure: function _insert_closure() { + }, + _index_closure: function _index_closure() { + }, + _slice_closure: function _slice_closure() { + }, + _toUpperCase_closure: function _toUpperCase_closure() { + }, + _toLowerCase_closure: function _toLowerCase_closure() { + }, + _uniqueId_closure: function _uniqueId_closure() { + }, + ImportCache$(importers, loadPaths) { + var t1 = type$.nullable_Record_3_Importer_and_Uri_and_Uri_originalUrl, + t2 = type$.Record_3_Importer_and_Uri_and_bool_forImport, + t3 = type$.Uri; + return new A.ImportCache(A.ImportCache__toImporters(importers, loadPaths, null), A.LinkedHashMap_LinkedHashMap$_empty(type$.Record_2_Uri_and_bool_forImport, t1), A.LinkedHashMap_LinkedHashMap$_empty(t2, t1), A.LinkedHashMap_LinkedHashMap$_empty(t2, t3), A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.nullable_Stylesheet), A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.ImporterResult), A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.DateTime)); + }, + ImportCache__toImporters(importers, loadPaths, packageConfig) { + var t1, t2, t3, t4, _i, path, _null = null, + sassPath = A.getEnvironmentVariable("SASS_PATH"); + if (A.isBrowser()) { + t1 = A._setArrayType([], type$.JSArray_Importer); + B.JSArray_methods.addAll$1(t1, importers); + return t1; + } + t1 = A._setArrayType([], type$.JSArray_Importer); + B.JSArray_methods.addAll$1(t1, importers); + for (t2 = J.get$iterator$ax(loadPaths); t2.moveNext$0();) { + t3 = t2.get$current(t2); + t1.push(new A.FilesystemImporter($.$get$context().absolute$15(t3, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null), false)); + } + if (sassPath != null) { + t2 = A.isNodeJs() ? self.process : _null; + t3 = sassPath.split(J.$eq$(t2 == null ? _null : J.get$platform$x(t2), "win32") ? ";" : ":"); + t4 = t3.length; + _i = 0; + for (; _i < t4; ++_i) { + path = t3[_i]; + t1.push(new A.FilesystemImporter($.$get$context().absolute$15(path, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null), false)); + } + } + return t1; + }, + ImportCache: function ImportCache(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._importers = t0; + _._canonicalizeCache = t1; + _._perImporterCanonicalizeCache = t2; + _._nonCanonicalRelativeUrls = t3; + _._importCache = t4; + _._resultsCache = t5; + _._loadTimes = t6; + }, + ImportCache_canonicalize_closure: function ImportCache_canonicalize_closure(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.$this = t0; + _.baseImporter = t1; + _.resolvedUrl = t2; + _.baseUrl = t3; + _.forImport = t4; + _.key = t5; + _.url = t6; + }, + ImportCache__canonicalize_closure: function ImportCache__canonicalize_closure(t0, t1) { + this.importer = t0; + this.url = t1; + }, + ImportCache_importCanonical_closure: function ImportCache_importCanonical_closure(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.importer = t1; + _.canonicalUrl = t2; + _.originalUrl = t3; + }, + ImportCache_humanize_closure: function ImportCache_humanize_closure(t0) { + this.canonicalUrl = t0; + }, + ImportCache_humanize_closure0: function ImportCache_humanize_closure0() { + }, + ImportCache_humanize_closure1: function ImportCache_humanize_closure1() { + }, + ImportCache_humanize_closure2: function ImportCache_humanize_closure2(t0) { + this.canonicalUrl = t0; + }, + Importer: function Importer() { + }, + AsyncImporter: function AsyncImporter() { + }, + CanonicalizeContext: function CanonicalizeContext(t0, t1) { + this._fromImport = t0; + this._containingUrl = t1; + this._wasContainingUrlAccessed = false; + }, + FilesystemImporter: function FilesystemImporter(t0, t1) { + this._loadPath = t0; + this._loadPathDeprecated = t1; + }, + FilesystemImporter_canonicalize_closure: function FilesystemImporter_canonicalize_closure() { + }, + NoOpImporter: function NoOpImporter() { + }, + NodePackageImporter: function NodePackageImporter() { + this.__NodePackageImporter__entryPointDirectory_F = $; + }, + NodePackageImporter__nodePackageExportsResolve_closure: function NodePackageImporter__nodePackageExportsResolve_closure() { + }, + NodePackageImporter__nodePackageExportsResolve_closure0: function NodePackageImporter__nodePackageExportsResolve_closure0() { + }, + NodePackageImporter__nodePackageExportsResolve_closure1: function NodePackageImporter__nodePackageExportsResolve_closure1() { + }, + NodePackageImporter__nodePackageExportsResolve_closure2: function NodePackageImporter__nodePackageExportsResolve_closure2(t0, t1, t2) { + this.$this = t0; + this.exports = t1; + this.packageRoot = t2; + }, + NodePackageImporter__nodePackageExportsResolve__closure: function NodePackageImporter__nodePackageExportsResolve__closure(t0, t1, t2) { + this.$this = t0; + this.variant = t1; + this.packageRoot = t2; + }, + NodePackageImporter__nodePackageExportsResolve__closure0: function NodePackageImporter__nodePackageExportsResolve__closure0() { + }, + NodePackageImporter__getMainExport_closure: function NodePackageImporter__getMainExport_closure() { + }, + ImporterResult: function ImporterResult(t0, t1, t2) { + this.contents = t0; + this._sourceMapUrl = t1; + this.syntax = t2; + }, + fromImport() { + var t1 = type$.nullable_CanonicalizeContext._as($.Zone__current.$index(0, B.Symbol__canonicalizeContext)); + t1 = t1 == null ? null : t1._fromImport; + return t1 === true; + }, + canonicalizeContext() { + var t1, + _0_0 = $.Zone__current.$index(0, B.Symbol__canonicalizeContext); + $label0$0: { + if (_0_0 == null) + A.throwExpression(A.StateError$(string$.canoni)); + if (_0_0 instanceof A.CanonicalizeContext) { + t1 = _0_0; + break $label0$0; + } + t1 = A.throwExpression(A.StateError$(string$.Unexpe + A.S(_0_0) + ".")); + } + return t1; + }, + resolveImportPath(path) { + var t1, + extension = A.ParsedPath_ParsedPath$parse(path, $.$get$context().style)._splitExtension$1(1)[1]; + if (extension === ".sass" || extension === ".scss" || extension === ".css") { + t1 = A.fromImport() ? new A.resolveImportPath_closure(path, extension).call$0() : null; + return t1 == null ? A._exactlyOne(A._tryPath(path)) : t1; + } + t1 = A.fromImport() ? new A.resolveImportPath_closure0(path).call$0() : null; + if (t1 == null) + t1 = A._exactlyOne(A._tryPathWithExtensions(path)); + return t1 == null ? A._tryPathAsDirectory(path) : t1; + }, + _tryPathWithExtensions(path) { + var result = A._tryPath(path + ".sass"); + B.JSArray_methods.addAll$1(result, A._tryPath(path + ".scss")); + return result.length !== 0 ? result : A._tryPath(path + ".css"); + }, + _tryPath(path) { + var t1 = $.$get$context(), + partial = A.join(t1.dirname$1(path), "_" + A.ParsedPath_ParsedPath$parse(path, t1.style).get$basename(), null); + t1 = A._setArrayType([], type$.JSArray_String); + if (A.fileExists(partial)) + t1.push(partial); + if (A.fileExists(path)) + t1.push(path); + return t1; + }, + _tryPathAsDirectory(path) { + var t1; + if (!A.dirExists(path)) + return null; + t1 = A.fromImport() ? new A._tryPathAsDirectory_closure(path).call$0() : null; + return t1 == null ? A._exactlyOne(A._tryPathWithExtensions(A.join(path, "index", null))) : t1; + }, + _exactlyOne(paths) { + var _0_1, t1, path; + $label0$0: { + _0_1 = paths.length; + if (_0_1 <= 0) { + t1 = null; + break $label0$0; + } + if (_0_1 === 1) { + path = paths[0]; + t1 = path; + break $label0$0; + } + t1 = A.throwExpression(string$.It_s_n + B.JSArray_methods.map$1$1(paths, new A._exactlyOne_closure(), type$.String).join$1(0, "\n")); + } + return t1; + }, + resolveImportPath_closure: function resolveImportPath_closure(t0, t1) { + this.path = t0; + this.extension = t1; + }, + resolveImportPath_closure0: function resolveImportPath_closure0(t0) { + this.path = t0; + }, + _tryPathAsDirectory_closure: function _tryPathAsDirectory_closure(t0) { + this.path = t0; + }, + _exactlyOne_closure: function _exactlyOne_closure() { + }, + InterpolationBuffer: function InterpolationBuffer(t0, t1, t2) { + this._interpolation_buffer$_text = t0; + this._interpolation_buffer$_contents = t1; + this._spans = t2; + }, + InterpolationMap$(_interpolation, targetLocations) { + var t1 = A.List_List$unmodifiable(targetLocations, type$.SourceLocation), + t2 = _interpolation.contents.length, + expectedLocations = Math.max(0, t2 - 1); + if (t1.length !== expectedLocations) + A.throwExpression(A.ArgumentError$("InterpolationMap must have " + A.S(expectedLocations) + string$.x20targe + t2 + " components.", null)); + return new A.InterpolationMap(_interpolation, t1); + }, + InterpolationMap: function InterpolationMap(t0, t1) { + this._interpolation = t0; + this._targetLocations = t1; + }, + InterpolationMap_mapException_closure: function InterpolationMap_mapException_closure() { + }, + _realCasePath(path) { + var prefix, _null = null, + t1 = A.isNodeJs() ? self.process : _null; + if (!J.$eq$(t1 == null ? _null : J.get$platform$x(t1), "win32")) { + t1 = A.isNodeJs() ? self.process : _null; + t1 = J.$eq$(t1 == null ? _null : J.get$platform$x(t1), "darwin"); + } else + t1 = true; + if (!t1) + return path; + t1 = A.isNodeJs() ? self.process : _null; + if (J.$eq$(t1 == null ? _null : J.get$platform$x(t1), "win32")) { + prefix = B.JSString_methods.substring$2(path, 0, $.$get$context().style.rootLength$1(path)); + t1 = prefix.length; + if (t1 !== 0 && A.CharacterExtension_get_isAlphabetic(prefix.charCodeAt(0))) + path = prefix.toUpperCase() + B.JSString_methods.substring$1(path, t1); + } + return new A._realCasePath_helper().call$1(path); + }, + _realCasePath_helper: function _realCasePath_helper() { + }, + _realCasePath_helper_closure: function _realCasePath_helper_closure(t0, t1, t2, t3) { + var _ = this; + _.path = t0; + _.realPath = t1; + _.helper = t2; + _.dirname = t3; + }, + _realCasePath_helper__closure: function _realCasePath_helper__closure(t0) { + this.basename = t0; + }, + printError(message) { + var t1 = A.isNodeJs() ? self.process : null; + if (t1 != null) { + t1 = J.get$stderr$x(t1); + J.write$1$x(t1, A.S(message == null ? "" : message) + "\n"); + } else { + t1 = self.console; + J.error$1$x(t1, message == null ? "" : message); + } + }, + readFile(path) { + var contents, sourceFile, t1, i; + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$("readFile() is only supported on Node.js")); + contents = A._asString(A._readFile(path, "utf8")); + if (!B.JSString_methods.contains$1(contents, "\ufffd")) + return contents; + sourceFile = A.SourceFile$fromString(contents, $.$get$context().toUri$1(path)); + for (t1 = contents.length, i = 0; i < t1; ++i) { + if (contents.charCodeAt(i) !== 65533) + continue; + throw A.wrapException(A.SassException$("Invalid UTF-8.", A.FileLocation$_(sourceFile, i).pointSpan$0(), null)); + } + return contents; + }, + _readFile(path, encoding) { + return A._systemErrorToFileSystemException(new A._readFile_closure(path, encoding)); + }, + writeFile(path, contents) { + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$("writeFile() is only supported on Node.js")); + return A._systemErrorToFileSystemException(new A.writeFile_closure(path, contents)); + }, + deleteFile(path) { + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$("deleteFile() is only supported on Node.js")); + return A._systemErrorToFileSystemException(new A.deleteFile_closure(path)); + }, + readStdin() { + return A.readStdin$body(); + }, + readStdin$body() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.String), + $async$returnValue, t3, completer, sink, t1, t2; + var $async$readStdin = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = {}; + t2 = A.isNodeJs() ? self.process : null; + if (t2 == null) + throw A.wrapException(A.UnsupportedError$("readStdin() is only supported on Node.js")); + t3 = new A._Future($.Zone__current, type$._Future_String); + completer = new A._AsyncCompleter(t3, type$._AsyncCompleter_String); + t1.contents = null; + sink = new A._StringCallbackSink(new A.readStdin_closure(t1, completer), new A.StringBuffer("")).asUtf8Sink$1(false); + t1 = J.getInterceptor$x(t2); + J.on$2$x(t1.get$stdin(t2), "data", A.allowInterop(new A.readStdin_closure0(sink))); + J.on$2$x(t1.get$stdin(t2), "end", A.allowInterop(new A.readStdin_closure1(sink))); + J.on$2$x(t1.get$stdin(t2), "error", A.allowInterop(new A.readStdin_closure2(completer))); + $async$returnValue = t3; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$readStdin, $async$completer); + }, + fileExists(path) { + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$(string$.fileEx)); + return A._systemErrorToFileSystemException(new A.fileExists_closure(path)); + }, + dirExists(path) { + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$("dirExists() is only supported on Node.js")); + return A._systemErrorToFileSystemException(new A.dirExists_closure(path)); + }, + linkExists(path) { + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$(string$.linkEx)); + return A._systemErrorToFileSystemException(new A.linkExists_closure(path)); + }, + ensureDir(path) { + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$("ensureDir() is only supported on Node.js")); + return A._systemErrorToFileSystemException(new A.ensureDir_closure(path)); + }, + listDir(path, recursive) { + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$("listDir() is only supported on Node.js")); + return A._systemErrorToFileSystemException(new A.listDir_closure(recursive, path)); + }, + realpath(path) { + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$("listDir() is only supported on Node.js")); + return A._systemErrorToFileSystemException(new A.realpath_closure(path)); + }, + modificationTime(path) { + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$("modificationTime() is only supported on Node.js")); + return A._systemErrorToFileSystemException(new A.modificationTime_closure(path)); + }, + getEnvironmentVariable($name) { + var t1 = A.isNodeJs() ? self.process : null, + env = t1 == null ? null : J.get$env$x(t1); + if (env == null) + t1 = null; + else + t1 = A._asStringQ(env[$name]); + return t1; + }, + _systemErrorToFileSystemException(callback) { + var error, t1, exception, t2; + try { + t1 = callback.call$0(); + return t1; + } catch (exception) { + error = A.unwrapException(exception); + if (!type$.JsSystemError._is(error)) + throw exception; + t1 = error; + t2 = J.getInterceptor$x(t1); + throw A.wrapException(new A.FileSystemException(J.substring$2$s(t2.get$message(t1), (A.S(t2.get$code(t1)) + ": ").length, J.get$length$asx(t2.get$message(t1)) - (", " + A.S(t2.get$syscall(t1)) + " '" + A.S(t2.get$path(t1)) + "'").length), J.get$path$x(error))); + } + }, + hasTerminal() { + var t1 = A.isNodeJs() ? self.process : null; + return J.$eq$(t1 == null ? null : J.get$isTTY$x(J.get$stdout$x(t1)), true); + }, + isWindows() { + var t1 = A.isNodeJs() ? self.process : null; + return J.$eq$(t1 == null ? null : J.get$platform$x(t1), "win32"); + }, + watchDir(path, poll) { + return A.watchDir$body(path, poll); + }, + watchDir$body(path, poll) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Stream_WatchEvent), + $async$returnValue, _0_0, t2, parcel, controller, watcher, t3, t1, $async$temp1, $async$temp2, $async$temp3; + var $async$watchDir = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = {}; + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$("watchDir() is only supported on Node.js")); + t1.controller = null; + _0_0 = self.parcel_watcher; + if (_0_0 != null) { + t2 = !poll; + parcel = _0_0; + } else { + parcel = null; + t2 = false; + } + $async$goto = t2 ? 3 : 5; + break; + case 3: + // then + $async$temp1 = t1; + $async$temp2 = A; + $async$temp3 = A; + $async$goto = 6; + return A._asyncAwait(A.ParcelWatcher_subscribe(parcel, path, new A.watchDir_closure0(t1)), $async$watchDir); + case 6: + // returning from await. + controller = $async$temp1.controller = $async$temp2.StreamController_StreamController(new $async$temp3.watchDir_closure($async$result), null, null, null, false, type$.WatchEvent); + $async$returnValue = new A._ControllerStream(controller, A._instanceType(controller)._eval$1("_ControllerStream<1>")); + // goto return + $async$goto = 1; + break; + // goto join + $async$goto = 4; + break; + case 5: + // else + watcher = J.watch$2$x(self.chokidar, path, {usePolling: poll}); + t2 = J.getInterceptor$x(watcher); + t2.on$2(watcher, "add", A.allowInterop(new A.watchDir_closure1(t1))); + t2.on$2(watcher, "change", A.allowInterop(new A.watchDir_closure2(t1))); + t2.on$2(watcher, "unlink", A.allowInterop(new A.watchDir_closure3(t1))); + t2.on$2(watcher, "error", A.allowInterop(new A.watchDir_closure4(t1))); + t3 = new A._Future($.Zone__current, type$._Future_Stream_WatchEvent); + t2.on$2(watcher, "ready", A.allowInterop(new A.watchDir_closure5(t1, watcher, new A._AsyncCompleter(t3, type$._AsyncCompleter_Stream_WatchEvent)))); + $async$returnValue = t3; + // goto return + $async$goto = 1; + break; + case 4: + // join + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$watchDir, $async$completer); + }, + FileSystemException: function FileSystemException(t0, t1) { + this.message = t0; + this.path = t1; + }, + _readFile_closure: function _readFile_closure(t0, t1) { + this.path = t0; + this.encoding = t1; + }, + writeFile_closure: function writeFile_closure(t0, t1) { + this.path = t0; + this.contents = t1; + }, + deleteFile_closure: function deleteFile_closure(t0) { + this.path = t0; + }, + readStdin_closure: function readStdin_closure(t0, t1) { + this._box_0 = t0; + this.completer = t1; + }, + readStdin_closure0: function readStdin_closure0(t0) { + this.sink = t0; + }, + readStdin_closure1: function readStdin_closure1(t0) { + this.sink = t0; + }, + readStdin_closure2: function readStdin_closure2(t0) { + this.completer = t0; + }, + fileExists_closure: function fileExists_closure(t0) { + this.path = t0; + }, + dirExists_closure: function dirExists_closure(t0) { + this.path = t0; + }, + linkExists_closure: function linkExists_closure(t0) { + this.path = t0; + }, + ensureDir_closure: function ensureDir_closure(t0) { + this.path = t0; + }, + listDir_closure: function listDir_closure(t0, t1) { + this.recursive = t0; + this.path = t1; + }, + listDir__closure: function listDir__closure(t0) { + this.path = t0; + }, + listDir__closure0: function listDir__closure0() { + }, + listDir_closure_list: function listDir_closure_list() { + }, + listDir__list_closure: function listDir__list_closure(t0, t1) { + this.parent = t0; + this.list = t1; + }, + realpath_closure: function realpath_closure(t0) { + this.path = t0; + }, + modificationTime_closure: function modificationTime_closure(t0) { + this.path = t0; + }, + watchDir_closure0: function watchDir_closure0(t0) { + this._box_0 = t0; + }, + watchDir_closure: function watchDir_closure(t0) { + this.subscription = t0; + }, + watchDir_closure1: function watchDir_closure1(t0) { + this._box_0 = t0; + }, + watchDir_closure2: function watchDir_closure2(t0) { + this._box_0 = t0; + }, + watchDir_closure3: function watchDir_closure3(t0) { + this._box_0 = t0; + }, + watchDir_closure4: function watchDir_closure4(t0) { + this._box_0 = t0; + }, + watchDir_closure5: function watchDir_closure5(t0, t1, t2) { + this._box_0 = t0; + this.watcher = t1; + this.completer = t2; + }, + watchDir__closure: function watchDir__closure(t0) { + this.watcher = t0; + }, + JSArray0: function JSArray0() { + }, + Chokidar: function Chokidar() { + }, + ChokidarOptions: function ChokidarOptions() { + }, + ChokidarWatcher: function ChokidarWatcher() { + }, + JSFunction: function JSFunction() { + }, + ImmutableList: function ImmutableList() { + }, + ImmutableMap: function ImmutableMap() { + }, + NodeImporterResult: function NodeImporterResult() { + }, + RenderContext: function RenderContext() { + }, + RenderContextOptions: function RenderContextOptions() { + }, + RenderContextResult: function RenderContextResult() { + }, + RenderContextResultStats: function RenderContextResultStats() { + }, + JSModule: function JSModule() { + }, + JSModuleRequire: function JSModuleRequire() { + }, + ParcelWatcher_subscribe(_this, path, callback) { + var result, + t1 = new A.ParcelWatcher_subscribe_closure(callback); + if (typeof t1 == "function") + A.throwExpression(A.ArgumentError$("Attempting to rewrap a JS function.", null)); + result = function(_call, f) { + return function(arg1, arg2) { + return _call(f, arg1, arg2, arguments.length); + }; + }(A._callDartFunctionFast2, t1); + result[$.$get$DART_CLOSURE_PROPERTY_NAME()] = t1; + return A.promiseToFuture(_this.subscribe(path, result), type$.JSObject); + }, + ParcelWatcher_subscribe_closure: function ParcelWatcher_subscribe_closure(t0) { + this.callback = t0; + }, + JSClass: function JSClass() { + }, + JSUrl: function JSUrl() { + }, + jsThrow0(error) { + return type$.Never._as($.$get$_jsThrow0().call$1(error)); + }, + _PropertyDescriptor: function _PropertyDescriptor() { + }, + _RequireMain: function _RequireMain() { + }, + WarnForDeprecation_warnForDeprecation(_this, deprecation, message, span, trace) { + _this.internalWarn$4$deprecation$span$trace(message, deprecation, span, trace); + }, + LoggerWithDeprecationType: function LoggerWithDeprecationType() { + }, + _QuietLogger: function _QuietLogger() { + }, + DeprecationProcessingLogger: function DeprecationProcessingLogger(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._warningCounts = t0; + _._inner = t1; + _.silenceDeprecations = t2; + _.fatalDeprecations = t3; + _.futureDeprecations = t4; + _.limitRepetition = t5; + }, + DeprecationProcessingLogger_summarize_closure: function DeprecationProcessingLogger_summarize_closure() { + }, + DeprecationProcessingLogger_summarize_closure0: function DeprecationProcessingLogger_summarize_closure0() { + }, + StderrLogger: function StderrLogger(t0) { + this.color = t0; + }, + TrackingLogger: function TrackingLogger(t0) { + this._tracking$_logger = t0; + this._emittedDebug = this._emittedWarning = false; + }, + BuiltInModule$($name, functions, mixins, variables, $T) { + var t1 = A._Uri__Uri(null, $name, null, "sass"), + t2 = A.BuiltInModule__callableMap(functions, $T), + t3 = A.BuiltInModule__callableMap(mixins, $T), + t4 = variables == null ? B.Map_empty6 : new A.UnmodifiableMapView(variables, type$.UnmodifiableMapView_String_Value); + return new A.BuiltInModule(t1, t2, t3, t4, $T._eval$1("BuiltInModule<0>")); + }, + BuiltInModule__callableMap(callables, $T) { + var t2, _i, callable, + t1 = type$.String; + if (callables == null) + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, $T); + else { + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, $T); + for (t2 = callables.length, _i = 0; _i < callables.length; callables.length === t2 || (0, A.throwConcurrentModificationError)(callables), ++_i) { + callable = callables[_i]; + t1.$indexSet(0, callable.get$name(callable), callable); + } + t1 = new A.UnmodifiableMapView(t1, type$.$env_1_1_String._bind$1($T)._eval$1("UnmodifiableMapView<1,2>")); + } + return new A.UnmodifiableMapView(t1, type$.$env_1_1_String._bind$1($T)._eval$1("UnmodifiableMapView<1,2>")); + }, + BuiltInModule: function BuiltInModule(t0, t1, t2, t3, t4) { + var _ = this; + _.url = t0; + _.functions = t1; + _.mixins = t2; + _.variables = t3; + _.$ti = t4; + }, + ForwardedModuleView_ifNecessary(inner, rule, $T) { + var t2, + t1 = false; + if (rule.prefix == null) + if (rule.shownMixinsAndFunctions == null) + if (rule.shownVariables == null) { + t2 = rule.hiddenMixinsAndFunctions; + t2 = t2 == null ? null : t2._base.get$isEmpty(0); + if (t2 === true) { + t1 = rule.hiddenVariables; + t1 = t1 == null ? null : t1._base.get$isEmpty(0); + t1 = t1 === true; + } + } + if (t1) + return inner; + else + return A.ForwardedModuleView$(inner, rule, $T); + }, + ForwardedModuleView$(_inner, _rule, $T) { + var t1 = _rule.prefix, + t2 = _rule.shownVariables, + t3 = _rule.hiddenVariables, + t4 = _rule.shownMixinsAndFunctions, + t5 = _rule.hiddenMixinsAndFunctions; + return new A.ForwardedModuleView(_inner, _rule, A.ForwardedModuleView__forwardedMap(_inner.get$variables(), t1, t2, t3, type$.Value), A.ForwardedModuleView__forwardedMap(_inner.get$variableNodes(), t1, t2, t3, type$.AstNode), A.ForwardedModuleView__forwardedMap(_inner.get$functions(_inner), t1, t4, t5, $T), A.ForwardedModuleView__forwardedMap(_inner.get$mixins(), t1, t4, t5, $T), $T._eval$1("ForwardedModuleView<0>")); + }, + ForwardedModuleView__forwardedMap(map, prefix, safelist, blocklist, $V) { + var t1 = prefix == null, + t2 = false; + if (t1) + if (safelist == null) + t2 = blocklist == null || blocklist._base.get$isEmpty(0); + if (t2) + return map; + if (!t1) + map = new A.PrefixedMapView(map, prefix, $V._eval$1("PrefixedMapView<0>")); + if (safelist != null) + map = new A.LimitedMapView(map, safelist._base.intersection$1(new A.MapKeySet(map, type$.MapKeySet_nullable_Object)), type$.$env_1_1_String._bind$1($V)._eval$1("LimitedMapView<1,2>")); + else if (blocklist != null && blocklist._base.get$isNotEmpty(0)) + map = A.LimitedMapView$blocklist(map, blocklist, type$.String, $V); + return map; + }, + ForwardedModuleView: function ForwardedModuleView(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._forwarded_view$_inner = t0; + _._rule = t1; + _.variables = t2; + _.variableNodes = t3; + _.functions = t4; + _.mixins = t5; + _.$ti = t6; + }, + ShadowedModuleView_ifNecessary(inner, functions, mixins, variables, $T) { + return A.ShadowedModuleView__needsBlocklist(inner.get$variables(), variables) || A.ShadowedModuleView__needsBlocklist(inner.get$functions(inner), functions) || A.ShadowedModuleView__needsBlocklist(inner.get$mixins(), mixins) ? new A.ShadowedModuleView(inner, A.ShadowedModuleView__shadowedMap(inner.get$variables(), variables, type$.Value), A.ShadowedModuleView__shadowedMap(inner.get$variableNodes(), variables, type$.AstNode), A.ShadowedModuleView__shadowedMap(inner.get$functions(inner), functions, $T), A.ShadowedModuleView__shadowedMap(inner.get$mixins(), mixins, $T), $T._eval$1("ShadowedModuleView<0>")) : null; + }, + ShadowedModuleView__shadowedMap(map, blocklist, $V) { + var t1 = A.ShadowedModuleView__needsBlocklist(map, blocklist); + return !t1 ? map : A.LimitedMapView$blocklist(map, blocklist, type$.String, $V); + }, + ShadowedModuleView__needsBlocklist(map, blocklist) { + return map.get$isNotEmpty(map) && blocklist.any$1(0, map.get$containsKey()); + }, + ShadowedModuleView: function ShadowedModuleView(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._shadowed_view$_inner = t0; + _.variables = t1; + _.variableNodes = t2; + _.functions = t3; + _.mixins = t4; + _.$ti = t5; + }, + AtRootQueryParser: function AtRootQueryParser(t0, t1) { + this.scanner = t0; + this._interpolationMap = t1; + }, + AtRootQueryParser_parse_closure: function AtRootQueryParser_parse_closure(t0) { + this.$this = t0; + }, + _disallowedFunctionNames_closure: function _disallowedFunctionNames_closure() { + }, + CssParser: function CssParser(t0, t1, t2, t3) { + var _ = this; + _._isUseAllowed = true; + _._inExpression = _._inParentheses = _._inStyleRule = _._stylesheet$_inUnknownAtRule = _._inControlDirective = _._inContentBlock = _._stylesheet$_inMixin = false; + _._globalVariables = t0; + _.warnings = t1; + _.lastSilentComment = null; + _.scanner = t2; + _._interpolationMap = t3; + }, + KeyframeSelectorParser: function KeyframeSelectorParser(t0, t1) { + this.scanner = t0; + this._interpolationMap = t1; + }, + KeyframeSelectorParser_parse_closure: function KeyframeSelectorParser_parse_closure(t0) { + this.$this = t0; + }, + MediaQueryParser: function MediaQueryParser(t0, t1) { + this.scanner = t0; + this._interpolationMap = t1; + }, + MediaQueryParser_parse_closure: function MediaQueryParser_parse_closure(t0) { + this.$this = t0; + }, + Parser_isIdentifier(text) { + var exception; + try { + new A.Parser(A.SpanScanner$(text, null), null)._parseIdentifier$0(); + return true; + } catch (exception) { + if (type$.SassFormatException._is(A.unwrapException(exception))) + return false; + else + throw exception; + } + }, + Parser: function Parser(t0, t1) { + this.scanner = t0; + this._interpolationMap = t1; + }, + Parser__parseIdentifier_closure: function Parser__parseIdentifier_closure(t0) { + this.$this = t0; + }, + Parser_escape_closure: function Parser_escape_closure() { + }, + Parser_scanIdentChar_matches: function Parser_scanIdentChar_matches(t0, t1) { + this.caseSensitive = t0; + this.char = t1; + }, + Parser_spanFrom_closure: function Parser_spanFrom_closure(t0, t1) { + this.$this = t0; + this.span = t1; + }, + SassParser: function SassParser(t0, t1, t2, t3) { + var _ = this; + _._currentIndentation = 0; + _._spaces = _._nextIndentationEnd = _._nextIndentation = null; + _._isUseAllowed = true; + _._inExpression = _._inParentheses = _._inStyleRule = _._stylesheet$_inUnknownAtRule = _._inControlDirective = _._inContentBlock = _._stylesheet$_inMixin = false; + _._globalVariables = t0; + _.warnings = t1; + _.lastSilentComment = null; + _.scanner = t2; + _._interpolationMap = t3; + }, + SassParser_styleRuleSelector_closure: function SassParser_styleRuleSelector_closure() { + }, + SassParser_children_closure: function SassParser_children_closure(t0, t1, t2) { + this.$this = t0; + this.child = t1; + this.children = t2; + }, + SassParser__peekIndentation_closure: function SassParser__peekIndentation_closure() { + }, + SassParser__peekIndentation_closure0: function SassParser__peekIndentation_closure0() { + }, + SassParser__tryTrailingSemicolon_closure: function SassParser__tryTrailingSemicolon_closure() { + }, + ScssParser$(contents, url) { + return new A.ScssParser(A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.FileSpan), A._setArrayType([], type$.JSArray_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span), A.SpanScanner$(contents, url), null); + }, + ScssParser: function ScssParser(t0, t1, t2, t3) { + var _ = this; + _._isUseAllowed = true; + _._inExpression = _._inParentheses = _._inStyleRule = _._stylesheet$_inUnknownAtRule = _._inControlDirective = _._inContentBlock = _._stylesheet$_inMixin = false; + _._globalVariables = t0; + _.warnings = t1; + _.lastSilentComment = null; + _.scanner = t2; + _._interpolationMap = t3; + }, + SelectorParser: function SelectorParser(t0, t1, t2, t3) { + var _ = this; + _._allowParent = t0; + _._plainCss = t1; + _.scanner = t2; + _._interpolationMap = t3; + }, + SelectorParser_parse_closure: function SelectorParser_parse_closure(t0) { + this.$this = t0; + }, + SelectorParser_parseCompoundSelector_closure: function SelectorParser_parseCompoundSelector_closure(t0) { + this.$this = t0; + }, + StylesheetParser: function StylesheetParser() { + }, + StylesheetParser_parse_closure: function StylesheetParser_parse_closure(t0) { + this.$this = t0; + }, + StylesheetParser_parse__closure: function StylesheetParser_parse__closure(t0) { + this.$this = t0; + }, + StylesheetParser_parseParameterList_closure: function StylesheetParser_parseParameterList_closure(t0) { + this.$this = t0; + }, + StylesheetParser_parseVariableDeclaration_closure: function StylesheetParser_parseVariableDeclaration_closure(t0) { + this.$this = t0; + }, + StylesheetParser_parseUseRule_closure: function StylesheetParser_parseUseRule_closure(t0) { + this.$this = t0; + }, + StylesheetParser__parseSingleProduction_closure: function StylesheetParser__parseSingleProduction_closure(t0, t1, t2) { + this.$this = t0; + this.production = t1; + this.T = t2; + }, + StylesheetParser__statement_closure: function StylesheetParser__statement_closure(t0) { + this.$this = t0; + }, + StylesheetParser_variableDeclarationWithoutNamespace_closure: function StylesheetParser_variableDeclarationWithoutNamespace_closure(t0, t1) { + this.$this = t0; + this.start = t1; + }, + StylesheetParser_variableDeclarationWithoutNamespace_closure0: function StylesheetParser_variableDeclarationWithoutNamespace_closure0(t0) { + this.declaration = t0; + }, + StylesheetParser__declarationOrBuffer_closure: function StylesheetParser__declarationOrBuffer_closure(t0) { + this.$this = t0; + }, + StylesheetParser__declarationOrBuffer_closure0: function StylesheetParser__declarationOrBuffer_closure0(t0) { + this.$this = t0; + }, + StylesheetParser__declarationOrBuffer_closure1: function StylesheetParser__declarationOrBuffer_closure1(t0) { + this.$this = t0; + }, + StylesheetParser__styleRule_closure: function StylesheetParser__styleRule_closure(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.wasInStyleRule = t2; + _.start = t3; + }, + StylesheetParser__propertyOrVariableDeclaration_closure: function StylesheetParser__propertyOrVariableDeclaration_closure(t0) { + this.$this = t0; + }, + StylesheetParser__tryDeclarationChildren_closure: function StylesheetParser__tryDeclarationChildren_closure(t0, t1) { + this.name = t0; + this.value = t1; + }, + StylesheetParser__atRootRule_closure: function StylesheetParser__atRootRule_closure(t0) { + this.query = t0; + }, + StylesheetParser__atRootRule_closure0: function StylesheetParser__atRootRule_closure0() { + }, + StylesheetParser__eachRule_closure: function StylesheetParser__eachRule_closure(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.wasInControlDirective = t1; + _.variables = t2; + _.list = t3; + }, + StylesheetParser__functionRule_closure: function StylesheetParser__functionRule_closure(t0, t1, t2) { + this.name = t0; + this.parameters = t1; + this.precedingComment = t2; + }, + StylesheetParser__forRule_closure: function StylesheetParser__forRule_closure(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + StylesheetParser__forRule_closure0: function StylesheetParser__forRule_closure0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.wasInControlDirective = t2; + _.variable = t3; + _.from = t4; + _.to = t5; + }, + StylesheetParser__memberList_closure: function StylesheetParser__memberList_closure(t0, t1, t2) { + this.$this = t0; + this.variables = t1; + this.identifiers = t2; + }, + StylesheetParser__includeRule_closure: function StylesheetParser__includeRule_closure(t0) { + this.contentParameters_ = t0; + }, + StylesheetParser_mediaRule_closure: function StylesheetParser_mediaRule_closure(t0) { + this.query = t0; + }, + StylesheetParser__mixinRule_closure: function StylesheetParser__mixinRule_closure(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.name = t1; + _.parameters = t2; + _.precedingComment = t3; + }, + StylesheetParser_mozDocumentRule_closure: function StylesheetParser_mozDocumentRule_closure(t0) { + this.$this = t0; + }, + StylesheetParser_mozDocumentRule_closure0: function StylesheetParser_mozDocumentRule_closure0(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.name = t2; + _.value = t3; + }, + StylesheetParser_supportsRule_closure: function StylesheetParser_supportsRule_closure(t0) { + this.condition = t0; + }, + StylesheetParser__whileRule_closure: function StylesheetParser__whileRule_closure(t0, t1, t2) { + this.$this = t0; + this.wasInControlDirective = t1; + this.condition = t2; + }, + StylesheetParser_unknownAtRule_closure: function StylesheetParser_unknownAtRule_closure(t0, t1) { + this._box_0 = t0; + this.name = t1; + }, + StylesheetParser__expression_resetState: function StylesheetParser__expression_resetState(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.start = t2; + }, + StylesheetParser__expression_resolveOneOperation: function StylesheetParser__expression_resolveOneOperation(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + StylesheetParser__expression_resolveOperations: function StylesheetParser__expression_resolveOperations(t0, t1) { + this._box_0 = t0; + this.resolveOneOperation = t1; + }, + StylesheetParser__expression_addSingleExpression: function StylesheetParser__expression_addSingleExpression(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.resetState = t2; + _.resolveOperations = t3; + }, + StylesheetParser__expression_addOperator: function StylesheetParser__expression_addOperator(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.resolveOneOperation = t2; + _.addSingleExpression = t3; + }, + StylesheetParser__expression_resolveSpaceExpressions: function StylesheetParser__expression_resolveSpaceExpressions(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.resolveOperations = t2; + }, + StylesheetParser_expressionUntilComma_closure: function StylesheetParser_expressionUntilComma_closure(t0) { + this.$this = t0; + }, + StylesheetParser__isHexColor_closure: function StylesheetParser__isHexColor_closure() { + }, + StylesheetParser__unicodeRange_closure: function StylesheetParser__unicodeRange_closure() { + }, + StylesheetParser__unicodeRange_closure0: function StylesheetParser__unicodeRange_closure0() { + }, + StylesheetParser_namespacedExpression_closure: function StylesheetParser_namespacedExpression_closure(t0, t1) { + this.$this = t0; + this.start = t1; + }, + StylesheetParser_trySpecialFunction_closure: function StylesheetParser_trySpecialFunction_closure() { + }, + StylesheetParser__expressionUntilComparison_closure: function StylesheetParser__expressionUntilComparison_closure(t0) { + this.$this = t0; + }, + StylesheetParser__publicIdentifier_closure: function StylesheetParser__publicIdentifier_closure(t0, t1) { + this.$this = t0; + this.start = t1; + }, + StylesheetNode$_(_stylesheet, importer, canonicalUrl, allUpstream) { + var t1 = new A.StylesheetNode(_stylesheet, importer, canonicalUrl, allUpstream._1, allUpstream._0, A.LinkedHashSet_LinkedHashSet$_empty(type$.StylesheetNode)); + t1.StylesheetNode$_$4(_stylesheet, importer, canonicalUrl, allUpstream); + return t1; + }, + StylesheetGraph: function StylesheetGraph(t0, t1, t2) { + this._nodes = t0; + this.importCache = t1; + this._transitiveModificationTimes = t2; + }, + StylesheetGraph_modifiedSince_transitiveModificationTime: function StylesheetGraph_modifiedSince_transitiveModificationTime(t0) { + this.$this = t0; + }, + StylesheetGraph_modifiedSince_transitiveModificationTime_closure: function StylesheetGraph_modifiedSince_transitiveModificationTime_closure(t0, t1) { + this.node = t0; + this.transitiveModificationTime = t1; + }, + StylesheetGraph__add_closure: function StylesheetGraph__add_closure(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.url = t1; + _.baseImporter = t2; + _.baseUrl = t3; + }, + StylesheetGraph_addCanonical_closure: function StylesheetGraph_addCanonical_closure(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.importer = t1; + _.canonicalUrl = t2; + _.originalUrl = t3; + }, + StylesheetGraph_reload_closure: function StylesheetGraph_reload_closure(t0, t1, t2) { + this.$this = t0; + this.node = t1; + this.canonicalUrl = t2; + }, + StylesheetGraph__nodeFor_closure: function StylesheetGraph__nodeFor_closure(t0, t1, t2, t3, t4) { + var _ = this; + _.$this = t0; + _.url = t1; + _.baseImporter = t2; + _.baseUrl = t3; + _.forImport = t4; + }, + StylesheetGraph__nodeFor_closure0: function StylesheetGraph__nodeFor_closure0(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + StylesheetNode: function StylesheetNode(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._stylesheet = t0; + _.importer = t1; + _.canonicalUrl = t2; + _._upstream = t3; + _._upstreamImports = t4; + _._downstream = t5; + }, + Syntax_forPath(path) { + var t1, + _0_0 = A.ParsedPath_ParsedPath$parse(path, $.$get$context().style)._splitExtension$1(1)[1]; + $label0$0: { + if (".sass" === _0_0) { + t1 = B.Syntax_Sass_sass; + break $label0$0; + } + if (".css" === _0_0) { + t1 = B.Syntax_CSS_css; + break $label0$0; + } + t1 = B.Syntax_SCSS_scss; + break $label0$0; + } + return t1; + }, + Syntax: function Syntax(t0, t1) { + this._syntax$_name = t0; + this._name = t1; + }, + Box: function Box(t0, t1) { + this._box$_inner = t0; + this.$ti = t1; + }, + ModifiableBox: function ModifiableBox(t0, t1) { + this.value = t0; + this.$ti = t1; + }, + LazyFileSpan: function LazyFileSpan(t0) { + this._builder = t0; + this._lazy_file_span$_span = null; + }, + LimitedMapView$blocklist(_map, blocklist, $K, $V) { + var t2, key, + t1 = A.LinkedHashSet_LinkedHashSet$_empty($K); + for (t2 = J.get$iterator$ax(_map.get$keys(_map)); t2.moveNext$0();) { + key = t2.get$current(t2); + if (!blocklist.contains$1(0, key)) + t1.add$1(0, key); + } + return new A.LimitedMapView(_map, t1, $K._eval$1("@<0>")._bind$1($V)._eval$1("LimitedMapView<1,2>")); + }, + LimitedMapView: function LimitedMapView(t0, t1, t2) { + this._limited_map_view$_map = t0; + this._limited_map_view$_keys = t1; + this.$ti = t2; + }, + MapExtensions_get_pairs(_this, $K, $V) { + var t1 = _this.get$entries(_this); + return t1.map$1$1(t1, new A.MapExtensions_get_pairs_closure($K, $V), $K._eval$1("@<0>")._bind$1($V)._eval$1("+(1,2)")); + }, + MapExtensions_get_pairs_closure: function MapExtensions_get_pairs_closure(t0, t1) { + this.K = t0; + this.V = t1; + }, + MergedMapView$(maps, $K, $V) { + var t1 = $K._eval$1("@<0>")._bind$1($V); + t1 = new A.MergedMapView(A.LinkedHashMap_LinkedHashMap$_empty($K, t1._eval$1("Map<1,2>")), t1._eval$1("MergedMapView<1,2>")); + t1.MergedMapView$1(maps, $K, $V); + return t1; + }, + MergedMapView: function MergedMapView(t0, t1) { + this._mapsByKey = t0; + this.$ti = t1; + }, + MultiDirWatcher: function MultiDirWatcher(t0, t1, t2) { + this._watchers = t0; + this._group = t1; + this._poll = t2; + }, + MultiSpan: function MultiSpan(t0, t1, t2) { + this._multi_span$_primary = t0; + this.primaryLabel = t1; + this.secondarySpans = t2; + }, + NoSourceMapBuffer: function NoSourceMapBuffer(t0) { + this._no_source_map_buffer$_buffer = t0; + }, + PrefixedMapView: function PrefixedMapView(t0, t1, t2) { + this._prefixed_map_view$_map = t0; + this._prefix = t1; + this.$ti = t2; + }, + _PrefixedKeys: function _PrefixedKeys(t0) { + this._view = t0; + }, + _PrefixedKeys_iterator_closure: function _PrefixedKeys_iterator_closure(t0) { + this.$this = t0; + }, + PublicMemberMapView: function PublicMemberMapView(t0, t1) { + this._public_member_map_view$_inner = t0; + this.$ti = t1; + }, + SourceMapBuffer: function SourceMapBuffer(t0, t1) { + var _ = this; + _._source_map_buffer$_buffer = t0; + _._entries = t1; + _._column = _._line = 0; + _._inSpan = false; + }, + SourceMapBuffer_buildSourceMap_closure: function SourceMapBuffer_buildSourceMap_closure(t0, t1) { + this._box_0 = t0; + this.prefixLength = t1; + }, + UnprefixedMapView: function UnprefixedMapView(t0, t1, t2) { + this._unprefixed_map_view$_map = t0; + this._unprefixed_map_view$_prefix = t1; + this.$ti = t2; + }, + _UnprefixedKeys: function _UnprefixedKeys(t0) { + this._unprefixed_map_view$_view = t0; + }, + _UnprefixedKeys_iterator_closure: function _UnprefixedKeys_iterator_closure(t0) { + this.$this = t0; + }, + _UnprefixedKeys_iterator_closure0: function _UnprefixedKeys_iterator_closure0(t0) { + this.$this = t0; + }, + toSentence(iter, conjunction) { + if (iter.get$length(iter) === 1) + return J.toString$0$(iter.get$first(iter)); + return A.IterableExtension_get_exceptLast(iter).join$1(0, ", ") + (" " + conjunction + " " + A.S(iter.get$last(iter))); + }, + indent(string, indentation) { + return new A.MappedListIterable(A._setArrayType(string.split("\n"), type$.JSArray_String), new A.indent_closure(indentation), type$.MappedListIterable_String_String).join$1(0, "\n"); + }, + pluralize($name, number, plural) { + if (number === 1) + return $name; + if (plural != null) + return plural; + return $name + "s"; + }, + trimAscii(string, excludeEscape) { + var t1, + start = A._firstNonWhitespace(string); + if (start == null) + t1 = ""; + else { + t1 = A._lastNonWhitespace(string, true); + t1.toString; + t1 = B.JSString_methods.substring$2(string, start, t1 + 1); + } + return t1; + }, + trimAsciiRight(string, excludeEscape) { + var end = A._lastNonWhitespace(string, excludeEscape); + return end == null ? "" : B.JSString_methods.substring$2(string, 0, end + 1); + }, + _firstNonWhitespace(string) { + var t1, i, t2; + for (t1 = string.length, i = 0; i < t1; ++i) { + t2 = string.charCodeAt(i); + if (!(t2 === 32 || t2 === 9 || t2 === 10 || t2 === 13 || t2 === 12)) + return i; + } + return null; + }, + _lastNonWhitespace(string, excludeEscape) { + var i, i0, codeUnit; + for (i = string.length - 1, i0 = i; i0 >= 0; --i0) { + codeUnit = string.charCodeAt(i0); + if (!(codeUnit === 32 || codeUnit === 9 || codeUnit === 10 || codeUnit === 13 || codeUnit === 12)) + if (excludeEscape && i0 !== 0 && i0 !== i && codeUnit === 92) + return i0 + 1; + else + return i0; + } + return null; + }, + isPublic(member) { + var start = member.charCodeAt(0); + return start !== 45 && start !== 95; + }, + flattenVertically(iterable, $T) { + var result, flags, + t1 = iterable.$ti._eval$1("@")._bind$1($T._eval$1("QueueList<0>"))._eval$1("MappedListIterable<1,2>"), + queues = A.List_List$of(new A.MappedListIterable(iterable, new A.flattenVertically_closure($T), t1), true, t1._eval$1("ListIterable.E")); + if (queues.length === 1) + return B.JSArray_methods.get$first(queues); + result = A._setArrayType([], $T._eval$1("JSArray<0>")); + for (flags = queues.$flags | 0; queues.length !== 0;) { + flags & 1 && A.throwUnsupportedOperation(queues, 16); + B.JSArray_methods._removeWhere$2(queues, new A.flattenVertically_closure0(result, $T), true); + } + return result; + }, + codepointIndexToCodeUnitIndex(string, codepointIndex) { + var codeUnitIndex, i, codeUnitIndex0; + for (codeUnitIndex = 0, i = 0; i < codepointIndex; ++i) { + codeUnitIndex0 = codeUnitIndex + 1; + codeUnitIndex = string.charCodeAt(codeUnitIndex) >>> 10 === 54 ? codeUnitIndex0 + 1 : codeUnitIndex0; + } + return codeUnitIndex; + }, + codeUnitIndexToCodepointIndex(string, codeUnitIndex) { + var codepointIndex, i; + for (codepointIndex = 0, i = 0; i < codeUnitIndex; i = (string.charCodeAt(i) >>> 10 === 54 ? i + 1 : i) + 1) + ++codepointIndex; + return codepointIndex; + }, + frameForSpan(span, member, url) { + var t2, t3, + t1 = url == null ? span.get$sourceUrl(span) : url; + if (t1 == null) + t1 = $.$get$_noSourceUrl(); + t2 = span.get$start(span); + t2 = t2.file.getLine$1(t2.offset); + t3 = span.get$start(span); + return new A.Frame(t1, t2 + 1, t3.file.getColumn$1(t3.offset) + 1, member); + }, + declarationName(span) { + var text = span.get$text(); + return A.trimAsciiRight(B.JSString_methods.substring$2(text, 0, B.JSString_methods.indexOf$1(text, ":")), false); + }, + unvendor($name) { + var i, + t1 = $name.length; + if (t1 < 2) + return $name; + if ($name.charCodeAt(0) !== 45) + return $name; + if ($name.charCodeAt(1) === 45) + return $name; + for (i = 2; i < t1; ++i) + if ($name.charCodeAt(i) === 45) + return B.JSString_methods.substring$1($name, i + 1); + return $name; + }, + equalsIgnoreCase(string1, string2) { + var t1, i; + if (string1 === string2) + return true; + if (string1 == null) + return false; + t1 = string1.length; + if (t1 !== string2.length) + return false; + for (i = 0; i < t1; ++i) + if (!A.characterEqualsIgnoreCase(string1.charCodeAt(i), string2.charCodeAt(i))) + return false; + return true; + }, + startsWithIgnoreCase(string, prefix) { + var i, + t1 = prefix.length; + if (string.length < t1) + return false; + for (i = 0; i < t1; ++i) + if (!A.characterEqualsIgnoreCase(string.charCodeAt(i), prefix.charCodeAt(i))) + return false; + return true; + }, + mapInPlace(list, $function) { + var i; + for (i = 0; i < list.length; ++i) + list[i] = $function.call$1(list[i]); + }, + longestCommonSubsequence(list1, list2, select, $T) { + var t1, _i, selections, i, i0, j, selection, j0, + _length = list1.get$length(0) + 1, + lengths = J.JSArray_JSArray$allocateFixed(_length, type$.List_int); + for (t1 = type$.int, _i = 0; _i < _length; ++_i) + lengths[_i] = A.List_List$filled(((list2._queue_list$_tail - list2._queue_list$_head & J.get$length$asx(list2._queue_list$_table) - 1) >>> 0) + 1, 0, false, t1); + _length = list1.get$length(0); + selections = J.JSArray_JSArray$allocateFixed(_length, $T._eval$1("List<0?>")); + for (t1 = $T._eval$1("0?"), _i = 0; _i < _length; ++_i) + selections[_i] = A.List_List$filled((list2._queue_list$_tail - list2._queue_list$_head & J.get$length$asx(list2._queue_list$_table) - 1) >>> 0, null, false, t1); + for (i = 0; i < (list1._queue_list$_tail - list1._queue_list$_head & J.get$length$asx(list1._queue_list$_table) - 1) >>> 0; i = i0) + for (i0 = i + 1, j = 0; j < (list2._queue_list$_tail - list2._queue_list$_head & J.get$length$asx(list2._queue_list$_table) - 1) >>> 0; j = j0) { + selection = select.call$2(list1.$index(0, i), list2.$index(0, j)); + selections[i][j] = selection; + t1 = lengths[i0]; + j0 = j + 1; + t1[j0] = selection == null ? Math.max(t1[j], lengths[i][j0]) : lengths[i][j] + 1; + } + return new A.longestCommonSubsequence_backtrack(selections, lengths, $T).call$2(list1.get$length(0) - 1, list2.get$length(0) - 1); + }, + removeFirstWhere(list, test, orElse) { + var i; + for (i = 0; i < list.length; ++i) { + if (!test.call$1(list[i])) + continue; + B.JSArray_methods.removeAt$1(list, i); + return; + } + orElse.call$0(); + }, + mapAddAll2(destination, source, K1, K2, $V) { + source.forEach$1(0, new A.mapAddAll2_closure(destination, K1, K2, $V)); + }, + setAll(map, keys, value) { + var t1; + for (t1 = J.get$iterator$ax(keys); t1.moveNext$0();) + map.$indexSet(0, t1.get$current(t1), value); + }, + rotateSlice(list, start, end) { + var i, next, + element = list.$index(0, end - 1); + for (i = start; i < end; ++i, element = next) { + next = list.$index(0, i); + list.$indexSet(0, i, element); + } + }, + mapAsync(iterable, callback, $E, $F) { + return A.mapAsync$body(iterable, callback, $E, $F, $F._eval$1("Iterable<0>")); + }, + mapAsync$body(iterable, callback, $E, $F, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, t2, _i, t1, $async$temp1; + var $async$mapAsync = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = A._setArrayType([], $F._eval$1("JSArray<0>")); + t2 = iterable.length, _i = 0; + case 3: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 5; + break; + } + $async$temp1 = t1; + $async$goto = 6; + return A._asyncAwait(callback.call$1(iterable[_i]), $async$mapAsync); + case 6: + // returning from await. + $async$temp1.push($async$result); + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$mapAsync, $async$completer); + }, + putIfAbsentAsync(map, key, ifAbsent, $K, $V) { + return A.putIfAbsentAsync$body(map, key, ifAbsent, $K, $V, $V); + }, + putIfAbsentAsync$body(map, key, ifAbsent, $K, $V, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, t1, value; + var $async$putIfAbsentAsync = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if (map.containsKey$1(key)) { + t1 = map.$index(0, key); + $async$returnValue = t1 == null ? $V._as(t1) : t1; + // goto return + $async$goto = 1; + break; + } + $async$goto = 3; + return A._asyncAwait(ifAbsent.call$0(), $async$putIfAbsentAsync); + case 3: + // returning from await. + value = $async$result; + map.$indexSet(0, key, value); + $async$returnValue = value; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$putIfAbsentAsync, $async$completer); + }, + copyMapOfMap(map, K1, K2, $V) { + var t3, key, child, + t1 = K2._eval$1("@<0>")._bind$1($V)._eval$1("Map<1,2>"), + t2 = A.LinkedHashMap_LinkedHashMap$_empty(K1, t1); + for (t1 = A.MapExtensions_get_pairs(map, K1, t1), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t3 = t1.get$current(t1); + key = t3._0; + child = t3._1; + t3 = A.LinkedHashMap_LinkedHashMap(null, null, null, K2, $V); + t3.addAll$1(0, child); + t2.$indexSet(0, key, t3); + } + return t2; + }, + copyMapOfList(map, $K, $E) { + var t3, + t1 = $E._eval$1("List<0>"), + t2 = A.LinkedHashMap_LinkedHashMap$_empty($K, t1); + for (t1 = A.MapExtensions_get_pairs(map, $K, t1), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t3 = t1.get$current(t1); + t2.$indexSet(0, t3._0, J.toList$0$ax(t3._1)); + } + return t2; + }, + consumeEscapedCharacter(scanner) { + var _1_0, value, i, next, t1; + scanner.expectChar$1(92); + _1_0 = scanner.peekChar$0(); + if (_1_0 == null) + return 65533; + if (_1_0 === 10 || _1_0 === 13 || _1_0 === 12) + scanner.error$1(0, "Expected escape sequence."); + if (A.CharacterExtension_get_isHex(_1_0)) { + for (value = 0, i = 0; i < 6; ++i) { + next = scanner.peekChar$0(); + if (next != null) { + t1 = true; + if (!(next >= 48 && next <= 57)) + if (!(next >= 97 && next <= 102)) + t1 = next >= 65 && next <= 70; + t1 = !t1; + } else + t1 = true; + if (t1) + break; + value = (value << 4 >>> 0) + A.asHex(scanner.readChar$0()); + } + t1 = scanner.peekChar$0(); + if (t1 === 32 || t1 === 9 || t1 === 10 || t1 === 13 || t1 === 12) + scanner.readChar$0(); + $label0$1: { + if (0 !== value) + t1 = value >= 55296 && value <= 57343 || value >= 1114111; + else + t1 = true; + if (t1) { + t1 = 65533; + break $label0$1; + } + t1 = value; + break $label0$1; + } + return t1; + } + return scanner.readChar$0(); + }, + throwWithTrace(error, originalError, trace) { + var t1 = A.getTrace(originalError); + A.attachTrace(error, t1 == null ? trace : t1); + throw A.wrapException(error); + }, + attachTrace(error, trace) { + var t1; + if (trace.toString$0(0).length === 0) + return; + t1 = $.$get$_traces(); + A.Expando__checkType(error); + if (t1._jsWeakMap.get(error) == null) + t1.$indexSet(0, error, trace); + }, + getTrace(error) { + var t1; + if (typeof error == "string" || typeof error == "number" || A._isBool(error)) + t1 = null; + else { + t1 = $.$get$_traces(); + A.Expando__checkType(error); + t1 = t1._jsWeakMap.get(error); + } + return t1; + }, + indent_closure: function indent_closure(t0) { + this.indentation = t0; + }, + flattenVertically_closure: function flattenVertically_closure(t0) { + this.T = t0; + }, + flattenVertically_closure0: function flattenVertically_closure0(t0, t1) { + this.result = t0; + this.T = t1; + }, + longestCommonSubsequence_backtrack: function longestCommonSubsequence_backtrack(t0, t1, t2) { + this.selections = t0; + this.lengths = t1; + this.T = t2; + }, + mapAddAll2_closure: function mapAddAll2_closure(t0, t1, t2, t3) { + var _ = this; + _.destination = t0; + _.K1 = t1; + _.K2 = t2; + _.V = t3; + }, + SassApiValue_assertSelector(_this, allowParent, $name) { + var error, stackTrace, t1, exception, + string = _this._selectorString$1($name); + try { + t1 = A.SelectorList_SelectorList$parse(string, allowParent, null, false); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.SassFormatException._is(t1)) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = B.JSString_methods.replaceFirst$2(J.toString$0$(error), "Error: ", ""); + A.throwWithTrace(new A.SassScriptException($name == null ? t1 : "$" + $name + ": " + t1), error, stackTrace); + } else + throw exception; + } + }, + SassApiValue_assertCompoundSelector(_this, $name) { + var error, stackTrace, t1, exception, + allowParent = false, + string = _this._selectorString$1($name); + try { + t1 = new A.SelectorParser(allowParent, false, A.SpanScanner$(string, null), null).parseCompoundSelector$0(); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.SassFormatException._is(t1)) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = B.JSString_methods.replaceFirst$2(J.toString$0$(error), "Error: ", ""); + A.throwWithTrace(new A.SassScriptException("$" + $name + ": " + t1), error, stackTrace); + } else + throw exception; + } + }, + Value: function Value() { + }, + SassArgumentList$(contents, keywords, separator) { + var t1 = type$.Value; + t1 = new A.SassArgumentList(A.ConstantMap_ConstantMap$from(keywords, type$.String, t1), A.List_List$unmodifiable(contents, t1), separator, false); + t1.SassList$3$brackets(contents, separator, false); + return t1; + }, + SassArgumentList: function SassArgumentList(t0, t1, t2, t3) { + var _ = this; + _._keywords = t0; + _._wereKeywordsAccessed = false; + _._list$_contents = t1; + _._separator = t2; + _._hasBrackets = t3; + }, + SassBoolean: function SassBoolean(t0) { + this.value = t0; + }, + SassCalculation_calc(argument) { + var t1, + _0_0 = A.SassCalculation__simplify(argument); + $label0$0: { + if (_0_0 instanceof A.SassNumber) { + t1 = _0_0; + break $label0$0; + } + if (_0_0 instanceof A.SassCalculation) { + t1 = _0_0; + break $label0$0; + } + t1 = new A.SassCalculation("calc", A.List_List$unmodifiable([_0_0], type$.Object)); + break $label0$0; + } + return t1; + }, + SassCalculation_min($arguments) { + var minimum, _i, arg, t2, + args = A.List_List$unmodifiable(new A.MappedListIterable($arguments, A.calculation_SassCalculation__simplify$closure(), A._arrayInstanceType($arguments)._eval$1("MappedListIterable<1,@>")), type$.Object), + t1 = args.length; + if (t1 === 0) + throw A.wrapException(A.ArgumentError$("min() must have at least one argument.", null)); + for (minimum = null, _i = 0; _i < t1; ++_i) { + arg = args[_i]; + if (arg instanceof A.SassNumber) + t2 = minimum != null && !minimum.isComparableTo$1(arg); + else + t2 = true; + if (t2) { + minimum = null; + break; + } else if (minimum == null || minimum.greaterThan$1(arg).value) + minimum = arg; + } + if (minimum != null) + return minimum; + A.SassCalculation__verifyCompatibleNumbers(args); + return new A.SassCalculation("min", args); + }, + SassCalculation_max($arguments) { + var maximum, _i, arg, t2, + args = A.List_List$unmodifiable(new A.MappedListIterable($arguments, A.calculation_SassCalculation__simplify$closure(), A._arrayInstanceType($arguments)._eval$1("MappedListIterable<1,@>")), type$.Object), + t1 = args.length; + if (t1 === 0) + throw A.wrapException(A.ArgumentError$("max() must have at least one argument.", null)); + for (maximum = null, _i = 0; _i < t1; ++_i) { + arg = args[_i]; + if (arg instanceof A.SassNumber) + t2 = maximum != null && !maximum.isComparableTo$1(arg); + else + t2 = true; + if (t2) { + maximum = null; + break; + } else if (maximum == null || maximum.lessThan$1(arg).value) + maximum = arg; + } + if (maximum != null) + return maximum; + A.SassCalculation__verifyCompatibleNumbers(args); + return new A.SassCalculation("max", args); + }, + SassCalculation_hypot($arguments) { + var first, subtotal, i, number, value, t2, t3, + args = A.List_List$unmodifiable(new A.MappedListIterable($arguments, A.calculation_SassCalculation__simplify$closure(), A._arrayInstanceType($arguments)._eval$1("MappedListIterable<1,@>")), type$.Object), + t1 = args.length; + if (t1 === 0) + throw A.wrapException(A.ArgumentError$("hypot() must have at least one argument.", null)); + A.SassCalculation__verifyCompatibleNumbers(args); + first = B.JSArray_methods.get$first(args); + if (!(first instanceof A.SassNumber) || first.hasUnit$1("%")) + return new A.SassCalculation("hypot", args); + for (subtotal = 0, i = 0; i < t1;) { + number = args[i]; + if (!(number instanceof A.SassNumber) || !number.hasCompatibleUnits$1(first)) + return new A.SassCalculation("hypot", args); + ++i; + value = number.convertValueToMatch$3(first, "numbers[" + i + "]", "numbers[1]"); + subtotal += value * value; + } + t1 = Math.sqrt(subtotal); + t2 = J.getInterceptor$x(first); + t3 = t2.get$numeratorUnits(first); + return A.SassNumber_SassNumber$withUnits(t1, t2.get$denominatorUnits(first), t3); + }, + SassCalculation_abs(argument) { + argument = A.SassCalculation__simplify(argument); + if (!(argument instanceof A.SassNumber)) + return new A.SassCalculation("abs", A._setArrayType([argument], type$.JSArray_Object)); + if (argument.hasUnit$1("%")) + A.warnForDeprecation(string$.Passinp + argument.toString$0(0) + ")\nTo emit a CSS abs() now: abs(#{" + argument.toString$0(0) + string$.x7d__Mor, B.Deprecation_pLJ); + return A.SassNumber_SassNumber(Math.abs(argument._number$_value), null).coerceToMatch$1(argument); + }, + SassCalculation_exp(argument) { + argument = A.SassCalculation__simplify(argument); + if (!(argument instanceof A.SassNumber)) + return new A.SassCalculation("exp", A._setArrayType([argument], type$.JSArray_Object)); + argument.assertNoUnits$0(); + return A.pow0(A.SassNumber_SassNumber(2.718281828459045, null), argument); + }, + SassCalculation_sign(argument) { + var t1, _0_2, t2, arg; + argument = A.SassCalculation__simplify(argument); + $label0$0: { + t1 = argument instanceof A.SassNumber; + if (t1) { + _0_2 = argument._number$_value; + if (!isNaN(_0_2)) + t2 = 0 === _0_2; + else + t2 = true; + } else + t2 = false; + if (t2) { + t1 = argument; + break $label0$0; + } + if (t1) { + t1 = !argument.hasUnit$1("%"); + arg = argument; + } else { + arg = null; + t1 = false; + } + if (t1) { + t1 = A.SassNumber_SassNumber(J.get$sign$in(arg._number$_value), null).coerceToMatch$1(argument); + break $label0$0; + } + t1 = new A.SassCalculation("sign", A._setArrayType([argument], type$.JSArray_Object)); + break $label0$0; + } + return t1; + }, + SassCalculation_clamp(min, value, max) { + var t1, args; + if (value == null && max != null) + throw A.wrapException(A.ArgumentError$("If value is null, max must also be null.", null)); + min = A.SassCalculation__simplify(min); + value = A.NullableExtension_andThen(value, A.calculation_SassCalculation__simplify$closure()); + max = A.NullableExtension_andThen(max, A.calculation_SassCalculation__simplify$closure()); + if (min instanceof A.SassNumber && value instanceof A.SassNumber && max instanceof A.SassNumber && min.hasCompatibleUnits$1(value) && min.hasCompatibleUnits$1(max)) { + if (value.lessThanOrEquals$1(min).value) + return min; + if (value.greaterThanOrEquals$1(max).value) + return max; + return value; + } + t1 = [min]; + if (value != null) + t1.push(value); + if (max != null) + t1.push(max); + args = A.List_List$unmodifiable(t1, type$.Object); + A.SassCalculation__verifyCompatibleNumbers(args); + A.SassCalculation__verifyLength(args, 3); + return new A.SassCalculation("clamp", args); + }, + SassCalculation_pow(base, exponent) { + var t1 = A._setArrayType([base], type$.JSArray_Object); + if (exponent != null) + t1.push(exponent); + A.SassCalculation__verifyLength(t1, 2); + base = A.SassCalculation__simplify(base); + exponent = A.NullableExtension_andThen(exponent, A.calculation_SassCalculation__simplify$closure()); + if (!(base instanceof A.SassNumber) || !(exponent instanceof A.SassNumber)) + return new A.SassCalculation("pow", t1); + base.assertNoUnits$0(); + exponent.assertNoUnits$0(); + return A.pow0(base, exponent); + }, + SassCalculation_log(number, base) { + var t1, t2; + number = A.SassCalculation__simplify(number); + base = A.NullableExtension_andThen(base, A.calculation_SassCalculation__simplify$closure()); + t1 = A._setArrayType([number], type$.JSArray_Object); + t2 = base != null; + if (t2) + t1.push(base); + if (number instanceof A.SassNumber) + t2 = t2 && !(base instanceof A.SassNumber); + else + t2 = true; + if (t2) + return new A.SassCalculation("log", t1); + number.assertNoUnits$0(); + if (base instanceof A.SassNumber) { + base.assertNoUnits$0(); + return A.log(number, base); + } + return A.log(number, null); + }, + SassCalculation_atan2(y, x) { + var t1; + y = A.SassCalculation__simplify(y); + x = A.NullableExtension_andThen(x, A.calculation_SassCalculation__simplify$closure()); + t1 = A._setArrayType([y], type$.JSArray_Object); + if (x != null) + t1.push(x); + A.SassCalculation__verifyLength(t1, 2); + A.SassCalculation__verifyCompatibleNumbers(t1); + if (!(y instanceof A.SassNumber) || !(x instanceof A.SassNumber) || y.hasUnit$1("%") || x.hasUnit$1("%") || !y.hasCompatibleUnits$1(x)) + return new A.SassCalculation("atan2", t1); + return A.SassNumber_SassNumber$withUnits(Math.atan2(y._number$_value, x.convertValueToMatch$3(y, "x", "y")) * 57.29577951308232, null, A._setArrayType(["deg"], type$.JSArray_String)); + }, + SassCalculation_rem(dividend, modulus) { + var t1, result; + dividend = A.SassCalculation__simplify(dividend); + modulus = A.NullableExtension_andThen(modulus, A.calculation_SassCalculation__simplify$closure()); + t1 = A._setArrayType([dividend], type$.JSArray_Object); + if (modulus != null) + t1.push(modulus); + A.SassCalculation__verifyLength(t1, 2); + A.SassCalculation__verifyCompatibleNumbers(t1); + if (!(dividend instanceof A.SassNumber) || !(modulus instanceof A.SassNumber) || !dividend.hasCompatibleUnits$1(modulus)) + return new A.SassCalculation("rem", t1); + result = dividend.modulo$1(modulus); + t1 = modulus._number$_value; + if (A.DoubleWithSignedZero_get_signIncludingZero(t1) !== A.DoubleWithSignedZero_get_signIncludingZero(dividend._number$_value)) { + if (t1 == 1 / 0 || t1 == -1 / 0) + return dividend; + if (result._number$_value === 0) + return result.unaryMinus$0(); + return result.minus$1(modulus); + } + return result; + }, + SassCalculation_mod(dividend, modulus) { + var t1; + dividend = A.SassCalculation__simplify(dividend); + modulus = A.NullableExtension_andThen(modulus, A.calculation_SassCalculation__simplify$closure()); + t1 = A._setArrayType([dividend], type$.JSArray_Object); + if (modulus != null) + t1.push(modulus); + A.SassCalculation__verifyLength(t1, 2); + A.SassCalculation__verifyCompatibleNumbers(t1); + if (!(dividend instanceof A.SassNumber) || !(modulus instanceof A.SassNumber) || !dividend.hasCompatibleUnits$1(modulus)) + return new A.SassCalculation("mod", t1); + return dividend.modulo$1(modulus); + }, + SassCalculation_roundInternal(strategyOrNumber, numberOrStep, step, inLegacySassFunction, span, warn) { + var _0_8_isSet, _0_6_isSet, t2, _0_6_isSet0, _0_14_isSet, _0_14, _0_12, _0_16, _0_18, _0_18_isSet, _0_20, _0_20_isSet, strategy, _0_9_isSet0, _0_16_isSet, t3, t4, _0_12_isSet, _0_12_isSet0, rest, _null = null, _s5_ = "round", + _0_1 = A.SassCalculation__simplify(strategyOrNumber), + _0_6 = A.NullableExtension_andThen(numberOrStep, A.calculation_SassCalculation__simplify$closure()), + _0_9 = A.NullableExtension_andThen(step, A.calculation_SassCalculation__simplify$closure()), + _0_10 = _0_1, + _0_8 = _null, + _0_60 = _null, + _0_100 = _null, + _0_10_isSet = false, + _0_90 = _null, + _0_9_isSet = false, + number = _null, + t1 = false; + if (_0_1 instanceof A.SassNumber) { + type$.SassNumber._as(_0_10); + _0_8_isSet = !_0_10.get$hasUnits(); + if (_0_8_isSet) { + _0_8 = _0_6 == null; + _0_9_isSet = _0_8; + _0_60 = _0_6; + if (_0_9_isSet) { + _0_100 = _0_9 == null; + t1 = _0_100; + _0_90 = _0_9; + } + _0_10_isSet = _0_9_isSet; + number = _0_10; + } + _0_6_isSet = _0_8_isSet; + _0_1 = _0_10; + _0_10 = _0_100; + } else { + _0_1 = _0_10; + _0_10 = _0_100; + _0_8_isSet = false; + _0_6_isSet = false; + } + if (t1) + return A.SassNumber_SassNumber(B.JSNumber_methods.round$0(number._number$_value), _null); + t1 = false; + if (_0_1 instanceof A.SassNumber) { + if (_0_8_isSet) + t2 = _0_8; + else { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_60 = t2; + _0_6_isSet = true; + } + _0_8 = t2 == null; + t2 = _0_8; + _0_8_isSet = true; + } + if (t2) { + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + _0_10_isSet = true; + } + t1 = t1 && inLegacySassFunction != null; + } + number = _0_1; + } else + number = _null; + if (t1) { + warn.call$2(string$.In_fut, B.Deprecation_1AX); + t1 = B.JSNumber_methods.round$0(number._number$_value); + t2 = number.get$numeratorUnits(number); + return A.SassNumber_SassNumber$withUnits(t1, number.get$denominatorUnits(number), t2); + } + step = _null; + t1 = false; + if (_0_1 instanceof A.SassNumber) { + _0_6_isSet0 = true; + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + if (t2 instanceof A.SassNumber) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + type$.SassNumber._as(t2); + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + _0_10_isSet = true; + } + t1 = t1 && !_0_1.hasCompatibleUnits$1(t2); + step = t2; + } + number = _0_1; + } else + number = _null; + if (t1) { + t1 = type$.JSArray_Object; + A.SassCalculation__verifyCompatibleNumbers(A._setArrayType([number, step], t1)); + return new A.SassCalculation(_s5_, A._setArrayType([number, step], t1)); + } + step = _null; + t1 = false; + if (_0_1 instanceof A.SassNumber) { + _0_6_isSet0 = true; + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + if (t2 instanceof A.SassNumber) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + type$.SassNumber._as(t2); + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + _0_10_isSet = true; + } + step = t2; + } + number = _0_1; + } else + number = _null; + if (t1) { + A.SassCalculation__verifyCompatibleNumbers(A._setArrayType([number, step], type$.JSArray_Object)); + return A.SassCalculation__roundWithStep("nearest", number, step); + } + _0_14_isSet = _0_1 instanceof A.SassString; + _0_14 = _null; + _0_12 = _null; + _0_16 = _null; + _0_18 = _null; + _0_18_isSet = false; + _0_20 = _null; + _0_20_isSet = false; + strategy = _null; + number = _null; + step = _null; + t1 = false; + if (_0_14_isSet) { + _0_6_isSet0 = true; + _0_9_isSet0 = true; + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_14 = "nearest" === t2; + t2 = _0_14; + _0_16_isSet = !t2; + t2 = true; + if (_0_16_isSet) { + _0_16 = "up" === _0_12; + t3 = _0_16; + _0_18_isSet = !t3; + if (_0_18_isSet) { + _0_18 = "down" === _0_12; + t3 = _0_18; + _0_20_isSet = !t3; + if (_0_20_isSet) { + _0_20 = "to-zero" === _0_12; + t2 = _0_20; + } + } + } + if (t2) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + if (t2 instanceof A.SassNumber) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + t3 = type$.SassNumber; + t3._as(t2); + if (_0_9_isSet) + t4 = _0_90; + else { + t4 = _0_9; + _0_9_isSet = _0_9_isSet0; + _0_90 = t4; + } + if (t4 instanceof A.SassNumber) { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_9_isSet = _0_9_isSet0; + _0_90 = t1; + } + t3._as(t1); + t3 = !t2.hasCompatibleUnits$1(t1); + step = t1; + t1 = t3; + } + number = t2; + } + strategy = _0_1; + } + } else + _0_16_isSet = false; + if (t1) { + t1 = type$.JSArray_Object; + A.SassCalculation__verifyCompatibleNumbers(A._setArrayType([number, step], t1)); + return new A.SassCalculation(_s5_, A._setArrayType([strategy, number, step], t1)); + } + strategy = _null; + number = _null; + step = _null; + t1 = false; + if (_0_1 instanceof A.SassString) { + _0_6_isSet0 = true; + _0_9_isSet0 = true; + _0_12_isSet = true; + if (_0_14_isSet) { + t2 = _0_14; + _0_12_isSet0 = _0_14_isSet; + } else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_14 = "nearest" === t2; + t2 = _0_14; + _0_12_isSet0 = _0_12_isSet; + _0_14_isSet = true; + } + t3 = true; + if (!t2) { + if (_0_16_isSet) + t2 = _0_16; + else { + if (_0_12_isSet0) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet0 = _0_12_isSet; + } + _0_16 = "up" === t2; + t2 = _0_16; + _0_16_isSet = true; + } + if (!t2) { + if (_0_18_isSet) + t2 = _0_18; + else { + if (_0_12_isSet0) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet0 = _0_12_isSet; + } + _0_18 = "down" === t2; + t2 = _0_18; + _0_18_isSet = true; + } + if (!t2) + if (_0_20_isSet) { + t2 = _0_20; + _0_12_isSet = _0_12_isSet0; + } else { + if (_0_12_isSet0) { + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + } + _0_20 = "to-zero" === t2; + t2 = _0_20; + _0_20_isSet = true; + } + else { + t2 = t3; + _0_12_isSet = _0_12_isSet0; + } + } else { + t2 = t3; + _0_12_isSet = _0_12_isSet0; + } + } else { + t2 = t3; + _0_12_isSet = _0_12_isSet0; + } + if (t2) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + if (t2 instanceof A.SassNumber) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + t3 = type$.SassNumber; + t3._as(t2); + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_9_isSet = _0_9_isSet0; + _0_90 = t1; + } + t1 = t1 instanceof A.SassNumber; + if (t1) { + if (_0_9_isSet) + t4 = _0_90; + else { + t4 = _0_9; + _0_9_isSet = _0_9_isSet0; + _0_90 = t4; + } + t3._as(t4); + step = t4; + } + number = t2; + } + strategy = _0_1; + } + } else + _0_12_isSet = _0_14_isSet; + if (t1) { + A.SassCalculation__verifyCompatibleNumbers(A._setArrayType([number, step], type$.JSArray_Object)); + return A.SassCalculation__roundWithStep(strategy._string$_text, number, step); + } + strategy = _null; + rest = _null; + t1 = false; + if (_0_1 instanceof A.SassString) { + _0_6_isSet0 = true; + _0_12_isSet0 = true; + if (_0_14_isSet) + t2 = _0_14; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_14 = "nearest" === t2; + t2 = _0_14; + _0_14_isSet = true; + } + t3 = true; + if (!t2) { + if (_0_16_isSet) + t2 = _0_16; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_16 = "up" === t2; + t2 = _0_16; + _0_16_isSet = true; + } + if (!t2) { + if (_0_18_isSet) + t2 = _0_18; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_18 = "down" === t2; + t2 = _0_18; + _0_18_isSet = true; + } + if (!t2) + if (_0_20_isSet) + t2 = _0_20; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_20 = "to-zero" === t2; + t2 = _0_20; + _0_20_isSet = true; + } + else + t2 = t3; + } else + t2 = t3; + } else + t2 = t3; + if (t2) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + if (t2 instanceof A.SassString) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + type$.SassString._as(t2); + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + _0_10_isSet = true; + } + rest = t2; + } + strategy = _0_1; + } + } + if (t1) + return new A.SassCalculation(_s5_, A._setArrayType([strategy, rest], type$.JSArray_Object)); + t1 = false; + if (_0_1 instanceof A.SassString) { + _0_12_isSet0 = true; + if (_0_14_isSet) + t2 = _0_14; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_14 = "nearest" === t2; + t2 = _0_14; + _0_14_isSet = true; + } + t3 = true; + if (!t2) { + if (_0_16_isSet) + t2 = _0_16; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_16 = "up" === t2; + t2 = _0_16; + _0_16_isSet = true; + } + if (!t2) { + if (_0_18_isSet) + t2 = _0_18; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_18 = "down" === t2; + t2 = _0_18; + _0_18_isSet = true; + } + if (!t2) + if (_0_20_isSet) + t2 = _0_20; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_20 = "to-zero" === t2; + t2 = _0_20; + _0_20_isSet = true; + } + else + t2 = t3; + } else + t2 = t3; + } else + t2 = t3; + if (t2) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_60 = t2; + _0_6_isSet = true; + } + if (t2 != null) + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + _0_10_isSet = true; + } + } + } + if (t1) + throw A.wrapException(A.SassScriptException$(string$.If_str, _null)); + t1 = false; + if (_0_1 instanceof A.SassString) { + _0_12_isSet0 = true; + if (_0_14_isSet) + t2 = _0_14; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_14 = "nearest" === t2; + t2 = _0_14; + _0_14_isSet = true; + } + t3 = true; + if (!t2) { + if (_0_16_isSet) + t2 = _0_16; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_16 = "up" === t2; + t2 = _0_16; + _0_16_isSet = true; + } + if (!t2) { + if (_0_18_isSet) + t2 = _0_18; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_18 = "down" === t2; + t2 = _0_18; + _0_18_isSet = true; + } + if (!t2) + if (_0_20_isSet) + t2 = _0_20; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_20 = "to-zero" === t2; + t2 = _0_20; + _0_20_isSet = true; + } + else + t2 = t3; + } else + t2 = t3; + } else + t2 = t3; + if (t2) { + if (_0_8_isSet) + t2 = _0_8; + else { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_60 = t2; + _0_6_isSet = true; + } + _0_8 = t2 == null; + t2 = _0_8; + _0_8_isSet = true; + } + if (t2) + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + _0_10_isSet = true; + } + } + } + if (t1) + throw A.wrapException(A.SassScriptException$(string$.Number, _null)); + t1 = false; + if (_0_8_isSet) + t2 = _0_8; + else { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_60 = t2; + _0_6_isSet = true; + } + _0_8 = t2 == null; + t2 = _0_8; + } + if (t2) + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + _0_10_isSet = true; + } + if (t1) + return new A.SassCalculation(_s5_, A._setArrayType([_0_1], type$.JSArray_Object)); + step = _null; + t1 = false; + _0_6_isSet0 = true; + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + if (t2 != null) { + if (_0_6_isSet) + step = _0_60; + else { + step = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = step; + } + if (step == null) + step = type$.Object._as(step); + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + } + } + if (t1) + return new A.SassCalculation(_s5_, A._setArrayType([_0_1, step], type$.JSArray_Object)); + if (_0_1 instanceof A.SassString) { + t1 = true; + if (_0_14_isSet) + t2 = _0_14; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet = true; + } + _0_14 = "nearest" === t2; + t2 = _0_14; + } + if (!t2) { + if (_0_16_isSet) + t2 = _0_16; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet = true; + } + _0_16 = "up" === t2; + t2 = _0_16; + } + if (!t2) { + if (_0_18_isSet) + t2 = _0_18; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string$_text; + t2 = _0_12; + _0_12_isSet = true; + } + _0_18 = "down" === t2; + t2 = _0_18; + } + if (!t2) + if (_0_20_isSet) + t1 = _0_20; + else { + if (_0_12_isSet) + t1 = _0_12; + else { + _0_12 = _0_1._string$_text; + t1 = _0_12; + } + _0_20 = "to-zero" === t1; + t1 = _0_20; + } + } + } + } else + t1 = false; + if (!t1) + if (_0_1 instanceof A.SassString) + t1 = _0_1.get$isVar(); + else + t1 = false; + else + t1 = true; + number = _null; + step = _null; + t2 = false; + if (t1) { + _0_6_isSet0 = true; + _0_9_isSet0 = true; + type$.SassString._as(_0_1); + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t1; + } + if (t1 != null) { + if (_0_6_isSet) + number = _0_60; + else { + number = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = number; + } + if (number == null) + number = type$.Object._as(number); + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_9_isSet = _0_9_isSet0; + _0_90 = t1; + } + t1 = t1 != null; + if (t1) { + if (_0_9_isSet) + step = _0_90; + else { + step = _0_9; + _0_9_isSet = _0_9_isSet0; + _0_90 = step; + } + if (step == null) + step = type$.Object._as(step); + } + } else + t1 = t2; + strategy = _0_1; + } else { + t1 = t2; + strategy = _null; + } + if (t1) + return new A.SassCalculation(_s5_, A._setArrayType([strategy, number, step], type$.JSArray_Object)); + t1 = false; + if ((_0_6_isSet ? _0_60 : _0_6) != null) + t1 = (_0_9_isSet ? _0_90 : _0_9) != null; + if (t1) + throw A.wrapException(A.SassScriptException$(A.S(strategyOrNumber) + string$.x20must_b, _null)); + t1 = A.SassScriptException$("Invalid parameters.", _null); + throw A.wrapException(t1); + }, + SassCalculation_calcSize(basis, value) { + var t1 = type$.JSArray_Object, + t2 = A._setArrayType([basis], t1); + if (value != null) + t2.push(value); + A.SassCalculation__verifyLength(t2, 2); + basis = A.SassCalculation__simplify(basis); + value = A.NullableExtension_andThen(value, A.calculation_SassCalculation__simplify$closure()); + t1 = A._setArrayType([basis], t1); + if (value != null) + t1.push(value); + return new A.SassCalculation("calc-size", t1); + }, + SassCalculation_operateInternal(operator, left, right, inLegacySassFunction, simplify, warn) { + var compatible, t1; + if (!simplify) + return new A.CalculationOperation(operator, left, right); + left = A.SassCalculation__simplify(left); + right = A.SassCalculation__simplify(right); + if (B.CalculationOperator_F7i === operator || B.CalculationOperator_oum === operator) { + if (left instanceof A.SassNumber && right instanceof A.SassNumber) { + compatible = left.hasCompatibleUnits$1(right); + if (!compatible && inLegacySassFunction != null && left.isComparableTo$1(right)) { + t1 = A.S(inLegacySassFunction); + warn.call$2("In future versions of Sass, " + t1 + "() will be interpreted as the CSS " + t1 + string$.x28__cal + t1 + string$.x28__ins, B.Deprecation_1AX); + compatible = true; + } + if (compatible) + return operator === B.CalculationOperator_F7i ? left.plus$1(right) : left.minus$1(right); + } + A.SassCalculation__verifyCompatibleNumbers(A._setArrayType([left, right], type$.JSArray_Object)); + if (right instanceof A.SassNumber) { + t1 = right._number$_value; + t1 = t1 < 0 && !A.fuzzyEquals(t1, 0); + } else + t1 = false; + if (t1) { + right = right.times$1(A.SassNumber_SassNumber(-1, null)); + operator = operator === B.CalculationOperator_F7i ? B.CalculationOperator_oum : B.CalculationOperator_F7i; + } + return new A.CalculationOperation(operator, left, right); + } else if (left instanceof A.SassNumber && right instanceof A.SassNumber) + return operator === B.CalculationOperator_kkN ? left.times$1(right) : left.dividedBy$1(right); + else + return new A.CalculationOperation(operator, left, right); + }, + SassCalculation__roundWithStep(strategy, number, step) { + var _0_2, t1, _0_6, _0_8_isSet, _0_8, _0_9_isSet, _0_9, _0_11, _0_13, stepWithNumberUnit, t2, _null = null; + if (!A.LinkedHashSet_LinkedHashSet$_literal(["nearest", "up", "down", "to-zero"], type$.String).contains$1(0, strategy)) + throw A.wrapException(A.ArgumentError$(strategy + string$.x20must_b, _null)); + _0_2 = number._number$_value; + if (_0_2 == 1 / 0 || _0_2 == -1 / 0) { + t1 = step._number$_value; + t1 = t1 == 1 / 0 || t1 == -1 / 0; + } else + t1 = false; + if (!t1) { + t1 = step._number$_value; + t1 = t1 === 0 || isNaN(_0_2) || isNaN(t1); + } else + t1 = true; + if (t1) { + t1 = number.get$numeratorUnits(number); + return A.SassNumber_SassNumber$withUnits(0 / 0, number.get$denominatorUnits(number), t1); + } + if (_0_2 == 1 / 0 || _0_2 == -1 / 0) + return number; + t1 = step._number$_value; + if (t1 == 1 / 0 || t1 == -1 / 0) { + $label0$0: { + if (0 === _0_2) { + t1 = number; + break $label0$0; + } + _0_6 = "nearest" === strategy; + t1 = _0_6; + _0_8_isSet = !t1; + _0_8 = _null; + if (_0_8_isSet) { + _0_8 = "to-zero" === strategy; + _0_9_isSet = _0_8; + } else + _0_9_isSet = true; + _0_9 = _null; + if (_0_9_isSet) { + _0_9 = _0_2 > 0; + t1 = _0_9; + } else + t1 = false; + if (t1) { + t1 = number.get$numeratorUnits(number); + t1 = A.SassNumber_SassNumber$withUnits(0, number.get$denominatorUnits(number), t1); + break $label0$0; + } + if (!_0_6) + if (_0_8_isSet) + t1 = _0_8; + else { + _0_8 = "to-zero" === strategy; + t1 = _0_8; + } + else + t1 = true; + if (t1) { + t1 = number.get$numeratorUnits(number); + t1 = A.SassNumber_SassNumber$withUnits(-0.0, number.get$denominatorUnits(number), t1); + break $label0$0; + } + _0_11 = "up" === strategy; + t1 = _0_11; + if (t1) + if (_0_9_isSet) + t1 = _0_9; + else { + _0_9 = _0_2 > 0; + t1 = _0_9; + } + else + t1 = false; + if (t1) { + t1 = number.get$numeratorUnits(number); + t1 = A.SassNumber_SassNumber$withUnits(1 / 0, number.get$denominatorUnits(number), t1); + break $label0$0; + } + if (_0_11) { + t1 = number.get$numeratorUnits(number); + t1 = A.SassNumber_SassNumber$withUnits(-0.0, number.get$denominatorUnits(number), t1); + break $label0$0; + } + _0_13 = "down" === strategy; + t1 = _0_13; + if (t1) + t1 = _0_2 < 0; + else + t1 = false; + if (t1) { + t1 = number.get$numeratorUnits(number); + t1 = A.SassNumber_SassNumber$withUnits(-1 / 0, number.get$denominatorUnits(number), t1); + break $label0$0; + } + if (_0_13) { + t1 = number.get$numeratorUnits(number); + t1 = A.SassNumber_SassNumber$withUnits(0, number.get$denominatorUnits(number), t1); + break $label0$0; + } + t1 = A.throwExpression(A.UnsupportedError$("Invalid argument: " + strategy + ".")); + } + return t1; + } + stepWithNumberUnit = step.convertValueToMatch$1(number); + $label1$1: { + if ("nearest" === strategy) { + t1 = B.JSNumber_methods.round$0(_0_2 / stepWithNumberUnit); + t2 = number.get$numeratorUnits(number); + t2 = A.SassNumber_SassNumber$withUnits(t1 * stepWithNumberUnit, number.get$denominatorUnits(number), t2); + t1 = t2; + break $label1$1; + } + if ("up" === strategy) { + t2 = _0_2 / stepWithNumberUnit; + t1 = t1 < 0 ? B.JSNumber_methods.floor$0(t2) : B.JSNumber_methods.ceil$0(t2); + t2 = number.get$numeratorUnits(number); + t2 = A.SassNumber_SassNumber$withUnits(t1 * stepWithNumberUnit, number.get$denominatorUnits(number), t2); + t1 = t2; + break $label1$1; + } + if ("down" === strategy) { + t2 = _0_2 / stepWithNumberUnit; + t1 = t1 < 0 ? B.JSNumber_methods.ceil$0(t2) : B.JSNumber_methods.floor$0(t2); + t2 = number.get$numeratorUnits(number); + t2 = A.SassNumber_SassNumber$withUnits(t1 * stepWithNumberUnit, number.get$denominatorUnits(number), t2); + t1 = t2; + break $label1$1; + } + if ("to-zero" === strategy) { + t1 = _0_2 / stepWithNumberUnit; + if (_0_2 < 0) { + t1 = B.JSNumber_methods.ceil$0(t1); + t2 = number.get$numeratorUnits(number); + t2 = A.SassNumber_SassNumber$withUnits(t1 * stepWithNumberUnit, number.get$denominatorUnits(number), t2); + t1 = t2; + } else { + t1 = B.JSNumber_methods.floor$0(t1); + t2 = number.get$numeratorUnits(number); + t2 = A.SassNumber_SassNumber$withUnits(t1 * stepWithNumberUnit, number.get$denominatorUnits(number), t2); + t1 = t2; + } + break $label1$1; + } + t1 = number.get$numeratorUnits(number); + t1 = A.SassNumber_SassNumber$withUnits(0 / 0, number.get$denominatorUnits(number), t1); + break $label1$1; + } + return t1; + }, + SassCalculation__simplify(arg) { + var t1, t2, _0_11_isSet, _0_15, _0_12, _0_16_isSet, text, _0_11, _0_16, _0_12_isSet, _0_15_isSet, value, _null = null, + _s32_ = " can't be used in a calculation."; + $label0$0: { + if (arg instanceof A.SassNumber || arg instanceof A.CalculationOperation) { + t1 = arg; + break $label0$0; + } + t1 = arg instanceof A.SassString; + t2 = _null; + if (t1 && !arg._hasQuotes) { + t1 = arg; + break $label0$0; + } + if (t1) + A.throwExpression(A.SassScriptException$("Quoted string " + arg.toString$0(0) + _s32_, _null)); + _0_11_isSet = arg instanceof A.SassCalculation; + _0_15 = _null; + _0_12 = _null; + _0_16_isSet = false; + text = _null; + t1 = false; + if (_0_11_isSet) { + _0_11 = "calc" === arg.name; + if (_0_11) { + _0_12 = arg.$arguments; + _0_15 = _0_12.length === 1; + _0_16_isSet = _0_15; + if (_0_16_isSet) { + _0_16 = _0_12[0]; + t2 = _0_16; + if (t2 instanceof A.SassString) { + type$.SassString._as(_0_16); + if (!_0_16._hasQuotes) { + text = _0_16._string$_text; + t1 = A.SassCalculation__needsParentheses(text); + } + } + } else + _0_16 = t2; + } else + _0_16 = t2; + _0_12_isSet = _0_11; + _0_15_isSet = _0_12_isSet; + } else { + _0_16 = t2; + _0_11 = _null; + _0_15_isSet = false; + _0_12_isSet = false; + } + if (t1) { + t1 = new A.SassString("(" + A.S(text) + ")", false); + break $label0$0; + } + t1 = false; + if (_0_11_isSet) + if (_0_11) + if (_0_15_isSet) + t1 = _0_15; + else { + if (_0_12_isSet) + t1 = _0_12; + else { + _0_12 = arg.$arguments; + t1 = _0_12; + _0_12_isSet = true; + } + _0_15 = t1.length === 1; + t1 = _0_15; + } + if (t1) { + if (_0_16_isSet) + value = _0_16; + else { + _0_16 = (_0_12_isSet ? _0_12 : arg.$arguments)[0]; + value = _0_16; + } + t1 = value; + break $label0$0; + } + if (_0_11_isSet) { + t1 = arg; + break $label0$0; + } + if (arg instanceof A.Value) + A.throwExpression(A.SassScriptException$("Value " + arg.toString$0(0) + _s32_, _null)); + t1 = A.throwExpression(A.ArgumentError$("Unexpected calculation argument " + A.S(arg) + ".", _null)); + } + return t1; + }, + SassCalculation__needsParentheses(text) { + var t1, couldBeVar, second, third, fourth, i, t2, + first = text.charCodeAt(0); + if (first === 32 || first === 9 || first === 10 || first === 13 || first === 12 || first === 47 || first === 42) + return true; + t1 = text.length; + couldBeVar = t1 >= 4 && A.characterEqualsIgnoreCase(first, 118); + if (t1 < 2) + return false; + second = text.charCodeAt(1); + if (second === 32 || second === 9 || second === 10 || second === 13 || second === 12 || second === 47 || second === 42) + return true; + couldBeVar = couldBeVar && A.characterEqualsIgnoreCase(second, 97); + if (t1 < 3) + return false; + third = text.charCodeAt(2); + if (third === 32 || third === 9 || third === 10 || third === 13 || third === 12 || third === 47 || third === 42) + return true; + couldBeVar = couldBeVar && A.characterEqualsIgnoreCase(third, 114); + if (t1 < 4) + return false; + fourth = text.charCodeAt(3); + if (couldBeVar && fourth === 40) + return true; + if (fourth === 32 || fourth === 9 || fourth === 10 || fourth === 13 || fourth === 12 || fourth === 47 || fourth === 42) + return true; + for (i = 4; i < t1; ++i) { + t2 = text.charCodeAt(i); + if (t2 === 32 || t2 === 9 || t2 === 10 || t2 === 13 || t2 === 12 || t2 === 47 || t2 === 42) + return true; + } + return false; + }, + SassCalculation__verifyCompatibleNumbers(args) { + var t1, _i, t2, arg, i, number1, j, number2; + for (t1 = args.length, _i = 0; t2 = args.length, _i < t2; args.length === t1 || (0, A.throwConcurrentModificationError)(args), ++_i) { + arg = args[_i]; + if (arg instanceof A.SassNumber && arg.get$hasComplexUnits()) + throw A.wrapException(A.SassScriptException$("Number " + A.S(arg) + " isn't compatible with CSS calculations.", null)); + } + for (t1 = t2, i = 0; i < t1 - 1; ++i) { + number1 = args[i]; + if (!(number1 instanceof A.SassNumber)) + continue; + for (j = i + 1; t1 = args.length, j < t1; ++j) { + number2 = args[j]; + if (!(number2 instanceof A.SassNumber)) + continue; + if (number1.hasPossiblyCompatibleUnits$1(number2)) + continue; + throw A.wrapException(A.SassScriptException$(number1.toString$0(0) + " and " + number2.toString$0(0) + " are incompatible.", null)); + } + } + }, + SassCalculation__verifyLength(args, expectedLength) { + var t1; + if (args.length === expectedLength) + return; + if (B.JSArray_methods.any$1(args, new A.SassCalculation__verifyLength_closure())) + return; + t1 = args.length; + throw A.wrapException(A.SassScriptException$("" + expectedLength + " arguments required, but only " + t1 + " " + A.pluralize("was", t1, "were") + " passed.", null)); + }, + SassCalculation__singleArgument($name, argument, mathFunc, forbidUnits) { + argument = A.SassCalculation__simplify(argument); + if (!(argument instanceof A.SassNumber)) + return new A.SassCalculation($name, A._setArrayType([argument], type$.JSArray_Object)); + if (forbidUnits) + argument.assertNoUnits$0(); + return mathFunc.call$1(argument); + }, + SassCalculation: function SassCalculation(t0, t1) { + this.name = t0; + this.$arguments = t1; + }, + SassCalculation__verifyLength_closure: function SassCalculation__verifyLength_closure() { + }, + CalculationOperation: function CalculationOperation(t0, t1, t2) { + this._operator = t0; + this._left = t1; + this._right = t2; + }, + CalculationOperator: function CalculationOperator(t0, t1, t2, t3) { + var _ = this; + _.name = t0; + _.operator = t1; + _.precedence = t2; + _._name = t3; + }, + SassColor_SassColor$rgb(red, green, blue, alpha) { + return A.SassColor_SassColor$rgbInternal(red, green, blue, alpha, null); + }, + SassColor_SassColor$rgbInternal(red, green, blue, alpha, format) { + var _null = null, + t1 = red == null ? _null : red, + t2 = green == null ? _null : green, + t3 = blue == null ? _null : blue; + return A.SassColor$_forSpace(B.RgbColorSpace_i0P, t1, t2, t3, alpha == null ? _null : alpha, format); + }, + SassColor_SassColor$hsl(hue, saturation, lightness, alpha) { + var _null = null, + t1 = hue == null ? _null : hue, + t2 = saturation == null ? _null : saturation, + t3 = lightness == null ? _null : lightness; + return A.SassColor_SassColor$forSpaceInternal(B.HslColorSpace_JQ2, t1, t2, t3, alpha == null ? _null : alpha); + }, + SassColor_SassColor$hwb(hue, whiteness, blackness, alpha) { + var _null = null, + t1 = hue == null ? _null : hue, + t2 = whiteness == null ? _null : whiteness, + t3 = blackness == null ? _null : blackness; + return A.SassColor_SassColor$forSpaceInternal(B.HwbColorSpace_guQ, t1, t2, t3, alpha == null ? _null : alpha); + }, + SassColor_SassColor$forSpaceInternal(space, channel0, channel1, channel2, alpha) { + var t1, t2, _null = null; + $label0$0: { + if (B.HslColorSpace_JQ2 === space) { + t1 = channel1 == null; + t2 = A.SassColor__normalizeHue(channel0, !t1 && channel1 < 0 && !A.fuzzyEquals(channel1, 0)); + t2 = A.SassColor$_forSpace(space, t2, t1 ? _null : Math.abs(channel1), channel2, alpha, _null); + t1 = t2; + break $label0$0; + } + if (B.HwbColorSpace_guQ === space) { + t1 = A.SassColor$_forSpace(space, A.SassColor__normalizeHue(channel0, false), channel1, channel2, alpha, _null); + break $label0$0; + } + if (B.LchColorSpace_Bpv === space || B.OklchColorSpace_9Gj === space) { + t1 = channel1 == null; + t2 = t1 ? _null : Math.abs(channel1); + t2 = A.SassColor$_forSpace(space, channel0, t2, A.SassColor__normalizeHue(channel2, !t1 && channel1 < 0 && !A.fuzzyEquals(channel1, 0)), alpha, _null); + t1 = t2; + break $label0$0; + } + t1 = A.SassColor$_forSpace(space, channel0, channel1, channel2, alpha, _null); + break $label0$0; + } + return t1; + }, + SassColor$_forSpace(_space, channel0OrNull, channel1OrNull, channel2OrNull, alpha, format) { + return new A.SassColor(_space, channel0OrNull, channel1OrNull, channel2OrNull, format, A.NullableExtension_andThen(alpha, new A.SassColor$_forSpace_closure())); + }, + SassColor__normalizeHue(hue, invert) { + var t1, t2; + if (hue == null) + return hue; + t1 = B.JSNumber_methods.$mod(hue, 360); + t2 = invert ? 180 : 0; + return B.JSNumber_methods.$mod(t1 + 360 + t2, 360); + }, + SassColor: function SassColor(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._space = t0; + _.channel0OrNull = t1; + _.channel1OrNull = t2; + _.channel2OrNull = t3; + _.format = t4; + _.alphaOrNull = t5; + }, + SassColor$_forSpace_closure: function SassColor$_forSpace_closure() { + }, + _ColorFormatEnum: function _ColorFormatEnum() { + }, + SpanColorFormat: function SpanColorFormat(t0) { + this._color$_span = t0; + }, + ColorChannel: function ColorChannel(t0, t1, t2) { + this.name = t0; + this.isPolarAngle = t1; + this.associatedUnit = t2; + }, + LinearChannel: function LinearChannel(t0, t1, t2, t3, t4, t5, t6, t7) { + var _ = this; + _.min = t0; + _.max = t1; + _.requiresPercent = t2; + _.lowerClamped = t3; + _.upperClamped = t4; + _.name = t5; + _.isPolarAngle = t6; + _.associatedUnit = t7; + }, + GamutMapMethod_GamutMapMethod$fromName($name) { + var t1; + $label0$0: { + if ("clip" === $name) { + t1 = B.ClipGamutMap_clip; + break $label0$0; + } + if ("local-minde" === $name) { + t1 = B.LocalMindeGamutMap_A2x; + break $label0$0; + } + t1 = A.throwExpression(A.SassScriptException$('Unknown gamut map method "' + $name + '".', null)); + } + return t1; + }, + GamutMapMethod: function GamutMapMethod() { + }, + ClipGamutMap: function ClipGamutMap(t0) { + this.name = t0; + }, + LocalMindeGamutMap: function LocalMindeGamutMap(t0) { + this.name = t0; + }, + InterpolationMethod$(space, hue) { + var t1; + if (space.get$isPolarInternal()) + t1 = hue == null ? B.HueInterpolationMethod_0 : hue; + else + t1 = null; + if (!space.get$isPolarInternal() && hue != null) + A.throwExpression(A.ArgumentError$(string$.Hue_in + space.toString$0(0) + ".", null)); + return new A.InterpolationMethod(space, t1); + }, + InterpolationMethod_InterpolationMethod$fromValue(value, $name) { + var t1, space, hueMethod, + list = value.assertCommonListStyle$2$allowSlash($name, false); + if (list.length === 0) + throw A.wrapException(A.SassScriptException$(string$.Expecta, $name)); + t1 = B.JSArray_methods.get$first(list).assertString$1($name); + t1.assertUnquoted$1($name); + space = A.ColorSpace_fromName(t1._string$_text, $name); + if (list.length === 1) + return A.InterpolationMethod$(space, null); + hueMethod = A.HueInterpolationMethod_HueInterpolationMethod$_fromValue(list[1], $name); + if (list.length === 2) + throw A.wrapException(A.SassScriptException$('Expected unquoted string "hue" after ' + value.toString$0(0) + ".", $name)); + else { + t1 = list[2].assertString$1($name); + t1.assertUnquoted$1($name); + if (t1._string$_text.toLowerCase() !== "hue") + throw A.wrapException(A.SassScriptException$(string$.Expectu + value.toString$0(0) + ", was " + list[2].toString$0(0) + ".", $name)); + else if (list.length > 3) + throw A.wrapException(A.SassScriptException$('Expected nothing after "hue" in ' + value.toString$0(0) + ".", $name)); + else if (!space.get$isPolarInternal()) + throw A.wrapException(A.SassScriptException$('Hue interpolation method "' + hueMethod.toString$0(0) + string$.x20hue__ + space.toString$0(0) + ".", $name)); + } + return A.InterpolationMethod$(space, hueMethod); + }, + HueInterpolationMethod_HueInterpolationMethod$_fromValue(value, $name) { + var _0_0, + t1 = value.assertString$1($name); + t1.assertUnquoted$0(); + _0_0 = t1._string$_text.toLowerCase(); + $label0$0: { + if ("shorter" === _0_0) { + t1 = B.HueInterpolationMethod_0; + break $label0$0; + } + if ("longer" === _0_0) { + t1 = B.HueInterpolationMethod_1; + break $label0$0; + } + if ("increasing" === _0_0) { + t1 = B.HueInterpolationMethod_2; + break $label0$0; + } + if ("decreasing" === _0_0) { + t1 = B.HueInterpolationMethod_3; + break $label0$0; + } + t1 = A.throwExpression(A.SassScriptException$("Unknown hue interpolation method " + value.toString$0(0) + ".", $name)); + } + return t1; + }, + InterpolationMethod: function InterpolationMethod(t0, t1) { + this.space = t0; + this.hue = t1; + }, + HueInterpolationMethod: function HueInterpolationMethod(t0) { + this._name = t0; + }, + ColorSpace_fromName($name, argumentName) { + var t1, + _0_0 = $name.toLowerCase(); + $label0$0: { + if ("rgb" === _0_0) { + t1 = B.RgbColorSpace_i0P; + break $label0$0; + } + if ("hwb" === _0_0) { + t1 = B.HwbColorSpace_guQ; + break $label0$0; + } + if ("hsl" === _0_0) { + t1 = B.HslColorSpace_JQ2; + break $label0$0; + } + if ("srgb" === _0_0) { + t1 = B.SrgbColorSpace_thf; + break $label0$0; + } + if ("srgb-linear" === _0_0) { + t1 = B.SrgbLinearColorSpace_kUj; + break $label0$0; + } + if ("display-p3" === _0_0) { + t1 = B.DisplayP3ColorSpace_MmT; + break $label0$0; + } + if ("a98-rgb" === _0_0) { + t1 = B.A98RgbColorSpace_lf2; + break $label0$0; + } + if ("prophoto-rgb" === _0_0) { + t1 = B.ProphotoRgbColorSpace_BDz; + break $label0$0; + } + if ("rec2020" === _0_0) { + t1 = B.Rec2020ColorSpace_6oo; + break $label0$0; + } + if ("xyz" === _0_0 || "xyz-d65" === _0_0) { + t1 = B.XyzD65ColorSpace_WiJ; + break $label0$0; + } + if ("xyz-d50" === _0_0) { + t1 = B.XyzD50ColorSpace_2OB; + break $label0$0; + } + if ("lab" === _0_0) { + t1 = B.LabColorSpace_2nT; + break $label0$0; + } + if ("lch" === _0_0) { + t1 = B.LchColorSpace_Bpv; + break $label0$0; + } + if ("oklab" === _0_0) { + t1 = B.OklabColorSpace_540; + break $label0$0; + } + if ("oklch" === _0_0) { + t1 = B.OklchColorSpace_9Gj; + break $label0$0; + } + t1 = A.throwExpression(A.SassScriptException$('Unknown color space "' + $name + '".', argumentName)); + } + return t1; + }, + ColorSpace: function ColorSpace() { + }, + A98RgbColorSpace: function A98RgbColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + DisplayP3ColorSpace: function DisplayP3ColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + HslColorSpace: function HslColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + HwbColorSpace: function HwbColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + HwbColorSpace_convert_toRgb: function HwbColorSpace_convert_toRgb(t0, t1) { + this._box_0 = t0; + this.factor = t1; + }, + LabColorSpace: function LabColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + LchColorSpace: function LchColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + LmsColorSpace: function LmsColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + OklabColorSpace: function OklabColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + OklchColorSpace: function OklchColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + ProphotoRgbColorSpace: function ProphotoRgbColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + Rec2020ColorSpace: function Rec2020ColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + RgbColorSpace: function RgbColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + SrgbColorSpace: function SrgbColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + SrgbLinearColorSpace: function SrgbLinearColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + XyzD50ColorSpace: function XyzD50ColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + XyzD65ColorSpace: function XyzD65ColorSpace(t0, t1) { + this.name = t0; + this._channels = t1; + }, + SassFunction: function SassFunction(t0) { + this.callable = t0; + }, + SassList$(contents, _separator, brackets) { + var t1 = new A.SassList(A.List_List$unmodifiable(contents, type$.Value), _separator, brackets); + t1.SassList$3$brackets(contents, _separator, brackets); + return t1; + }, + SassList: function SassList(t0, t1, t2) { + this._list$_contents = t0; + this._separator = t1; + this._hasBrackets = t2; + }, + SassList_isBlank_closure: function SassList_isBlank_closure() { + }, + ListSeparator: function ListSeparator(t0, t1, t2) { + this._list$_name = t0; + this.separator = t1; + this._name = t2; + }, + SassMap: function SassMap(t0) { + this._map$_contents = t0; + }, + SassMixin: function SassMixin(t0) { + this.callable = t0; + }, + _SassNull: function _SassNull() { + }, + conversionFactor(unit1, unit2) { + var _0_0; + if (unit1 === unit2) + return 1; + _0_0 = B.Map_NtHoP.$index(0, unit1); + if (_0_0 != null) + return _0_0.$index(0, unit2); + return null; + }, + SassNumber_SassNumber(value, unit) { + return unit == null ? new A.UnitlessSassNumber(value, null) : new A.SingleUnitSassNumber(unit, value, null); + }, + SassNumber_SassNumber$withUnits(value, denominatorUnits, numeratorUnits) { + var t1, _0_8_isSet, _0_8, _0_10, _0_10_isSet, _0_7, unit, t2, _0_7_isSet, t3, _0_4_isSet, _0_7_isSet0, numerators, denominators, unsimplifiedDenominators, valueDouble, _i, denominator, simplifiedAway, i, factor, _1_2, _1_7_isSet, _1_7, _null = null, + _0_6_isSet = !false, + _0_6 = _null, + _0_4 = _null; + if (_0_6_isSet) { + _0_4 = (numeratorUnits === null ? type$.List_String._as(numeratorUnits) : numeratorUnits).length; + t1 = _0_4; + _0_6 = t1 <= 0; + _0_8_isSet = _0_6; + } else + _0_8_isSet = true; + _0_8 = _null; + _0_10 = _null; + if (_0_8_isSet) { + _0_8 = denominatorUnits == null; + t1 = _0_8; + _0_10_isSet = !t1; + if (_0_10_isSet) { + _0_10 = (denominatorUnits == null ? type$.List_String._as(denominatorUnits) : denominatorUnits).length <= 0; + t1 = _0_10; + } else + t1 = true; + _0_7 = denominatorUnits; + } else { + _0_7 = _null; + _0_10_isSet = false; + t1 = false; + } + if (t1) + return new A.UnitlessSassNumber(value, _null); + t1 = type$.List_String; + unit = _null; + t2 = false; + if (t1._is(numeratorUnits)) { + _0_7_isSet = true; + if (_0_6_isSet) { + t3 = _0_4; + _0_4_isSet = _0_6_isSet; + } else { + _0_4 = numeratorUnits.length; + t3 = _0_4; + _0_4_isSet = true; + } + if (t3 === 1) { + unit = numeratorUnits[0]; + if (_0_8_isSet) { + t2 = _0_8; + _0_7_isSet0 = _0_8_isSet; + } else { + _0_8 = denominatorUnits == null; + t2 = _0_8; + _0_7_isSet0 = _0_7_isSet; + _0_7 = denominatorUnits; + _0_8_isSet = true; + } + if (!t2) + if (_0_10_isSet) { + t2 = _0_10; + _0_7_isSet = _0_7_isSet0; + } else { + if (_0_7_isSet0) { + t2 = _0_7; + _0_7_isSet = _0_7_isSet0; + } else { + t2 = denominatorUnits; + _0_7 = t2; + } + _0_10 = (t2 == null ? t1._as(t2) : t2).length <= 0; + t2 = _0_10; + _0_10_isSet = true; + } + else { + _0_7_isSet = _0_7_isSet0; + t2 = true; + } + } else + _0_7_isSet = _0_8_isSet; + } else { + _0_7_isSet = _0_8_isSet; + _0_4_isSet = _0_6_isSet; + } + if (t2) + return new A.SingleUnitSassNumber(unit, value, _null); + t2 = numeratorUnits === null; + t3 = false; + if (!t2) { + _0_7_isSet0 = true; + numerators = numeratorUnits; + if (_0_8_isSet) + t3 = _0_8; + else { + if (_0_7_isSet) + t3 = _0_7; + else { + t3 = denominatorUnits; + _0_7_isSet = _0_7_isSet0; + _0_7 = t3; + } + _0_8 = t3 == null; + t3 = _0_8; + } + if (!t3) + if (_0_10_isSet) + t3 = _0_10; + else { + if (_0_7_isSet) + t3 = _0_7; + else { + t3 = denominatorUnits; + _0_7_isSet = _0_7_isSet0; + _0_7 = t3; + } + _0_10 = (t3 == null ? t1._as(t3) : t3).length <= 0; + t3 = _0_10; + } + else + t3 = true; + } else + numerators = _null; + if (t3) + return new A.ComplexSassNumber(A.List_List$unmodifiable(numerators, type$.String), B.List_empty, value, _null); + if (!false) + if (_0_6_isSet) + t2 = _0_6; + else { + if (_0_4_isSet) + t2 = _0_4; + else { + _0_4 = (t2 ? t1._as(numeratorUnits) : numeratorUnits).length; + t2 = _0_4; + } + _0_6 = t2 <= 0; + t2 = _0_6; + } + else + t2 = true; + denominators = _null; + if (t2) { + if (_0_7_isSet) + t2 = _0_7; + else { + t2 = denominatorUnits; + _0_7 = t2; + _0_7_isSet = true; + } + t2 = t2 != null; + if (t2) { + denominators = _0_7_isSet ? _0_7 : denominatorUnits; + if (denominators == null) + denominators = t1._as(denominators); + } + t1 = t2; + } else + t1 = false; + if (t1) + return new A.ComplexSassNumber(B.List_empty, A.List_List$unmodifiable(denominators, type$.String), value, _null); + numerators = A._setArrayType(numeratorUnits.slice(0), A._arrayInstanceType(numeratorUnits)); + unsimplifiedDenominators = A._setArrayType(denominatorUnits.slice(0), A.instanceType(denominatorUnits)); + denominators = A._setArrayType([], type$.JSArray_String); + for (t1 = unsimplifiedDenominators.length, valueDouble = value, _i = 0; _i < unsimplifiedDenominators.length; unsimplifiedDenominators.length === t1 || (0, A.throwConcurrentModificationError)(unsimplifiedDenominators), ++_i) { + denominator = unsimplifiedDenominators[_i]; + i = 0; + while (true) { + if (!(i < numerators.length)) { + simplifiedAway = false; + break; + } + c$0: { + factor = A.conversionFactor(denominator, numerators[i]); + if (factor == null) + break c$0; + valueDouble *= factor; + B.JSArray_methods.removeAt$1(numerators, i); + simplifiedAway = true; + break; + } + ++i; + } + if (!simplifiedAway) + denominators.push(denominator); + } + $label0$1: { + _1_2 = numerators.length; + t1 = _1_2; + _1_7_isSet = t1 <= 0; + if (_1_7_isSet) { + _1_7 = denominators.length <= 0; + t1 = _1_7; + } else { + _1_7 = _null; + t1 = false; + } + if (t1) { + t1 = new A.UnitlessSassNumber(valueDouble, _null); + break $label0$1; + } + t1 = false; + if (_1_2 === 1) { + unit = numerators[0]; + t1 = _1_7_isSet ? _1_7 : denominators.length <= 0; + } else + unit = _null; + if (t1) { + t1 = new A.SingleUnitSassNumber(unit, valueDouble, _null); + break $label0$1; + } + t1 = type$.String; + t1 = new A.ComplexSassNumber(A.List_List$unmodifiable(numerators, t1), A.List_List$unmodifiable(denominators, t1), valueDouble, _null); + break $label0$1; + } + return t1; + }, + SassNumber: function SassNumber() { + }, + SassNumber__coerceOrConvertValue_compatibilityException: function SassNumber__coerceOrConvertValue_compatibilityException(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.$this = t0; + _.other = t1; + _.otherName = t2; + _.otherHasUnits = t3; + _.name = t4; + _.newNumerators = t5; + _.newDenominators = t6; + }, + SassNumber__coerceOrConvertValue_closure: function SassNumber__coerceOrConvertValue_closure(t0, t1) { + this._box_0 = t0; + this.newNumerator = t1; + }, + SassNumber__coerceOrConvertValue_closure0: function SassNumber__coerceOrConvertValue_closure0(t0) { + this.compatibilityException = t0; + }, + SassNumber__coerceOrConvertValue_closure1: function SassNumber__coerceOrConvertValue_closure1(t0, t1) { + this._box_0 = t0; + this.newDenominator = t1; + }, + SassNumber__coerceOrConvertValue_closure2: function SassNumber__coerceOrConvertValue_closure2(t0) { + this.compatibilityException = t0; + }, + SassNumber_plus_closure: function SassNumber_plus_closure() { + }, + SassNumber_minus_closure: function SassNumber_minus_closure() { + }, + SassNumber_multiplyUnits_closure: function SassNumber_multiplyUnits_closure(t0, t1) { + this._box_0 = t0; + this.numerator = t1; + }, + SassNumber_multiplyUnits_closure0: function SassNumber_multiplyUnits_closure0(t0, t1) { + this.newNumerators = t0; + this.numerator = t1; + }, + SassNumber_multiplyUnits_closure1: function SassNumber_multiplyUnits_closure1(t0, t1) { + this._box_0 = t0; + this.numerator = t1; + }, + SassNumber_multiplyUnits_closure2: function SassNumber_multiplyUnits_closure2(t0, t1) { + this.newNumerators = t0; + this.numerator = t1; + }, + SassNumber__areAnyConvertible_closure: function SassNumber__areAnyConvertible_closure(t0) { + this.units2 = t0; + }, + SassNumber__canonicalizeUnitList_closure: function SassNumber__canonicalizeUnitList_closure() { + }, + SassNumber__canonicalMultiplier_closure: function SassNumber__canonicalMultiplier_closure(t0) { + this.$this = t0; + }, + SassNumber_unitSuggestion_closure: function SassNumber_unitSuggestion_closure() { + }, + SassNumber_unitSuggestion_closure0: function SassNumber_unitSuggestion_closure0() { + }, + ComplexSassNumber: function ComplexSassNumber(t0, t1, t2, t3) { + var _ = this; + _._numeratorUnits = t0; + _._denominatorUnits = t1; + _._number$_value = t2; + _.hashCache = null; + _.asSlash = t3; + }, + SingleUnitSassNumber: function SingleUnitSassNumber(t0, t1, t2) { + var _ = this; + _._unit = t0; + _._number$_value = t1; + _.hashCache = null; + _.asSlash = t2; + }, + SingleUnitSassNumber__coerceToUnit_closure: function SingleUnitSassNumber__coerceToUnit_closure(t0, t1) { + this.$this = t0; + this.unit = t1; + }, + SingleUnitSassNumber__coerceValueToUnit_closure: function SingleUnitSassNumber__coerceValueToUnit_closure(t0) { + this.$this = t0; + }, + SingleUnitSassNumber_multiplyUnits_closure: function SingleUnitSassNumber_multiplyUnits_closure(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + SingleUnitSassNumber_multiplyUnits_closure0: function SingleUnitSassNumber_multiplyUnits_closure0(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + UnitlessSassNumber: function UnitlessSassNumber(t0, t1) { + this._number$_value = t0; + this.hashCache = null; + this.asSlash = t1; + }, + SassString$(_text, quotes) { + return new A.SassString(_text, quotes); + }, + SassString: function SassString(t0, t1) { + var _ = this; + _._string$_text = t0; + _._hasQuotes = t1; + _.__SassString__sassLength_FI = $; + _._hashCache = null; + }, + AnySelectorVisitor: function AnySelectorVisitor() { + }, + AnySelectorVisitor_visitComplexSelector_closure: function AnySelectorVisitor_visitComplexSelector_closure(t0) { + this.$this = t0; + }, + AnySelectorVisitor_visitCompoundSelector_closure: function AnySelectorVisitor_visitCompoundSelector_closure(t0) { + this.$this = t0; + }, + _EvaluateVisitor$0(functions, importCache, logger, nodeImporter, quietDeps, sourceMap) { + var t1 = type$.Uri, + t2 = type$.Module_AsyncCallable, + t3 = A._setArrayType([], type$.JSArray_Record_2_String_and_AstNode); + t1 = new A._EvaluateVisitor0(importCache, nodeImporter, A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.AsyncCallable), A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Configuration), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.AstNode), logger, A.LinkedHashSet_LinkedHashSet$_empty(type$.Record_2_String_and_SourceSpan), quietDeps, sourceMap, A.AsyncEnvironment$(), A.LinkedHashSet_LinkedHashSet$_empty(t1), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.nullable_AstNode), t3, B.Configuration_Map_empty_null); + t1._EvaluateVisitor$6$functions$importCache$logger$nodeImporter$quietDeps$sourceMap0(functions, importCache, logger, nodeImporter, quietDeps, sourceMap); + return t1; + }, + _EvaluateVisitor0: function _EvaluateVisitor0(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15) { + var _ = this; + _._async_evaluate$_importCache = t0; + _._async_evaluate$_nodeImporter = t1; + _._async_evaluate$_builtInFunctions = t2; + _._async_evaluate$_builtInModules = t3; + _._async_evaluate$_modules = t4; + _._async_evaluate$_moduleConfigurations = t5; + _._async_evaluate$_moduleNodes = t6; + _._async_evaluate$_logger = t7; + _._async_evaluate$_warningsEmitted = t8; + _._async_evaluate$_quietDeps = t9; + _._async_evaluate$_sourceMap = t10; + _._async_evaluate$_environment = t11; + _._async_evaluate$_declarationName = _._async_evaluate$__parent = _._async_evaluate$_mediaQuerySources = _._async_evaluate$_mediaQueries = _._async_evaluate$_styleRuleIgnoringAtRoot = null; + _._async_evaluate$_member = "root stylesheet"; + _._async_evaluate$_importSpan = _._async_evaluate$_callableNode = _._async_evaluate$_currentCallable = null; + _._async_evaluate$_inSupportsDeclaration = _._async_evaluate$_inKeyframes = _._async_evaluate$_atRootExcludingStyleRule = _._async_evaluate$_inUnknownAtRule = _._async_evaluate$_inFunction = false; + _._async_evaluate$_loadedUrls = t12; + _._async_evaluate$_activeModules = t13; + _._async_evaluate$_stack = t14; + _._async_evaluate$_importer = null; + _._async_evaluate$_inDependency = false; + _._async_evaluate$__extensionStore = _._async_evaluate$_preModuleComments = _._async_evaluate$_outOfOrderImports = _._async_evaluate$__endOfImports = _._async_evaluate$__root = _._async_evaluate$__stylesheet = null; + _._async_evaluate$_configuration = t15; + }, + _EvaluateVisitor_closure12: function _EvaluateVisitor_closure12(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure13: function _EvaluateVisitor_closure13(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure14: function _EvaluateVisitor_closure14(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure15: function _EvaluateVisitor_closure15(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure16: function _EvaluateVisitor_closure16(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure17: function _EvaluateVisitor_closure17(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure18: function _EvaluateVisitor_closure18(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure19: function _EvaluateVisitor_closure19(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure20: function _EvaluateVisitor_closure20(t0) { + this.$this = t0; + }, + _EvaluateVisitor__closure6: function _EvaluateVisitor__closure6(t0, t1, t2) { + this.$this = t0; + this.name = t1; + this.module = t2; + }, + _EvaluateVisitor_closure21: function _EvaluateVisitor_closure21(t0) { + this.$this = t0; + }, + _EvaluateVisitor__closure5: function _EvaluateVisitor__closure5(t0, t1, t2) { + this.$this = t0; + this.name = t1; + this.module = t2; + }, + _EvaluateVisitor_closure22: function _EvaluateVisitor_closure22(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure23: function _EvaluateVisitor_closure23(t0) { + this.$this = t0; + }, + _EvaluateVisitor__closure3: function _EvaluateVisitor__closure3(t0, t1, t2) { + this.values = t0; + this.span = t1; + this.callableNode = t2; + }, + _EvaluateVisitor__closure4: function _EvaluateVisitor__closure4(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure24: function _EvaluateVisitor_closure24(t0) { + this.$this = t0; + }, + _EvaluateVisitor_run_closure0: function _EvaluateVisitor_run_closure0(t0, t1, t2) { + this.$this = t0; + this.node = t1; + this.importer = t2; + }, + _EvaluateVisitor_run__closure0: function _EvaluateVisitor_run__closure0(t0, t1, t2) { + this.$this = t0; + this.importer = t1; + this.node = t2; + }, + _EvaluateVisitor__loadModule_closure1: function _EvaluateVisitor__loadModule_closure1(t0, t1) { + this._box_0 = t0; + this.callback = t1; + }, + _EvaluateVisitor__loadModule_closure2: function _EvaluateVisitor__loadModule_closure2(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.$this = t0; + _.url = t1; + _.nodeWithSpan = t2; + _.baseUrl = t3; + _.namesInErrors = t4; + _.configuration = t5; + _.callback = t6; + }, + _EvaluateVisitor__loadModule__closure1: function _EvaluateVisitor__loadModule__closure1(t0, t1) { + this.$this = t0; + this.message = t1; + }, + _EvaluateVisitor__loadModule__closure2: function _EvaluateVisitor__loadModule__closure2(t0, t1, t2) { + this._box_1 = t0; + this.callback = t1; + this.firstLoad = t2; + }, + _EvaluateVisitor__execute_closure0: function _EvaluateVisitor__execute_closure0(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.$this = t0; + _.importer = t1; + _.stylesheet = t2; + _.extensionStore = t3; + _.configuration = t4; + _.css = t5; + _.preModuleComments = t6; + }, + _EvaluateVisitor__combineCss_closure1: function _EvaluateVisitor__combineCss_closure1() { + }, + _EvaluateVisitor__combineCss_closure2: function _EvaluateVisitor__combineCss_closure2(t0) { + this.selectors = t0; + }, + _EvaluateVisitor__combineCss_visitModule0: function _EvaluateVisitor__combineCss_visitModule0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.seen = t1; + _.clone = t2; + _.css = t3; + _.imports = t4; + _.sorted = t5; + }, + _EvaluateVisitor__extendModules_closure1: function _EvaluateVisitor__extendModules_closure1(t0) { + this.originalSelectors = t0; + }, + _EvaluateVisitor__extendModules_closure2: function _EvaluateVisitor__extendModules_closure2() { + }, + _EvaluateVisitor_visitAtRootRule_closure1: function _EvaluateVisitor_visitAtRootRule_closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitAtRootRule_closure2: function _EvaluateVisitor_visitAtRootRule_closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure5: function _EvaluateVisitor__scopeForAtRoot_closure5(t0, t1, t2) { + this.$this = t0; + this.newParent = t1; + this.node = t2; + }, + _EvaluateVisitor__scopeForAtRoot_closure6: function _EvaluateVisitor__scopeForAtRoot_closure6(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure7: function _EvaluateVisitor__scopeForAtRoot_closure7(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor__scopeForAtRoot__closure0: function _EvaluateVisitor__scopeForAtRoot__closure0(t0, t1) { + this.innerScope = t0; + this.callback = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure8: function _EvaluateVisitor__scopeForAtRoot_closure8(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure9: function _EvaluateVisitor__scopeForAtRoot_closure9() { + }, + _EvaluateVisitor__scopeForAtRoot_closure10: function _EvaluateVisitor__scopeForAtRoot_closure10(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor_visitContentRule_closure0: function _EvaluateVisitor_visitContentRule_closure0(t0, t1) { + this.$this = t0; + this.content = t1; + }, + _EvaluateVisitor_visitDeclaration_closure0: function _EvaluateVisitor_visitDeclaration_closure0(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + _EvaluateVisitor_visitEachRule_closure2: function _EvaluateVisitor_visitEachRule_closure2(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.nodeWithSpan = t2; + }, + _EvaluateVisitor_visitEachRule_closure3: function _EvaluateVisitor_visitEachRule_closure3(t0, t1, t2) { + this._box_1 = t0; + this.$this = t1; + this.nodeWithSpan = t2; + }, + _EvaluateVisitor_visitEachRule_closure4: function _EvaluateVisitor_visitEachRule_closure4(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.list = t1; + _.setVariables = t2; + _.node = t3; + }, + _EvaluateVisitor_visitEachRule__closure0: function _EvaluateVisitor_visitEachRule__closure0(t0, t1, t2) { + this.$this = t0; + this.setVariables = t1; + this.node = t2; + }, + _EvaluateVisitor_visitEachRule___closure0: function _EvaluateVisitor_visitEachRule___closure0(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitAtRule_closure2: function _EvaluateVisitor_visitAtRule_closure2(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitAtRule_closure3: function _EvaluateVisitor_visitAtRule_closure3(t0, t1, t2) { + this.$this = t0; + this.name = t1; + this.children = t2; + }, + _EvaluateVisitor_visitAtRule__closure0: function _EvaluateVisitor_visitAtRule__closure0(t0, t1) { + this.$this = t0; + this.children = t1; + }, + _EvaluateVisitor_visitAtRule_closure4: function _EvaluateVisitor_visitAtRule_closure4() { + }, + _EvaluateVisitor_visitForRule_closure4: function _EvaluateVisitor_visitForRule_closure4(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitForRule_closure5: function _EvaluateVisitor_visitForRule_closure5(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitForRule_closure6: function _EvaluateVisitor_visitForRule_closure6(t0) { + this.fromNumber = t0; + }, + _EvaluateVisitor_visitForRule_closure7: function _EvaluateVisitor_visitForRule_closure7(t0, t1) { + this.toNumber = t0; + this.fromNumber = t1; + }, + _EvaluateVisitor_visitForRule_closure8: function _EvaluateVisitor_visitForRule_closure8(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.node = t2; + _.from = t3; + _.direction = t4; + _.fromNumber = t5; + }, + _EvaluateVisitor_visitForRule__closure0: function _EvaluateVisitor_visitForRule__closure0(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitForwardRule_closure1: function _EvaluateVisitor_visitForwardRule_closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitForwardRule_closure2: function _EvaluateVisitor_visitForwardRule_closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__registerCommentsForModule_closure0: function _EvaluateVisitor__registerCommentsForModule_closure0() { + }, + _EvaluateVisitor_visitIfRule_closure0: function _EvaluateVisitor_visitIfRule_closure0(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitIfRule__closure0: function _EvaluateVisitor_visitIfRule__closure0(t0, t1) { + this.$this = t0; + this.clause = t1; + }, + _EvaluateVisitor_visitIfRule___closure0: function _EvaluateVisitor_visitIfRule___closure0(t0) { + this.$this = t0; + }, + _EvaluateVisitor__visitDynamicImport_closure0: function _EvaluateVisitor__visitDynamicImport_closure0(t0, t1) { + this.$this = t0; + this.$import = t1; + }, + _EvaluateVisitor__visitDynamicImport__closure3: function _EvaluateVisitor__visitDynamicImport__closure3(t0) { + this.$this = t0; + }, + _EvaluateVisitor__visitDynamicImport__closure4: function _EvaluateVisitor__visitDynamicImport__closure4() { + }, + _EvaluateVisitor__visitDynamicImport__closure5: function _EvaluateVisitor__visitDynamicImport__closure5() { + }, + _EvaluateVisitor__visitDynamicImport__closure6: function _EvaluateVisitor__visitDynamicImport__closure6(t0, t1, t2, t3, t4) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.loadsUserDefinedModules = t2; + _.environment = t3; + _.children = t4; + }, + _EvaluateVisitor__applyMixin_closure1: function _EvaluateVisitor__applyMixin_closure1(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.$arguments = t1; + _.mixin = t2; + _.nodeWithSpanWithoutContent = t3; + }, + _EvaluateVisitor__applyMixin__closure2: function _EvaluateVisitor__applyMixin__closure2(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.$arguments = t1; + _.mixin = t2; + _.nodeWithSpanWithoutContent = t3; + }, + _EvaluateVisitor__applyMixin_closure2: function _EvaluateVisitor__applyMixin_closure2(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.contentCallable = t1; + _.mixin = t2; + _.nodeWithSpanWithoutContent = t3; + }, + _EvaluateVisitor__applyMixin__closure1: function _EvaluateVisitor__applyMixin__closure1(t0, t1, t2) { + this.$this = t0; + this.mixin = t1; + this.nodeWithSpanWithoutContent = t2; + }, + _EvaluateVisitor__applyMixin___closure0: function _EvaluateVisitor__applyMixin___closure0(t0, t1, t2) { + this.$this = t0; + this.mixin = t1; + this.nodeWithSpanWithoutContent = t2; + }, + _EvaluateVisitor__applyMixin____closure0: function _EvaluateVisitor__applyMixin____closure0(t0, t1) { + this.$this = t0; + this.statement = t1; + }, + _EvaluateVisitor_visitIncludeRule_closure2: function _EvaluateVisitor_visitIncludeRule_closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitIncludeRule_closure3: function _EvaluateVisitor_visitIncludeRule_closure3(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitIncludeRule_closure4: function _EvaluateVisitor_visitIncludeRule_closure4(t0) { + this.node = t0; + }, + _EvaluateVisitor_visitMediaRule_closure2: function _EvaluateVisitor_visitMediaRule_closure2(t0, t1) { + this.$this = t0; + this.queries = t1; + }, + _EvaluateVisitor_visitMediaRule_closure3: function _EvaluateVisitor_visitMediaRule_closure3(t0, t1, t2, t3, t4) { + var _ = this; + _.$this = t0; + _.mergedQueries = t1; + _.queries = t2; + _.mergedSources = t3; + _.node = t4; + }, + _EvaluateVisitor_visitMediaRule__closure0: function _EvaluateVisitor_visitMediaRule__closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitMediaRule___closure0: function _EvaluateVisitor_visitMediaRule___closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitMediaRule_closure4: function _EvaluateVisitor_visitMediaRule_closure4(t0) { + this.mergedSources = t0; + }, + _EvaluateVisitor_visitStyleRule_closure3: function _EvaluateVisitor_visitStyleRule_closure3(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitStyleRule_closure4: function _EvaluateVisitor_visitStyleRule_closure4() { + }, + _EvaluateVisitor_visitStyleRule_closure6: function _EvaluateVisitor_visitStyleRule_closure6(t0, t1, t2) { + this.$this = t0; + this.rule = t1; + this.node = t2; + }, + _EvaluateVisitor_visitStyleRule__closure0: function _EvaluateVisitor_visitStyleRule__closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitStyleRule_closure5: function _EvaluateVisitor_visitStyleRule_closure5() { + }, + _EvaluateVisitor__warnForBogusCombinators_closure0: function _EvaluateVisitor__warnForBogusCombinators_closure0() { + }, + _EvaluateVisitor_visitSupportsRule_closure1: function _EvaluateVisitor_visitSupportsRule_closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitSupportsRule__closure0: function _EvaluateVisitor_visitSupportsRule__closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitSupportsRule_closure2: function _EvaluateVisitor_visitSupportsRule_closure2() { + }, + _EvaluateVisitor__visitSupportsCondition_closure0: function _EvaluateVisitor__visitSupportsCondition_closure0(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + _EvaluateVisitor_visitVariableDeclaration_closure2: function _EvaluateVisitor_visitVariableDeclaration_closure2(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.node = t2; + }, + _EvaluateVisitor_visitVariableDeclaration_closure3: function _EvaluateVisitor_visitVariableDeclaration_closure3(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitVariableDeclaration_closure4: function _EvaluateVisitor_visitVariableDeclaration_closure4(t0, t1, t2) { + this.$this = t0; + this.node = t1; + this.value = t2; + }, + _EvaluateVisitor_visitUseRule_closure0: function _EvaluateVisitor_visitUseRule_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitWarnRule_closure0: function _EvaluateVisitor_visitWarnRule_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitWhileRule_closure0: function _EvaluateVisitor_visitWhileRule_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitWhileRule__closure0: function _EvaluateVisitor_visitWhileRule__closure0(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitBinaryOperationExpression_closure0: function _EvaluateVisitor_visitBinaryOperationExpression_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__slash_recommendation0: function _EvaluateVisitor__slash_recommendation0() { + }, + _EvaluateVisitor_visitVariableExpression_closure0: function _EvaluateVisitor_visitVariableExpression_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitUnaryOperationExpression_closure0: function _EvaluateVisitor_visitUnaryOperationExpression_closure0(t0, t1) { + this.node = t0; + this.operand = t1; + }, + _EvaluateVisitor_visitListExpression_closure0: function _EvaluateVisitor_visitListExpression_closure0(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitFunctionExpression_closure2: function _EvaluateVisitor_visitFunctionExpression_closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitFunctionExpression_closure3: function _EvaluateVisitor_visitFunctionExpression_closure3() { + }, + _EvaluateVisitor_visitFunctionExpression_closure4: function _EvaluateVisitor_visitFunctionExpression_closure4(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.node = t2; + }, + _EvaluateVisitor__visitCalculation_closure0: function _EvaluateVisitor__visitCalculation_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__checkCalculationArguments_check0: function _EvaluateVisitor__checkCalculationArguments_check0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__visitCalculationExpression_closure0: function _EvaluateVisitor__visitCalculationExpression_closure0(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.node = t2; + _.inLegacySassFunction = t3; + }, + _EvaluateVisitor__visitCalculationExpression__closure0: function _EvaluateVisitor__visitCalculationExpression__closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitInterpolatedFunctionExpression_closure0: function _EvaluateVisitor_visitInterpolatedFunctionExpression_closure0(t0, t1, t2) { + this.$this = t0; + this.node = t1; + this.$function = t2; + }, + _EvaluateVisitor__runUserDefinedCallable_closure0: function _EvaluateVisitor__runUserDefinedCallable_closure0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.callable = t1; + _.evaluated = t2; + _.nodeWithSpan = t3; + _.run = t4; + _.V = t5; + }, + _EvaluateVisitor__runUserDefinedCallable__closure0: function _EvaluateVisitor__runUserDefinedCallable__closure0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.evaluated = t1; + _.callable = t2; + _.nodeWithSpan = t3; + _.run = t4; + _.V = t5; + }, + _EvaluateVisitor__runUserDefinedCallable___closure0: function _EvaluateVisitor__runUserDefinedCallable___closure0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.evaluated = t1; + _.callable = t2; + _.nodeWithSpan = t3; + _.run = t4; + _.V = t5; + }, + _EvaluateVisitor__runUserDefinedCallable____closure0: function _EvaluateVisitor__runUserDefinedCallable____closure0() { + }, + _EvaluateVisitor__runFunctionCallable_closure0: function _EvaluateVisitor__runFunctionCallable_closure0(t0, t1) { + this.$this = t0; + this.callable = t1; + }, + _EvaluateVisitor__runBuiltInCallable_closure2: function _EvaluateVisitor__runBuiltInCallable_closure2(t0, t1, t2) { + this._box_0 = t0; + this.evaluated = t1; + this.namedSet = t2; + }, + _EvaluateVisitor__runBuiltInCallable_closure3: function _EvaluateVisitor__runBuiltInCallable_closure3(t0, t1) { + this._box_0 = t0; + this.evaluated = t1; + }, + _EvaluateVisitor__runBuiltInCallable_closure4: function _EvaluateVisitor__runBuiltInCallable_closure4() { + }, + _EvaluateVisitor__evaluateArguments_closure3: function _EvaluateVisitor__evaluateArguments_closure3() { + }, + _EvaluateVisitor__evaluateArguments_closure4: function _EvaluateVisitor__evaluateArguments_closure4(t0, t1) { + this.$this = t0; + this.restNodeForSpan = t1; + }, + _EvaluateVisitor__evaluateArguments_closure5: function _EvaluateVisitor__evaluateArguments_closure5(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.named = t1; + _.restNodeForSpan = t2; + _.namedNodes = t3; + }, + _EvaluateVisitor__evaluateArguments_closure6: function _EvaluateVisitor__evaluateArguments_closure6() { + }, + _EvaluateVisitor__evaluateMacroArguments_closure3: function _EvaluateVisitor__evaluateMacroArguments_closure3(t0) { + this.restArgs = t0; + }, + _EvaluateVisitor__evaluateMacroArguments_closure4: function _EvaluateVisitor__evaluateMacroArguments_closure4(t0, t1, t2) { + this.$this = t0; + this.restNodeForSpan = t1; + this.restArgs = t2; + }, + _EvaluateVisitor__evaluateMacroArguments_closure5: function _EvaluateVisitor__evaluateMacroArguments_closure5(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.named = t1; + _.restNodeForSpan = t2; + _.restArgs = t3; + }, + _EvaluateVisitor__evaluateMacroArguments_closure6: function _EvaluateVisitor__evaluateMacroArguments_closure6(t0, t1, t2) { + this.$this = t0; + this.keywordRestNodeForSpan = t1; + this.keywordRestArgs = t2; + }, + _EvaluateVisitor__addRestMap_closure0: function _EvaluateVisitor__addRestMap_closure0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.values = t1; + _.convert = t2; + _.expressionNode = t3; + _.map = t4; + _.nodeWithSpan = t5; + }, + _EvaluateVisitor__verifyArguments_closure0: function _EvaluateVisitor__verifyArguments_closure0(t0, t1, t2) { + this.parameters = t0; + this.positional = t1; + this.named = t2; + }, + _EvaluateVisitor_visitCssAtRule_closure1: function _EvaluateVisitor_visitCssAtRule_closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssAtRule_closure2: function _EvaluateVisitor_visitCssAtRule_closure2() { + }, + _EvaluateVisitor_visitCssKeyframeBlock_closure1: function _EvaluateVisitor_visitCssKeyframeBlock_closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssKeyframeBlock_closure2: function _EvaluateVisitor_visitCssKeyframeBlock_closure2() { + }, + _EvaluateVisitor_visitCssMediaRule_closure2: function _EvaluateVisitor_visitCssMediaRule_closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssMediaRule_closure3: function _EvaluateVisitor_visitCssMediaRule_closure3(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.mergedQueries = t1; + _.node = t2; + _.mergedSources = t3; + }, + _EvaluateVisitor_visitCssMediaRule__closure0: function _EvaluateVisitor_visitCssMediaRule__closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssMediaRule___closure0: function _EvaluateVisitor_visitCssMediaRule___closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssMediaRule_closure4: function _EvaluateVisitor_visitCssMediaRule_closure4(t0) { + this.mergedSources = t0; + }, + _EvaluateVisitor_visitCssStyleRule_closure2: function _EvaluateVisitor_visitCssStyleRule_closure2(t0, t1, t2) { + this.$this = t0; + this.rule = t1; + this.node = t2; + }, + _EvaluateVisitor_visitCssStyleRule__closure0: function _EvaluateVisitor_visitCssStyleRule__closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssStyleRule_closure1: function _EvaluateVisitor_visitCssStyleRule_closure1() { + }, + _EvaluateVisitor_visitCssSupportsRule_closure1: function _EvaluateVisitor_visitCssSupportsRule_closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssSupportsRule__closure0: function _EvaluateVisitor_visitCssSupportsRule__closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssSupportsRule_closure2: function _EvaluateVisitor_visitCssSupportsRule_closure2() { + }, + _EvaluateVisitor__performInterpolationHelper_closure0: function _EvaluateVisitor__performInterpolationHelper_closure0(t0) { + this.interpolation = t0; + }, + _EvaluateVisitor__serialize_closure0: function _EvaluateVisitor__serialize_closure0(t0, t1) { + this.value = t0; + this.quote = t1; + }, + _EvaluateVisitor__expressionNode_closure0: function _EvaluateVisitor__expressionNode_closure0(t0, t1) { + this.$this = t0; + this.expression = t1; + }, + _EvaluateVisitor__withoutSlash_recommendation0: function _EvaluateVisitor__withoutSlash_recommendation0() { + }, + _EvaluateVisitor__stackFrame_closure0: function _EvaluateVisitor__stackFrame_closure0(t0) { + this.$this = t0; + }, + _ImportedCssVisitor0: function _ImportedCssVisitor0(t0) { + this._async_evaluate$_visitor = t0; + }, + _ImportedCssVisitor_visitCssAtRule_closure0: function _ImportedCssVisitor_visitCssAtRule_closure0() { + }, + _ImportedCssVisitor_visitCssMediaRule_closure0: function _ImportedCssVisitor_visitCssMediaRule_closure0(t0) { + this.hasBeenMerged = t0; + }, + _ImportedCssVisitor_visitCssStyleRule_closure0: function _ImportedCssVisitor_visitCssStyleRule_closure0() { + }, + _ImportedCssVisitor_visitCssSupportsRule_closure0: function _ImportedCssVisitor_visitCssSupportsRule_closure0() { + }, + _EvaluationContext0: function _EvaluationContext0(t0, t1) { + this._async_evaluate$_visitor = t0; + this._async_evaluate$_defaultWarnNodeWithSpan = t1; + }, + cloneCssStylesheet(stylesheet, extensionStore) { + var _0_0 = extensionStore.clone$0(); + return new A._Record_2(new A._CloneCssVisitor(_0_0._1)._visitChildren$2(A.ModifiableCssStylesheet$(stylesheet.get$span(stylesheet)), stylesheet), _0_0._0); + }, + _CloneCssVisitor: function _CloneCssVisitor(t0) { + this._oldToNewSelectors = t0; + }, + _EvaluateVisitor$(functions, importCache, logger, nodeImporter, quietDeps, sourceMap) { + var t1 = type$.Uri, + t2 = type$.Module_Callable, + t3 = A._setArrayType([], type$.JSArray_Record_2_String_and_AstNode); + t1 = new A._EvaluateVisitor(importCache, nodeImporter, A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.Callable), A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Configuration), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.AstNode), logger, A.LinkedHashSet_LinkedHashSet$_empty(type$.Record_2_String_and_SourceSpan), quietDeps, sourceMap, A.Environment$(), A.LinkedHashSet_LinkedHashSet$_empty(t1), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.nullable_AstNode), t3, B.Configuration_Map_empty_null); + t1._EvaluateVisitor$6$functions$importCache$logger$nodeImporter$quietDeps$sourceMap(functions, importCache, logger, nodeImporter, quietDeps, sourceMap); + return t1; + }, + Evaluator: function Evaluator(t0, t1) { + this._visitor = t0; + this._importer = t1; + }, + _EvaluateVisitor: function _EvaluateVisitor(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15) { + var _ = this; + _._evaluate$_importCache = t0; + _._evaluate$_nodeImporter = t1; + _._builtInFunctions = t2; + _._builtInModules = t3; + _._modules = t4; + _._moduleConfigurations = t5; + _._moduleNodes = t6; + _._logger = t7; + _._warningsEmitted = t8; + _._quietDeps = t9; + _._sourceMap = t10; + _._environment = t11; + _._declarationName = _.__parent = _._mediaQuerySources = _._mediaQueries = _._styleRuleIgnoringAtRoot = null; + _._member = "root stylesheet"; + _._importSpan = _._callableNode = _._currentCallable = null; + _._inSupportsDeclaration = _._inKeyframes = _._atRootExcludingStyleRule = _._inUnknownAtRule = _._inFunction = false; + _._loadedUrls = t12; + _._activeModules = t13; + _._stack = t14; + _._importer = null; + _._inDependency = false; + _.__extensionStore = _._preModuleComments = _._outOfOrderImports = _.__endOfImports = _.__root = _.__stylesheet = null; + _._configuration = t15; + }, + _EvaluateVisitor_closure: function _EvaluateVisitor_closure(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure0: function _EvaluateVisitor_closure0(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure1: function _EvaluateVisitor_closure1(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure2: function _EvaluateVisitor_closure2(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure3: function _EvaluateVisitor_closure3(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure4: function _EvaluateVisitor_closure4(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure5: function _EvaluateVisitor_closure5(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure6: function _EvaluateVisitor_closure6(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure7: function _EvaluateVisitor_closure7(t0) { + this.$this = t0; + }, + _EvaluateVisitor__closure2: function _EvaluateVisitor__closure2(t0, t1, t2) { + this.$this = t0; + this.name = t1; + this.module = t2; + }, + _EvaluateVisitor_closure8: function _EvaluateVisitor_closure8(t0) { + this.$this = t0; + }, + _EvaluateVisitor__closure1: function _EvaluateVisitor__closure1(t0, t1, t2) { + this.$this = t0; + this.name = t1; + this.module = t2; + }, + _EvaluateVisitor_closure9: function _EvaluateVisitor_closure9(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure10: function _EvaluateVisitor_closure10(t0) { + this.$this = t0; + }, + _EvaluateVisitor__closure: function _EvaluateVisitor__closure(t0, t1, t2) { + this.values = t0; + this.span = t1; + this.callableNode = t2; + }, + _EvaluateVisitor__closure0: function _EvaluateVisitor__closure0(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure11: function _EvaluateVisitor_closure11(t0) { + this.$this = t0; + }, + _EvaluateVisitor_run_closure: function _EvaluateVisitor_run_closure(t0, t1, t2) { + this.$this = t0; + this.node = t1; + this.importer = t2; + }, + _EvaluateVisitor_run__closure: function _EvaluateVisitor_run__closure(t0, t1, t2) { + this.$this = t0; + this.importer = t1; + this.node = t2; + }, + _EvaluateVisitor_runExpression_closure: function _EvaluateVisitor_runExpression_closure(t0, t1, t2) { + this.$this = t0; + this.importer = t1; + this.expression = t2; + }, + _EvaluateVisitor_runExpression__closure: function _EvaluateVisitor_runExpression__closure(t0, t1) { + this.$this = t0; + this.expression = t1; + }, + _EvaluateVisitor_runExpression___closure: function _EvaluateVisitor_runExpression___closure(t0, t1) { + this.$this = t0; + this.expression = t1; + }, + _EvaluateVisitor_runStatement_closure: function _EvaluateVisitor_runStatement_closure(t0, t1, t2) { + this.$this = t0; + this.importer = t1; + this.statement = t2; + }, + _EvaluateVisitor_runStatement__closure: function _EvaluateVisitor_runStatement__closure(t0, t1) { + this.$this = t0; + this.statement = t1; + }, + _EvaluateVisitor_runStatement___closure: function _EvaluateVisitor_runStatement___closure(t0, t1) { + this.$this = t0; + this.statement = t1; + }, + _EvaluateVisitor__loadModule_closure: function _EvaluateVisitor__loadModule_closure(t0, t1) { + this._box_0 = t0; + this.callback = t1; + }, + _EvaluateVisitor__loadModule_closure0: function _EvaluateVisitor__loadModule_closure0(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.$this = t0; + _.url = t1; + _.nodeWithSpan = t2; + _.baseUrl = t3; + _.namesInErrors = t4; + _.configuration = t5; + _.callback = t6; + }, + _EvaluateVisitor__loadModule__closure: function _EvaluateVisitor__loadModule__closure(t0, t1) { + this.$this = t0; + this.message = t1; + }, + _EvaluateVisitor__loadModule__closure0: function _EvaluateVisitor__loadModule__closure0(t0, t1, t2) { + this._box_1 = t0; + this.callback = t1; + this.firstLoad = t2; + }, + _EvaluateVisitor__execute_closure: function _EvaluateVisitor__execute_closure(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.$this = t0; + _.importer = t1; + _.stylesheet = t2; + _.extensionStore = t3; + _.configuration = t4; + _.css = t5; + _.preModuleComments = t6; + }, + _EvaluateVisitor__combineCss_closure: function _EvaluateVisitor__combineCss_closure() { + }, + _EvaluateVisitor__combineCss_closure0: function _EvaluateVisitor__combineCss_closure0(t0) { + this.selectors = t0; + }, + _EvaluateVisitor__combineCss_visitModule: function _EvaluateVisitor__combineCss_visitModule(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.seen = t1; + _.clone = t2; + _.css = t3; + _.imports = t4; + _.sorted = t5; + }, + _EvaluateVisitor__extendModules_closure: function _EvaluateVisitor__extendModules_closure(t0) { + this.originalSelectors = t0; + }, + _EvaluateVisitor__extendModules_closure0: function _EvaluateVisitor__extendModules_closure0() { + }, + _EvaluateVisitor_visitAtRootRule_closure: function _EvaluateVisitor_visitAtRootRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitAtRootRule_closure0: function _EvaluateVisitor_visitAtRootRule_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure: function _EvaluateVisitor__scopeForAtRoot_closure(t0, t1, t2) { + this.$this = t0; + this.newParent = t1; + this.node = t2; + }, + _EvaluateVisitor__scopeForAtRoot_closure0: function _EvaluateVisitor__scopeForAtRoot_closure0(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure1: function _EvaluateVisitor__scopeForAtRoot_closure1(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor__scopeForAtRoot__closure: function _EvaluateVisitor__scopeForAtRoot__closure(t0, t1) { + this.innerScope = t0; + this.callback = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure2: function _EvaluateVisitor__scopeForAtRoot_closure2(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure3: function _EvaluateVisitor__scopeForAtRoot_closure3() { + }, + _EvaluateVisitor__scopeForAtRoot_closure4: function _EvaluateVisitor__scopeForAtRoot_closure4(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor_visitContentRule_closure: function _EvaluateVisitor_visitContentRule_closure(t0, t1) { + this.$this = t0; + this.content = t1; + }, + _EvaluateVisitor_visitDeclaration_closure: function _EvaluateVisitor_visitDeclaration_closure(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + _EvaluateVisitor_visitEachRule_closure: function _EvaluateVisitor_visitEachRule_closure(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.nodeWithSpan = t2; + }, + _EvaluateVisitor_visitEachRule_closure0: function _EvaluateVisitor_visitEachRule_closure0(t0, t1, t2) { + this._box_1 = t0; + this.$this = t1; + this.nodeWithSpan = t2; + }, + _EvaluateVisitor_visitEachRule_closure1: function _EvaluateVisitor_visitEachRule_closure1(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.list = t1; + _.setVariables = t2; + _.node = t3; + }, + _EvaluateVisitor_visitEachRule__closure: function _EvaluateVisitor_visitEachRule__closure(t0, t1, t2) { + this.$this = t0; + this.setVariables = t1; + this.node = t2; + }, + _EvaluateVisitor_visitEachRule___closure: function _EvaluateVisitor_visitEachRule___closure(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitAtRule_closure: function _EvaluateVisitor_visitAtRule_closure(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitAtRule_closure0: function _EvaluateVisitor_visitAtRule_closure0(t0, t1, t2) { + this.$this = t0; + this.name = t1; + this.children = t2; + }, + _EvaluateVisitor_visitAtRule__closure: function _EvaluateVisitor_visitAtRule__closure(t0, t1) { + this.$this = t0; + this.children = t1; + }, + _EvaluateVisitor_visitAtRule_closure1: function _EvaluateVisitor_visitAtRule_closure1() { + }, + _EvaluateVisitor_visitForRule_closure: function _EvaluateVisitor_visitForRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitForRule_closure0: function _EvaluateVisitor_visitForRule_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitForRule_closure1: function _EvaluateVisitor_visitForRule_closure1(t0) { + this.fromNumber = t0; + }, + _EvaluateVisitor_visitForRule_closure2: function _EvaluateVisitor_visitForRule_closure2(t0, t1) { + this.toNumber = t0; + this.fromNumber = t1; + }, + _EvaluateVisitor_visitForRule_closure3: function _EvaluateVisitor_visitForRule_closure3(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.node = t2; + _.from = t3; + _.direction = t4; + _.fromNumber = t5; + }, + _EvaluateVisitor_visitForRule__closure: function _EvaluateVisitor_visitForRule__closure(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitForwardRule_closure: function _EvaluateVisitor_visitForwardRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitForwardRule_closure0: function _EvaluateVisitor_visitForwardRule_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__registerCommentsForModule_closure: function _EvaluateVisitor__registerCommentsForModule_closure() { + }, + _EvaluateVisitor_visitIfRule_closure: function _EvaluateVisitor_visitIfRule_closure(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitIfRule__closure: function _EvaluateVisitor_visitIfRule__closure(t0, t1) { + this.$this = t0; + this.clause = t1; + }, + _EvaluateVisitor_visitIfRule___closure: function _EvaluateVisitor_visitIfRule___closure(t0) { + this.$this = t0; + }, + _EvaluateVisitor__visitDynamicImport_closure: function _EvaluateVisitor__visitDynamicImport_closure(t0, t1) { + this.$this = t0; + this.$import = t1; + }, + _EvaluateVisitor__visitDynamicImport__closure: function _EvaluateVisitor__visitDynamicImport__closure(t0) { + this.$this = t0; + }, + _EvaluateVisitor__visitDynamicImport__closure0: function _EvaluateVisitor__visitDynamicImport__closure0() { + }, + _EvaluateVisitor__visitDynamicImport__closure1: function _EvaluateVisitor__visitDynamicImport__closure1() { + }, + _EvaluateVisitor__visitDynamicImport__closure2: function _EvaluateVisitor__visitDynamicImport__closure2(t0, t1, t2, t3, t4) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.loadsUserDefinedModules = t2; + _.environment = t3; + _.children = t4; + }, + _EvaluateVisitor__applyMixin_closure: function _EvaluateVisitor__applyMixin_closure(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.$arguments = t1; + _.mixin = t2; + _.nodeWithSpanWithoutContent = t3; + }, + _EvaluateVisitor__applyMixin__closure0: function _EvaluateVisitor__applyMixin__closure0(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.$arguments = t1; + _.mixin = t2; + _.nodeWithSpanWithoutContent = t3; + }, + _EvaluateVisitor__applyMixin_closure0: function _EvaluateVisitor__applyMixin_closure0(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.contentCallable = t1; + _.mixin = t2; + _.nodeWithSpanWithoutContent = t3; + }, + _EvaluateVisitor__applyMixin__closure: function _EvaluateVisitor__applyMixin__closure(t0, t1, t2) { + this.$this = t0; + this.mixin = t1; + this.nodeWithSpanWithoutContent = t2; + }, + _EvaluateVisitor__applyMixin___closure: function _EvaluateVisitor__applyMixin___closure(t0, t1, t2) { + this.$this = t0; + this.mixin = t1; + this.nodeWithSpanWithoutContent = t2; + }, + _EvaluateVisitor__applyMixin____closure: function _EvaluateVisitor__applyMixin____closure(t0, t1) { + this.$this = t0; + this.statement = t1; + }, + _EvaluateVisitor_visitIncludeRule_closure: function _EvaluateVisitor_visitIncludeRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitIncludeRule_closure0: function _EvaluateVisitor_visitIncludeRule_closure0(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitIncludeRule_closure1: function _EvaluateVisitor_visitIncludeRule_closure1(t0) { + this.node = t0; + }, + _EvaluateVisitor_visitMediaRule_closure: function _EvaluateVisitor_visitMediaRule_closure(t0, t1) { + this.$this = t0; + this.queries = t1; + }, + _EvaluateVisitor_visitMediaRule_closure0: function _EvaluateVisitor_visitMediaRule_closure0(t0, t1, t2, t3, t4) { + var _ = this; + _.$this = t0; + _.mergedQueries = t1; + _.queries = t2; + _.mergedSources = t3; + _.node = t4; + }, + _EvaluateVisitor_visitMediaRule__closure: function _EvaluateVisitor_visitMediaRule__closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitMediaRule___closure: function _EvaluateVisitor_visitMediaRule___closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitMediaRule_closure1: function _EvaluateVisitor_visitMediaRule_closure1(t0) { + this.mergedSources = t0; + }, + _EvaluateVisitor_visitStyleRule_closure: function _EvaluateVisitor_visitStyleRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitStyleRule_closure0: function _EvaluateVisitor_visitStyleRule_closure0() { + }, + _EvaluateVisitor_visitStyleRule_closure2: function _EvaluateVisitor_visitStyleRule_closure2(t0, t1, t2) { + this.$this = t0; + this.rule = t1; + this.node = t2; + }, + _EvaluateVisitor_visitStyleRule__closure: function _EvaluateVisitor_visitStyleRule__closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitStyleRule_closure1: function _EvaluateVisitor_visitStyleRule_closure1() { + }, + _EvaluateVisitor__warnForBogusCombinators_closure: function _EvaluateVisitor__warnForBogusCombinators_closure() { + }, + _EvaluateVisitor_visitSupportsRule_closure: function _EvaluateVisitor_visitSupportsRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitSupportsRule__closure: function _EvaluateVisitor_visitSupportsRule__closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitSupportsRule_closure0: function _EvaluateVisitor_visitSupportsRule_closure0() { + }, + _EvaluateVisitor__visitSupportsCondition_closure: function _EvaluateVisitor__visitSupportsCondition_closure(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + _EvaluateVisitor_visitVariableDeclaration_closure: function _EvaluateVisitor_visitVariableDeclaration_closure(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.node = t2; + }, + _EvaluateVisitor_visitVariableDeclaration_closure0: function _EvaluateVisitor_visitVariableDeclaration_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitVariableDeclaration_closure1: function _EvaluateVisitor_visitVariableDeclaration_closure1(t0, t1, t2) { + this.$this = t0; + this.node = t1; + this.value = t2; + }, + _EvaluateVisitor_visitUseRule_closure: function _EvaluateVisitor_visitUseRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitWarnRule_closure: function _EvaluateVisitor_visitWarnRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitWhileRule_closure: function _EvaluateVisitor_visitWhileRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitWhileRule__closure: function _EvaluateVisitor_visitWhileRule__closure(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitBinaryOperationExpression_closure: function _EvaluateVisitor_visitBinaryOperationExpression_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__slash_recommendation: function _EvaluateVisitor__slash_recommendation() { + }, + _EvaluateVisitor_visitVariableExpression_closure: function _EvaluateVisitor_visitVariableExpression_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitUnaryOperationExpression_closure: function _EvaluateVisitor_visitUnaryOperationExpression_closure(t0, t1) { + this.node = t0; + this.operand = t1; + }, + _EvaluateVisitor_visitListExpression_closure: function _EvaluateVisitor_visitListExpression_closure(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitFunctionExpression_closure: function _EvaluateVisitor_visitFunctionExpression_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitFunctionExpression_closure0: function _EvaluateVisitor_visitFunctionExpression_closure0() { + }, + _EvaluateVisitor_visitFunctionExpression_closure1: function _EvaluateVisitor_visitFunctionExpression_closure1(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.node = t2; + }, + _EvaluateVisitor__visitCalculation_closure: function _EvaluateVisitor__visitCalculation_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__checkCalculationArguments_check: function _EvaluateVisitor__checkCalculationArguments_check(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__visitCalculationExpression_closure: function _EvaluateVisitor__visitCalculationExpression_closure(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.node = t2; + _.inLegacySassFunction = t3; + }, + _EvaluateVisitor__visitCalculationExpression__closure: function _EvaluateVisitor__visitCalculationExpression__closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitInterpolatedFunctionExpression_closure: function _EvaluateVisitor_visitInterpolatedFunctionExpression_closure(t0, t1, t2) { + this.$this = t0; + this.node = t1; + this.$function = t2; + }, + _EvaluateVisitor__runUserDefinedCallable_closure: function _EvaluateVisitor__runUserDefinedCallable_closure(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.callable = t1; + _.evaluated = t2; + _.nodeWithSpan = t3; + _.run = t4; + _.V = t5; + }, + _EvaluateVisitor__runUserDefinedCallable__closure: function _EvaluateVisitor__runUserDefinedCallable__closure(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.evaluated = t1; + _.callable = t2; + _.nodeWithSpan = t3; + _.run = t4; + _.V = t5; + }, + _EvaluateVisitor__runUserDefinedCallable___closure: function _EvaluateVisitor__runUserDefinedCallable___closure(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.evaluated = t1; + _.callable = t2; + _.nodeWithSpan = t3; + _.run = t4; + _.V = t5; + }, + _EvaluateVisitor__runUserDefinedCallable____closure: function _EvaluateVisitor__runUserDefinedCallable____closure() { + }, + _EvaluateVisitor__runFunctionCallable_closure: function _EvaluateVisitor__runFunctionCallable_closure(t0, t1) { + this.$this = t0; + this.callable = t1; + }, + _EvaluateVisitor__runBuiltInCallable_closure: function _EvaluateVisitor__runBuiltInCallable_closure(t0, t1, t2) { + this._box_0 = t0; + this.evaluated = t1; + this.namedSet = t2; + }, + _EvaluateVisitor__runBuiltInCallable_closure0: function _EvaluateVisitor__runBuiltInCallable_closure0(t0, t1) { + this._box_0 = t0; + this.evaluated = t1; + }, + _EvaluateVisitor__runBuiltInCallable_closure1: function _EvaluateVisitor__runBuiltInCallable_closure1() { + }, + _EvaluateVisitor__evaluateArguments_closure: function _EvaluateVisitor__evaluateArguments_closure() { + }, + _EvaluateVisitor__evaluateArguments_closure0: function _EvaluateVisitor__evaluateArguments_closure0(t0, t1) { + this.$this = t0; + this.restNodeForSpan = t1; + }, + _EvaluateVisitor__evaluateArguments_closure1: function _EvaluateVisitor__evaluateArguments_closure1(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.named = t1; + _.restNodeForSpan = t2; + _.namedNodes = t3; + }, + _EvaluateVisitor__evaluateArguments_closure2: function _EvaluateVisitor__evaluateArguments_closure2() { + }, + _EvaluateVisitor__evaluateMacroArguments_closure: function _EvaluateVisitor__evaluateMacroArguments_closure(t0) { + this.restArgs = t0; + }, + _EvaluateVisitor__evaluateMacroArguments_closure0: function _EvaluateVisitor__evaluateMacroArguments_closure0(t0, t1, t2) { + this.$this = t0; + this.restNodeForSpan = t1; + this.restArgs = t2; + }, + _EvaluateVisitor__evaluateMacroArguments_closure1: function _EvaluateVisitor__evaluateMacroArguments_closure1(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.named = t1; + _.restNodeForSpan = t2; + _.restArgs = t3; + }, + _EvaluateVisitor__evaluateMacroArguments_closure2: function _EvaluateVisitor__evaluateMacroArguments_closure2(t0, t1, t2) { + this.$this = t0; + this.keywordRestNodeForSpan = t1; + this.keywordRestArgs = t2; + }, + _EvaluateVisitor__addRestMap_closure: function _EvaluateVisitor__addRestMap_closure(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.values = t1; + _.convert = t2; + _.expressionNode = t3; + _.map = t4; + _.nodeWithSpan = t5; + }, + _EvaluateVisitor__verifyArguments_closure: function _EvaluateVisitor__verifyArguments_closure(t0, t1, t2) { + this.parameters = t0; + this.positional = t1; + this.named = t2; + }, + _EvaluateVisitor_visitCssAtRule_closure: function _EvaluateVisitor_visitCssAtRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssAtRule_closure0: function _EvaluateVisitor_visitCssAtRule_closure0() { + }, + _EvaluateVisitor_visitCssKeyframeBlock_closure: function _EvaluateVisitor_visitCssKeyframeBlock_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssKeyframeBlock_closure0: function _EvaluateVisitor_visitCssKeyframeBlock_closure0() { + }, + _EvaluateVisitor_visitCssMediaRule_closure: function _EvaluateVisitor_visitCssMediaRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssMediaRule_closure0: function _EvaluateVisitor_visitCssMediaRule_closure0(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.mergedQueries = t1; + _.node = t2; + _.mergedSources = t3; + }, + _EvaluateVisitor_visitCssMediaRule__closure: function _EvaluateVisitor_visitCssMediaRule__closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssMediaRule___closure: function _EvaluateVisitor_visitCssMediaRule___closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssMediaRule_closure1: function _EvaluateVisitor_visitCssMediaRule_closure1(t0) { + this.mergedSources = t0; + }, + _EvaluateVisitor_visitCssStyleRule_closure0: function _EvaluateVisitor_visitCssStyleRule_closure0(t0, t1, t2) { + this.$this = t0; + this.rule = t1; + this.node = t2; + }, + _EvaluateVisitor_visitCssStyleRule__closure: function _EvaluateVisitor_visitCssStyleRule__closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssStyleRule_closure: function _EvaluateVisitor_visitCssStyleRule_closure() { + }, + _EvaluateVisitor_visitCssSupportsRule_closure: function _EvaluateVisitor_visitCssSupportsRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssSupportsRule__closure: function _EvaluateVisitor_visitCssSupportsRule__closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssSupportsRule_closure0: function _EvaluateVisitor_visitCssSupportsRule_closure0() { + }, + _EvaluateVisitor__performInterpolationHelper_closure: function _EvaluateVisitor__performInterpolationHelper_closure(t0) { + this.interpolation = t0; + }, + _EvaluateVisitor__serialize_closure: function _EvaluateVisitor__serialize_closure(t0, t1) { + this.value = t0; + this.quote = t1; + }, + _EvaluateVisitor__expressionNode_closure: function _EvaluateVisitor__expressionNode_closure(t0, t1) { + this.$this = t0; + this.expression = t1; + }, + _EvaluateVisitor__withoutSlash_recommendation: function _EvaluateVisitor__withoutSlash_recommendation() { + }, + _EvaluateVisitor__stackFrame_closure: function _EvaluateVisitor__stackFrame_closure(t0) { + this.$this = t0; + }, + _ImportedCssVisitor: function _ImportedCssVisitor(t0) { + this._visitor = t0; + }, + _ImportedCssVisitor_visitCssAtRule_closure: function _ImportedCssVisitor_visitCssAtRule_closure() { + }, + _ImportedCssVisitor_visitCssMediaRule_closure: function _ImportedCssVisitor_visitCssMediaRule_closure(t0) { + this.hasBeenMerged = t0; + }, + _ImportedCssVisitor_visitCssStyleRule_closure: function _ImportedCssVisitor_visitCssStyleRule_closure() { + }, + _ImportedCssVisitor_visitCssSupportsRule_closure: function _ImportedCssVisitor_visitCssSupportsRule_closure() { + }, + _EvaluationContext: function _EvaluationContext(t0, t1) { + this._visitor = t0; + this._defaultWarnNodeWithSpan = t1; + }, + EveryCssVisitor: function EveryCssVisitor() { + }, + EveryCssVisitor_visitCssAtRule_closure: function EveryCssVisitor_visitCssAtRule_closure(t0) { + this.$this = t0; + }, + EveryCssVisitor_visitCssKeyframeBlock_closure: function EveryCssVisitor_visitCssKeyframeBlock_closure(t0) { + this.$this = t0; + }, + EveryCssVisitor_visitCssMediaRule_closure: function EveryCssVisitor_visitCssMediaRule_closure(t0) { + this.$this = t0; + }, + EveryCssVisitor_visitCssStyleRule_closure: function EveryCssVisitor_visitCssStyleRule_closure(t0) { + this.$this = t0; + }, + EveryCssVisitor_visitCssStylesheet_closure: function EveryCssVisitor_visitCssStylesheet_closure(t0) { + this.$this = t0; + }, + EveryCssVisitor_visitCssSupportsRule_closure: function EveryCssVisitor_visitCssSupportsRule_closure(t0) { + this.$this = t0; + }, + expressionToCalc(expression) { + var t4, + t1 = A._setArrayType([B.C__MakeExpressionCalculationSafe.visitBinaryOperationExpression$1(0, expression)], type$.JSArray_Expression), + t2 = expression.get$span(0), + t3 = type$.Expression; + t1 = A.List_List$unmodifiable(t1, t3); + t3 = A.ConstantMap_ConstantMap$from(B.Map_empty5, type$.String, t3); + t4 = expression.get$span(0); + return new A.FunctionExpression(null, A.stringReplaceAllUnchecked("calc", "_", "-"), "calc", new A.ArgumentList(t1, t3, null, null, t2), t4); + }, + _MakeExpressionCalculationSafe: function _MakeExpressionCalculationSafe() { + }, + __MakeExpressionCalculationSafe_Object_ReplaceExpressionVisitor: function __MakeExpressionCalculationSafe_Object_ReplaceExpressionVisitor() { + }, + _FindDependenciesVisitor: function _FindDependenciesVisitor(t0, t1, t2, t3, t4) { + var _ = this; + _._find_dependencies$_uses = t0; + _._find_dependencies$_forwards = t1; + _._metaLoadCss = t2; + _._imports = t3; + _._metaNamespaces = t4; + }, + DependencyReport: function DependencyReport(t0, t1, t2, t3) { + var _ = this; + _.uses = t0; + _.forwards = t1; + _.metaLoadCss = t2; + _.imports = t3; + }, + __FindDependenciesVisitor_Object_RecursiveStatementVisitor: function __FindDependenciesVisitor_Object_RecursiveStatementVisitor() { + }, + IsCalculationSafeVisitor: function IsCalculationSafeVisitor() { + }, + IsCalculationSafeVisitor_visitListExpression_closure: function IsCalculationSafeVisitor_visitListExpression_closure(t0) { + this.$this = t0; + }, + RecursiveStatementVisitor: function RecursiveStatementVisitor() { + }, + ReplaceExpressionVisitor: function ReplaceExpressionVisitor() { + }, + ReplaceExpressionVisitor_visitListExpression_closure: function ReplaceExpressionVisitor_visitListExpression_closure(t0) { + this.$this = t0; + }, + ReplaceExpressionVisitor_visitArgumentList_closure: function ReplaceExpressionVisitor_visitArgumentList_closure(t0) { + this.$this = t0; + }, + ReplaceExpressionVisitor_visitInterpolation_closure: function ReplaceExpressionVisitor_visitInterpolation_closure(t0) { + this.$this = t0; + }, + SelectorSearchVisitor: function SelectorSearchVisitor() { + }, + SelectorSearchVisitor_visitComplexSelector_closure: function SelectorSearchVisitor_visitComplexSelector_closure(t0) { + this.$this = t0; + }, + SelectorSearchVisitor_visitCompoundSelector_closure: function SelectorSearchVisitor_visitCompoundSelector_closure(t0) { + this.$this = t0; + }, + serialize(node, charset, indentWidth, inspect, lineFeed, logger, sourceMap, style, useSpaces) { + var t1, css, t2, prefix, + visitor = A._SerializeVisitor$(2, inspect, lineFeed, logger, true, sourceMap, style, true); + node.accept$1(visitor); + t1 = visitor._serialize$_buffer; + css = t1.toString$0(0); + if (charset) { + t2 = new A.CodeUnits(css); + t2 = t2.any$1(t2, new A.serialize_closure()); + } else + t2 = false; + if (t2) + prefix = style === B.OutputStyle_1 ? "\ufeff" : '@charset "UTF-8";\n'; + else + prefix = ""; + t1 = sourceMap ? t1.buildSourceMap$1$prefix(prefix) : null; + return new A._Record_2_sourceMap(prefix + css, t1); + }, + serializeValue(value, inspect, quote) { + var _null = null, + visitor = A._SerializeVisitor$(_null, inspect, _null, _null, quote, false, _null, true); + value.accept$1(visitor); + return visitor._serialize$_buffer.toString$0(0); + }, + serializeSelector(selector, inspect) { + var _null = null, + visitor = A._SerializeVisitor$(_null, true, _null, _null, true, false, _null, true); + selector.accept$1(visitor); + return visitor._serialize$_buffer.toString$0(0); + }, + _SerializeVisitor$(indentWidth, inspect, lineFeed, logger, quote, sourceMap, style, useSpaces) { + var t1 = sourceMap ? new A.SourceMapBuffer(new A.StringBuffer(""), A._setArrayType([], type$.JSArray_Entry)) : new A.NoSourceMapBuffer(new A.StringBuffer("")), + t2 = style == null ? B.OutputStyle_0 : style, + t3 = indentWidth == null ? 2 : indentWidth, + t4 = logger == null ? B.StderrLogger_false : logger; + A.RangeError_checkValueInInterval(t3, 0, 10, "indentWidth"); + return new A._SerializeVisitor(t1, t2, inspect, quote, 32, t3, B.LineFeed_lf, t4); + }, + serialize_closure: function serialize_closure() { + }, + _SerializeVisitor: function _SerializeVisitor(t0, t1, t2, t3, t4, t5, t6, t7) { + var _ = this; + _._serialize$_buffer = t0; + _._indentation = 0; + _._style = t1; + _._inspect = t2; + _._quote = t3; + _._indentCharacter = t4; + _._indentWidth = t5; + _._serialize$_lineFeed = t6; + _._serialize$_logger = t7; + }, + _SerializeVisitor_visitCssComment_closure: function _SerializeVisitor_visitCssComment_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssAtRule_closure: function _SerializeVisitor_visitCssAtRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssMediaRule_closure: function _SerializeVisitor_visitCssMediaRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssImport_closure: function _SerializeVisitor_visitCssImport_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssImport__closure: function _SerializeVisitor_visitCssImport__closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssKeyframeBlock_closure: function _SerializeVisitor_visitCssKeyframeBlock_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssStyleRule_closure: function _SerializeVisitor_visitCssStyleRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssSupportsRule_closure: function _SerializeVisitor_visitCssSupportsRule_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssDeclaration_closure: function _SerializeVisitor_visitCssDeclaration_closure(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssDeclaration_closure0: function _SerializeVisitor_visitCssDeclaration_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitList_closure: function _SerializeVisitor_visitList_closure() { + }, + _SerializeVisitor_visitList_closure0: function _SerializeVisitor_visitList_closure0(t0, t1) { + this.$this = t0; + this.value = t1; + }, + _SerializeVisitor_visitList_closure1: function _SerializeVisitor_visitList_closure1(t0) { + this.$this = t0; + }, + _SerializeVisitor_visitMap_closure: function _SerializeVisitor_visitMap_closure(t0) { + this.$this = t0; + }, + _SerializeVisitor_visitSelectorList_closure: function _SerializeVisitor_visitSelectorList_closure() { + }, + _SerializeVisitor__write_closure: function _SerializeVisitor__write_closure(t0, t1) { + this.$this = t0; + this.value = t1; + }, + _SerializeVisitor__visitChildren_closure: function _SerializeVisitor__visitChildren_closure(t0, t1) { + this.$this = t0; + this.child = t1; + }, + _SerializeVisitor__visitChildren_closure0: function _SerializeVisitor__visitChildren_closure0(t0, t1) { + this.$this = t0; + this.child = t1; + }, + OutputStyle: function OutputStyle(t0) { + this._name = t0; + }, + LineFeed: function LineFeed(t0) { + this._name = t0; + }, + StatementSearchVisitor: function StatementSearchVisitor() { + }, + StatementSearchVisitor_visitIfRule_closure: function StatementSearchVisitor_visitIfRule_closure(t0) { + this.$this = t0; + }, + StatementSearchVisitor_visitIfRule__closure0: function StatementSearchVisitor_visitIfRule__closure0(t0) { + this.$this = t0; + }, + StatementSearchVisitor_visitIfRule_closure0: function StatementSearchVisitor_visitIfRule_closure0(t0) { + this.$this = t0; + }, + StatementSearchVisitor_visitIfRule__closure: function StatementSearchVisitor_visitIfRule__closure(t0) { + this.$this = t0; + }, + StatementSearchVisitor_visitChildren_closure: function StatementSearchVisitor_visitChildren_closure(t0) { + this.$this = t0; + }, + Entry: function Entry(t0, t1, t2) { + this.source = t0; + this.target = t1; + this.identifierName = t2; + }, + SingleMapping_SingleMapping$fromEntries(entries) { + var lines, t1, t2, urls, names, files, targetEntries, t3, lineNum, _i, sourceEntry, t4, t5, sourceUrl, t6, urlId, + sourceEntries = J.toList$0$ax(entries); + B.JSArray_methods.sort$0(sourceEntries); + lines = A._setArrayType([], type$.JSArray_TargetLineEntry); + t1 = type$.String; + t2 = type$.int; + urls = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + names = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + files = A.LinkedHashMap_LinkedHashMap$_empty(t2, type$.SourceFile); + targetEntries = A._Cell$(); + for (t2 = sourceEntries.length, t3 = type$.JSArray_TargetEntry, lineNum = null, _i = 0; _i < sourceEntries.length; sourceEntries.length === t2 || (0, A.throwConcurrentModificationError)(sourceEntries), ++_i) { + sourceEntry = sourceEntries[_i]; + if (lineNum == null || sourceEntry.target.line > lineNum) { + lineNum = sourceEntry.target.line; + t4 = A._setArrayType([], t3); + targetEntries.__late_helper$_value = t4; + lines.push(new A.TargetLineEntry(lineNum, t4)); + } + t4 = sourceEntry.source; + t5 = t4.file; + sourceUrl = t5.url; + t6 = sourceUrl == null ? "" : sourceUrl.toString$0(0); + urlId = urls.putIfAbsent$2(t6, new A.SingleMapping_SingleMapping$fromEntries_closure(urls)); + files.putIfAbsent$2(urlId, new A.SingleMapping_SingleMapping$fromEntries_closure0(sourceEntry)); + t6 = targetEntries.__late_helper$_value; + if (t6 === targetEntries) + A.throwExpression(A.LateError$localNI("")); + t4 = t4.offset; + J.add$1$ax(t6, new A.TargetEntry(sourceEntry.target.column, urlId, t5.getLine$1(t4), t5.getColumn$1(t4), null)); + } + t2 = urls.$ti; + t3 = t2._eval$1("LinkedHashMapValuesIterable<2>"); + t3 = A.MappedIterable_MappedIterable(new A.LinkedHashMapValuesIterable(urls, t3), new A.SingleMapping_SingleMapping$fromEntries_closure1(files), t3._eval$1("Iterable.E"), type$.nullable_SourceFile); + t3 = A.List_List$of(t3, true, A._instanceType(t3)._eval$1("Iterable.E")); + t2 = t2._eval$1("LinkedHashMapKeysIterable<1>"); + t4 = names.$ti._eval$1("LinkedHashMapKeysIterable<1>"); + return new A.SingleMapping(A.List_List$of(new A.LinkedHashMapKeysIterable(urls, t2), true, t2._eval$1("Iterable.E")), A.List_List$of(new A.LinkedHashMapKeysIterable(names, t4), true, t4._eval$1("Iterable.E")), t3, lines, null, A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.dynamic)); + }, + Mapping: function Mapping() { + }, + SingleMapping: function SingleMapping(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.urls = t0; + _.names = t1; + _.files = t2; + _.lines = t3; + _.targetUrl = t4; + _.sourceRoot = null; + _.extensions = t5; + }, + SingleMapping_SingleMapping$fromEntries_closure: function SingleMapping_SingleMapping$fromEntries_closure(t0) { + this.urls = t0; + }, + SingleMapping_SingleMapping$fromEntries_closure0: function SingleMapping_SingleMapping$fromEntries_closure0(t0) { + this.sourceEntry = t0; + }, + SingleMapping_SingleMapping$fromEntries_closure1: function SingleMapping_SingleMapping$fromEntries_closure1(t0) { + this.files = t0; + }, + SingleMapping_toJson_closure: function SingleMapping_toJson_closure() { + }, + SingleMapping_toJson_closure0: function SingleMapping_toJson_closure0(t0) { + this.result = t0; + }, + TargetLineEntry: function TargetLineEntry(t0, t1) { + this.line = t0; + this.entries = t1; + }, + TargetEntry: function TargetEntry(t0, t1, t2, t3, t4) { + var _ = this; + _.column = t0; + _.sourceUrlId = t1; + _.sourceLine = t2; + _.sourceColumn = t3; + _.sourceNameId = t4; + }, + SourceFile$fromString(text, url) { + var t1 = new A.CodeUnits(text), + t2 = A._setArrayType([0], type$.JSArray_int), + t3 = typeof url == "string" ? A.Uri_parse(url) : type$.nullable_Uri._as(url); + t2 = new A.SourceFile(t3, t2, new Uint32Array(A._ensureNativeList(t1.toList$0(t1)))); + t2.SourceFile$decoded$2$url(t1, url); + return t2; + }, + SourceFile$decoded(decodedChars, url) { + var t1 = A._setArrayType([0], type$.JSArray_int), + t2 = typeof url == "string" ? A.Uri_parse(url) : type$.nullable_Uri._as(url); + t1 = new A.SourceFile(t2, t1, new Uint32Array(A._ensureNativeList(J.toList$0$ax(decodedChars)))); + t1.SourceFile$decoded$2$url(decodedChars, url); + return t1; + }, + FileLocation$_(file, offset) { + if (offset < 0) + A.throwExpression(A.RangeError$("Offset may not be negative, was " + offset + ".")); + else if (offset > file._decodedChars.length) + A.throwExpression(A.RangeError$("Offset " + offset + string$.x20must_n + file.get$length(0) + ".")); + return new A.FileLocation(file, offset); + }, + _FileSpan$(file, _start, _end) { + if (_end < _start) + A.throwExpression(A.ArgumentError$("End " + _end + " must come after start " + _start + ".", null)); + else if (_end > file._decodedChars.length) + A.throwExpression(A.RangeError$("End " + _end + string$.x20must_n + file.get$length(0) + ".")); + else if (_start < 0) + A.throwExpression(A.RangeError$("Start may not be negative, was " + _start + ".")); + return new A._FileSpan(file, _start, _end); + }, + FileSpanExtension_subspan(_this, start, end) { + var t1, startOffset, t2; + A.RangeError_checkValidRange(start, end, _this.get$length(_this)); + if (start === 0) + t1 = end == null || end === _this.get$length(_this); + else + t1 = false; + if (t1) + return _this; + startOffset = _this.get$start(_this).offset; + t1 = _this.get$file(_this); + t2 = end == null ? _this.get$end(_this).offset : startOffset + end; + return t1.span$2(0, startOffset + start, t2); + }, + SourceFile: function SourceFile(t0, t1, t2) { + var _ = this; + _.url = t0; + _._lineStarts = t1; + _._decodedChars = t2; + _._cachedLine = null; + }, + FileLocation: function FileLocation(t0, t1) { + this.file = t0; + this.offset = t1; + }, + _FileSpan: function _FileSpan(t0, t1, t2) { + this.file = t0; + this._file$_start = t1; + this._end = t2; + }, + Highlighter$(span, color) { + var t1 = A.Highlighter__collateLines(A._setArrayType([A._Highlight$(span, null, true)], type$.JSArray__Highlight)), + t2 = new A.Highlighter_closure(color).call$0(), + t3 = B.JSInt_methods.toString$0(B.JSArray_methods.get$last(t1).number + 1), + t4 = A.Highlighter__contiguous(t1) ? 0 : 3, + t5 = A._arrayInstanceType(t1); + return new A.Highlighter(t1, t2, null, 1 + Math.max(t3.length, t4), new A.MappedListIterable(t1, new A.Highlighter$__closure(), t5._eval$1("MappedListIterable<1,int>")).reduce$1(0, B.CONSTANT), !A.isAllTheSame(new A.MappedListIterable(t1, new A.Highlighter$__closure0(), t5._eval$1("MappedListIterable<1,Object?>"))), new A.StringBuffer("")); + }, + Highlighter$multiple(primarySpan, primaryLabel, secondarySpans, color, primaryColor, secondaryColor) { + var t2, t3, t4, t5, t6, + t1 = A._setArrayType([A._Highlight$(primarySpan, primaryLabel, true)], type$.JSArray__Highlight); + for (t2 = secondarySpans.get$entries(secondarySpans), t2 = t2.get$iterator(t2); t2.moveNext$0();) { + t3 = t2.get$current(t2); + t1.push(A._Highlight$(t3.key, t3.value, false)); + } + t1 = A.Highlighter__collateLines(t1); + if (color) + t2 = primaryColor == null ? "\x1b[31m" : primaryColor; + else + t2 = null; + if (color) + t3 = "\x1b[34m"; + else + t3 = null; + t4 = B.JSInt_methods.toString$0(B.JSArray_methods.get$last(t1).number + 1); + t5 = A.Highlighter__contiguous(t1) ? 0 : 3; + t6 = A._arrayInstanceType(t1); + return new A.Highlighter(t1, t2, t3, 1 + Math.max(t4.length, t5), new A.MappedListIterable(t1, new A.Highlighter$__closure(), t6._eval$1("MappedListIterable<1,int>")).reduce$1(0, B.CONSTANT), !A.isAllTheSame(new A.MappedListIterable(t1, new A.Highlighter$__closure0(), t6._eval$1("MappedListIterable<1,Object?>"))), new A.StringBuffer("")); + }, + Highlighter__contiguous(lines) { + var i, thisLine, nextLine; + for (i = 0; i < lines.length - 1;) { + thisLine = lines[i]; + ++i; + nextLine = lines[i]; + if (thisLine.number + 1 !== nextLine.number && J.$eq$(thisLine.url, nextLine.url)) + return false; + } + return true; + }, + Highlighter__collateLines(highlights) { + var t1, t2, + highlightsByUrl = A.groupBy(highlights, new A.Highlighter__collateLines_closure(), type$._Highlight, type$.Object); + for (t1 = new A.LinkedHashMapValueIterator(highlightsByUrl, highlightsByUrl.__js_helper$_modifications, highlightsByUrl.__js_helper$_first); t1.moveNext$0();) + J.sort$1$ax(t1.__js_helper$_current, new A.Highlighter__collateLines_closure0()); + t1 = A._instanceType(highlightsByUrl)._eval$1("LinkedHashMapEntriesIterable<1,2>"); + t2 = t1._eval$1("ExpandIterable"); + return A.List_List$of(new A.ExpandIterable(new A.LinkedHashMapEntriesIterable(highlightsByUrl, t1), new A.Highlighter__collateLines_closure1(), t2), true, t2._eval$1("Iterable.E")); + }, + _Highlight$(span, label, primary) { + var t2, + t1 = new A._Highlight_closure(span).call$0(); + if (label == null) + t2 = null; + else + t2 = A.stringReplaceAllUnchecked(label, "\r\n", "\n"); + return new A._Highlight(t1, primary, t2); + }, + _Highlight__normalizeNewlines(span) { + var endOffset, t1, i, t2, t3, t4, + text = span.get$text(); + if (!B.JSString_methods.contains$1(text, "\r\n")) + return span; + endOffset = span.get$end(span).get$offset(); + for (t1 = text.length - 1, i = 0; i < t1; ++i) + if (text.charCodeAt(i) === 13 && text.charCodeAt(i + 1) === 10) + --endOffset; + t1 = span.get$start(span); + t2 = span.get$sourceUrl(span); + t3 = span.get$end(span).get$line(); + t2 = A.SourceLocation$(endOffset, span.get$end(span).get$column(), t3, t2); + t3 = A.stringReplaceAllUnchecked(text, "\r\n", "\n"); + t4 = span.get$context(span); + return A.SourceSpanWithContext$(t1, t2, t3, A.stringReplaceAllUnchecked(t4, "\r\n", "\n")); + }, + _Highlight__normalizeTrailingNewline(span) { + var context, text, start, end, t1, t2, t3; + if (!B.JSString_methods.endsWith$1(span.get$context(span), "\n")) + return span; + if (B.JSString_methods.endsWith$1(span.get$text(), "\n\n")) + return span; + context = B.JSString_methods.substring$2(span.get$context(span), 0, span.get$context(span).length - 1); + text = span.get$text(); + start = span.get$start(span); + end = span.get$end(span); + if (B.JSString_methods.endsWith$1(span.get$text(), "\n")) { + t1 = A.findLineStart(span.get$context(span), span.get$text(), span.get$start(span).get$column()); + t1.toString; + t1 = t1 + span.get$start(span).get$column() + span.get$length(span) === span.get$context(span).length; + } else + t1 = false; + if (t1) { + text = B.JSString_methods.substring$2(span.get$text(), 0, span.get$text().length - 1); + if (text.length === 0) + end = start; + else { + t1 = span.get$end(span).get$offset(); + t2 = span.get$sourceUrl(span); + t3 = span.get$end(span).get$line(); + end = A.SourceLocation$(t1 - 1, A._Highlight__lastLineLength(context), t3 - 1, t2); + start = span.get$start(span).get$offset() === span.get$end(span).get$offset() ? end : span.get$start(span); + } + } + return A.SourceSpanWithContext$(start, end, text, context); + }, + _Highlight__normalizeEndOfLine(span) { + var text, t1, t2, t3, t4; + if (span.get$end(span).get$column() !== 0) + return span; + if (span.get$end(span).get$line() === span.get$start(span).get$line()) + return span; + text = B.JSString_methods.substring$2(span.get$text(), 0, span.get$text().length - 1); + t1 = span.get$start(span); + t2 = span.get$end(span).get$offset(); + t3 = span.get$sourceUrl(span); + t4 = span.get$end(span).get$line(); + t3 = A.SourceLocation$(t2 - 1, text.length - B.JSString_methods.lastIndexOf$1(text, "\n") - 1, t4 - 1, t3); + return A.SourceSpanWithContext$(t1, t3, text, B.JSString_methods.endsWith$1(span.get$context(span), "\n") ? B.JSString_methods.substring$2(span.get$context(span), 0, span.get$context(span).length - 1) : span.get$context(span)); + }, + _Highlight__lastLineLength(text) { + var t1 = text.length; + if (t1 === 0) + return 0; + else if (text.charCodeAt(t1 - 1) === 10) + return t1 === 1 ? 0 : t1 - B.JSString_methods.lastIndexOf$2(text, "\n", t1 - 2) - 1; + else + return t1 - B.JSString_methods.lastIndexOf$1(text, "\n") - 1; + }, + Highlighter: function Highlighter(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._lines = t0; + _._primaryColor = t1; + _._secondaryColor = t2; + _._paddingBeforeSidebar = t3; + _._maxMultilineSpans = t4; + _._multipleFiles = t5; + _._highlighter$_buffer = t6; + }, + Highlighter_closure: function Highlighter_closure(t0) { + this.color = t0; + }, + Highlighter$__closure: function Highlighter$__closure() { + }, + Highlighter$___closure: function Highlighter$___closure() { + }, + Highlighter$__closure0: function Highlighter$__closure0() { + }, + Highlighter__collateLines_closure: function Highlighter__collateLines_closure() { + }, + Highlighter__collateLines_closure0: function Highlighter__collateLines_closure0() { + }, + Highlighter__collateLines_closure1: function Highlighter__collateLines_closure1() { + }, + Highlighter__collateLines__closure: function Highlighter__collateLines__closure(t0) { + this.line = t0; + }, + Highlighter_highlight_closure: function Highlighter_highlight_closure() { + }, + Highlighter__writeFileStart_closure: function Highlighter__writeFileStart_closure(t0) { + this.$this = t0; + }, + Highlighter__writeMultilineHighlights_closure: function Highlighter__writeMultilineHighlights_closure(t0, t1, t2) { + this.$this = t0; + this.startLine = t1; + this.line = t2; + }, + Highlighter__writeMultilineHighlights_closure0: function Highlighter__writeMultilineHighlights_closure0(t0, t1) { + this.$this = t0; + this.highlight = t1; + }, + Highlighter__writeMultilineHighlights_closure1: function Highlighter__writeMultilineHighlights_closure1(t0) { + this.$this = t0; + }, + Highlighter__writeMultilineHighlights_closure2: function Highlighter__writeMultilineHighlights_closure2(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.current = t2; + _.startLine = t3; + _.line = t4; + _.highlight = t5; + _.endLine = t6; + }, + Highlighter__writeMultilineHighlights__closure: function Highlighter__writeMultilineHighlights__closure(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + Highlighter__writeMultilineHighlights__closure0: function Highlighter__writeMultilineHighlights__closure0(t0, t1) { + this.$this = t0; + this.vertical = t1; + }, + Highlighter__writeHighlightedText_closure: function Highlighter__writeHighlightedText_closure(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.text = t1; + _.startColumn = t2; + _.endColumn = t3; + }, + Highlighter__writeIndicator_closure: function Highlighter__writeIndicator_closure(t0, t1, t2) { + this.$this = t0; + this.line = t1; + this.highlight = t2; + }, + Highlighter__writeIndicator_closure0: function Highlighter__writeIndicator_closure0(t0, t1, t2) { + this.$this = t0; + this.line = t1; + this.highlight = t2; + }, + Highlighter__writeIndicator_closure1: function Highlighter__writeIndicator_closure1(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.coversWholeLine = t1; + _.line = t2; + _.highlight = t3; + }, + Highlighter__writeLabel_closure: function Highlighter__writeLabel_closure(t0, t1) { + this.$this = t0; + this.lines = t1; + }, + Highlighter__writeLabel_closure0: function Highlighter__writeLabel_closure0(t0, t1) { + this.$this = t0; + this.text = t1; + }, + Highlighter__writeSidebar_closure: function Highlighter__writeSidebar_closure(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.end = t2; + }, + _Highlight: function _Highlight(t0, t1, t2) { + this.span = t0; + this.isPrimary = t1; + this.label = t2; + }, + _Highlight_closure: function _Highlight_closure(t0) { + this.span = t0; + }, + _Line: function _Line(t0, t1, t2, t3) { + var _ = this; + _.text = t0; + _.number = t1; + _.url = t2; + _.highlights = t3; + }, + SourceLocation$(offset, column, line, sourceUrl) { + var t1 = line == null, + t2 = t1 ? 0 : line, + t3 = column == null, + t4 = t3 ? offset : column; + if (offset < 0) + A.throwExpression(A.RangeError$("Offset may not be negative, was " + offset + ".")); + else if (!t1 && line < 0) + A.throwExpression(A.RangeError$("Line may not be negative, was " + A.S(line) + ".")); + else if (!t3 && column < 0) + A.throwExpression(A.RangeError$("Column may not be negative, was " + A.S(column) + ".")); + return new A.SourceLocation(sourceUrl, offset, t2, t4); + }, + SourceLocation: function SourceLocation(t0, t1, t2, t3) { + var _ = this; + _.sourceUrl = t0; + _.offset = t1; + _.line = t2; + _.column = t3; + }, + SourceLocationMixin: function SourceLocationMixin() { + }, + SourceSpanExtension_messageMultiple(_this, message, label, secondarySpans, color, primaryColor, secondaryColor) { + var t2, t3, + t1 = _this.get$start(_this); + t1 = t1.file.getLine$1(t1.offset); + t2 = _this.get$start(_this); + t2 = "" + ("line " + (t1 + 1) + ", column " + (t2.file.getColumn$1(t2.offset) + 1)); + if (_this.get$sourceUrl(_this) != null) { + t1 = _this.get$sourceUrl(_this); + t3 = $.$get$context(); + t1.toString; + t1 = t2 + (" of " + t3.prettyUri$1(t1)); + } else + t1 = t2; + t1 = t1 + (": " + message + "\n") + A.Highlighter$multiple(_this, label, secondarySpans, color, primaryColor, secondaryColor).highlight$0(); + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + SourceSpanBase: function SourceSpanBase() { + }, + SourceSpanException: function SourceSpanException() { + }, + SourceSpanFormatException: function SourceSpanFormatException(t0, t1, t2) { + this.source = t0; + this._span_exception$_message = t1; + this._span = t2; + }, + MultiSourceSpanException: function MultiSourceSpanException() { + }, + MultiSourceSpanFormatException: function MultiSourceSpanFormatException(t0, t1, t2, t3, t4) { + var _ = this; + _.source = t0; + _.primaryLabel = t1; + _.secondarySpans = t2; + _._span_exception$_message = t3; + _._span = t4; + }, + SourceSpanMixin: function SourceSpanMixin() { + }, + SourceSpanWithContext$(start, end, text, _context) { + var t1 = new A.SourceSpanWithContext(_context, start, end, text); + t1.SourceSpanBase$3(start, end, text); + if (!B.JSString_methods.contains$1(_context, text)) + A.throwExpression(A.ArgumentError$('The context line "' + _context + '" must contain "' + text + '".', null)); + if (A.findLineStart(_context, text, start.get$column()) == null) + A.throwExpression(A.ArgumentError$('The span text "' + text + '" must start at column ' + (start.get$column() + 1) + ' in a line within "' + _context + '".', null)); + return t1; + }, + SourceSpanWithContext: function SourceSpanWithContext(t0, t1, t2, t3) { + var _ = this; + _._context = t0; + _.start = t1; + _.end = t2; + _.text = t3; + }, + Chain_Chain$parse(chain) { + var t1, t2, + _s51_ = string$.x3d_____; + if (chain.length === 0) + return new A.Chain(A.List_List$unmodifiable(A._setArrayType([], type$.JSArray_Trace), type$.Trace)); + t1 = $.$get$vmChainGap(); + if (B.JSString_methods.contains$1(chain, t1)) { + t1 = B.JSString_methods.split$1(chain, t1); + t2 = A._arrayInstanceType(t1); + return new A.Chain(A.List_List$unmodifiable(new A.MappedIterable(new A.WhereIterable(t1, new A.Chain_Chain$parse_closure(), t2._eval$1("WhereIterable<1>")), A.trace_Trace___parseVM_tearOff$closure(), t2._eval$1("MappedIterable<1,Trace>")), type$.Trace)); + } + if (!B.JSString_methods.contains$1(chain, _s51_)) + return new A.Chain(A.List_List$unmodifiable(A._setArrayType([A.Trace_Trace$parse(chain)], type$.JSArray_Trace), type$.Trace)); + return new A.Chain(A.List_List$unmodifiable(new A.MappedListIterable(A._setArrayType(chain.split(_s51_), type$.JSArray_String), A.trace_Trace___parseFriendly_tearOff$closure(), type$.MappedListIterable_String_Trace), type$.Trace)); + }, + Chain: function Chain(t0) { + this.traces = t0; + }, + Chain_Chain$parse_closure: function Chain_Chain$parse_closure() { + }, + Chain_toTrace_closure: function Chain_toTrace_closure() { + }, + Chain_toString_closure0: function Chain_toString_closure0() { + }, + Chain_toString__closure0: function Chain_toString__closure0() { + }, + Chain_toString_closure: function Chain_toString_closure(t0) { + this.longest = t0; + }, + Chain_toString__closure: function Chain_toString__closure(t0) { + this.longest = t0; + }, + Frame___parseVM_tearOff(frame) { + return A.Frame_Frame$parseVM(frame); + }, + Frame_Frame$parseVM(frame) { + return A.Frame__catchFormatException(frame, new A.Frame_Frame$parseVM_closure(frame)); + }, + Frame___parseV8_tearOff(frame) { + return A.Frame_Frame$parseV8(frame); + }, + Frame_Frame$parseV8(frame) { + return A.Frame__catchFormatException(frame, new A.Frame_Frame$parseV8_closure(frame)); + }, + Frame_Frame$_parseFirefoxEval(frame) { + return A.Frame__catchFormatException(frame, new A.Frame_Frame$_parseFirefoxEval_closure(frame)); + }, + Frame___parseFirefox_tearOff(frame) { + return A.Frame_Frame$parseFirefox(frame); + }, + Frame_Frame$parseFirefox(frame) { + return A.Frame__catchFormatException(frame, new A.Frame_Frame$parseFirefox_closure(frame)); + }, + Frame___parseFriendly_tearOff(frame) { + return A.Frame_Frame$parseFriendly(frame); + }, + Frame_Frame$parseFriendly(frame) { + return A.Frame__catchFormatException(frame, new A.Frame_Frame$parseFriendly_closure(frame)); + }, + Frame__uriOrPathToUri(uriOrPath) { + if (B.JSString_methods.contains$1(uriOrPath, $.$get$Frame__uriRegExp())) + return A.Uri_parse(uriOrPath); + else if (B.JSString_methods.contains$1(uriOrPath, $.$get$Frame__windowsRegExp())) + return A._Uri__Uri$file(uriOrPath, true); + else if (B.JSString_methods.startsWith$1(uriOrPath, "/")) + return A._Uri__Uri$file(uriOrPath, false); + if (B.JSString_methods.contains$1(uriOrPath, "\\")) + return $.$get$windows().toUri$1(uriOrPath); + return A.Uri_parse(uriOrPath); + }, + Frame__catchFormatException(text, body) { + var t1, exception; + try { + t1 = body.call$0(); + return t1; + } catch (exception) { + if (type$.FormatException._is(A.unwrapException(exception))) + return new A.UnparsedFrame(A._Uri__Uri(null, "unparsed", null, null), text); + else + throw exception; + } + }, + Frame: function Frame(t0, t1, t2, t3) { + var _ = this; + _.uri = t0; + _.line = t1; + _.column = t2; + _.member = t3; + }, + Frame_Frame$parseVM_closure: function Frame_Frame$parseVM_closure(t0) { + this.frame = t0; + }, + Frame_Frame$parseV8_closure: function Frame_Frame$parseV8_closure(t0) { + this.frame = t0; + }, + Frame_Frame$parseV8_closure_parseJsLocation: function Frame_Frame$parseV8_closure_parseJsLocation(t0) { + this.frame = t0; + }, + Frame_Frame$_parseFirefoxEval_closure: function Frame_Frame$_parseFirefoxEval_closure(t0) { + this.frame = t0; + }, + Frame_Frame$parseFirefox_closure: function Frame_Frame$parseFirefox_closure(t0) { + this.frame = t0; + }, + Frame_Frame$parseFriendly_closure: function Frame_Frame$parseFriendly_closure(t0) { + this.frame = t0; + }, + LazyTrace: function LazyTrace(t0) { + this._thunk = t0; + this.__LazyTrace__trace_FI = $; + }, + LazyTrace_terse_closure: function LazyTrace_terse_closure(t0) { + this.$this = t0; + }, + Trace_Trace$from(trace) { + if (type$.Trace._is(trace)) + return trace; + if (trace instanceof A.Chain) + return trace.toTrace$0(); + return new A.LazyTrace(new A.Trace_Trace$from_closure(trace)); + }, + Trace_Trace$parse(trace) { + var error, t1, exception; + try { + if (trace.length === 0) { + t1 = A.Trace$(A._setArrayType([], type$.JSArray_Frame), null); + return t1; + } + if (B.JSString_methods.contains$1(trace, $.$get$_v8Trace())) { + t1 = A.Trace$parseV8(trace); + return t1; + } + if (B.JSString_methods.contains$1(trace, "\tat ")) { + t1 = A.Trace$parseJSCore(trace); + return t1; + } + if (B.JSString_methods.contains$1(trace, $.$get$_firefoxSafariTrace()) || B.JSString_methods.contains$1(trace, $.$get$_firefoxEvalTrace())) { + t1 = A.Trace$parseFirefox(trace); + return t1; + } + if (B.JSString_methods.contains$1(trace, string$.x3d_____)) { + t1 = A.Chain_Chain$parse(trace).toTrace$0(); + return t1; + } + if (B.JSString_methods.contains$1(trace, $.$get$_friendlyTrace())) { + t1 = A.Trace$parseFriendly(trace); + return t1; + } + t1 = A.Trace$parseVM(trace); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.FormatException._is(t1)) { + error = t1; + throw A.wrapException(A.FormatException$(J.get$message$x(error) + "\nStack trace:\n" + trace, null, null)); + } else + throw exception; + } + }, + Trace___parseVM_tearOff(trace) { + return A.Trace$parseVM(trace); + }, + Trace$parseVM(trace) { + var t1 = A.List_List$unmodifiable(A.Trace__parseVM(trace), type$.Frame); + return new A.Trace(t1, new A._StringStackTrace(trace)); + }, + Trace__parseVM(trace) { + var $frames, + t1 = B.JSString_methods.trim$0(trace), + t2 = $.$get$vmChainGap(), + t3 = type$.WhereIterable_String, + lines = new A.WhereIterable(A._setArrayType(A.stringReplaceAllUnchecked(t1, t2, "").split("\n"), type$.JSArray_String), new A.Trace__parseVM_closure(), t3); + if (!lines.get$iterator(0).moveNext$0()) + return A._setArrayType([], type$.JSArray_Frame); + t1 = A.TakeIterable_TakeIterable(lines, lines.get$length(0) - 1, t3._eval$1("Iterable.E")); + t1 = A.MappedIterable_MappedIterable(t1, A.frame_Frame___parseVM_tearOff$closure(), A._instanceType(t1)._eval$1("Iterable.E"), type$.Frame); + $frames = A.List_List$of(t1, true, A._instanceType(t1)._eval$1("Iterable.E")); + if (!J.endsWith$1$s(lines.get$last(0), ".da")) + B.JSArray_methods.add$1($frames, A.Frame_Frame$parseVM(lines.get$last(0))); + return $frames; + }, + Trace$parseV8(trace) { + var t1 = A.SubListIterable$(A._setArrayType(trace.split("\n"), type$.JSArray_String), 1, null, type$.String).super$Iterable$skipWhile(0, new A.Trace$parseV8_closure()), + t2 = type$.Frame; + t2 = A.List_List$unmodifiable(A.MappedIterable_MappedIterable(t1, A.frame_Frame___parseV8_tearOff$closure(), t1.$ti._eval$1("Iterable.E"), t2), t2); + return new A.Trace(t2, new A._StringStackTrace(trace)); + }, + Trace$parseJSCore(trace) { + var t1 = A.List_List$unmodifiable(new A.MappedIterable(new A.WhereIterable(A._setArrayType(trace.split("\n"), type$.JSArray_String), new A.Trace$parseJSCore_closure(), type$.WhereIterable_String), A.frame_Frame___parseV8_tearOff$closure(), type$.MappedIterable_String_Frame), type$.Frame); + return new A.Trace(t1, new A._StringStackTrace(trace)); + }, + Trace$parseFirefox(trace) { + var t1 = A.List_List$unmodifiable(new A.MappedIterable(new A.WhereIterable(A._setArrayType(B.JSString_methods.trim$0(trace).split("\n"), type$.JSArray_String), new A.Trace$parseFirefox_closure(), type$.WhereIterable_String), A.frame_Frame___parseFirefox_tearOff$closure(), type$.MappedIterable_String_Frame), type$.Frame); + return new A.Trace(t1, new A._StringStackTrace(trace)); + }, + Trace___parseFriendly_tearOff(trace) { + return A.Trace$parseFriendly(trace); + }, + Trace$parseFriendly(trace) { + var t1 = trace.length === 0 ? A._setArrayType([], type$.JSArray_Frame) : new A.MappedIterable(new A.WhereIterable(A._setArrayType(B.JSString_methods.trim$0(trace).split("\n"), type$.JSArray_String), new A.Trace$parseFriendly_closure(), type$.WhereIterable_String), A.frame_Frame___parseFriendly_tearOff$closure(), type$.MappedIterable_String_Frame); + t1 = A.List_List$unmodifiable(t1, type$.Frame); + return new A.Trace(t1, new A._StringStackTrace(trace)); + }, + Trace$($frames, original) { + var t1 = A.List_List$unmodifiable($frames, type$.Frame); + return new A.Trace(t1, new A._StringStackTrace(original == null ? "" : original)); + }, + Trace: function Trace(t0, t1) { + this.frames = t0; + this.original = t1; + }, + Trace_Trace$from_closure: function Trace_Trace$from_closure(t0) { + this.trace = t0; + }, + Trace__parseVM_closure: function Trace__parseVM_closure() { + }, + Trace$parseV8_closure: function Trace$parseV8_closure() { + }, + Trace$parseJSCore_closure: function Trace$parseJSCore_closure() { + }, + Trace$parseFirefox_closure: function Trace$parseFirefox_closure() { + }, + Trace$parseFriendly_closure: function Trace$parseFriendly_closure() { + }, + Trace_terse_closure: function Trace_terse_closure() { + }, + Trace_foldFrames_closure: function Trace_foldFrames_closure(t0) { + this.oldPredicate = t0; + }, + Trace_foldFrames_closure0: function Trace_foldFrames_closure0(t0) { + this._box_0 = t0; + }, + Trace_toString_closure0: function Trace_toString_closure0() { + }, + Trace_toString_closure: function Trace_toString_closure(t0) { + this.longest = t0; + }, + UnparsedFrame: function UnparsedFrame(t0, t1) { + this.uri = t0; + this.member = t1; + }, + TransformByHandlers_transformByHandlers(_this, onData, onDone, $S, $T) { + var _null = null, t1 = {}, + controller = A.StreamController_StreamController(_null, _null, _null, _null, true, $T); + t1.subscription = null; + controller.onListen = new A.TransformByHandlers_transformByHandlers_closure(t1, _this, onData, controller, A.instantiate1(A.from_handlers__TransformByHandlers__defaultHandleError$closure(), $T), onDone, $S); + return controller.get$stream(); + }, + TransformByHandlers__defaultHandleError(error, stackTrace, sink) { + sink.addError$2(error, stackTrace); + }, + TransformByHandlers_transformByHandlers_closure: function TransformByHandlers_transformByHandlers_closure(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._box_1 = t0; + _._this = t1; + _.onData = t2; + _.controller = t3; + _.handleError = t4; + _.handleDone = t5; + _.S = t6; + }, + TransformByHandlers_transformByHandlers__closure: function TransformByHandlers_transformByHandlers__closure(t0, t1, t2) { + this.onData = t0; + this.controller = t1; + this.S = t2; + }, + TransformByHandlers_transformByHandlers__closure1: function TransformByHandlers_transformByHandlers__closure1(t0, t1) { + this.handleError = t0; + this.controller = t1; + }, + TransformByHandlers_transformByHandlers__closure0: function TransformByHandlers_transformByHandlers__closure0(t0, t1, t2) { + this._box_0 = t0; + this.handleDone = t1; + this.controller = t2; + }, + TransformByHandlers_transformByHandlers__closure2: function TransformByHandlers_transformByHandlers__closure2(t0, t1) { + this._box_1 = t0; + this._box_0 = t1; + }, + RateLimit__debounceAggregate(_this, duration, collect, leading, trailing, $T, $S) { + var t1 = {}; + t1.soFar = t1.timer = null; + t1.emittedLatestAsLeading = t1.shouldClose = t1.hasPending = false; + return A.TransformByHandlers_transformByHandlers(_this, new A.RateLimit__debounceAggregate_closure(t1, $S, collect, false, duration, true, $T), new A.RateLimit__debounceAggregate_closure0(t1, true, $S), $T, $S); + }, + _collect($event, soFar, $T) { + var t1 = soFar == null ? A._setArrayType([], $T._eval$1("JSArray<0>")) : soFar; + J.add$1$ax(t1, $event); + return t1; + }, + RateLimit__debounceAggregate_closure: function RateLimit__debounceAggregate_closure(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._box_0 = t0; + _.S = t1; + _.collect = t2; + _.leading = t3; + _.duration = t4; + _.trailing = t5; + _.T = t6; + }, + RateLimit__debounceAggregate_closure_emit: function RateLimit__debounceAggregate_closure_emit(t0, t1, t2) { + this._box_0 = t0; + this.sink = t1; + this.S = t2; + }, + RateLimit__debounceAggregate__closure: function RateLimit__debounceAggregate__closure(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.trailing = t1; + _.emit = t2; + _.sink = t3; + }, + RateLimit__debounceAggregate_closure0: function RateLimit__debounceAggregate_closure0(t0, t1, t2) { + this._box_0 = t0; + this.trailing = t1; + this.S = t2; + }, + StringScannerException$(message, span, source) { + return new A.StringScannerException(source, message, span); + }, + StringScannerException: function StringScannerException(t0, t1, t2) { + this.source = t0; + this._span_exception$_message = t1; + this._span = t2; + }, + LineScanner$(string) { + return new A.LineScanner(null, string); + }, + LineScanner: function LineScanner(t0, t1) { + var _ = this; + _._line_scanner$_column = _._line_scanner$_line = 0; + _.sourceUrl = t0; + _.string = t1; + _._string_scanner$_position = 0; + _._lastMatchPosition = _._lastMatch = null; + }, + SpanScanner$(string, sourceUrl) { + var t2, + t1 = A.SourceFile$fromString(string, sourceUrl); + if (sourceUrl == null) + t2 = null; + else + t2 = typeof sourceUrl == "string" ? A.Uri_parse(sourceUrl) : type$.Uri._as(sourceUrl); + return new A.SpanScanner(t1, t2, string); + }, + SpanScanner: function SpanScanner(t0, t1, t2) { + var _ = this; + _._sourceFile = t0; + _.sourceUrl = t1; + _.string = t2; + _._string_scanner$_position = 0; + _._lastMatchPosition = _._lastMatch = null; + }, + _SpanScannerState: function _SpanScannerState(t0, t1) { + this._scanner = t0; + this.position = t1; + }, + StringScanner$(string, position, sourceUrl) { + var t1; + if (sourceUrl == null) + t1 = null; + else + t1 = typeof sourceUrl == "string" ? A.Uri_parse(sourceUrl) : type$.Uri._as(sourceUrl); + return new A.StringScanner(t1, string); + }, + StringScanner: function StringScanner(t0, t1) { + var _ = this; + _.sourceUrl = t0; + _.string = t1; + _._string_scanner$_position = 0; + _._lastMatchPosition = _._lastMatch = null; + }, + AsciiGlyphSet: function AsciiGlyphSet() { + }, + UnicodeGlyphSet: function UnicodeGlyphSet() { + }, + WatchEvent: function WatchEvent(t0, t1) { + this.type = t0; + this.path = t1; + }, + ChangeType: function ChangeType(t0) { + this._watch_event$_name = t0; + }, + A98RgbColorSpace0: function A98RgbColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + AnySelectorVisitor0: function AnySelectorVisitor0() { + }, + AnySelectorVisitor_visitComplexSelector_closure0: function AnySelectorVisitor_visitComplexSelector_closure0(t0) { + this.$this = t0; + }, + AnySelectorVisitor_visitCompoundSelector_closure0: function AnySelectorVisitor_visitCompoundSelector_closure0(t0) { + this.$this = t0; + }, + SupportsAnything0: function SupportsAnything0(t0, t1) { + this.contents = t0; + this.span = t1; + }, + ArgumentList$empty0(span) { + return new A.ArgumentList0(B.List_empty21, B.Map_empty14, null, null, span); + }, + ArgumentList0: function ArgumentList0(t0, t1, t2, t3, t4) { + var _ = this; + _.positional = t0; + _.named = t1; + _.rest = t2; + _.keywordRest = t3; + _.span = t4; + }, + argumentListClass_closure: function argumentListClass_closure() { + }, + argumentListClass__closure: function argumentListClass__closure() { + }, + argumentListClass__closure0: function argumentListClass__closure0() { + }, + SassArgumentList$0(contents, keywords, separator) { + var t1 = type$.Value_2; + t1 = new A.SassArgumentList0(A.ConstantMap_ConstantMap$from(keywords, type$.String, t1), A.List_List$unmodifiable(contents, t1), separator, false); + t1.SassList$3$brackets0(contents, separator, false); + return t1; + }, + SassArgumentList0: function SassArgumentList0(t0, t1, t2, t3) { + var _ = this; + _._argument_list$_keywords = t0; + _._argument_list$_wereKeywordsAccessed = false; + _._list1$_contents = t1; + _._list1$_separator = t2; + _._list1$_hasBrackets = t3; + }, + JSArray1: function JSArray1() { + }, + AsyncImporter0: function AsyncImporter0() { + }, + JSToDartAsyncImporter: function JSToDartAsyncImporter(t0, t1, t2) { + this._async0$_canonicalize = t0; + this._load = t1; + this._nonCanonicalSchemes = t2; + }, + JSToDartAsyncImporter_canonicalize_closure: function JSToDartAsyncImporter_canonicalize_closure(t0, t1) { + this.$this = t0; + this.url = t1; + }, + JSToDartAsyncImporter_load_closure: function JSToDartAsyncImporter_load_closure(t0, t1) { + this.$this = t0; + this.url = t1; + }, + AsyncBuiltInCallable$mixin0($name, parameters, callback, acceptsContent, url) { + return new A.AsyncBuiltInCallable0($name, A.ScssParser$0("@mixin " + $name + "(" + parameters + ") {", url).parseParameterList$0(), new A.AsyncBuiltInCallable$mixin_closure0(callback), false); + }, + AsyncBuiltInCallable0: function AsyncBuiltInCallable0(t0, t1, t2, t3) { + var _ = this; + _.name = t0; + _._async_built_in0$_parameters = t1; + _._async_built_in0$_callback = t2; + _.acceptsContent = t3; + }, + AsyncBuiltInCallable$mixin_closure0: function AsyncBuiltInCallable$mixin_closure0(t0) { + this.callback = t0; + }, + AsyncBuiltInCallable_withDeprecationWarning_closure0: function AsyncBuiltInCallable_withDeprecationWarning_closure0(t0, t1, t2) { + this.$this = t0; + this.module = t1; + this.newName = t2; + }, + compileAsync0(path, charset, fatalDeprecations, functions, futureDeprecations, importCache, indentWidth, lineFeed, logger, nodeImporter, quietDeps, silenceDeprecations, sourceMap, style, syntax, useSpaces, verbose) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.CompileResult_2), + $async$returnValue, t3, t4, t0, stylesheet, result, t1, t2; + var $async$compileAsync0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = type$.Deprecation_3; + t2 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + if (silenceDeprecations != null) + t2.addAll$1(0, silenceDeprecations); + t3 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + if (fatalDeprecations != null) + t3.addAll$1(0, fatalDeprecations); + t4 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + if (futureDeprecations != null) + t4.addAll$1(0, futureDeprecations); + logger = new A.DeprecationProcessingLogger0(A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.int), logger, t2, t3, t4, !verbose); + logger.validate$0(); + t1 = nodeImporter == null; + if (t1) + t2 = syntax == null || syntax === A.Syntax_forPath0(path); + else + t2 = false; + $async$goto = t2 ? 3 : 5; + break; + case 3: + // then + if (importCache == null) + importCache = A.AsyncImportCache$none(); + t2 = $.$get$FilesystemImporter_cwd0(); + t3 = A.isNodeJs() ? self.process : null; + if (!J.$eq$(t3 == null ? null : J.get$platform$x(t3), "win32")) { + t3 = A.isNodeJs() ? self.process : null; + t3 = J.$eq$(t3 == null ? null : J.get$platform$x(t3), "darwin"); + } else + t3 = true; + if (t3) { + t3 = A.absolute(path, null, null, null, null, null, null, null, null, null, null, null, null, null, null); + t4 = $.$get$context(); + t3 = A._realCasePath0(t4.normalize$1(t3)); + } else { + t3 = $.$get$context(); + t4 = t3.canonicalize$1(0, path); + t0 = t4; + t4 = t3; + t3 = t0; + } + $async$goto = 6; + return A._asyncAwait(importCache.importCanonical$3$originalUrl(t2, t4.toUri$1(t3), t4.toUri$1(path)), $async$compileAsync0); + case 6: + // returning from await. + t4 = $async$result; + t4.toString; + stylesheet = t4; + // goto join + $async$goto = 4; + break; + case 5: + // else + t2 = A.readFile0(path); + t3 = syntax == null ? A.Syntax_forPath0(path) : syntax; + stylesheet = A.Stylesheet_Stylesheet$parse0(t2, t3, $.$get$context().toUri$1(path)); + case 4: + // join + $async$goto = 7; + return A._asyncAwait(A._compileStylesheet2(stylesheet, logger, importCache, nodeImporter, $.$get$FilesystemImporter_cwd0(), functions, style, useSpaces, indentWidth, lineFeed, quietDeps, sourceMap, charset), $async$compileAsync0); + case 7: + // returning from await. + result = $async$result; + logger.summarize$1$js(!t1); + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$compileAsync0, $async$completer); + }, + compileStringAsync0(source, charset, fatalDeprecations, functions, futureDeprecations, importCache, importer, indentWidth, lineFeed, logger, nodeImporter, quietDeps, silenceDeprecations, sourceMap, style, syntax, url, useSpaces, verbose) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.CompileResult_2), + $async$returnValue, t3, t4, stylesheet, result, t1, t2; + var $async$compileStringAsync0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = type$.Deprecation_3; + t2 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + if (silenceDeprecations != null) + t2.addAll$1(0, silenceDeprecations); + t3 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + if (fatalDeprecations != null) + t3.addAll$1(0, fatalDeprecations); + t4 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + if (futureDeprecations != null) + t4.addAll$1(0, futureDeprecations); + logger = new A.DeprecationProcessingLogger0(A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.int), logger, t2, t3, t4, !verbose); + logger.validate$0(); + stylesheet = A.Stylesheet_Stylesheet$parse0(source, syntax == null ? B.Syntax_SCSS_scss0 : syntax, url); + if (importer == null) + t1 = A.isBrowser() ? new A.NoOpImporter0() : $.$get$FilesystemImporter_cwd0(); + else + t1 = importer; + $async$goto = 3; + return A._asyncAwait(A._compileStylesheet2(stylesheet, logger, importCache, nodeImporter, t1, functions, style, useSpaces, indentWidth, lineFeed, quietDeps, sourceMap, charset), $async$compileStringAsync0); + case 3: + // returning from await. + result = $async$result; + logger.summarize$1$js(nodeImporter != null); + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$compileStringAsync0, $async$completer); + }, + _compileStylesheet2(stylesheet, logger, importCache, nodeImporter, importer, functions, style, useSpaces, indentWidth, lineFeed, quietDeps, sourceMap, charset) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.CompileResult_2), + $async$returnValue, evaluateResult, serializeResult, resultSourceMap; + var $async$_compileStylesheet2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if (nodeImporter != null) + A.WarnForDeprecation_warnForDeprecation0(logger, B.Deprecation_F8y, string$.The_le, null, null); + $async$goto = 3; + return A._asyncAwait(A._EvaluateVisitor$2(functions, importCache, logger, nodeImporter, quietDeps, sourceMap).run$2(0, importer, stylesheet), $async$_compileStylesheet2); + case 3: + // returning from await. + evaluateResult = $async$result; + serializeResult = A.serialize0(evaluateResult._1, charset, indentWidth, false, lineFeed, logger, sourceMap, style, useSpaces); + resultSourceMap = serializeResult._1; + if (resultSourceMap != null && importCache != null) + A.mapInPlace0(resultSourceMap.urls, new A._compileStylesheet_closure2(stylesheet, importCache)); + $async$returnValue = new A.CompileResult0(evaluateResult, serializeResult); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_compileStylesheet2, $async$completer); + }, + _compileStylesheet_closure2: function _compileStylesheet_closure2(t0, t1) { + this.stylesheet = t0; + this.importCache = t1; + }, + AsyncEnvironment$0() { + var t1 = type$.String, + t2 = type$.Module_AsyncCallable_2, + t3 = type$.AstNode_2, + t4 = type$.int, + t5 = type$.AsyncCallable_2, + t6 = type$.JSArray_Map_String_AsyncCallable_2; + return new A.AsyncEnvironment0(A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), A.LinkedHashMap_LinkedHashMap$_empty(t1, t3), A.LinkedHashMap_LinkedHashMap$_empty(t2, t3), A.LinkedHashMap_LinkedHashMap$_empty(t2, t3), null, null, A._setArrayType([], type$.JSArray_Module_AsyncCallable_2), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Value_2)], type$.JSArray_Map_String_Value_2), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, t3)], type$.JSArray_Map_String_AstNode_2), A.LinkedHashMap_LinkedHashMap$_empty(t1, t4), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, t5)], t6), A.LinkedHashMap_LinkedHashMap$_empty(t1, t4), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, t5)], t6), A.LinkedHashMap_LinkedHashMap$_empty(t1, t4), null); + }, + AsyncEnvironment$_0(_modules, _namespaceNodes, _globalModules, _importedModules, _forwardedModules, _nestedForwardedModules, _allModules, _variables, _variableNodes, _functions, _mixins, _content) { + var t1 = type$.String, + t2 = type$.int; + return new A.AsyncEnvironment0(_modules, _namespaceNodes, _globalModules, _importedModules, _forwardedModules, _nestedForwardedModules, _allModules, _variables, _variableNodes, A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), _functions, A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), _mixins, A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), _content); + }, + _EnvironmentModule__EnvironmentModule2(environment, css, preModuleComments, extensionStore, forwarded) { + var t1, t2, t3, t4, t5, t6, module, result, t7; + if (forwarded == null) + forwarded = B.Set_empty6; + t1 = type$.dynamic; + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t2 = type$.Module_AsyncCallable_2, t3 = type$.List_CssComment_2, t4 = A.MapExtensions_get_pairs0(preModuleComments, t2, t3), t4 = t4.get$iterator(t4), t5 = type$.CssComment_2; t4.moveNext$0();) { + t6 = t4.get$current(t4); + module = t6._0; + result = A.List_List$from(t6._1, false, t5); + result.$flags = 3; + t1.$indexSet(0, module, result); + } + t1 = A.ConstantMap_ConstantMap$from(t1, t2, t3); + t2 = A._EnvironmentModule__makeModulesByVariable2(forwarded); + t3 = A._EnvironmentModule__memberMap2(B.JSArray_methods.get$first(environment._async_environment0$_variables), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure17(), type$.Map_String_Value_2), type$.Value_2); + t4 = A._EnvironmentModule__memberMap2(B.JSArray_methods.get$first(environment._async_environment0$_variableNodes), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure18(), type$.Map_String_AstNode_2), type$.AstNode_2); + t5 = type$.Map_String_AsyncCallable_2; + t6 = type$.AsyncCallable_2; + t7 = A._EnvironmentModule__memberMap2(B.JSArray_methods.get$first(environment._async_environment0$_functions), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure19(), t5), t6); + t6 = A._EnvironmentModule__memberMap2(B.JSArray_methods.get$first(environment._async_environment0$_mixins), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure20(), t5), t6); + t5 = J.get$isNotEmpty$asx(css.get$children(css)) || preModuleComments.get$isNotEmpty(preModuleComments) || B.JSArray_methods.any$1(environment._async_environment0$_allModules, new A._EnvironmentModule__EnvironmentModule_closure21()); + return A._EnvironmentModule$_2(environment, css, t1, extensionStore, t2, t3, t4, t7, t6, t5, !extensionStore.get$isEmpty(extensionStore) || B.JSArray_methods.any$1(environment._async_environment0$_allModules, new A._EnvironmentModule__EnvironmentModule_closure22())); + }, + _EnvironmentModule__makeModulesByVariable2(forwarded) { + var modulesByVariable, t1, t2, t3, t4, t5; + if (forwarded.get$isEmpty(forwarded)) + return B.Map_empty17; + modulesByVariable = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.Module_AsyncCallable_2); + for (t1 = forwarded.get$iterator(forwarded); t1.moveNext$0();) { + t2 = t1.get$current(t1); + if (t2 instanceof A._EnvironmentModule2) { + for (t3 = t2._async_environment0$_modulesByVariable, t3 = t3.get$values(t3), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t5 = t4.get$variables(); + A.setAll0(modulesByVariable, t5.get$keys(t5), t4); + } + A.setAll0(modulesByVariable, J.get$keys$z(B.JSArray_methods.get$first(t2._async_environment0$_environment._async_environment0$_variables)), t2); + } else { + t3 = t2.get$variables(); + A.setAll0(modulesByVariable, t3.get$keys(t3), t2); + } + } + return modulesByVariable; + }, + _EnvironmentModule__memberMap2(localMap, otherMaps, $V) { + var t1, t2, t3; + localMap = new A.PublicMemberMapView0(localMap, $V._eval$1("PublicMemberMapView0<0>")); + if (otherMaps.get$isEmpty(otherMaps)) + return localMap; + t1 = A._setArrayType([], $V._eval$1("JSArray>")); + for (t2 = otherMaps.get$iterator(otherMaps); t2.moveNext$0();) { + t3 = t2.get$current(t2); + if (t3.get$isNotEmpty(t3)) + t1.push(t3); + } + t1.push(localMap); + if (t1.length === 1) + return localMap; + return A.MergedMapView$0(t1, type$.String, $V); + }, + _EnvironmentModule$_2(_environment, css, preModuleComments, extensionStore, _modulesByVariable, variables, variableNodes, functions, mixins, transitivelyContainsCss, transitivelyContainsExtensions) { + return new A._EnvironmentModule2(_environment._async_environment0$_allModules, variables, variableNodes, functions, mixins, extensionStore, css, preModuleComments, transitivelyContainsCss, transitivelyContainsExtensions, _environment, _modulesByVariable); + }, + AsyncEnvironment0: function AsyncEnvironment0(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14) { + var _ = this; + _._async_environment0$_modules = t0; + _._async_environment0$_namespaceNodes = t1; + _._async_environment0$_globalModules = t2; + _._async_environment0$_importedModules = t3; + _._async_environment0$_forwardedModules = t4; + _._async_environment0$_nestedForwardedModules = t5; + _._async_environment0$_allModules = t6; + _._async_environment0$_variables = t7; + _._async_environment0$_variableNodes = t8; + _._async_environment0$_variableIndices = t9; + _._async_environment0$_functions = t10; + _._async_environment0$_functionIndices = t11; + _._async_environment0$_mixins = t12; + _._async_environment0$_mixinIndices = t13; + _._async_environment0$_content = t14; + _._async_environment0$_inMixin = false; + _._async_environment0$_inSemiGlobalScope = true; + _._async_environment0$_lastVariableIndex = _._async_environment0$_lastVariableName = null; + }, + AsyncEnvironment__getVariableFromGlobalModule_closure0: function AsyncEnvironment__getVariableFromGlobalModule_closure0(t0) { + this.name = t0; + }, + AsyncEnvironment_setVariable_closure2: function AsyncEnvironment_setVariable_closure2(t0, t1) { + this.$this = t0; + this.name = t1; + }, + AsyncEnvironment_setVariable_closure3: function AsyncEnvironment_setVariable_closure3(t0) { + this.name = t0; + }, + AsyncEnvironment_setVariable_closure4: function AsyncEnvironment_setVariable_closure4(t0, t1) { + this.$this = t0; + this.name = t1; + }, + AsyncEnvironment__getFunctionFromGlobalModule_closure0: function AsyncEnvironment__getFunctionFromGlobalModule_closure0(t0) { + this.name = t0; + }, + AsyncEnvironment__getMixinFromGlobalModule_closure0: function AsyncEnvironment__getMixinFromGlobalModule_closure0(t0) { + this.name = t0; + }, + AsyncEnvironment_toModule_closure0: function AsyncEnvironment_toModule_closure0() { + }, + AsyncEnvironment_toDummyModule_closure0: function AsyncEnvironment_toDummyModule_closure0() { + }, + _EnvironmentModule2: function _EnvironmentModule2(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11) { + var _ = this; + _.upstream = t0; + _.variables = t1; + _.variableNodes = t2; + _.functions = t3; + _.mixins = t4; + _.extensionStore = t5; + _.css = t6; + _.preModuleComments = t7; + _.transitivelyContainsCss = t8; + _.transitivelyContainsExtensions = t9; + _._async_environment0$_environment = t10; + _._async_environment0$_modulesByVariable = t11; + }, + _EnvironmentModule__EnvironmentModule_closure17: function _EnvironmentModule__EnvironmentModule_closure17() { + }, + _EnvironmentModule__EnvironmentModule_closure18: function _EnvironmentModule__EnvironmentModule_closure18() { + }, + _EnvironmentModule__EnvironmentModule_closure19: function _EnvironmentModule__EnvironmentModule_closure19() { + }, + _EnvironmentModule__EnvironmentModule_closure20: function _EnvironmentModule__EnvironmentModule_closure20() { + }, + _EnvironmentModule__EnvironmentModule_closure21: function _EnvironmentModule__EnvironmentModule_closure21() { + }, + _EnvironmentModule__EnvironmentModule_closure22: function _EnvironmentModule__EnvironmentModule_closure22() { + }, + _EvaluateVisitor$2(functions, importCache, logger, nodeImporter, quietDeps, sourceMap) { + var t4, + t1 = type$.Uri, + t2 = type$.Module_AsyncCallable_2, + t3 = A._setArrayType([], type$.JSArray_Record_2_String_and_AstNode_2); + if (importCache == null) + t4 = nodeImporter == null ? A.AsyncImportCache$none() : null; + else + t4 = importCache; + t1 = new A._EvaluateVisitor2(t4, nodeImporter, A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.AsyncCallable_2), A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Configuration_2), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.AstNode_2), logger, A.LinkedHashSet_LinkedHashSet$_empty(type$.Record_2_String_and_SourceSpan), quietDeps, sourceMap, A.AsyncEnvironment$0(), A.LinkedHashSet_LinkedHashSet$_empty(t1), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.nullable_AstNode_2), t3, B.Configuration_Map_empty_null0); + t1._EvaluateVisitor$6$functions$importCache$logger$nodeImporter$quietDeps$sourceMap2(functions, importCache, logger, nodeImporter, quietDeps, sourceMap); + return t1; + }, + _EvaluateVisitor2: function _EvaluateVisitor2(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15) { + var _ = this; + _._async_evaluate0$_importCache = t0; + _._async_evaluate0$_nodeImporter = t1; + _._async_evaluate0$_builtInFunctions = t2; + _._async_evaluate0$_builtInModules = t3; + _._async_evaluate0$_modules = t4; + _._async_evaluate0$_moduleConfigurations = t5; + _._async_evaluate0$_moduleNodes = t6; + _._async_evaluate0$_logger = t7; + _._async_evaluate0$_warningsEmitted = t8; + _._async_evaluate0$_quietDeps = t9; + _._async_evaluate0$_sourceMap = t10; + _._async_evaluate0$_environment = t11; + _._async_evaluate0$_declarationName = _._async_evaluate0$__parent = _._async_evaluate0$_mediaQuerySources = _._async_evaluate0$_mediaQueries = _._async_evaluate0$_styleRuleIgnoringAtRoot = null; + _._async_evaluate0$_member = "root stylesheet"; + _._async_evaluate0$_importSpan = _._async_evaluate0$_callableNode = _._async_evaluate0$_currentCallable = null; + _._async_evaluate0$_inSupportsDeclaration = _._async_evaluate0$_inKeyframes = _._async_evaluate0$_atRootExcludingStyleRule = _._async_evaluate0$_inUnknownAtRule = _._async_evaluate0$_inFunction = false; + _._async_evaluate0$_loadedUrls = t12; + _._async_evaluate0$_activeModules = t13; + _._async_evaluate0$_stack = t14; + _._async_evaluate0$_importer = null; + _._async_evaluate0$_inDependency = false; + _._async_evaluate0$__extensionStore = _._async_evaluate0$_preModuleComments = _._async_evaluate0$_outOfOrderImports = _._async_evaluate0$__endOfImports = _._async_evaluate0$__root = _._async_evaluate0$__stylesheet = null; + _._async_evaluate0$_configuration = t15; + }, + _EvaluateVisitor_closure38: function _EvaluateVisitor_closure38(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure39: function _EvaluateVisitor_closure39(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure40: function _EvaluateVisitor_closure40(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure41: function _EvaluateVisitor_closure41(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure42: function _EvaluateVisitor_closure42(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure43: function _EvaluateVisitor_closure43(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure44: function _EvaluateVisitor_closure44(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure45: function _EvaluateVisitor_closure45(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure46: function _EvaluateVisitor_closure46(t0) { + this.$this = t0; + }, + _EvaluateVisitor__closure14: function _EvaluateVisitor__closure14(t0, t1, t2) { + this.$this = t0; + this.name = t1; + this.module = t2; + }, + _EvaluateVisitor_closure47: function _EvaluateVisitor_closure47(t0) { + this.$this = t0; + }, + _EvaluateVisitor__closure13: function _EvaluateVisitor__closure13(t0, t1, t2) { + this.$this = t0; + this.name = t1; + this.module = t2; + }, + _EvaluateVisitor_closure48: function _EvaluateVisitor_closure48(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure49: function _EvaluateVisitor_closure49(t0) { + this.$this = t0; + }, + _EvaluateVisitor__closure11: function _EvaluateVisitor__closure11(t0, t1, t2) { + this.values = t0; + this.span = t1; + this.callableNode = t2; + }, + _EvaluateVisitor__closure12: function _EvaluateVisitor__closure12(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure50: function _EvaluateVisitor_closure50(t0) { + this.$this = t0; + }, + _EvaluateVisitor_run_closure2: function _EvaluateVisitor_run_closure2(t0, t1, t2) { + this.$this = t0; + this.node = t1; + this.importer = t2; + }, + _EvaluateVisitor_run__closure2: function _EvaluateVisitor_run__closure2(t0, t1, t2) { + this.$this = t0; + this.importer = t1; + this.node = t2; + }, + _EvaluateVisitor__loadModule_closure5: function _EvaluateVisitor__loadModule_closure5(t0, t1) { + this._box_0 = t0; + this.callback = t1; + }, + _EvaluateVisitor__loadModule_closure6: function _EvaluateVisitor__loadModule_closure6(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.$this = t0; + _.url = t1; + _.nodeWithSpan = t2; + _.baseUrl = t3; + _.namesInErrors = t4; + _.configuration = t5; + _.callback = t6; + }, + _EvaluateVisitor__loadModule__closure5: function _EvaluateVisitor__loadModule__closure5(t0, t1) { + this.$this = t0; + this.message = t1; + }, + _EvaluateVisitor__loadModule__closure6: function _EvaluateVisitor__loadModule__closure6(t0, t1, t2) { + this._box_1 = t0; + this.callback = t1; + this.firstLoad = t2; + }, + _EvaluateVisitor__execute_closure2: function _EvaluateVisitor__execute_closure2(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.$this = t0; + _.importer = t1; + _.stylesheet = t2; + _.extensionStore = t3; + _.configuration = t4; + _.css = t5; + _.preModuleComments = t6; + }, + _EvaluateVisitor__combineCss_closure5: function _EvaluateVisitor__combineCss_closure5() { + }, + _EvaluateVisitor__combineCss_closure6: function _EvaluateVisitor__combineCss_closure6(t0) { + this.selectors = t0; + }, + _EvaluateVisitor__combineCss_visitModule2: function _EvaluateVisitor__combineCss_visitModule2(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.seen = t1; + _.clone = t2; + _.css = t3; + _.imports = t4; + _.sorted = t5; + }, + _EvaluateVisitor__extendModules_closure5: function _EvaluateVisitor__extendModules_closure5(t0) { + this.originalSelectors = t0; + }, + _EvaluateVisitor__extendModules_closure6: function _EvaluateVisitor__extendModules_closure6() { + }, + _EvaluateVisitor_visitAtRootRule_closure5: function _EvaluateVisitor_visitAtRootRule_closure5(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitAtRootRule_closure6: function _EvaluateVisitor_visitAtRootRule_closure6(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure17: function _EvaluateVisitor__scopeForAtRoot_closure17(t0, t1, t2) { + this.$this = t0; + this.newParent = t1; + this.node = t2; + }, + _EvaluateVisitor__scopeForAtRoot_closure18: function _EvaluateVisitor__scopeForAtRoot_closure18(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure19: function _EvaluateVisitor__scopeForAtRoot_closure19(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor__scopeForAtRoot__closure2: function _EvaluateVisitor__scopeForAtRoot__closure2(t0, t1) { + this.innerScope = t0; + this.callback = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure20: function _EvaluateVisitor__scopeForAtRoot_closure20(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure21: function _EvaluateVisitor__scopeForAtRoot_closure21() { + }, + _EvaluateVisitor__scopeForAtRoot_closure22: function _EvaluateVisitor__scopeForAtRoot_closure22(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor_visitContentRule_closure2: function _EvaluateVisitor_visitContentRule_closure2(t0, t1) { + this.$this = t0; + this.content = t1; + }, + _EvaluateVisitor_visitDeclaration_closure2: function _EvaluateVisitor_visitDeclaration_closure2(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + _EvaluateVisitor_visitEachRule_closure8: function _EvaluateVisitor_visitEachRule_closure8(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.nodeWithSpan = t2; + }, + _EvaluateVisitor_visitEachRule_closure9: function _EvaluateVisitor_visitEachRule_closure9(t0, t1, t2) { + this._box_1 = t0; + this.$this = t1; + this.nodeWithSpan = t2; + }, + _EvaluateVisitor_visitEachRule_closure10: function _EvaluateVisitor_visitEachRule_closure10(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.list = t1; + _.setVariables = t2; + _.node = t3; + }, + _EvaluateVisitor_visitEachRule__closure2: function _EvaluateVisitor_visitEachRule__closure2(t0, t1, t2) { + this.$this = t0; + this.setVariables = t1; + this.node = t2; + }, + _EvaluateVisitor_visitEachRule___closure2: function _EvaluateVisitor_visitEachRule___closure2(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitAtRule_closure8: function _EvaluateVisitor_visitAtRule_closure8(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitAtRule_closure9: function _EvaluateVisitor_visitAtRule_closure9(t0, t1, t2) { + this.$this = t0; + this.name = t1; + this.children = t2; + }, + _EvaluateVisitor_visitAtRule__closure2: function _EvaluateVisitor_visitAtRule__closure2(t0, t1) { + this.$this = t0; + this.children = t1; + }, + _EvaluateVisitor_visitAtRule_closure10: function _EvaluateVisitor_visitAtRule_closure10() { + }, + _EvaluateVisitor_visitForRule_closure14: function _EvaluateVisitor_visitForRule_closure14(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitForRule_closure15: function _EvaluateVisitor_visitForRule_closure15(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitForRule_closure16: function _EvaluateVisitor_visitForRule_closure16(t0) { + this.fromNumber = t0; + }, + _EvaluateVisitor_visitForRule_closure17: function _EvaluateVisitor_visitForRule_closure17(t0, t1) { + this.toNumber = t0; + this.fromNumber = t1; + }, + _EvaluateVisitor_visitForRule_closure18: function _EvaluateVisitor_visitForRule_closure18(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.node = t2; + _.from = t3; + _.direction = t4; + _.fromNumber = t5; + }, + _EvaluateVisitor_visitForRule__closure2: function _EvaluateVisitor_visitForRule__closure2(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitForwardRule_closure5: function _EvaluateVisitor_visitForwardRule_closure5(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitForwardRule_closure6: function _EvaluateVisitor_visitForwardRule_closure6(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__registerCommentsForModule_closure2: function _EvaluateVisitor__registerCommentsForModule_closure2() { + }, + _EvaluateVisitor_visitIfRule_closure2: function _EvaluateVisitor_visitIfRule_closure2(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitIfRule__closure2: function _EvaluateVisitor_visitIfRule__closure2(t0, t1) { + this.$this = t0; + this.clause = t1; + }, + _EvaluateVisitor_visitIfRule___closure2: function _EvaluateVisitor_visitIfRule___closure2(t0) { + this.$this = t0; + }, + _EvaluateVisitor__visitDynamicImport_closure2: function _EvaluateVisitor__visitDynamicImport_closure2(t0, t1) { + this.$this = t0; + this.$import = t1; + }, + _EvaluateVisitor__visitDynamicImport__closure11: function _EvaluateVisitor__visitDynamicImport__closure11(t0) { + this.$this = t0; + }, + _EvaluateVisitor__visitDynamicImport__closure12: function _EvaluateVisitor__visitDynamicImport__closure12() { + }, + _EvaluateVisitor__visitDynamicImport__closure13: function _EvaluateVisitor__visitDynamicImport__closure13() { + }, + _EvaluateVisitor__visitDynamicImport__closure14: function _EvaluateVisitor__visitDynamicImport__closure14(t0, t1, t2, t3, t4) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.loadsUserDefinedModules = t2; + _.environment = t3; + _.children = t4; + }, + _EvaluateVisitor__applyMixin_closure5: function _EvaluateVisitor__applyMixin_closure5(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.$arguments = t1; + _.mixin = t2; + _.nodeWithSpanWithoutContent = t3; + }, + _EvaluateVisitor__applyMixin__closure6: function _EvaluateVisitor__applyMixin__closure6(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.$arguments = t1; + _.mixin = t2; + _.nodeWithSpanWithoutContent = t3; + }, + _EvaluateVisitor__applyMixin_closure6: function _EvaluateVisitor__applyMixin_closure6(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.contentCallable = t1; + _.mixin = t2; + _.nodeWithSpanWithoutContent = t3; + }, + _EvaluateVisitor__applyMixin__closure5: function _EvaluateVisitor__applyMixin__closure5(t0, t1, t2) { + this.$this = t0; + this.mixin = t1; + this.nodeWithSpanWithoutContent = t2; + }, + _EvaluateVisitor__applyMixin___closure2: function _EvaluateVisitor__applyMixin___closure2(t0, t1, t2) { + this.$this = t0; + this.mixin = t1; + this.nodeWithSpanWithoutContent = t2; + }, + _EvaluateVisitor__applyMixin____closure2: function _EvaluateVisitor__applyMixin____closure2(t0, t1) { + this.$this = t0; + this.statement = t1; + }, + _EvaluateVisitor_visitIncludeRule_closure8: function _EvaluateVisitor_visitIncludeRule_closure8(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitIncludeRule_closure9: function _EvaluateVisitor_visitIncludeRule_closure9(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitIncludeRule_closure10: function _EvaluateVisitor_visitIncludeRule_closure10(t0) { + this.node = t0; + }, + _EvaluateVisitor_visitMediaRule_closure8: function _EvaluateVisitor_visitMediaRule_closure8(t0, t1) { + this.$this = t0; + this.queries = t1; + }, + _EvaluateVisitor_visitMediaRule_closure9: function _EvaluateVisitor_visitMediaRule_closure9(t0, t1, t2, t3, t4) { + var _ = this; + _.$this = t0; + _.mergedQueries = t1; + _.queries = t2; + _.mergedSources = t3; + _.node = t4; + }, + _EvaluateVisitor_visitMediaRule__closure2: function _EvaluateVisitor_visitMediaRule__closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitMediaRule___closure2: function _EvaluateVisitor_visitMediaRule___closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitMediaRule_closure10: function _EvaluateVisitor_visitMediaRule_closure10(t0) { + this.mergedSources = t0; + }, + _EvaluateVisitor_visitStyleRule_closure11: function _EvaluateVisitor_visitStyleRule_closure11(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitStyleRule_closure12: function _EvaluateVisitor_visitStyleRule_closure12() { + }, + _EvaluateVisitor_visitStyleRule_closure14: function _EvaluateVisitor_visitStyleRule_closure14(t0, t1, t2) { + this.$this = t0; + this.rule = t1; + this.node = t2; + }, + _EvaluateVisitor_visitStyleRule__closure2: function _EvaluateVisitor_visitStyleRule__closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitStyleRule_closure13: function _EvaluateVisitor_visitStyleRule_closure13() { + }, + _EvaluateVisitor__warnForBogusCombinators_closure2: function _EvaluateVisitor__warnForBogusCombinators_closure2() { + }, + _EvaluateVisitor_visitSupportsRule_closure5: function _EvaluateVisitor_visitSupportsRule_closure5(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitSupportsRule__closure2: function _EvaluateVisitor_visitSupportsRule__closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitSupportsRule_closure6: function _EvaluateVisitor_visitSupportsRule_closure6() { + }, + _EvaluateVisitor__visitSupportsCondition_closure2: function _EvaluateVisitor__visitSupportsCondition_closure2(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + _EvaluateVisitor_visitVariableDeclaration_closure8: function _EvaluateVisitor_visitVariableDeclaration_closure8(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.node = t2; + }, + _EvaluateVisitor_visitVariableDeclaration_closure9: function _EvaluateVisitor_visitVariableDeclaration_closure9(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitVariableDeclaration_closure10: function _EvaluateVisitor_visitVariableDeclaration_closure10(t0, t1, t2) { + this.$this = t0; + this.node = t1; + this.value = t2; + }, + _EvaluateVisitor_visitUseRule_closure2: function _EvaluateVisitor_visitUseRule_closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitWarnRule_closure2: function _EvaluateVisitor_visitWarnRule_closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitWhileRule_closure2: function _EvaluateVisitor_visitWhileRule_closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitWhileRule__closure2: function _EvaluateVisitor_visitWhileRule__closure2(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitBinaryOperationExpression_closure2: function _EvaluateVisitor_visitBinaryOperationExpression_closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__slash_recommendation2: function _EvaluateVisitor__slash_recommendation2() { + }, + _EvaluateVisitor_visitVariableExpression_closure2: function _EvaluateVisitor_visitVariableExpression_closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitUnaryOperationExpression_closure2: function _EvaluateVisitor_visitUnaryOperationExpression_closure2(t0, t1) { + this.node = t0; + this.operand = t1; + }, + _EvaluateVisitor_visitListExpression_closure2: function _EvaluateVisitor_visitListExpression_closure2(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitFunctionExpression_closure8: function _EvaluateVisitor_visitFunctionExpression_closure8(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitFunctionExpression_closure9: function _EvaluateVisitor_visitFunctionExpression_closure9() { + }, + _EvaluateVisitor_visitFunctionExpression_closure10: function _EvaluateVisitor_visitFunctionExpression_closure10(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.node = t2; + }, + _EvaluateVisitor__visitCalculation_closure2: function _EvaluateVisitor__visitCalculation_closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__checkCalculationArguments_check2: function _EvaluateVisitor__checkCalculationArguments_check2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__visitCalculationExpression_closure2: function _EvaluateVisitor__visitCalculationExpression_closure2(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.node = t2; + _.inLegacySassFunction = t3; + }, + _EvaluateVisitor__visitCalculationExpression__closure2: function _EvaluateVisitor__visitCalculationExpression__closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitInterpolatedFunctionExpression_closure2: function _EvaluateVisitor_visitInterpolatedFunctionExpression_closure2(t0, t1, t2) { + this.$this = t0; + this.node = t1; + this.$function = t2; + }, + _EvaluateVisitor__runUserDefinedCallable_closure2: function _EvaluateVisitor__runUserDefinedCallable_closure2(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.callable = t1; + _.evaluated = t2; + _.nodeWithSpan = t3; + _.run = t4; + _.V = t5; + }, + _EvaluateVisitor__runUserDefinedCallable__closure2: function _EvaluateVisitor__runUserDefinedCallable__closure2(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.evaluated = t1; + _.callable = t2; + _.nodeWithSpan = t3; + _.run = t4; + _.V = t5; + }, + _EvaluateVisitor__runUserDefinedCallable___closure2: function _EvaluateVisitor__runUserDefinedCallable___closure2(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.evaluated = t1; + _.callable = t2; + _.nodeWithSpan = t3; + _.run = t4; + _.V = t5; + }, + _EvaluateVisitor__runUserDefinedCallable____closure2: function _EvaluateVisitor__runUserDefinedCallable____closure2() { + }, + _EvaluateVisitor__runFunctionCallable_closure2: function _EvaluateVisitor__runFunctionCallable_closure2(t0, t1) { + this.$this = t0; + this.callable = t1; + }, + _EvaluateVisitor__runBuiltInCallable_closure8: function _EvaluateVisitor__runBuiltInCallable_closure8(t0, t1, t2) { + this._box_0 = t0; + this.evaluated = t1; + this.namedSet = t2; + }, + _EvaluateVisitor__runBuiltInCallable_closure9: function _EvaluateVisitor__runBuiltInCallable_closure9(t0, t1) { + this._box_0 = t0; + this.evaluated = t1; + }, + _EvaluateVisitor__runBuiltInCallable_closure10: function _EvaluateVisitor__runBuiltInCallable_closure10() { + }, + _EvaluateVisitor__evaluateArguments_closure11: function _EvaluateVisitor__evaluateArguments_closure11() { + }, + _EvaluateVisitor__evaluateArguments_closure12: function _EvaluateVisitor__evaluateArguments_closure12(t0, t1) { + this.$this = t0; + this.restNodeForSpan = t1; + }, + _EvaluateVisitor__evaluateArguments_closure13: function _EvaluateVisitor__evaluateArguments_closure13(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.named = t1; + _.restNodeForSpan = t2; + _.namedNodes = t3; + }, + _EvaluateVisitor__evaluateArguments_closure14: function _EvaluateVisitor__evaluateArguments_closure14() { + }, + _EvaluateVisitor__evaluateMacroArguments_closure11: function _EvaluateVisitor__evaluateMacroArguments_closure11(t0) { + this.restArgs = t0; + }, + _EvaluateVisitor__evaluateMacroArguments_closure12: function _EvaluateVisitor__evaluateMacroArguments_closure12(t0, t1, t2) { + this.$this = t0; + this.restNodeForSpan = t1; + this.restArgs = t2; + }, + _EvaluateVisitor__evaluateMacroArguments_closure13: function _EvaluateVisitor__evaluateMacroArguments_closure13(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.named = t1; + _.restNodeForSpan = t2; + _.restArgs = t3; + }, + _EvaluateVisitor__evaluateMacroArguments_closure14: function _EvaluateVisitor__evaluateMacroArguments_closure14(t0, t1, t2) { + this.$this = t0; + this.keywordRestNodeForSpan = t1; + this.keywordRestArgs = t2; + }, + _EvaluateVisitor__addRestMap_closure2: function _EvaluateVisitor__addRestMap_closure2(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.values = t1; + _.convert = t2; + _.expressionNode = t3; + _.map = t4; + _.nodeWithSpan = t5; + }, + _EvaluateVisitor__verifyArguments_closure2: function _EvaluateVisitor__verifyArguments_closure2(t0, t1, t2) { + this.parameters = t0; + this.positional = t1; + this.named = t2; + }, + _EvaluateVisitor_visitCssAtRule_closure5: function _EvaluateVisitor_visitCssAtRule_closure5(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssAtRule_closure6: function _EvaluateVisitor_visitCssAtRule_closure6() { + }, + _EvaluateVisitor_visitCssKeyframeBlock_closure5: function _EvaluateVisitor_visitCssKeyframeBlock_closure5(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssKeyframeBlock_closure6: function _EvaluateVisitor_visitCssKeyframeBlock_closure6() { + }, + _EvaluateVisitor_visitCssMediaRule_closure8: function _EvaluateVisitor_visitCssMediaRule_closure8(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssMediaRule_closure9: function _EvaluateVisitor_visitCssMediaRule_closure9(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.mergedQueries = t1; + _.node = t2; + _.mergedSources = t3; + }, + _EvaluateVisitor_visitCssMediaRule__closure2: function _EvaluateVisitor_visitCssMediaRule__closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssMediaRule___closure2: function _EvaluateVisitor_visitCssMediaRule___closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssMediaRule_closure10: function _EvaluateVisitor_visitCssMediaRule_closure10(t0) { + this.mergedSources = t0; + }, + _EvaluateVisitor_visitCssStyleRule_closure6: function _EvaluateVisitor_visitCssStyleRule_closure6(t0, t1, t2) { + this.$this = t0; + this.rule = t1; + this.node = t2; + }, + _EvaluateVisitor_visitCssStyleRule__closure2: function _EvaluateVisitor_visitCssStyleRule__closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssStyleRule_closure5: function _EvaluateVisitor_visitCssStyleRule_closure5() { + }, + _EvaluateVisitor_visitCssSupportsRule_closure5: function _EvaluateVisitor_visitCssSupportsRule_closure5(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssSupportsRule__closure2: function _EvaluateVisitor_visitCssSupportsRule__closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssSupportsRule_closure6: function _EvaluateVisitor_visitCssSupportsRule_closure6() { + }, + _EvaluateVisitor__performInterpolationHelper_closure2: function _EvaluateVisitor__performInterpolationHelper_closure2(t0) { + this.interpolation = t0; + }, + _EvaluateVisitor__serialize_closure2: function _EvaluateVisitor__serialize_closure2(t0, t1) { + this.value = t0; + this.quote = t1; + }, + _EvaluateVisitor__expressionNode_closure2: function _EvaluateVisitor__expressionNode_closure2(t0, t1) { + this.$this = t0; + this.expression = t1; + }, + _EvaluateVisitor__withoutSlash_recommendation2: function _EvaluateVisitor__withoutSlash_recommendation2() { + }, + _EvaluateVisitor__stackFrame_closure2: function _EvaluateVisitor__stackFrame_closure2(t0) { + this.$this = t0; + }, + _ImportedCssVisitor2: function _ImportedCssVisitor2(t0) { + this._async_evaluate0$_visitor = t0; + }, + _ImportedCssVisitor_visitCssAtRule_closure2: function _ImportedCssVisitor_visitCssAtRule_closure2() { + }, + _ImportedCssVisitor_visitCssMediaRule_closure2: function _ImportedCssVisitor_visitCssMediaRule_closure2(t0) { + this.hasBeenMerged = t0; + }, + _ImportedCssVisitor_visitCssStyleRule_closure2: function _ImportedCssVisitor_visitCssStyleRule_closure2() { + }, + _ImportedCssVisitor_visitCssSupportsRule_closure2: function _ImportedCssVisitor_visitCssSupportsRule_closure2() { + }, + _EvaluationContext2: function _EvaluationContext2(t0, t1) { + this._async_evaluate0$_visitor = t0; + this._async_evaluate0$_defaultWarnNodeWithSpan = t1; + }, + JSToDartAsyncFileImporter: function JSToDartAsyncFileImporter(t0) { + this._findFileUrl = t0; + }, + JSToDartAsyncFileImporter_canonicalize_closure: function JSToDartAsyncFileImporter_canonicalize_closure(t0, t1) { + this.$this = t0; + this.url = t1; + }, + AsyncImportCache$(importers, loadPaths, packageConfig) { + var t1 = type$.nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_2, + t2 = type$.Record_3_AsyncImporter_and_Uri_and_bool_forImport_2, + t3 = type$.Uri; + return new A.AsyncImportCache0(A.AsyncImportCache__toImporters0(importers, loadPaths, packageConfig), A.LinkedHashMap_LinkedHashMap$_empty(type$.Record_2_Uri_and_bool_forImport, t1), A.LinkedHashMap_LinkedHashMap$_empty(t2, t1), A.LinkedHashMap_LinkedHashMap$_empty(t2, t3), A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.nullable_Stylesheet_2), A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.ImporterResult_2), A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.DateTime)); + }, + AsyncImportCache$none() { + var t1 = type$.nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_2, + t2 = type$.Record_3_AsyncImporter_and_Uri_and_bool_forImport_2, + t3 = type$.Uri; + return new A.AsyncImportCache0(B.List_empty27, A.LinkedHashMap_LinkedHashMap$_empty(type$.Record_2_Uri_and_bool_forImport, t1), A.LinkedHashMap_LinkedHashMap$_empty(t2, t1), A.LinkedHashMap_LinkedHashMap$_empty(t2, t3), A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.nullable_Stylesheet_2), A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.ImporterResult_2), A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.DateTime)); + }, + AsyncImportCache__toImporters0(importers, loadPaths, packageConfig) { + var t1, t2, t3, t4, _i, path, _null = null, + sassPath = A.getEnvironmentVariable0("SASS_PATH"); + if (A.isBrowser()) { + t1 = A._setArrayType([], type$.JSArray_AsyncImporter); + if (importers != null) + B.JSArray_methods.addAll$1(t1, importers); + return t1; + } + t1 = A._setArrayType([], type$.JSArray_AsyncImporter); + if (importers != null) + B.JSArray_methods.addAll$1(t1, importers); + if (loadPaths != null) + for (t2 = J.get$iterator$ax(loadPaths); t2.moveNext$0();) { + t3 = t2.get$current(t2); + t1.push(new A.FilesystemImporter0($.$get$context().absolute$15(t3, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null), false)); + } + if (sassPath != null) { + t2 = A.isNodeJs() ? self.process : _null; + t3 = sassPath.split(J.$eq$(t2 == null ? _null : J.get$platform$x(t2), "win32") ? ";" : ":"); + t4 = t3.length; + _i = 0; + for (; _i < t4; ++_i) { + path = t3[_i]; + t1.push(new A.FilesystemImporter0($.$get$context().absolute$15(path, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null), false)); + } + } + return t1; + }, + AsyncImportCache0: function AsyncImportCache0(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._async_import_cache0$_importers = t0; + _._async_import_cache0$_canonicalizeCache = t1; + _._async_import_cache0$_perImporterCanonicalizeCache = t2; + _._async_import_cache0$_nonCanonicalRelativeUrls = t3; + _._async_import_cache0$_importCache = t4; + _._async_import_cache0$_resultsCache = t5; + _._async_import_cache0$_loadTimes = t6; + }, + AsyncImportCache_canonicalize_closure0: function AsyncImportCache_canonicalize_closure0(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.$this = t0; + _.baseImporter = t1; + _.resolvedUrl = t2; + _.baseUrl = t3; + _.forImport = t4; + _.key = t5; + _.url = t6; + }, + AsyncImportCache__canonicalize_closure0: function AsyncImportCache__canonicalize_closure0(t0, t1) { + this.importer = t0; + this.url = t1; + }, + AsyncImportCache_importCanonical_closure0: function AsyncImportCache_importCanonical_closure0(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.importer = t1; + _.canonicalUrl = t2; + _.originalUrl = t3; + }, + AsyncImportCache_humanize_closure3: function AsyncImportCache_humanize_closure3(t0) { + this.canonicalUrl = t0; + }, + AsyncImportCache_humanize_closure4: function AsyncImportCache_humanize_closure4() { + }, + AsyncImportCache_humanize_closure5: function AsyncImportCache_humanize_closure5() { + }, + AsyncImportCache_humanize_closure6: function AsyncImportCache_humanize_closure6(t0) { + this.canonicalUrl = t0; + }, + AtRootQueryParser0: function AtRootQueryParser0(t0, t1) { + this.scanner = t0; + this._parser1$_interpolationMap = t1; + }, + AtRootQueryParser_parse_closure0: function AtRootQueryParser_parse_closure0(t0) { + this.$this = t0; + }, + AtRootQuery0: function AtRootQuery0(t0, t1, t2, t3) { + var _ = this; + _.include = t0; + _.names = t1; + _._at_root_query0$_all = t2; + _._at_root_query0$_rule = t3; + }, + AtRootRule$0(children, span, query) { + var t1 = A.List_List$unmodifiable(children, type$.Statement_2), + t2 = B.JSArray_methods.any$1(t1, new A.ParentStatement_closure0()); + return new A.AtRootRule0(query, span, t1, t2); + }, + AtRootRule0: function AtRootRule0(t0, t1, t2, t3) { + var _ = this; + _.query = t0; + _.span = t1; + _.children = t2; + _.hasDeclarations = t3; + }, + ModifiableCssAtRule$0($name, span, childless, value) { + var t1 = A._setArrayType([], type$.JSArray_ModifiableCssNode_2); + return new A.ModifiableCssAtRule0($name, value, childless, span, new A.UnmodifiableListView(t1, type$.UnmodifiableListView_ModifiableCssNode_2), t1); + }, + ModifiableCssAtRule0: function ModifiableCssAtRule0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.name = t0; + _.value = t1; + _.isChildless = t2; + _.span = t3; + _.children = t4; + _._node$_children = t5; + _._node$_indexInParent = _._node$_parent = null; + _.isGroupEnd = false; + }, + AtRule$0($name, span, children, value) { + var t1 = children == null ? null : A.List_List$unmodifiable(children, type$.Statement_2), + t2 = t1 == null ? null : B.JSArray_methods.any$1(t1, new A.ParentStatement_closure0()); + return new A.AtRule0($name, value, span, t1, t2 === true); + }, + AtRule0: function AtRule0(t0, t1, t2, t3, t4) { + var _ = this; + _.name = t0; + _.value = t1; + _.span = t2; + _.children = t3; + _.hasDeclarations = t4; + }, + AttributeSelector0: function AttributeSelector0(t0, t1, t2, t3, t4) { + var _ = this; + _.name = t0; + _.op = t1; + _.value = t2; + _.modifier = t3; + _.span = t4; + }, + AttributeOperator0: function AttributeOperator0(t0, t1) { + this._attribute0$_text = t0; + this._name = t1; + }, + BinaryOperationExpression0: function BinaryOperationExpression0(t0, t1, t2, t3) { + var _ = this; + _.operator = t0; + _.left = t1; + _.right = t2; + _.allowsSlash = t3; + }, + BinaryOperator0: function BinaryOperator0(t0, t1, t2, t3, t4) { + var _ = this; + _.name = t0; + _.operator = t1; + _.precedence = t2; + _.isAssociative = t3; + _._name = t4; + }, + BooleanExpression0: function BooleanExpression0(t0, t1) { + this.value = t0; + this.span = t1; + }, + booleanClass_closure: function booleanClass_closure() { + }, + booleanClass__closure: function booleanClass__closure() { + }, + legacyBooleanClass_closure: function legacyBooleanClass_closure() { + }, + legacyBooleanClass__closure: function legacyBooleanClass__closure() { + }, + legacyBooleanClass__closure0: function legacyBooleanClass__closure0() { + }, + SassBoolean0: function SassBoolean0(t0) { + this.value = t0; + }, + Box0: function Box0(t0, t1) { + this._box0$_inner = t0; + this.$ti = t1; + }, + ModifiableBox0: function ModifiableBox0(t0, t1) { + this.value = t0; + this.$ti = t1; + }, + BuiltInCallable$function0($name, parameters, callback, url) { + return new A.BuiltInCallable0($name, A._setArrayType([new A._Record_2(A.ScssParser$0("@function " + $name + "(" + parameters + ") {", url).parseParameterList$0(), callback)], type$.JSArray_Record_2_ParameterList_and_Value_Function_List_Value_2), false); + }, + BuiltInCallable$mixin0($name, parameters, callback, acceptsContent, url) { + return new A.BuiltInCallable0($name, A._setArrayType([new A._Record_2(A.ScssParser$0("@mixin " + $name + "(" + parameters + ") {", url).parseParameterList$0(), new A.BuiltInCallable$mixin_closure0(callback))], type$.JSArray_Record_2_ParameterList_and_Value_Function_List_Value_2), acceptsContent); + }, + BuiltInCallable$overloadedFunction0($name, overloads) { + var t2, t3, t4, t5, t6, t7, args, callback, + t1 = A._setArrayType([], type$.JSArray_Record_2_ParameterList_and_Value_Function_List_Value_2); + for (t2 = type$.String, t3 = A.MapExtensions_get_pairs0(overloads, t2, type$.Value_Function_List_Value_2), t3 = t3.get$iterator(t3), t4 = "@function " + $name + "(", t5 = type$.FileSpan, t6 = type$.JSArray_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span_2; t3.moveNext$0();) { + t7 = t3.get$current(t3); + args = t7._0; + callback = t7._1; + t1.push(new A._Record_2(new A.ScssParser0(A.LinkedHashMap_LinkedHashMap$_empty(t2, t5), A._setArrayType([], t6), A.SpanScanner$(t4 + args + ") {", null), null).parseParameterList$0(), callback)); + } + return new A.BuiltInCallable0($name, t1, false); + }, + BuiltInCallable0: function BuiltInCallable0(t0, t1, t2) { + this.name = t0; + this._built_in$_overloads = t1; + this.acceptsContent = t2; + }, + BuiltInCallable$mixin_closure0: function BuiltInCallable$mixin_closure0(t0) { + this.callback = t0; + }, + BuiltInCallable_withDeprecationWarning_closure0: function BuiltInCallable_withDeprecationWarning_closure0(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.module = t2; + _.newName = t3; + }, + BuiltInModule$0($name, functions, mixins, variables, $T) { + var t1 = A._Uri__Uri(null, $name, null, "sass"), + t2 = A.BuiltInModule__callableMap0(functions, $T), + t3 = A.BuiltInModule__callableMap0(mixins, $T), + t4 = variables == null ? B.Map_empty15 : new A.UnmodifiableMapView(variables, type$.UnmodifiableMapView_String_Value_2); + return new A.BuiltInModule0(t1, t2, t3, t4, $T._eval$1("BuiltInModule0<0>")); + }, + BuiltInModule__callableMap0(callables, $T) { + var t2, _i, callable, + t1 = type$.String; + if (callables == null) + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, $T); + else { + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, $T); + for (t2 = callables.length, _i = 0; _i < callables.length; callables.length === t2 || (0, A.throwConcurrentModificationError)(callables), ++_i) { + callable = callables[_i]; + t1.$indexSet(0, callable.get$name(callable), callable); + } + t1 = new A.UnmodifiableMapView(t1, type$.$env_1_1_String._bind$1($T)._eval$1("UnmodifiableMapView<1,2>")); + } + return new A.UnmodifiableMapView(t1, type$.$env_1_1_String._bind$1($T)._eval$1("UnmodifiableMapView<1,2>")); + }, + BuiltInModule0: function BuiltInModule0(t0, t1, t2, t3, t4) { + var _ = this; + _.url = t0; + _.functions = t1; + _.mixins = t2; + _.variables = t3; + _.$ti = t4; + }, + _assertCalculationValue(arg) { + var t1; + $label0$0: { + if (!(arg instanceof A.SassNumber0)) + t1 = arg instanceof A.SassString0 && !arg._string0$_hasQuotes || arg instanceof A.SassCalculation0 || arg instanceof A.CalculationOperation0 || arg instanceof A.CalculationInterpolation; + else + t1 = true; + if (t1) { + t1 = null; + break $label0$0; + } + t1 = A.jsThrow0(new self.Error("Argument `" + A.S(arg) + "` must be one of SassNumber, unquoted SassString, SassCalculation, CalculationOperation, CalculationInterpolation")); + } + return t1; + }, + _isValidClampArg(arg) { + var t1; + $label0$0: { + if (!(arg instanceof A.CalculationInterpolation)) + t1 = arg instanceof A.SassString0 && !arg._string0$_hasQuotes; + else + t1 = true; + if (t1) + break $label0$0; + break $label0$0; + } + return t1; + }, + calculationClass_closure: function calculationClass_closure() { + }, + calculationClass__closure: function calculationClass__closure() { + }, + calculationClass__closure0: function calculationClass__closure0() { + }, + calculationClass__closure1: function calculationClass__closure1() { + }, + calculationClass__closure2: function calculationClass__closure2() { + }, + calculationClass__closure3: function calculationClass__closure3() { + }, + calculationClass__closure4: function calculationClass__closure4() { + }, + calculationClass__closure5: function calculationClass__closure5() { + }, + calculationOperationClass_closure: function calculationOperationClass_closure() { + }, + calculationOperationClass__closure: function calculationOperationClass__closure() { + }, + calculationOperationClass___closure: function calculationOperationClass___closure(t0) { + this.strOperator = t0; + }, + calculationOperationClass__closure0: function calculationOperationClass__closure0() { + }, + calculationOperationClass__closure1: function calculationOperationClass__closure1() { + }, + calculationOperationClass__closure2: function calculationOperationClass__closure2() { + }, + calculationOperationClass__closure3: function calculationOperationClass__closure3() { + }, + calculationOperationClass__closure4: function calculationOperationClass__closure4() { + }, + calculationInterpolationClass_closure: function calculationInterpolationClass_closure() { + }, + calculationInterpolationClass__closure: function calculationInterpolationClass__closure() { + }, + calculationInterpolationClass__closure0: function calculationInterpolationClass__closure0() { + }, + calculationInterpolationClass__closure1: function calculationInterpolationClass__closure1() { + }, + calculationInterpolationClass__closure2: function calculationInterpolationClass__closure2() { + }, + SassCalculation_calc0(argument) { + var t1, + _0_0 = A.SassCalculation__simplify0(argument); + $label0$0: { + if (_0_0 instanceof A.SassNumber0) { + t1 = _0_0; + break $label0$0; + } + if (_0_0 instanceof A.SassCalculation0) { + t1 = _0_0; + break $label0$0; + } + t1 = new A.SassCalculation0("calc", A.List_List$unmodifiable([_0_0], type$.Object)); + break $label0$0; + } + return t1; + }, + SassCalculation_min0($arguments) { + var minimum, _i, arg, t2, + args = A.List_List$unmodifiable(new A.MappedListIterable($arguments, A.calculation0_SassCalculation__simplify$closure(), A._arrayInstanceType($arguments)._eval$1("MappedListIterable<1,@>")), type$.Object), + t1 = args.length; + if (t1 === 0) + throw A.wrapException(A.ArgumentError$("min() must have at least one argument.", null)); + for (minimum = null, _i = 0; _i < t1; ++_i) { + arg = args[_i]; + if (arg instanceof A.SassNumber0) + t2 = minimum != null && !minimum.isComparableTo$1(arg); + else + t2 = true; + if (t2) { + minimum = null; + break; + } else if (minimum == null || minimum.greaterThan$1(arg).value) + minimum = arg; + } + if (minimum != null) + return minimum; + A.SassCalculation__verifyCompatibleNumbers0(args); + return new A.SassCalculation0("min", args); + }, + SassCalculation_max0($arguments) { + var maximum, _i, arg, t2, + args = A.List_List$unmodifiable(new A.MappedListIterable($arguments, A.calculation0_SassCalculation__simplify$closure(), A._arrayInstanceType($arguments)._eval$1("MappedListIterable<1,@>")), type$.Object), + t1 = args.length; + if (t1 === 0) + throw A.wrapException(A.ArgumentError$("max() must have at least one argument.", null)); + for (maximum = null, _i = 0; _i < t1; ++_i) { + arg = args[_i]; + if (arg instanceof A.SassNumber0) + t2 = maximum != null && !maximum.isComparableTo$1(arg); + else + t2 = true; + if (t2) { + maximum = null; + break; + } else if (maximum == null || maximum.lessThan$1(arg).value) + maximum = arg; + } + if (maximum != null) + return maximum; + A.SassCalculation__verifyCompatibleNumbers0(args); + return new A.SassCalculation0("max", args); + }, + SassCalculation_hypot0($arguments) { + var first, subtotal, i, number, value, t2, t3, + args = A.List_List$unmodifiable(new A.MappedListIterable($arguments, A.calculation0_SassCalculation__simplify$closure(), A._arrayInstanceType($arguments)._eval$1("MappedListIterable<1,@>")), type$.Object), + t1 = args.length; + if (t1 === 0) + throw A.wrapException(A.ArgumentError$("hypot() must have at least one argument.", null)); + A.SassCalculation__verifyCompatibleNumbers0(args); + first = B.JSArray_methods.get$first(args); + if (!(first instanceof A.SassNumber0) || first.hasUnit$1("%")) + return new A.SassCalculation0("hypot", args); + for (subtotal = 0, i = 0; i < t1;) { + number = args[i]; + if (!(number instanceof A.SassNumber0) || !number.hasCompatibleUnits$1(first)) + return new A.SassCalculation0("hypot", args); + ++i; + value = number.convertValueToMatch$3(first, "numbers[" + i + "]", "numbers[1]"); + subtotal += value * value; + } + t1 = Math.sqrt(subtotal); + t2 = J.getInterceptor$x(first); + t3 = t2.get$numeratorUnits(first); + return A.SassNumber_SassNumber$withUnits0(t1, t2.get$denominatorUnits(first), t3); + }, + SassCalculation_abs0(argument) { + argument = A.SassCalculation__simplify0(argument); + if (!(argument instanceof A.SassNumber0)) + return new A.SassCalculation0("abs", A._setArrayType([argument], type$.JSArray_Object)); + if (argument.hasUnit$1("%")) + A.warnForDeprecation0(string$.Passinp + argument.toString$0(0) + ")\nTo emit a CSS abs() now: abs(#{" + argument.toString$0(0) + string$.x7d__Mor, B.Deprecation_UYp); + return A.SassNumber_SassNumber0(Math.abs(argument._number1$_value), null).coerceToMatch$1(argument); + }, + SassCalculation_exp0(argument) { + argument = A.SassCalculation__simplify0(argument); + if (!(argument instanceof A.SassNumber0)) + return new A.SassCalculation0("exp", A._setArrayType([argument], type$.JSArray_Object)); + argument.assertNoUnits$0(); + return A.pow1(A.SassNumber_SassNumber0(2.718281828459045, null), argument); + }, + SassCalculation_sign0(argument) { + var t1, _0_2, t2, arg; + argument = A.SassCalculation__simplify0(argument); + $label0$0: { + t1 = argument instanceof A.SassNumber0; + if (t1) { + _0_2 = argument._number1$_value; + if (!isNaN(_0_2)) + t2 = 0 === _0_2; + else + t2 = true; + } else + t2 = false; + if (t2) { + t1 = argument; + break $label0$0; + } + if (t1) { + t1 = !argument.hasUnit$1("%"); + arg = argument; + } else { + arg = null; + t1 = false; + } + if (t1) { + t1 = A.SassNumber_SassNumber0(J.get$sign$in(arg._number1$_value), null).coerceToMatch$1(argument); + break $label0$0; + } + t1 = new A.SassCalculation0("sign", A._setArrayType([argument], type$.JSArray_Object)); + break $label0$0; + } + return t1; + }, + SassCalculation_clamp0(min, value, max) { + var t1, args; + if (value == null && max != null) + throw A.wrapException(A.ArgumentError$("If value is null, max must also be null.", null)); + min = A.SassCalculation__simplify0(min); + value = A.NullableExtension_andThen0(value, A.calculation0_SassCalculation__simplify$closure()); + max = A.NullableExtension_andThen0(max, A.calculation0_SassCalculation__simplify$closure()); + if (min instanceof A.SassNumber0 && value instanceof A.SassNumber0 && max instanceof A.SassNumber0 && min.hasCompatibleUnits$1(value) && min.hasCompatibleUnits$1(max)) { + if (value.lessThanOrEquals$1(min).value) + return min; + if (value.greaterThanOrEquals$1(max).value) + return max; + return value; + } + t1 = [min]; + if (value != null) + t1.push(value); + if (max != null) + t1.push(max); + args = A.List_List$unmodifiable(t1, type$.Object); + A.SassCalculation__verifyCompatibleNumbers0(args); + A.SassCalculation__verifyLength0(args, 3); + return new A.SassCalculation0("clamp", args); + }, + SassCalculation_pow0(base, exponent) { + var t1 = A._setArrayType([base], type$.JSArray_Object); + if (exponent != null) + t1.push(exponent); + A.SassCalculation__verifyLength0(t1, 2); + base = A.SassCalculation__simplify0(base); + exponent = A.NullableExtension_andThen0(exponent, A.calculation0_SassCalculation__simplify$closure()); + if (!(base instanceof A.SassNumber0) || !(exponent instanceof A.SassNumber0)) + return new A.SassCalculation0("pow", t1); + base.assertNoUnits$0(); + exponent.assertNoUnits$0(); + return A.pow1(base, exponent); + }, + SassCalculation_log0(number, base) { + var t1, t2; + number = A.SassCalculation__simplify0(number); + base = A.NullableExtension_andThen0(base, A.calculation0_SassCalculation__simplify$closure()); + t1 = A._setArrayType([number], type$.JSArray_Object); + t2 = base != null; + if (t2) + t1.push(base); + if (number instanceof A.SassNumber0) + t2 = t2 && !(base instanceof A.SassNumber0); + else + t2 = true; + if (t2) + return new A.SassCalculation0("log", t1); + number.assertNoUnits$0(); + if (base instanceof A.SassNumber0) { + base.assertNoUnits$0(); + return A.log0(number, base); + } + return A.log0(number, null); + }, + SassCalculation_atan20(y, x) { + var t1; + y = A.SassCalculation__simplify0(y); + x = A.NullableExtension_andThen0(x, A.calculation0_SassCalculation__simplify$closure()); + t1 = A._setArrayType([y], type$.JSArray_Object); + if (x != null) + t1.push(x); + A.SassCalculation__verifyLength0(t1, 2); + A.SassCalculation__verifyCompatibleNumbers0(t1); + if (!(y instanceof A.SassNumber0) || !(x instanceof A.SassNumber0) || y.hasUnit$1("%") || x.hasUnit$1("%") || !y.hasCompatibleUnits$1(x)) + return new A.SassCalculation0("atan2", t1); + return A.SassNumber_SassNumber$withUnits0(Math.atan2(y._number1$_value, x.convertValueToMatch$3(y, "x", "y")) * 57.29577951308232, null, A._setArrayType(["deg"], type$.JSArray_String)); + }, + SassCalculation_rem0(dividend, modulus) { + var t1, result; + dividend = A.SassCalculation__simplify0(dividend); + modulus = A.NullableExtension_andThen0(modulus, A.calculation0_SassCalculation__simplify$closure()); + t1 = A._setArrayType([dividend], type$.JSArray_Object); + if (modulus != null) + t1.push(modulus); + A.SassCalculation__verifyLength0(t1, 2); + A.SassCalculation__verifyCompatibleNumbers0(t1); + if (!(dividend instanceof A.SassNumber0) || !(modulus instanceof A.SassNumber0) || !dividend.hasCompatibleUnits$1(modulus)) + return new A.SassCalculation0("rem", t1); + result = dividend.modulo$1(modulus); + t1 = modulus._number1$_value; + if (A.DoubleWithSignedZero_get_signIncludingZero0(t1) !== A.DoubleWithSignedZero_get_signIncludingZero0(dividend._number1$_value)) { + if (t1 == 1 / 0 || t1 == -1 / 0) + return dividend; + if (result._number1$_value === 0) + return result.unaryMinus$0(); + return result.minus$1(modulus); + } + return result; + }, + SassCalculation_mod0(dividend, modulus) { + var t1; + dividend = A.SassCalculation__simplify0(dividend); + modulus = A.NullableExtension_andThen0(modulus, A.calculation0_SassCalculation__simplify$closure()); + t1 = A._setArrayType([dividend], type$.JSArray_Object); + if (modulus != null) + t1.push(modulus); + A.SassCalculation__verifyLength0(t1, 2); + A.SassCalculation__verifyCompatibleNumbers0(t1); + if (!(dividend instanceof A.SassNumber0) || !(modulus instanceof A.SassNumber0) || !dividend.hasCompatibleUnits$1(modulus)) + return new A.SassCalculation0("mod", t1); + return dividend.modulo$1(modulus); + }, + SassCalculation_roundInternal0(strategyOrNumber, numberOrStep, step, inLegacySassFunction, span, warn) { + var _0_8_isSet, _0_6_isSet, t2, _0_6_isSet0, _0_14_isSet, _0_14, _0_12, _0_16, _0_18, _0_18_isSet, _0_20, _0_20_isSet, strategy, _0_9_isSet0, _0_16_isSet, t3, t4, _0_12_isSet, _0_12_isSet0, rest, _null = null, _s5_ = "round", + _0_1 = A.SassCalculation__simplify0(strategyOrNumber), + _0_6 = A.NullableExtension_andThen0(numberOrStep, A.calculation0_SassCalculation__simplify$closure()), + _0_9 = A.NullableExtension_andThen0(step, A.calculation0_SassCalculation__simplify$closure()), + _0_10 = _0_1, + _0_8 = _null, + _0_60 = _null, + _0_100 = _null, + _0_10_isSet = false, + _0_90 = _null, + _0_9_isSet = false, + number = _null, + t1 = false; + if (_0_1 instanceof A.SassNumber0) { + type$.SassNumber_2._as(_0_10); + _0_8_isSet = !_0_10.get$hasUnits(); + if (_0_8_isSet) { + _0_8 = _0_6 == null; + _0_9_isSet = _0_8; + _0_60 = _0_6; + if (_0_9_isSet) { + _0_100 = _0_9 == null; + t1 = _0_100; + _0_90 = _0_9; + } + _0_10_isSet = _0_9_isSet; + number = _0_10; + } + _0_6_isSet = _0_8_isSet; + _0_1 = _0_10; + _0_10 = _0_100; + } else { + _0_1 = _0_10; + _0_10 = _0_100; + _0_8_isSet = false; + _0_6_isSet = false; + } + if (t1) + return A.SassNumber_SassNumber0(B.JSNumber_methods.round$0(number._number1$_value), _null); + t1 = false; + if (_0_1 instanceof A.SassNumber0) { + if (_0_8_isSet) + t2 = _0_8; + else { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_60 = t2; + _0_6_isSet = true; + } + _0_8 = t2 == null; + t2 = _0_8; + _0_8_isSet = true; + } + if (t2) { + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + _0_10_isSet = true; + } + t1 = t1 && inLegacySassFunction != null; + } + number = _0_1; + } else + number = _null; + if (t1) { + warn.call$2(string$.In_fut, B.Deprecation_ZDV); + t1 = B.JSNumber_methods.round$0(number._number1$_value); + t2 = number.get$numeratorUnits(number); + return A.SassNumber_SassNumber$withUnits0(t1, number.get$denominatorUnits(number), t2); + } + step = _null; + t1 = false; + if (_0_1 instanceof A.SassNumber0) { + _0_6_isSet0 = true; + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + if (t2 instanceof A.SassNumber0) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + type$.SassNumber_2._as(t2); + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + _0_10_isSet = true; + } + t1 = t1 && !_0_1.hasCompatibleUnits$1(t2); + step = t2; + } + number = _0_1; + } else + number = _null; + if (t1) { + t1 = type$.JSArray_Object; + A.SassCalculation__verifyCompatibleNumbers0(A._setArrayType([number, step], t1)); + return new A.SassCalculation0(_s5_, A._setArrayType([number, step], t1)); + } + step = _null; + t1 = false; + if (_0_1 instanceof A.SassNumber0) { + _0_6_isSet0 = true; + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + if (t2 instanceof A.SassNumber0) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + type$.SassNumber_2._as(t2); + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + _0_10_isSet = true; + } + step = t2; + } + number = _0_1; + } else + number = _null; + if (t1) { + A.SassCalculation__verifyCompatibleNumbers0(A._setArrayType([number, step], type$.JSArray_Object)); + return A.SassCalculation__roundWithStep0("nearest", number, step); + } + _0_14_isSet = _0_1 instanceof A.SassString0; + _0_14 = _null; + _0_12 = _null; + _0_16 = _null; + _0_18 = _null; + _0_18_isSet = false; + _0_20 = _null; + _0_20_isSet = false; + strategy = _null; + number = _null; + step = _null; + t1 = false; + if (_0_14_isSet) { + _0_6_isSet0 = true; + _0_9_isSet0 = true; + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_14 = "nearest" === t2; + t2 = _0_14; + _0_16_isSet = !t2; + t2 = true; + if (_0_16_isSet) { + _0_16 = "up" === _0_12; + t3 = _0_16; + _0_18_isSet = !t3; + if (_0_18_isSet) { + _0_18 = "down" === _0_12; + t3 = _0_18; + _0_20_isSet = !t3; + if (_0_20_isSet) { + _0_20 = "to-zero" === _0_12; + t2 = _0_20; + } + } + } + if (t2) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + if (t2 instanceof A.SassNumber0) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + t3 = type$.SassNumber_2; + t3._as(t2); + if (_0_9_isSet) + t4 = _0_90; + else { + t4 = _0_9; + _0_9_isSet = _0_9_isSet0; + _0_90 = t4; + } + if (t4 instanceof A.SassNumber0) { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_9_isSet = _0_9_isSet0; + _0_90 = t1; + } + t3._as(t1); + t3 = !t2.hasCompatibleUnits$1(t1); + step = t1; + t1 = t3; + } + number = t2; + } + strategy = _0_1; + } + } else + _0_16_isSet = false; + if (t1) { + t1 = type$.JSArray_Object; + A.SassCalculation__verifyCompatibleNumbers0(A._setArrayType([number, step], t1)); + return new A.SassCalculation0(_s5_, A._setArrayType([strategy, number, step], t1)); + } + strategy = _null; + number = _null; + step = _null; + t1 = false; + if (_0_1 instanceof A.SassString0) { + _0_6_isSet0 = true; + _0_9_isSet0 = true; + _0_12_isSet = true; + if (_0_14_isSet) { + t2 = _0_14; + _0_12_isSet0 = _0_14_isSet; + } else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_14 = "nearest" === t2; + t2 = _0_14; + _0_12_isSet0 = _0_12_isSet; + _0_14_isSet = true; + } + t3 = true; + if (!t2) { + if (_0_16_isSet) + t2 = _0_16; + else { + if (_0_12_isSet0) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet0 = _0_12_isSet; + } + _0_16 = "up" === t2; + t2 = _0_16; + _0_16_isSet = true; + } + if (!t2) { + if (_0_18_isSet) + t2 = _0_18; + else { + if (_0_12_isSet0) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet0 = _0_12_isSet; + } + _0_18 = "down" === t2; + t2 = _0_18; + _0_18_isSet = true; + } + if (!t2) + if (_0_20_isSet) { + t2 = _0_20; + _0_12_isSet = _0_12_isSet0; + } else { + if (_0_12_isSet0) { + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + } + _0_20 = "to-zero" === t2; + t2 = _0_20; + _0_20_isSet = true; + } + else { + t2 = t3; + _0_12_isSet = _0_12_isSet0; + } + } else { + t2 = t3; + _0_12_isSet = _0_12_isSet0; + } + } else { + t2 = t3; + _0_12_isSet = _0_12_isSet0; + } + if (t2) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + if (t2 instanceof A.SassNumber0) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + t3 = type$.SassNumber_2; + t3._as(t2); + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_9_isSet = _0_9_isSet0; + _0_90 = t1; + } + t1 = t1 instanceof A.SassNumber0; + if (t1) { + if (_0_9_isSet) + t4 = _0_90; + else { + t4 = _0_9; + _0_9_isSet = _0_9_isSet0; + _0_90 = t4; + } + t3._as(t4); + step = t4; + } + number = t2; + } + strategy = _0_1; + } + } else + _0_12_isSet = _0_14_isSet; + if (t1) { + A.SassCalculation__verifyCompatibleNumbers0(A._setArrayType([number, step], type$.JSArray_Object)); + return A.SassCalculation__roundWithStep0(strategy._string0$_text, number, step); + } + strategy = _null; + rest = _null; + t1 = false; + if (_0_1 instanceof A.SassString0) { + _0_6_isSet0 = true; + _0_12_isSet0 = true; + if (_0_14_isSet) + t2 = _0_14; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_14 = "nearest" === t2; + t2 = _0_14; + _0_14_isSet = true; + } + t3 = true; + if (!t2) { + if (_0_16_isSet) + t2 = _0_16; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_16 = "up" === t2; + t2 = _0_16; + _0_16_isSet = true; + } + if (!t2) { + if (_0_18_isSet) + t2 = _0_18; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_18 = "down" === t2; + t2 = _0_18; + _0_18_isSet = true; + } + if (!t2) + if (_0_20_isSet) + t2 = _0_20; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_20 = "to-zero" === t2; + t2 = _0_20; + _0_20_isSet = true; + } + else + t2 = t3; + } else + t2 = t3; + } else + t2 = t3; + if (t2) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + if (t2 instanceof A.SassString0) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + type$.SassString_2._as(t2); + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + _0_10_isSet = true; + } + rest = t2; + } + strategy = _0_1; + } + } + if (t1) + return new A.SassCalculation0(_s5_, A._setArrayType([strategy, rest], type$.JSArray_Object)); + t1 = false; + if (_0_1 instanceof A.SassString0) { + _0_12_isSet0 = true; + if (_0_14_isSet) + t2 = _0_14; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_14 = "nearest" === t2; + t2 = _0_14; + _0_14_isSet = true; + } + t3 = true; + if (!t2) { + if (_0_16_isSet) + t2 = _0_16; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_16 = "up" === t2; + t2 = _0_16; + _0_16_isSet = true; + } + if (!t2) { + if (_0_18_isSet) + t2 = _0_18; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_18 = "down" === t2; + t2 = _0_18; + _0_18_isSet = true; + } + if (!t2) + if (_0_20_isSet) + t2 = _0_20; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_20 = "to-zero" === t2; + t2 = _0_20; + _0_20_isSet = true; + } + else + t2 = t3; + } else + t2 = t3; + } else + t2 = t3; + if (t2) { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_60 = t2; + _0_6_isSet = true; + } + if (t2 != null) + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + _0_10_isSet = true; + } + } + } + if (t1) + throw A.wrapException(A.SassScriptException$0(string$.If_str, _null)); + t1 = false; + if (_0_1 instanceof A.SassString0) { + _0_12_isSet0 = true; + if (_0_14_isSet) + t2 = _0_14; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_14 = "nearest" === t2; + t2 = _0_14; + _0_14_isSet = true; + } + t3 = true; + if (!t2) { + if (_0_16_isSet) + t2 = _0_16; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_16 = "up" === t2; + t2 = _0_16; + _0_16_isSet = true; + } + if (!t2) { + if (_0_18_isSet) + t2 = _0_18; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_18 = "down" === t2; + t2 = _0_18; + _0_18_isSet = true; + } + if (!t2) + if (_0_20_isSet) + t2 = _0_20; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet = _0_12_isSet0; + } + _0_20 = "to-zero" === t2; + t2 = _0_20; + _0_20_isSet = true; + } + else + t2 = t3; + } else + t2 = t3; + } else + t2 = t3; + if (t2) { + if (_0_8_isSet) + t2 = _0_8; + else { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_60 = t2; + _0_6_isSet = true; + } + _0_8 = t2 == null; + t2 = _0_8; + _0_8_isSet = true; + } + if (t2) + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + _0_10_isSet = true; + } + } + } + if (t1) + throw A.wrapException(A.SassScriptException$0(string$.Number, _null)); + t1 = false; + if (_0_8_isSet) + t2 = _0_8; + else { + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_60 = t2; + _0_6_isSet = true; + } + _0_8 = t2 == null; + t2 = _0_8; + } + if (t2) + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + _0_10_isSet = true; + } + if (t1) + return new A.SassCalculation0(_s5_, A._setArrayType([_0_1], type$.JSArray_Object)); + step = _null; + t1 = false; + _0_6_isSet0 = true; + if (_0_6_isSet) + t2 = _0_60; + else { + t2 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t2; + } + if (t2 != null) { + if (_0_6_isSet) + step = _0_60; + else { + step = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = step; + } + if (step == null) + step = type$.Object._as(step); + if (_0_10_isSet) + t1 = _0_10; + else { + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_90 = t1; + _0_9_isSet = true; + } + _0_10 = t1 == null; + t1 = _0_10; + } + } + if (t1) + return new A.SassCalculation0(_s5_, A._setArrayType([_0_1, step], type$.JSArray_Object)); + if (_0_1 instanceof A.SassString0) { + t1 = true; + if (_0_14_isSet) + t2 = _0_14; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet = true; + } + _0_14 = "nearest" === t2; + t2 = _0_14; + } + if (!t2) { + if (_0_16_isSet) + t2 = _0_16; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet = true; + } + _0_16 = "up" === t2; + t2 = _0_16; + } + if (!t2) { + if (_0_18_isSet) + t2 = _0_18; + else { + if (_0_12_isSet) + t2 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t2 = _0_12; + _0_12_isSet = true; + } + _0_18 = "down" === t2; + t2 = _0_18; + } + if (!t2) + if (_0_20_isSet) + t1 = _0_20; + else { + if (_0_12_isSet) + t1 = _0_12; + else { + _0_12 = _0_1._string0$_text; + t1 = _0_12; + } + _0_20 = "to-zero" === t1; + t1 = _0_20; + } + } + } + } else + t1 = false; + if (!t1) + if (_0_1 instanceof A.SassString0) + t1 = _0_1.get$isVar(); + else + t1 = false; + else + t1 = true; + number = _null; + step = _null; + t2 = false; + if (t1) { + _0_6_isSet0 = true; + _0_9_isSet0 = true; + type$.SassString_2._as(_0_1); + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t1; + } + if (t1 != null) { + if (_0_6_isSet) + number = _0_60; + else { + number = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = number; + } + if (number == null) + number = type$.Object._as(number); + if (_0_9_isSet) + t1 = _0_90; + else { + t1 = _0_9; + _0_9_isSet = _0_9_isSet0; + _0_90 = t1; + } + t1 = t1 != null; + if (t1) { + if (_0_9_isSet) + step = _0_90; + else { + step = _0_9; + _0_9_isSet = _0_9_isSet0; + _0_90 = step; + } + if (step == null) + step = type$.Object._as(step); + } + } else + t1 = t2; + strategy = _0_1; + } else { + t1 = t2; + strategy = _null; + } + if (t1) + return new A.SassCalculation0(_s5_, A._setArrayType([strategy, number, step], type$.JSArray_Object)); + t1 = false; + if ((_0_6_isSet ? _0_60 : _0_6) != null) + t1 = (_0_9_isSet ? _0_90 : _0_9) != null; + if (t1) + throw A.wrapException(A.SassScriptException$0(A.S(strategyOrNumber) + string$.x20must_b, _null)); + t1 = A.SassScriptException$0("Invalid parameters.", _null); + throw A.wrapException(t1); + }, + SassCalculation_calcSize0(basis, value) { + var t1 = type$.JSArray_Object, + t2 = A._setArrayType([basis], t1); + if (value != null) + t2.push(value); + A.SassCalculation__verifyLength0(t2, 2); + basis = A.SassCalculation__simplify0(basis); + value = A.NullableExtension_andThen0(value, A.calculation0_SassCalculation__simplify$closure()); + t1 = A._setArrayType([basis], t1); + if (value != null) + t1.push(value); + return new A.SassCalculation0("calc-size", t1); + }, + SassCalculation_operateInternal0(operator, left, right, inLegacySassFunction, simplify, warn) { + var compatible, t1; + if (!simplify) + return new A.CalculationOperation0(operator, left, right); + left = A.SassCalculation__simplify0(left); + right = A.SassCalculation__simplify0(right); + if (B.CalculationOperator_F7i0 === operator || B.CalculationOperator_oum0 === operator) { + if (left instanceof A.SassNumber0 && right instanceof A.SassNumber0) { + compatible = left.hasCompatibleUnits$1(right); + if (!compatible && inLegacySassFunction != null && left.isComparableTo$1(right)) { + t1 = A.S(inLegacySassFunction); + warn.call$2("In future versions of Sass, " + t1 + "() will be interpreted as the CSS " + t1 + string$.x28__cal + t1 + string$.x28__ins, B.Deprecation_ZDV); + compatible = true; + } + if (compatible) + return operator === B.CalculationOperator_F7i0 ? left.plus$1(right) : left.minus$1(right); + } + A.SassCalculation__verifyCompatibleNumbers0(A._setArrayType([left, right], type$.JSArray_Object)); + if (right instanceof A.SassNumber0) { + t1 = right._number1$_value; + t1 = t1 < 0 && !A.fuzzyEquals0(t1, 0); + } else + t1 = false; + if (t1) { + right = right.times$1(A.SassNumber_SassNumber0(-1, null)); + operator = operator === B.CalculationOperator_F7i0 ? B.CalculationOperator_oum0 : B.CalculationOperator_F7i0; + } + return new A.CalculationOperation0(operator, left, right); + } else if (left instanceof A.SassNumber0 && right instanceof A.SassNumber0) + return operator === B.CalculationOperator_kkN0 ? left.times$1(right) : left.dividedBy$1(right); + else + return new A.CalculationOperation0(operator, left, right); + }, + SassCalculation__roundWithStep0(strategy, number, step) { + var _0_2, t1, _0_6, _0_8_isSet, _0_8, _0_9_isSet, _0_9, _0_11, _0_13, stepWithNumberUnit, t2, _null = null; + if (!A.LinkedHashSet_LinkedHashSet$_literal(["nearest", "up", "down", "to-zero"], type$.String).contains$1(0, strategy)) + throw A.wrapException(A.ArgumentError$(strategy + string$.x20must_b, _null)); + _0_2 = number._number1$_value; + if (_0_2 == 1 / 0 || _0_2 == -1 / 0) { + t1 = step._number1$_value; + t1 = t1 == 1 / 0 || t1 == -1 / 0; + } else + t1 = false; + if (!t1) { + t1 = step._number1$_value; + t1 = t1 === 0 || isNaN(_0_2) || isNaN(t1); + } else + t1 = true; + if (t1) { + t1 = number.get$numeratorUnits(number); + return A.SassNumber_SassNumber$withUnits0(0 / 0, number.get$denominatorUnits(number), t1); + } + if (_0_2 == 1 / 0 || _0_2 == -1 / 0) + return number; + t1 = step._number1$_value; + if (t1 == 1 / 0 || t1 == -1 / 0) { + $label0$0: { + if (0 === _0_2) { + t1 = number; + break $label0$0; + } + _0_6 = "nearest" === strategy; + t1 = _0_6; + _0_8_isSet = !t1; + _0_8 = _null; + if (_0_8_isSet) { + _0_8 = "to-zero" === strategy; + _0_9_isSet = _0_8; + } else + _0_9_isSet = true; + _0_9 = _null; + if (_0_9_isSet) { + _0_9 = _0_2 > 0; + t1 = _0_9; + } else + t1 = false; + if (t1) { + t1 = number.get$numeratorUnits(number); + t1 = A.SassNumber_SassNumber$withUnits0(0, number.get$denominatorUnits(number), t1); + break $label0$0; + } + if (!_0_6) + if (_0_8_isSet) + t1 = _0_8; + else { + _0_8 = "to-zero" === strategy; + t1 = _0_8; + } + else + t1 = true; + if (t1) { + t1 = number.get$numeratorUnits(number); + t1 = A.SassNumber_SassNumber$withUnits0(-0.0, number.get$denominatorUnits(number), t1); + break $label0$0; + } + _0_11 = "up" === strategy; + t1 = _0_11; + if (t1) + if (_0_9_isSet) + t1 = _0_9; + else { + _0_9 = _0_2 > 0; + t1 = _0_9; + } + else + t1 = false; + if (t1) { + t1 = number.get$numeratorUnits(number); + t1 = A.SassNumber_SassNumber$withUnits0(1 / 0, number.get$denominatorUnits(number), t1); + break $label0$0; + } + if (_0_11) { + t1 = number.get$numeratorUnits(number); + t1 = A.SassNumber_SassNumber$withUnits0(-0.0, number.get$denominatorUnits(number), t1); + break $label0$0; + } + _0_13 = "down" === strategy; + t1 = _0_13; + if (t1) + t1 = _0_2 < 0; + else + t1 = false; + if (t1) { + t1 = number.get$numeratorUnits(number); + t1 = A.SassNumber_SassNumber$withUnits0(-1 / 0, number.get$denominatorUnits(number), t1); + break $label0$0; + } + if (_0_13) { + t1 = number.get$numeratorUnits(number); + t1 = A.SassNumber_SassNumber$withUnits0(0, number.get$denominatorUnits(number), t1); + break $label0$0; + } + t1 = A.throwExpression(A.UnsupportedError$("Invalid argument: " + strategy + ".")); + } + return t1; + } + stepWithNumberUnit = step.convertValueToMatch$1(number); + $label1$1: { + if ("nearest" === strategy) { + t1 = B.JSNumber_methods.round$0(_0_2 / stepWithNumberUnit); + t2 = number.get$numeratorUnits(number); + t2 = A.SassNumber_SassNumber$withUnits0(t1 * stepWithNumberUnit, number.get$denominatorUnits(number), t2); + t1 = t2; + break $label1$1; + } + if ("up" === strategy) { + t2 = _0_2 / stepWithNumberUnit; + t1 = t1 < 0 ? B.JSNumber_methods.floor$0(t2) : B.JSNumber_methods.ceil$0(t2); + t2 = number.get$numeratorUnits(number); + t2 = A.SassNumber_SassNumber$withUnits0(t1 * stepWithNumberUnit, number.get$denominatorUnits(number), t2); + t1 = t2; + break $label1$1; + } + if ("down" === strategy) { + t2 = _0_2 / stepWithNumberUnit; + t1 = t1 < 0 ? B.JSNumber_methods.ceil$0(t2) : B.JSNumber_methods.floor$0(t2); + t2 = number.get$numeratorUnits(number); + t2 = A.SassNumber_SassNumber$withUnits0(t1 * stepWithNumberUnit, number.get$denominatorUnits(number), t2); + t1 = t2; + break $label1$1; + } + if ("to-zero" === strategy) { + t1 = _0_2 / stepWithNumberUnit; + if (_0_2 < 0) { + t1 = B.JSNumber_methods.ceil$0(t1); + t2 = number.get$numeratorUnits(number); + t2 = A.SassNumber_SassNumber$withUnits0(t1 * stepWithNumberUnit, number.get$denominatorUnits(number), t2); + t1 = t2; + } else { + t1 = B.JSNumber_methods.floor$0(t1); + t2 = number.get$numeratorUnits(number); + t2 = A.SassNumber_SassNumber$withUnits0(t1 * stepWithNumberUnit, number.get$denominatorUnits(number), t2); + t1 = t2; + } + break $label1$1; + } + t1 = number.get$numeratorUnits(number); + t1 = A.SassNumber_SassNumber$withUnits0(0 / 0, number.get$denominatorUnits(number), t1); + break $label1$1; + } + return t1; + }, + SassCalculation__simplify0(arg) { + var t1, t2, _0_11_isSet, _0_15, _0_12, _0_16_isSet, text, _0_11, _0_16, _0_12_isSet, _0_15_isSet, value, _null = null, + _s32_ = " can't be used in a calculation."; + $label0$0: { + if (arg instanceof A.SassNumber0 || arg instanceof A.CalculationOperation0) { + t1 = arg; + break $label0$0; + } + if (arg instanceof A.CalculationInterpolation) { + t1 = new A.SassString0("(" + arg._calculation0$_value + ")", false); + break $label0$0; + } + t1 = arg instanceof A.SassString0; + t2 = _null; + if (t1 && !arg._string0$_hasQuotes) { + t1 = arg; + break $label0$0; + } + if (t1) + A.throwExpression(A.SassScriptException$0("Quoted string " + arg.toString$0(0) + _s32_, _null)); + _0_11_isSet = arg instanceof A.SassCalculation0; + _0_15 = _null; + _0_12 = _null; + _0_16_isSet = false; + text = _null; + t1 = false; + if (_0_11_isSet) { + _0_11 = "calc" === arg.name; + if (_0_11) { + _0_12 = arg.$arguments; + _0_15 = _0_12.length === 1; + _0_16_isSet = _0_15; + if (_0_16_isSet) { + _0_16 = _0_12[0]; + t2 = _0_16; + if (t2 instanceof A.SassString0) { + type$.SassString_2._as(_0_16); + if (!_0_16._string0$_hasQuotes) { + text = _0_16._string0$_text; + t1 = A.SassCalculation__needsParentheses0(text); + } + } + } else + _0_16 = t2; + } else + _0_16 = t2; + _0_12_isSet = _0_11; + _0_15_isSet = _0_12_isSet; + } else { + _0_16 = t2; + _0_11 = _null; + _0_15_isSet = false; + _0_12_isSet = false; + } + if (t1) { + t1 = new A.SassString0("(" + A.S(text) + ")", false); + break $label0$0; + } + t1 = false; + if (_0_11_isSet) + if (_0_11) + if (_0_15_isSet) + t1 = _0_15; + else { + if (_0_12_isSet) + t1 = _0_12; + else { + _0_12 = arg.$arguments; + t1 = _0_12; + _0_12_isSet = true; + } + _0_15 = t1.length === 1; + t1 = _0_15; + } + if (t1) { + if (_0_16_isSet) + value = _0_16; + else { + _0_16 = (_0_12_isSet ? _0_12 : arg.$arguments)[0]; + value = _0_16; + } + t1 = value; + break $label0$0; + } + if (_0_11_isSet) { + t1 = arg; + break $label0$0; + } + if (arg instanceof A.Value0) + A.throwExpression(A.SassScriptException$0("Value " + arg.toString$0(0) + _s32_, _null)); + t1 = A.throwExpression(A.ArgumentError$("Unexpected calculation argument " + A.S(arg) + ".", _null)); + } + return t1; + }, + SassCalculation__needsParentheses0(text) { + var t1, couldBeVar, second, third, fourth, i, t2, + first = text.charCodeAt(0); + if (first === 32 || first === 9 || first === 10 || first === 13 || first === 12 || first === 47 || first === 42) + return true; + t1 = text.length; + couldBeVar = t1 >= 4 && A.characterEqualsIgnoreCase0(first, 118); + if (t1 < 2) + return false; + second = text.charCodeAt(1); + if (second === 32 || second === 9 || second === 10 || second === 13 || second === 12 || second === 47 || second === 42) + return true; + couldBeVar = couldBeVar && A.characterEqualsIgnoreCase0(second, 97); + if (t1 < 3) + return false; + third = text.charCodeAt(2); + if (third === 32 || third === 9 || third === 10 || third === 13 || third === 12 || third === 47 || third === 42) + return true; + couldBeVar = couldBeVar && A.characterEqualsIgnoreCase0(third, 114); + if (t1 < 4) + return false; + fourth = text.charCodeAt(3); + if (couldBeVar && fourth === 40) + return true; + if (fourth === 32 || fourth === 9 || fourth === 10 || fourth === 13 || fourth === 12 || fourth === 47 || fourth === 42) + return true; + for (i = 4; i < t1; ++i) { + t2 = text.charCodeAt(i); + if (t2 === 32 || t2 === 9 || t2 === 10 || t2 === 13 || t2 === 12 || t2 === 47 || t2 === 42) + return true; + } + return false; + }, + SassCalculation__verifyCompatibleNumbers0(args) { + var t1, _i, t2, arg, i, number1, j, number2; + for (t1 = args.length, _i = 0; t2 = args.length, _i < t2; args.length === t1 || (0, A.throwConcurrentModificationError)(args), ++_i) { + arg = args[_i]; + if (arg instanceof A.SassNumber0 && arg.get$hasComplexUnits()) + throw A.wrapException(A.SassScriptException$0("Number " + A.S(arg) + " isn't compatible with CSS calculations.", null)); + } + for (t1 = t2, i = 0; i < t1 - 1; ++i) { + number1 = args[i]; + if (!(number1 instanceof A.SassNumber0)) + continue; + for (j = i + 1; t1 = args.length, j < t1; ++j) { + number2 = args[j]; + if (!(number2 instanceof A.SassNumber0)) + continue; + if (number1.hasPossiblyCompatibleUnits$1(number2)) + continue; + throw A.wrapException(A.SassScriptException$0(number1.toString$0(0) + " and " + number2.toString$0(0) + " are incompatible.", null)); + } + } + }, + SassCalculation__verifyLength0(args, expectedLength) { + var t1; + if (args.length === expectedLength) + return; + if (B.JSArray_methods.any$1(args, new A.SassCalculation__verifyLength_closure0())) + return; + t1 = args.length; + throw A.wrapException(A.SassScriptException$0("" + expectedLength + " arguments required, but only " + t1 + " " + A.pluralize0("was", t1, "were") + " passed.", null)); + }, + SassCalculation__singleArgument0($name, argument, mathFunc, forbidUnits) { + argument = A.SassCalculation__simplify0(argument); + if (!(argument instanceof A.SassNumber0)) + return new A.SassCalculation0($name, A._setArrayType([argument], type$.JSArray_Object)); + if (forbidUnits) + argument.assertNoUnits$0(); + return mathFunc.call$1(argument); + }, + SassCalculation0: function SassCalculation0(t0, t1) { + this.name = t0; + this.$arguments = t1; + }, + SassCalculation__verifyLength_closure0: function SassCalculation__verifyLength_closure0() { + }, + CalculationOperation0: function CalculationOperation0(t0, t1, t2) { + this._calculation0$_operator = t0; + this._calculation0$_left = t1; + this._calculation0$_right = t2; + }, + CalculationOperator0: function CalculationOperator0(t0, t1, t2, t3) { + var _ = this; + _.name = t0; + _.operator = t1; + _.precedence = t2; + _._name = t3; + }, + CalculationInterpolation: function CalculationInterpolation(t0) { + this._calculation0$_value = t0; + }, + CallableDeclaration0: function CallableDeclaration0() { + }, + updateCanonicalizeContextPrototype() { + var t1 = type$.JSClass._as(new A.CanonicalizeContext0(false, null).constructor); + A.LinkedHashMap_LinkedHashMap$_literal(["fromImport", new A.updateCanonicalizeContextPrototype_closure(), "containingUrl", new A.updateCanonicalizeContextPrototype_closure0()], type$.String, type$.Function).forEach$1(0, A.JSClassExtension_get_defineGetter(t1)); + return null; + }, + updateCanonicalizeContextPrototype_closure: function updateCanonicalizeContextPrototype_closure() { + }, + updateCanonicalizeContextPrototype_closure0: function updateCanonicalizeContextPrototype_closure0() { + }, + CanonicalizeContext0: function CanonicalizeContext0(t0, t1) { + this._canonicalize_context$_fromImport = t0; + this._canonicalize_context$_containingUrl = t1; + this._canonicalize_context$_wasContainingUrlAccessed = false; + }, + ColorChannel0: function ColorChannel0(t0, t1, t2) { + this.name = t0; + this.isPolarAngle = t1; + this.associatedUnit = t2; + }, + LinearChannel0: function LinearChannel0(t0, t1, t2, t3, t4, t5, t6, t7) { + var _ = this; + _.min = t0; + _.max = t1; + _.requiresPercent = t2; + _.lowerClamped = t3; + _.upperClamped = t4; + _.name = t5; + _.isPolarAngle = t6; + _.associatedUnit = t7; + }, + Chokidar0: function Chokidar0() { + }, + ChokidarOptions0: function ChokidarOptions0() { + }, + ChokidarWatcher0: function ChokidarWatcher0() { + }, + ClassSelector0: function ClassSelector0(t0, t1) { + this.name = t0; + this.span = t1; + }, + ClipGamutMap0: function ClipGamutMap0(t0) { + this.name = t0; + }, + cloneCssStylesheet0(stylesheet, extensionStore) { + var _0_0 = extensionStore.clone$0(); + return new A._Record_2(new A._CloneCssVisitor0(_0_0._1)._clone_css$_visitChildren$2(A.ModifiableCssStylesheet$0(stylesheet.get$span(stylesheet)), stylesheet), _0_0._0); + }, + _CloneCssVisitor0: function _CloneCssVisitor0(t0) { + this._clone_css$_oldToNewSelectors = t0; + }, + ColorExpression0: function ColorExpression0(t0, t1) { + this.value = t0; + this.span = t1; + }, + _invert0($arguments, global) { + var t2, color, rgb, channel2, space, weight, inSpace, t3, _1_9, channel0, channel1, t4, _s6_ = "weight", _s5_ = "space", + t1 = J.getInterceptor$asx($arguments), + weightNumber = t1.$index($arguments, 1).assertNumber$1(_s6_); + if (!(t1.$index($arguments, 0) instanceof A.SassNumber0)) + t2 = global && t1.$index($arguments, 0).get$isSpecialNumber(); + else + t2 = true; + if (t2) { + if (weightNumber._number1$_value !== 100 || !weightNumber.hasUnit$1("%")) + throw A.wrapException(string$.Only_oa); + return A._functionString0("invert", t1.take$1($arguments, 1)); + } + color = t1.$index($arguments, 0).assertColor$1("color"); + if (t1.$index($arguments, 2).$eq(0, B.C__SassNull0)) { + t1 = color._color0$_space; + if (!t1.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0(string$.To_usei + color.toString$0(0) + ", you must provide a $space.", "color")); + A._checkPercent0(weightNumber, _s6_); + rgb = color.toSpace$1(B.RgbColorSpace_i0P0); + channel2 = B.LinearChannel_vJ30; + return A._mixLegacy0(A.SassColor_SassColor$rgbInternal0(A._invertChannel0(rgb, B.LinearChannel_qXC0, rgb.channel0OrNull), A._invertChannel0(rgb, B.LinearChannel_Z5r0, rgb.channel1OrNull), A._invertChannel0(rgb, channel2, rgb.channel2OrNull), color.alphaOrNull, null), color, weightNumber).toSpace$1(t1); + } + t1 = t1.$index($arguments, 2).assertString$1(_s5_); + t1.assertUnquoted$1(_s5_); + space = A.ColorSpace_fromName0(t1._string0$_text, _s5_); + weight = weightNumber.valueInRangeWithUnit$4(0, 100, _s6_, "%") / 100; + if (A.fuzzyEquals0(weight, 0)) + return color; + inSpace = color.toSpace$1(space); + $label0$0: { + if (B.HwbColorSpace_guQ0 === space) { + t1 = A._invertChannel0(inSpace, space._space$_channels[0], inSpace.channel0OrNull); + t2 = inSpace.alphaOrNull; + if (t2 == null) + t2 = 0; + t2 = A.SassColor_SassColor$hwb0(t1, inSpace.channel2OrNull, inSpace.channel1OrNull, t2); + t1 = t2; + break $label0$0; + } + if (B.HslColorSpace_JQ20 === space || B.LchColorSpace_Bpv0 === space || B.OklchColorSpace_9Gj0 === space) { + t1 = space._space$_channels; + t2 = A._invertChannel0(inSpace, t1[0], inSpace.channel0OrNull); + t1 = A._invertChannel0(inSpace, t1[2], inSpace.channel2OrNull); + t3 = inSpace.alphaOrNull; + if (t3 == null) + t3 = 0; + t3 = A.SassColor_SassColor$forSpaceInternal0(space, t2, inSpace.channel1OrNull, t1, t3); + t1 = t3; + break $label0$0; + } + _1_9 = space._space$_channels; + channel0 = _1_9[0]; + channel1 = _1_9[1]; + channel2 = _1_9[2]; + t1 = A._invertChannel0(inSpace, channel0, inSpace.channel0OrNull); + t2 = A._invertChannel0(inSpace, channel1, inSpace.channel1OrNull); + t3 = A._invertChannel0(inSpace, channel2, inSpace.channel2OrNull); + t4 = inSpace.alphaOrNull; + t1 = A.SassColor_SassColor$forSpaceInternal0(space, t1, t2, t3, t4 == null ? 0 : t4); + break $label0$0; + } + return A.fuzzyEquals0(weight, 1) ? t1.toSpace$2$legacyMissing(color._color0$_space, false) : color.interpolate$4$legacyMissing$weight(t1, A.InterpolationMethod$0(space, null), false, 1 - weight); + }, + _invertChannel0(color, channel, value) { + var _0_2_isSet, _0_2, t1; + if (value == null) + A._missingChannelError0(color, channel.name); + $label0$0: { + _0_2_isSet = channel instanceof A.LinearChannel0; + if (_0_2_isSet) { + _0_2 = channel.min; + t1 = _0_2 < 0; + } else { + _0_2 = null; + t1 = false; + } + if (t1) { + t1 = -value; + break $label0$0; + } + if (_0_2_isSet) + t1 = 0 === _0_2; + else + t1 = false; + if (t1) { + t1 = channel.max - value; + break $label0$0; + } + if (channel.isPolarAngle) { + t1 = B.JSNumber_methods.$mod(value + 180, 360); + break $label0$0; + } + t1 = A.throwExpression(A.UnsupportedError$("Unknown channel " + channel.toString$0(0) + ".")); + } + return t1; + }, + _grayscale0(colorArg) { + var hsl, t2, oklch, + color = colorArg.assertColor$1("color"), + t1 = color._color0$_space; + if (t1.get$isLegacyInternal()) { + hsl = color.toSpace$1(B.HslColorSpace_JQ20); + t2 = hsl.alphaOrNull; + if (t2 == null) + t2 = 0; + return A.SassColor_SassColor$hsl0(hsl.channel0OrNull, 0, hsl.channel2OrNull, t2).toSpace$2$legacyMissing(t1, false); + } else { + oklch = color.toSpace$1(B.OklchColorSpace_9Gj0); + t2 = oklch.alphaOrNull; + if (t2 == null) + t2 = 0; + return A.SassColor_SassColor$forSpaceInternal0(B.OklchColorSpace_9Gj0, oklch.channel0OrNull, 0, oklch.channel2OrNull, t2).toSpace$1(t1); + } + }, + _updateComponents0($arguments, adjust, change, scale) { + var t2, t3, keywords, originalColor, spaceKeyword, alphaArg, color, channelArgs, channelInfo, t4, value, channelIndex, result, i, alphaNumber, _null = null, _s5_ = "space", + t1 = J.getInterceptor$asx($arguments), + argumentList = type$.SassArgumentList_2._as(t1.$index($arguments, 1)); + if (argumentList._list1$_contents.length !== 0) + throw A.wrapException(A.SassScriptException$0(string$.Only_op, _null)); + argumentList._argument_list$_wereKeywordsAccessed = true; + t2 = type$.String; + t3 = type$.Value_2; + keywords = A.LinkedHashMap_LinkedHashMap$of(argumentList._argument_list$_keywords, t2, t3); + originalColor = t1.$index($arguments, 0).assertColor$1("color"); + t1 = keywords.remove$1(0, _s5_); + spaceKeyword = t1 == null ? _null : t1.assertString$1(_s5_); + if (spaceKeyword == null) + spaceKeyword = _null; + else + spaceKeyword.assertUnquoted$1(_s5_); + alphaArg = keywords.remove$1(0, "alpha"); + t1 = spaceKeyword == null; + if (t1 && originalColor._color0$_space.get$isLegacyInternal() && keywords.__js_helper$_length !== 0) { + t1 = A.NullableExtension_andThen0(A._sniffLegacyColorSpace0(keywords), new A._updateComponents_closure1(originalColor)); + color = t1 == null ? originalColor : t1; + } else + color = A._colorInSpace0(originalColor, t1 ? B.C__SassNull0 : spaceKeyword, true); + channelArgs = A.List_List$filled(color.get$channels().length, _null, false, type$.nullable_Value_2); + t1 = color._color0$_space; + channelInfo = t1._space$_channels; + for (t2 = A.MapExtensions_get_pairs0(keywords, t2, t3), t2 = t2.get$iterator(t2); t2.moveNext$0();) { + t3 = {}; + t4 = t2.get$current(t2); + t3.name = null; + t3.name = t4._0; + value = t4._1; + channelIndex = B.JSArray_methods.indexWhere$1(channelInfo, new A._updateComponents_closure2(t3)); + if (channelIndex === -1) + throw A.wrapException(A.SassScriptException$0("Color space " + t1.toString$0(0) + " doesn't have a channel with this name.", t3.name)); + channelArgs[channelIndex] = value; + } + if (change) + result = A._changeColor0(color, channelArgs, alphaArg); + else { + t2 = A._setArrayType([], type$.JSArray_nullable_SassNumber_2); + for (i = 0; i < 3; ++i) { + t3 = channelArgs[i]; + t2.push(t3 == null ? _null : t3.assertNumber$1(channelInfo[i].name)); + } + alphaNumber = alphaArg == null ? _null : alphaArg.assertNumber$1("alpha"); + result = scale ? A.SassColor_SassColor$forSpaceInternal0(t1, A._scaleChannel0(color, channelInfo[0], color.channel0OrNull, t2[0]), A._scaleChannel0(color, channelInfo[1], color.channel1OrNull, t2[1]), A._scaleChannel0(color, channelInfo[2], color.channel2OrNull, t2[2]), A._scaleChannel0(color, B.LinearChannel_XL80, color.alphaOrNull, alphaNumber)) : A._adjustColor0(color, t2, alphaNumber); + } + return result.toSpace$2$legacyMissing(originalColor._color0$_space, false); + }, + _changeColor0(color, channelArgs, alphaArg) { + var t4, _s5_ = "alpha", + t1 = A._channelForChange0(channelArgs[0], color, 0), + t2 = A._channelForChange0(channelArgs[1], color, 1), + t3 = A._channelForChange0(channelArgs[2], color, 2); + $label0$0: { + if (alphaArg == null) { + t4 = color.alphaOrNull; + if (t4 == null) + t4 = 0; + break $label0$0; + } + t4 = A._isNone0(alphaArg); + if (t4) { + t4 = null; + break $label0$0; + } + t4 = alphaArg instanceof A.SassNumber0; + if (t4 && !alphaArg.get$hasUnits()) { + t4 = alphaArg.valueInRange$3(0, 1, _s5_); + break $label0$0; + } + if (t4 && alphaArg.hasUnit$1("%")) { + t4 = alphaArg.valueInRangeWithUnit$4(0, 100, _s5_, "%") / 100; + break $label0$0; + } + if (t4) { + t4 = new A._changeColor_closure0(alphaArg).call$0(); + break $label0$0; + } + t4 = A.throwExpression(A.SassScriptException$0(alphaArg.toString$0(0) + ' is not a number or unquoted "none".', _s5_)); + } + return A._colorFromChannels0(color._color0$_space, t1, t2, t3, t4, false, false); + }, + _channelForChange0(channelArg, color, channel) { + var _0_0, t1, t2; + if (channelArg == null) { + _0_0 = color.get$channelsOrNull()[channel]; + $label0$0: { + if (_0_0 != null) { + t1 = color._color0$_space; + t2 = A.SassNumber_SassNumber0(_0_0, (t1 === B.HslColorSpace_JQ20 || t1 === B.HwbColorSpace_guQ0) && channel > 0 ? "%" : null); + t1 = t2; + break $label0$0; + } + t1 = null; + break $label0$0; + } + return t1; + } + if (A._isNone0(channelArg)) + return null; + if (channelArg instanceof A.SassNumber0) + return channelArg; + throw A.wrapException(A.SassScriptException$0(channelArg.toString$0(0) + ' is not a number or unquoted "none".', color._color0$_space._space$_channels[channel].name)); + }, + _scaleChannel0(color, channel, oldValue, factorArg) { + var t1, factor; + if (factorArg == null) + return oldValue; + if (!(channel instanceof A.LinearChannel0)) + throw A.wrapException(A.SassScriptException$0("Channel isn't scalable.", channel.name)); + if (oldValue == null) + A._missingChannelError0(color, channel.name); + t1 = channel.name; + factorArg.assertUnit$2("%", t1); + factor = factorArg.valueInRangeWithUnit$4(-100, 100, t1, "%") / 100; + $label0$0: { + if (0 === factor) { + t1 = oldValue; + break $label0$0; + } + if (factor > 0) { + t1 = channel.max; + t1 = oldValue >= t1 ? oldValue : oldValue + (t1 - oldValue) * factor; + break $label0$0; + } + t1 = channel.min; + t1 = oldValue <= t1 ? oldValue : oldValue + (oldValue - t1) * factor; + break $label0$0; + } + return t1; + }, + _adjustColor0(color, channelArgs, alphaArg) { + var t1 = color._color0$_space, + t2 = t1._space$_channels; + return A.SassColor_SassColor$forSpaceInternal0(t1, A._adjustChannel0(color, t2[0], color.channel0OrNull, channelArgs[0]), A._adjustChannel0(color, t2[1], color.channel1OrNull, channelArgs[1]), A._adjustChannel0(color, t2[2], color.channel2OrNull, channelArgs[2]), A.NullableExtension_andThen0(A._adjustChannel0(color, B.LinearChannel_XL80, color.alphaOrNull, alphaArg), new A._adjustColor_closure0())); + }, + _adjustChannel0(color, channel, oldValue, adjustmentArg) { + var _0_1, _0_3, t1, _0_6_isSet, _0_6, _0_6_isSet0, t2, _0_11, result, min, max, _null = null; + if (adjustmentArg == null) + return oldValue; + if (oldValue == null) + A._missingChannelError0(color, channel.name); + $label0$0: { + _0_1 = color._color0$_space; + _0_3 = B.HslColorSpace_JQ20 === _0_1; + t1 = _0_3; + if (!t1) + _0_6_isSet = B.HwbColorSpace_guQ0 === _0_1; + else + _0_6_isSet = true; + if (_0_6_isSet) { + t1 = channel.isPolarAngle; + _0_6 = channel; + } else { + _0_6 = _null; + t1 = false; + } + if (t1) { + adjustmentArg = A.SassNumber_SassNumber0(A._angleValue0(adjustmentArg, "hue"), _null); + break $label0$0; + } + t1 = false; + if (_0_3) { + _0_6_isSet0 = true; + if (_0_6_isSet) + t2 = _0_6; + else { + t2 = channel; + _0_6_isSet = _0_6_isSet0; + _0_6 = t2; + } + if (t2 instanceof A.LinearChannel0) { + if (_0_6_isSet) + t1 = _0_6; + else { + t1 = channel; + _0_6_isSet = _0_6_isSet0; + _0_6 = t1; + } + _0_11 = type$.LinearChannel_2._as(t1).name; + t1 = _0_11; + if ("saturation" !== t1) + t1 = "lightness" === _0_11; + else + t1 = true; + } + } + if (t1) { + A._checkPercent0(adjustmentArg, channel.name); + adjustmentArg = A.SassNumber_SassNumber0(adjustmentArg._number1$_value, "%"); + break $label0$0; + } + if (B.LinearChannel_XL80 === (_0_6_isSet ? _0_6 : channel) && adjustmentArg.get$hasUnits()) { + A.warnForDeprecation0("$alpha: Passing a number with unit " + adjustmentArg.get$unitString() + string$.x20is_de + adjustmentArg.unitSuggestion$1("alpha") + string$.x0a_Morex3af, B.Deprecation_vn5); + adjustmentArg = A.SassNumber_SassNumber0(adjustmentArg._number1$_value, _null); + } + } + t1 = A._channelFromValue0(channel, adjustmentArg, false); + t1.toString; + result = oldValue + t1; + $label1$1: { + t1 = channel instanceof A.LinearChannel0; + min = _null; + t2 = false; + if (t1) + if (channel.lowerClamped) { + min = channel.min; + t2 = result < min; + } + if (t2) { + t1 = oldValue < min ? Math.max(oldValue, result) : min; + break $label1$1; + } + max = _null; + t2 = false; + if (t1) + if (channel.upperClamped) { + max = channel.max; + t1 = result > max; + } else + t1 = t2; + else + t1 = t2; + if (t1) { + t1 = oldValue > max ? Math.min(oldValue, result) : max; + break $label1$1; + } + t1 = result; + break $label1$1; + } + return t1; + }, + _sniffLegacyColorSpace0(keywords) { + var t1, t2; + for (t1 = new A.LinkedHashMapKeyIterator(keywords, keywords.__js_helper$_modifications, keywords.__js_helper$_first); t1.moveNext$0();) { + t2 = t1.__js_helper$_current; + if ("red" === t2 || "green" === t2 || "blue" === t2) + return B.RgbColorSpace_i0P0; + if ("saturation" === t2 || "lightness" === t2) + return B.HslColorSpace_JQ20; + if ("whiteness" === t2 || "blackness" === t2) + return B.HwbColorSpace_guQ0; + } + return keywords.containsKey$1("hue") ? B.HslColorSpace_JQ20 : null; + }, + _functionString0($name, $arguments) { + return new A.SassString0($name + "(" + J.map$1$1$ax($arguments, new A._functionString_closure0(), type$.String).join$1(0, ", ") + ")", false); + }, + _removedColorFunction0($name, argument, negative) { + return A.BuiltInCallable$function0($name, "$color, $amount", new A._removedColorFunction_closure0($name, argument, negative), "sass:color"); + }, + _rgb0($name, $arguments) { + var t3, t4, + t1 = J.getInterceptor$asx($arguments), + alpha = t1.get$length($arguments) > 3 ? t1.$index($arguments, 3) : null, + t2 = true; + if (!t1.$index($arguments, 0).get$isSpecialNumber()) + if (!t1.$index($arguments, 1).get$isSpecialNumber()) + if (!t1.$index($arguments, 2).get$isSpecialNumber()) { + t2 = alpha == null ? null : alpha.get$isSpecialNumber(); + t2 = t2 === true; + } + if (t2) + return A._functionString0($name, $arguments); + t2 = t1.$index($arguments, 0).assertNumber$1("red"); + t3 = t1.$index($arguments, 1).assertNumber$1("green"); + t1 = t1.$index($arguments, 2).assertNumber$1("blue"); + t4 = A.NullableExtension_andThen0(alpha, new A._rgb_closure0()); + return A._colorFromChannels0(B.RgbColorSpace_i0P0, t2, t3, t1, t4 == null ? 1 : t4, true, true); + }, + _rgbTwoArg0($name, $arguments) { + var t2, color, + t1 = J.getInterceptor$asx($arguments), + first = t1.$index($arguments, 0), + second = t1.$index($arguments, 1); + if (!first.get$isVar()) + t2 = !(first instanceof A.SassColor0) && second.get$isVar(); + else + t2 = true; + if (t2) + return A._functionString0($name, $arguments); + color = first.assertColor$1("color"); + if (!color._color0$_space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0("Expected " + color.toString$0(0) + string$.x20to_be_ + color.toString$0(0) + ", $alpha: " + second.toString$0(0) + ")", $name)); + color.assertLegacy$1("color"); + color = color.toSpace$1(B.RgbColorSpace_i0P0); + if (second.get$isSpecialNumber()) + return A._functionString0($name, A._setArrayType([A.SassNumber_SassNumber0(color.channel$1(0, "red"), null), A.SassNumber_SassNumber0(color.channel$1(0, "green"), null), A.SassNumber_SassNumber0(color.channel$1(0, "blue"), null), t1.$index($arguments, 1)], type$.JSArray_Value_2)); + t1 = A._percentageOrUnitless0(t1.$index($arguments, 1).assertNumber$1("alpha"), 1, "alpha"); + return color.changeAlpha$1(isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 1)); + }, + _hsl0($name, $arguments) { + var t3, t4, + t1 = J.getInterceptor$asx($arguments), + alpha = t1.get$length($arguments) > 3 ? t1.$index($arguments, 3) : null, + t2 = true; + if (!t1.$index($arguments, 0).get$isSpecialNumber()) + if (!t1.$index($arguments, 1).get$isSpecialNumber()) + if (!t1.$index($arguments, 2).get$isSpecialNumber()) { + t2 = alpha == null ? null : alpha.get$isSpecialNumber(); + t2 = t2 === true; + } + if (t2) + return A._functionString0($name, $arguments); + t2 = t1.$index($arguments, 0).assertNumber$1("hue"); + t3 = t1.$index($arguments, 1).assertNumber$1("saturation"); + t1 = t1.$index($arguments, 2).assertNumber$1("lightness"); + t4 = A.NullableExtension_andThen0(alpha, new A._hsl_closure0()); + return A._colorFromChannels0(B.HslColorSpace_JQ20, t2, t3, t1, t4 == null ? 1 : t4, true, false); + }, + _angleValue0(angleValue, $name) { + var angle = angleValue.assertNumber$1($name); + if (angle.compatibleWithUnit$1("deg")) + return angle.coerceValueToUnit$1("deg"); + A.warnForDeprecation0("$" + $name + ": Passing a unit other than deg (" + angle.toString$0(0) + string$.x29x20is_d + angle.unitSuggestion$1($name) + string$.x0a_See_, B.Deprecation_vn5); + return angle._number1$_value; + }, + _checkPercent0(number, $name) { + if (number.hasUnit$1("%")) + return; + A.warnForDeprecation0("$" + $name + ": Passing a number without unit % (" + number.toString$0(0) + string$.x29x20is_d + number.unitSuggestion$2($name, "%") + string$.x0a_Morex3af, B.Deprecation_vn5); + }, + _percentageOrUnitless0(number, max, $name) { + var value; + if (!number.get$hasUnits()) + value = number._number1$_value; + else if (number.hasUnit$1("%")) + value = max * number._number1$_value / 100; + else + throw A.wrapException(A.SassScriptException$0("Expected " + number.toString$0(0) + ' to have unit "%" or no units.', $name)); + return value; + }, + _mixLegacy0(color1, color2, weight) { + var t2, alphaDistance, weight1, weight2, t3, t4, t5, t6, t7, t8, + rgb1 = color1.toSpace$1(B.RgbColorSpace_i0P0), + rgb2 = color2.toSpace$1(B.RgbColorSpace_i0P0), + weightScale = weight.valueInRange$3(0, 100, "weight") / 100, + normalizedWeight = weightScale * 2 - 1, + t1 = color1.alphaOrNull; + if (t1 == null) + t1 = 0; + t2 = color2.alphaOrNull; + alphaDistance = t1 - (t2 == null ? 0 : t2); + t1 = normalizedWeight * alphaDistance; + weight1 = ((t1 === -1 ? normalizedWeight : (normalizedWeight + alphaDistance) / (1 + t1)) + 1) / 2; + weight2 = 1 - weight1; + t1 = rgb1.channel0OrNull; + if (t1 == null) + t1 = 0; + t2 = rgb2.channel0OrNull; + if (t2 == null) + t2 = 0; + t3 = rgb1.channel1OrNull; + if (t3 == null) + t3 = 0; + t4 = rgb2.channel1OrNull; + if (t4 == null) + t4 = 0; + t5 = rgb1.channel2OrNull; + if (t5 == null) + t5 = 0; + t6 = rgb2.channel2OrNull; + if (t6 == null) + t6 = 0; + t7 = rgb1.alphaOrNull; + if (t7 == null) + t7 = 0; + t8 = rgb2.alphaOrNull; + if (t8 == null) + t8 = 0; + return A.SassColor_SassColor$rgbInternal0(t1 * weight1 + t2 * weight2, t3 * weight1 + t4 * weight2, t5 * weight1 + t6 * weight2, t7 * weightScale + t8 * (1 - weightScale), null); + }, + _opacify0($name, $arguments) { + var result, + t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + amount = t1.$index($arguments, 1).assertNumber$1("amount"); + if (!color._color0$_space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0($name + string$.x28__is_oa, null)); + t1 = color.alphaOrNull; + if (t1 == null) + t1 = 0; + t1 += amount.valueInRangeWithUnit$4(0, 1, "amount", ""); + result = color.changeAlpha$1(isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 1)); + A.warnForDeprecation0($name + "() is deprecated. " + A._suggestScaleAndAdjust0(color, amount._number1$_value, "alpha") + string$.x0a_Morex3ac, B.Deprecation_fdF); + return result; + }, + _transparentize0($name, $arguments) { + var result, + t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + amount = t1.$index($arguments, 1).assertNumber$1("amount"); + if (!color._color0$_space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0($name + string$.x28__is_oa, null)); + t1 = color.alphaOrNull; + if (t1 == null) + t1 = 0; + t1 -= amount.valueInRangeWithUnit$4(0, 1, "amount", ""); + result = color.changeAlpha$1(isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 1)); + A.warnForDeprecation0($name + "() is deprecated. " + A._suggestScaleAndAdjust0(color, -amount._number1$_value, "alpha") + string$.x0a_Morex3ac, B.Deprecation_fdF); + return result; + }, + _colorInSpace0(colorUntyped, spaceUntyped, legacyMissing) { + var t1, _s5_ = "space", + color = colorUntyped.assertColor$1("color"); + if (spaceUntyped.$eq(0, B.C__SassNull0)) + return color; + t1 = spaceUntyped.assertString$1(_s5_); + t1.assertUnquoted$1(_s5_); + return color.toSpace$2$legacyMissing(A.ColorSpace_fromName0(t1._string0$_text, _s5_), legacyMissing); + }, + _parseChannels0(functionName, input, $name, space) { + var parsedSlash, components, alphaValue, _2_0, _2_1, _2_5, t1, t2, _2_6, channels, first, rest, componentList, spaceName, i, channel, channelName, t3, t4, _null = null; + if (input.get$isVar()) + return A._functionString0(functionName, A._setArrayType([input], type$.JSArray_Value_2)); + parsedSlash = A._parseSlashChannels0(input, $name); + if (parsedSlash == null) + return A._functionString0(functionName, A._setArrayType([input], type$.JSArray_Value_2)); + components = parsedSlash._0; + alphaValue = parsedSlash._1; + $label0$0: { + _2_0 = components.assertCommonListStyle$2$allowSlash($name, false); + _2_1 = _2_0.length; + if (_2_1 <= 0) + throw A.wrapException(A.SassScriptException$0("Color component list may not be empty.", $name)); + _2_5 = _2_1 >= 1; + t1 = _2_5; + t2 = false; + if (t1) { + _2_6 = _2_0[0]; + if (_2_6 instanceof A.SassString0) { + type$.SassString_2._as(_2_6); + t2 = !_2_6._string0$_hasQuotes && _2_6._string0$_text.toLowerCase() === "from"; + } + } else + _2_6 = _null; + if (t2) + return A._functionString0(functionName, A._setArrayType([input], type$.JSArray_Value_2)); + t2 = components.get$isVar(); + if (t2) { + channels = A._setArrayType([components], type$.JSArray_Value_2); + break $label0$0; + } + channels = _null; + if (_2_5) { + first = t1 ? _2_6 : _2_0[0]; + rest = B.JSArray_methods.sublist$1(_2_0, 1); + componentList = _2_0; + } else { + componentList = channels; + rest = componentList; + first = _null; + } + if (_2_5) { + if (space == null) { + spaceName = first.assertString$1($name); + spaceName.assertUnquoted$1($name); + space = spaceName.get$isVar() ? _null : A.ColorSpace_fromName0(spaceName._string0$_text, $name); + if (B.RgbColorSpace_i0P0 === space || B.HslColorSpace_JQ20 === space || B.HwbColorSpace_guQ0 === space || B.LabColorSpace_2nT0 === space || B.LchColorSpace_Bpv0 === space || B.OklabColorSpace_5400 === space || B.OklchColorSpace_9Gj0 === space) + throw A.wrapException(A.SassScriptException$0(string$.The_co + A.S(space) + ". Use the " + A.S(space) + "() function instead.", $name)); + channels = rest; + } else + channels = componentList; + for (i = 0; i < channels.length; ++i) { + channel = channels[i]; + t1 = false; + if (!channel.get$isSpecialNumber()) + if (!(channel instanceof A.SassNumber0)) + t1 = !(channel instanceof A.SassString0 && !channel._string0$_hasQuotes && channel._string0$_text.toLowerCase() === "none"); + if (t1) { + t1 = _null; + if (space == null) + channelName = t1; + else { + t2 = space._space$_channels; + t2 = i < 3 ? t2[i] : _null; + if (!(t2 == null)) + t1 = new A._parseChannels_closure1().call$1(t2.name); + channelName = t1; + } + if (channelName == null) + channelName = "channel " + (i + 1); + throw A.wrapException(A.SassScriptException$0("Expected " + channelName + " to be a number, was " + channel.toString$0(0) + ".", $name)); + } + } + break $label0$0; + } + throw A.wrapException("unreachable"); + } + t1 = alphaValue == null; + t2 = t1 ? _null : alphaValue.get$isSpecialNumber(); + if (t2 === true) { + if (channels.length === 3 && B.Set_9FDyj0.contains$1(0, space)) { + t1 = A.List_List$of(channels, true, type$.Value_2); + alphaValue.toString; + t1.push(alphaValue); + t1 = A._functionString0(functionName, t1); + } else + t1 = A._functionString0(functionName, A._setArrayType([input], type$.JSArray_Value_2)); + return t1; + } + $label1$1: { + if (t1) { + t2 = 1; + break $label1$1; + } + if (alphaValue instanceof A.SassString0 && !alphaValue._string0$_hasQuotes && "none" === alphaValue._string0$_text) { + t2 = _null; + break $label1$1; + } + t2 = A._percentageOrUnitless0(alphaValue.assertNumber$1($name), 1, "alpha"); + t2 = isNaN(t2) ? 0 : B.JSNumber_methods.clamp$2(t2, 0, 1); + break $label1$1; + } + if (space == null) + return A._functionString0(functionName, A._setArrayType([input], type$.JSArray_Value_2)); + if (B.JSArray_methods.any$1(channels, new A._parseChannels_closure2())) { + if (channels.length === 3 && B.Set_9FDyj0.contains$1(0, space)) { + t2 = A.List_List$of(channels, true, type$.Value_2); + if (!t1) + t2.push(alphaValue); + t1 = A._functionString0(functionName, t2); + } else + t1 = A._functionString0(functionName, A._setArrayType([input], type$.JSArray_Value_2)); + return t1; + } + if (channels.length !== 3) + throw A.wrapException(A.SassScriptException$0("The " + space.toString$0(0) + " color space has 3 channels but " + input.toString$0(0) + " has " + channels.length + ".", $name)); + t1 = channels[0]; + t1 = t1 instanceof A.SassNumber0 ? t1 : _null; + t3 = channels[1]; + t3 = t3 instanceof A.SassNumber0 ? t3 : _null; + t4 = channels[2]; + t4 = t4 instanceof A.SassNumber0 ? t4 : _null; + return A._colorFromChannels0(space, t1, t3, t4, t2, true, space === B.RgbColorSpace_i0P0); + }, + _parseSlashChannels0(input, $name) { + var _1_1, alphaValue, t1, components, _1_7, _1_9_isSet, _1_8, _1_9, initial, t2, _0_0, _0_1, channel3, alpha, _1_16, _1_16_isSet, _1_9_isSet0, t3, _null = null, + _1_0 = input.assertCommonListStyle$2$allowSlash($name, true); + $label0$0: { + _1_1 = _1_0.length; + alphaValue = _null; + t1 = false; + if (_1_1 === 2) { + components = _1_0[0]; + alphaValue = _1_0[1]; + t1 = input.get$separator(input) === B.ListSeparator_bRz0; + } else + components = _null; + if (t1) { + t1 = new A._Record_2(components, alphaValue); + break $label0$0; + } + t1 = input.get$separator(input); + if (t1 === B.ListSeparator_bRz0) { + t1 = _1_0.length; + A.throwExpression(A.SassScriptException$0(string$.Only_2 + t1 + " " + A.pluralize0("was", t1, "were") + " passed.", $name)); + } + _1_7 = _1_1 >= 1; + _1_9_isSet = _1_7; + _1_8 = _null; + _1_9 = _null; + initial = _null; + t1 = false; + if (_1_9_isSet) { + _1_8 = B.JSArray_methods.sublist$2(_1_0, 0, _1_1 - 1); + initial = _1_8; + _1_9 = _1_0[_1_1 - 1]; + t2 = _1_9; + if (t2 instanceof A.SassString0) { + type$.SassString_2._as(_1_9); + t1 = !_1_9._string0$_hasQuotes; + } + } + if (t1) { + if (_1_9_isSet) + t1 = _1_9; + else { + _1_9 = _1_0[_1_1 - 1]; + t1 = _1_9; + } + _0_0 = type$.SassString_2._as(t1)._string0$_text.split("/"); + $label1$1: { + _0_1 = _0_0.length; + if (_0_1 === 1) { + t1 = new A._Record_2(input, _null); + break $label1$1; + } + if (_0_1 === 2) { + channel3 = _0_0[0]; + alpha = _0_0[1]; + t1 = A.List_List$of(initial, true, type$.Value_2); + t1.push(A._parseNumberOrString0(channel3)); + t1 = new A._Record_2(A.SassList$0(t1, B.ListSeparator_qSL0, false), A._parseNumberOrString0(alpha)); + break $label1$1; + } + t1 = _null; + break $label1$1; + } + break $label0$0; + } + _1_16 = _null; + _1_16_isSet = false; + t1 = false; + if (_1_7) { + _1_9_isSet0 = true; + if (_1_9_isSet) + initial = _1_8; + else { + _1_8 = B.JSArray_methods.sublist$2(_1_0, 0, _1_1 - 1); + initial = _1_8; + } + if (_1_9_isSet) + t2 = _1_9; + else { + _1_9 = _1_0[_1_1 - 1]; + t2 = _1_9; + _1_9_isSet = _1_9_isSet0; + } + _1_16_isSet = t2 instanceof A.SassNumber0; + if (_1_16_isSet) { + if (_1_9_isSet) + t1 = _1_9; + else { + _1_9 = _1_0[_1_1 - 1]; + t1 = _1_9; + _1_9_isSet = _1_9_isSet0; + } + _1_16 = type$.SassNumber_2._as(t1).asSlash; + t1 = _1_16; + t1 = type$.Record_2_nullable_Object_and_nullable_Object._is(t1); + } + } else + initial = _null; + if (t1) { + if (_1_16_isSet) + t1 = _1_16; + else { + if (_1_9_isSet) + t1 = _1_9; + else { + _1_9 = _1_0[_1_1 - 1]; + t1 = _1_9; + _1_9_isSet = true; + } + _1_16 = type$.SassNumber_2._as(t1).asSlash; + t1 = _1_16; + _1_16_isSet = true; + } + if (t1 == null) + t1 = type$.Record_2_nullable_Object_and_nullable_Object._as(t1); + if (_1_16_isSet) + t2 = _1_16; + else { + if (_1_9_isSet) + t2 = _1_9; + else { + _1_9 = _1_0[_1_1 - 1]; + t2 = _1_9; + } + _1_16 = type$.SassNumber_2._as(t2).asSlash; + t2 = _1_16; + } + if (t2 == null) + t2 = type$.Record_2_nullable_Object_and_nullable_Object._as(t2); + t3 = A.List_List$of(initial, true, type$.Value_2); + t3.push(t1._0); + t2 = new A._Record_2(A.SassList$0(t3, B.ListSeparator_qSL0, false), t2._1); + t1 = t2; + break $label0$0; + } + t1 = new A._Record_2(input, _null); + break $label0$0; + } + return t1; + }, + _parseNumberOrString0(text) { + var t1, expression, exception; + try { + t1 = A.ScssParser$0(text, null); + expression = t1._stylesheet0$_parseSingleProduction$1$1(t1.get$_stylesheet0$_number(), type$.NumberExpression_2); + t1 = A.SassNumber_SassNumber0(expression.value, expression.unit); + return t1; + } catch (exception) { + if (type$.SassFormatException_2._is(A.unwrapException(exception))) + return new A.SassString0(text, false); + else + throw exception; + } + }, + _colorFromChannels0(space, channel0, channel1, channel2, alpha, clamp, fromRgbFunction) { + var t1, t2, whiteness, blackness, t3; + switch (space) { + case B.HslColorSpace_JQ20: + if (channel1 != null) + A._checkPercent0(channel1, "saturation"); + if (channel2 != null) + A._checkPercent0(channel2, "lightness"); + t1 = space._space$_channels; + return A.SassColor_SassColor$hsl0(A.NullableExtension_andThen0(channel0, new A._colorFromChannels_closure1()), A._channelFromValue0(t1[1], A._forcePercent0(channel1), clamp), A._channelFromValue0(t1[2], A._forcePercent0(channel2), clamp), alpha); + case B.HwbColorSpace_guQ0: + t1 = channel1 == null; + if (!t1) + channel1.assertUnit$2("%", "whiteness"); + t2 = channel2 == null; + if (!t2) + channel2.assertUnit$2("%", "blackness"); + whiteness = t1 ? null : channel1._number1$_value; + blackness = t2 ? null : channel2._number1$_value; + if (whiteness != null && blackness != null && whiteness + blackness > 100) { + t1 = whiteness + blackness; + whiteness = whiteness / t1 * 100; + blackness = blackness / t1 * 100; + } + return A.SassColor_SassColor$hwb0(A.NullableExtension_andThen0(channel0, new A._colorFromChannels_closure2()), whiteness, blackness, alpha); + case B.RgbColorSpace_i0P0: + t1 = space._space$_channels; + t2 = A._channelFromValue0(t1[0], channel0, clamp); + t3 = A._channelFromValue0(t1[1], channel1, clamp); + t1 = A._channelFromValue0(t1[2], channel2, clamp); + return A.SassColor_SassColor$rgbInternal0(t2, t3, t1, alpha, fromRgbFunction ? B.C__ColorFormatEnum0 : null); + default: + t1 = space._space$_channels; + return A.SassColor_SassColor$forSpaceInternal0(space, A._channelFromValue0(t1[0], channel0, clamp), A._channelFromValue0(t1[1], channel1, clamp), A._channelFromValue0(t1[2], channel2, clamp), alpha); + } + }, + _forcePercent0(number) { + var t1, _0_3; + $label0$0: { + if (number == null) { + t1 = null; + break $label0$0; + } + _0_3 = number.get$numeratorUnits(number); + if (_0_3.length === 1) + t1 = "%" === _0_3[0] && number.get$denominatorUnits(number).length <= 0; + else + t1 = false; + if (t1) { + t1 = number; + break $label0$0; + } + t1 = A.SassNumber_SassNumber0(number._number1$_value, "%"); + break $label0$0; + } + return t1; + }, + _channelFromValue0(channel, value, clamp) { + return A.NullableExtension_andThen0(value, new A._channelFromValue_closure0(channel, clamp)); + }, + _isNone0(value) { + return value instanceof A.SassString0 && !value._string0$_hasQuotes && value._string0$_text.toLowerCase() === "none"; + }, + _channelFunction0($name, space, getter, global, unit) { + return A.BuiltInCallable$function0($name, "$color", new A._channelFunction_closure0(getter, unit, global, $name, space), "sass:color"); + }, + _suggestScaleAndAdjust0(original, adjustment, channelName) { + var t2, oldValue, newValue, factor, t3, suggestion, + channel = channelName === "alpha" ? B.LinearChannel_XL80 : type$.LinearChannel_2._as(B.JSArray_methods.firstWhere$1(B.List_oAL0, new A._suggestScaleAndAdjust_closure0(channelName))), + t1 = channel === B.LinearChannel_XL80; + if (t1) { + t2 = original.alphaOrNull; + oldValue = t2 == null ? 0 : t2; + } else + oldValue = original.toSpace$1(B.HslColorSpace_JQ20).channel$1(0, channelName); + newValue = oldValue + adjustment; + if (adjustment !== 0) { + factor = A._Cell$(); + t2 = channel.max; + if (newValue > t2) + factor.__late_helper$_value = 1; + else { + t3 = channel.min; + if (newValue < t3) + factor.__late_helper$_value = -1; + else if (adjustment > 0) + factor.__late_helper$_value = adjustment / (t2 - oldValue); + else + factor.__late_helper$_value = (newValue - oldValue) / (oldValue - t3); + } + suggestion = "Suggestion" + ("s:\n\ncolor.scale($color, $" + channelName + ": " + A.SassNumber_SassNumber0(factor._readLocal$0() * 100, "%").toString$0(0) + ")\n"); + } else + suggestion = "Suggestion:\n\n"; + return suggestion + ("color.adjust($color, $" + channelName + ": " + A.SassNumber_SassNumber0(adjustment, t1 ? null : "%").toString$0(0) + ")"); + }, + _missingChannelError0(color, channel) { + return A.throwExpression(A.SassScriptException$0(string$.Becaus + color.toString$0(0) + ").", channel)); + }, + _channelName0(value) { + var t1 = value.assertString$1("channel"); + t1.assertQuoted$1("channel"); + return t1._string0$_text; + }, + _function12($name, $arguments, callback) { + return A.BuiltInCallable$function0($name, $arguments, callback, "sass:color"); + }, + global_closure44: function global_closure44() { + }, + global_closure45: function global_closure45() { + }, + global_closure46: function global_closure46() { + }, + global_closure47: function global_closure47() { + }, + global_closure48: function global_closure48() { + }, + global_closure49: function global_closure49() { + }, + global_closure50: function global_closure50() { + }, + global_closure51: function global_closure51() { + }, + global_closure52: function global_closure52() { + }, + global_closure53: function global_closure53() { + }, + global_closure54: function global_closure54() { + }, + global_closure55: function global_closure55() { + }, + global_closure56: function global_closure56() { + }, + global_closure57: function global_closure57() { + }, + global_closure58: function global_closure58() { + }, + global_closure59: function global_closure59() { + }, + global_closure60: function global_closure60() { + }, + global_closure61: function global_closure61() { + }, + global_closure62: function global_closure62() { + }, + global_closure63: function global_closure63() { + }, + global_closure64: function global_closure64() { + }, + global_closure65: function global_closure65() { + }, + global_closure66: function global_closure66() { + }, + global_closure67: function global_closure67() { + }, + global_closure68: function global_closure68() { + }, + global_closure69: function global_closure69() { + }, + global_closure70: function global_closure70() { + }, + global_closure71: function global_closure71() { + }, + global_closure72: function global_closure72() { + }, + global_closure73: function global_closure73() { + }, + global_closure74: function global_closure74() { + }, + global_closure75: function global_closure75() { + }, + global_closure76: function global_closure76() { + }, + global_closure77: function global_closure77() { + }, + global_closure78: function global_closure78() { + }, + global_closure79: function global_closure79() { + }, + global__closure0: function global__closure0() { + }, + global_closure80: function global_closure80() { + }, + global_closure81: function global_closure81() { + }, + global_closure82: function global_closure82() { + }, + global_closure83: function global_closure83() { + }, + global_closure84: function global_closure84() { + }, + global_closure85: function global_closure85() { + }, + global_closure86: function global_closure86() { + }, + module_closure27: function module_closure27() { + }, + module_closure28: function module_closure28() { + }, + module_closure29: function module_closure29() { + }, + module_closure30: function module_closure30() { + }, + module_closure31: function module_closure31() { + }, + module_closure32: function module_closure32() { + }, + module_closure33: function module_closure33() { + }, + module_closure34: function module_closure34() { + }, + module_closure35: function module_closure35() { + }, + module_closure36: function module_closure36() { + }, + module_closure37: function module_closure37() { + }, + module_closure38: function module_closure38() { + }, + module_closure39: function module_closure39() { + }, + module_closure40: function module_closure40() { + }, + module__closure6: function module__closure6() { + }, + module_closure41: function module_closure41() { + }, + module_closure42: function module_closure42() { + }, + module_closure43: function module_closure43() { + }, + module_closure44: function module_closure44() { + }, + module_closure45: function module_closure45() { + }, + module_closure46: function module_closure46() { + }, + module_closure47: function module_closure47() { + }, + module_closure48: function module_closure48() { + }, + module__closure5: function module__closure5(t0) { + this.channelName = t0; + }, + module_closure49: function module_closure49() { + }, + module_closure_toXyzNoMissing0: function module_closure_toXyzNoMissing0() { + }, + module_closure50: function module_closure50() { + }, + _mix_closure0: function _mix_closure0() { + }, + _complement_closure0: function _complement_closure0() { + }, + _adjust_closure0: function _adjust_closure0() { + }, + _scale_closure0: function _scale_closure0() { + }, + _change_closure0: function _change_closure0() { + }, + _ieHexStr_closure0: function _ieHexStr_closure0() { + }, + _ieHexStr_closure_hexString0: function _ieHexStr_closure_hexString0() { + }, + _updateComponents_closure1: function _updateComponents_closure1(t0) { + this.originalColor = t0; + }, + _updateComponents_closure2: function _updateComponents_closure2(t0) { + this._box_0 = t0; + }, + _changeColor_closure0: function _changeColor_closure0(t0) { + this.alphaArg = t0; + }, + _adjustColor_closure0: function _adjustColor_closure0() { + }, + _functionString_closure0: function _functionString_closure0() { + }, + _removedColorFunction_closure0: function _removedColorFunction_closure0(t0, t1, t2) { + this.name = t0; + this.argument = t1; + this.negative = t2; + }, + _rgb_closure0: function _rgb_closure0() { + }, + _hsl_closure0: function _hsl_closure0() { + }, + _parseChannels_closure1: function _parseChannels_closure1() { + }, + _parseChannels_closure2: function _parseChannels_closure2() { + }, + _colorFromChannels_closure1: function _colorFromChannels_closure1() { + }, + _colorFromChannels_closure2: function _colorFromChannels_closure2() { + }, + _channelFromValue_closure0: function _channelFromValue_closure0(t0, t1) { + this.channel = t0; + this.clamp = t1; + }, + _channelFunction_closure0: function _channelFunction_closure0(t0, t1, t2, t3, t4) { + var _ = this; + _.getter = t0; + _.unit = t1; + _.global = t2; + _.name = t3; + _.space = t4; + }, + _suggestScaleAndAdjust_closure0: function _suggestScaleAndAdjust_closure0(t0) { + this.channelName = t0; + }, + _constructionSpace(options) { + var t1 = J.getInterceptor$x(options); + if (t1.get$space(options) != null) { + t1 = t1.get$space(options); + t1.toString; + return A.ColorSpace_fromName0(t1, null); + } + if (t1.get$red(options) != null) + return B.RgbColorSpace_i0P0; + if (t1.get$saturation(options) != null) + return B.HslColorSpace_JQ20; + if (t1.get$whiteness(options) != null) + return B.HwbColorSpace_guQ0; + throw A.wrapException("No color space found"); + }, + _toSpace($self, space) { + return $self.toSpace$1(A.ColorSpace_fromName0(space == null ? $self._color0$_space.name : space, null)); + }, + _checkNullAlphaDeprecation(options) { + var t1 = J.getInterceptor$x(options), + t2 = t1.get$alpha(options); + if (!A._asBool($.$get$_isUndefined().call$1(t2)) && t1.get$alpha(options) == null && t1.get$space(options) == null) + A.warnForDeprecationFromApi(string$.Passin_, B.Deprecation_l0m); + }, + colorClass_closure: function colorClass_closure() { + }, + colorClass__closure: function colorClass__closure() { + }, + colorClass__closure0: function colorClass__closure0() { + }, + colorClass__closure1: function colorClass__closure1() { + }, + colorClass__closure2: function colorClass__closure2() { + }, + colorClass__closure3: function colorClass__closure3() { + }, + colorClass__closure4: function colorClass__closure4() { + }, + colorClass__closure5: function colorClass__closure5() { + }, + colorClass__closure6: function colorClass__closure6() { + }, + colorClass__closure7: function colorClass__closure7() { + }, + colorClass__closure8: function colorClass__closure8() { + }, + colorClass___closure: function colorClass___closure(t0) { + this.key = t0; + }, + colorClass__closure_changedValue: function colorClass__closure_changedValue(t0, t1) { + this.color = t0; + this.options = t1; + }, + colorClass__closure9: function colorClass__closure9() { + }, + colorClass__closure10: function colorClass__closure10() { + }, + colorClass__closure11: function colorClass__closure11() { + }, + colorClass__closure12: function colorClass__closure12() { + }, + colorClass__closure13: function colorClass__closure13() { + }, + colorClass__closure14: function colorClass__closure14() { + }, + colorClass__closure15: function colorClass__closure15() { + }, + colorClass__closure16: function colorClass__closure16() { + }, + colorClass__closure17: function colorClass__closure17() { + }, + colorClass__closure18: function colorClass__closure18() { + }, + colorClass__closure19: function colorClass__closure19() { + }, + colorClass__closure20: function colorClass__closure20() { + }, + colorClass__closure21: function colorClass__closure21() { + }, + colorClass__closure22: function colorClass__closure22() { + }, + _Channels: function _Channels() { + }, + _ConstructionOptions: function _ConstructionOptions() { + }, + _ChannelOptions: function _ChannelOptions() { + }, + _ToGamutOptions: function _ToGamutOptions() { + }, + _InterpolationOptions: function _InterpolationOptions() { + }, + _NodeSassColor: function _NodeSassColor() { + }, + legacyColorClass_closure: function legacyColorClass_closure() { + }, + legacyColorClass__closure: function legacyColorClass__closure() { + }, + legacyColorClass_closure0: function legacyColorClass_closure0() { + }, + legacyColorClass_closure1: function legacyColorClass_closure1() { + }, + legacyColorClass_closure2: function legacyColorClass_closure2() { + }, + legacyColorClass_closure3: function legacyColorClass_closure3() { + }, + legacyColorClass_closure4: function legacyColorClass_closure4() { + }, + legacyColorClass_closure5: function legacyColorClass_closure5() { + }, + legacyColorClass_closure6: function legacyColorClass_closure6() { + }, + legacyColorClass_closure7: function legacyColorClass_closure7() { + }, + SassColor_SassColor$rgb0(red, green, blue, alpha) { + return A.SassColor_SassColor$rgbInternal0(red, green, blue, alpha, null); + }, + SassColor_SassColor$rgbInternal0(red, green, blue, alpha, format) { + var _null = null, + t1 = red == null ? _null : red, + t2 = green == null ? _null : green, + t3 = blue == null ? _null : blue; + return A.SassColor$_forSpace0(B.RgbColorSpace_i0P0, t1, t2, t3, alpha == null ? _null : alpha, format); + }, + SassColor_SassColor$hsl0(hue, saturation, lightness, alpha) { + var _null = null, + t1 = hue == null ? _null : hue, + t2 = saturation == null ? _null : saturation, + t3 = lightness == null ? _null : lightness; + return A.SassColor_SassColor$forSpaceInternal0(B.HslColorSpace_JQ20, t1, t2, t3, alpha == null ? _null : alpha); + }, + SassColor_SassColor$hwb0(hue, whiteness, blackness, alpha) { + var _null = null, + t1 = hue == null ? _null : hue, + t2 = whiteness == null ? _null : whiteness, + t3 = blackness == null ? _null : blackness; + return A.SassColor_SassColor$forSpaceInternal0(B.HwbColorSpace_guQ0, t1, t2, t3, alpha == null ? _null : alpha); + }, + SassColor_SassColor$forSpaceInternal0(space, channel0, channel1, channel2, alpha) { + var t1, t2, _null = null; + $label0$0: { + if (B.HslColorSpace_JQ20 === space) { + t1 = channel1 == null; + t2 = A.SassColor__normalizeHue0(channel0, !t1 && channel1 < 0 && !A.fuzzyEquals0(channel1, 0)); + t2 = A.SassColor$_forSpace0(space, t2, t1 ? _null : Math.abs(channel1), channel2, alpha, _null); + t1 = t2; + break $label0$0; + } + if (B.HwbColorSpace_guQ0 === space) { + t1 = A.SassColor$_forSpace0(space, A.SassColor__normalizeHue0(channel0, false), channel1, channel2, alpha, _null); + break $label0$0; + } + if (B.LchColorSpace_Bpv0 === space || B.OklchColorSpace_9Gj0 === space) { + t1 = channel1 == null; + t2 = t1 ? _null : Math.abs(channel1); + t2 = A.SassColor$_forSpace0(space, channel0, t2, A.SassColor__normalizeHue0(channel2, !t1 && channel1 < 0 && !A.fuzzyEquals0(channel1, 0)), alpha, _null); + t1 = t2; + break $label0$0; + } + t1 = A.SassColor$_forSpace0(space, channel0, channel1, channel2, alpha, _null); + break $label0$0; + } + return t1; + }, + SassColor$_forSpace0(_space, channel0OrNull, channel1OrNull, channel2OrNull, alpha, format) { + return new A.SassColor0(_space, channel0OrNull, channel1OrNull, channel2OrNull, format, A.NullableExtension_andThen0(alpha, new A.SassColor$_forSpace_closure0())); + }, + SassColor__normalizeHue0(hue, invert) { + var t1, t2; + if (hue == null) + return hue; + t1 = B.JSNumber_methods.$mod(hue, 360); + t2 = invert ? 180 : 0; + return B.JSNumber_methods.$mod(t1 + 360 + t2, 360); + }, + SassColor0: function SassColor0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._color0$_space = t0; + _.channel0OrNull = t1; + _.channel1OrNull = t2; + _.channel2OrNull = t3; + _.format = t4; + _.alphaOrNull = t5; + }, + SassColor$_forSpace_closure0: function SassColor$_forSpace_closure0() { + }, + _ColorFormatEnum0: function _ColorFormatEnum0() { + }, + SpanColorFormat0: function SpanColorFormat0(t0) { + this._color0$_span = t0; + }, + Combinator0: function Combinator0(t0, t1) { + this._combinator0$_text = t0; + this._name = t1; + }, + ModifiableCssComment0: function ModifiableCssComment0(t0, t1) { + var _ = this; + _.text = t0; + _.span = t1; + _._node$_indexInParent = _._node$_parent = null; + _.isGroupEnd = false; + }, + compile0(path, options) { + var color, ascii, logger, result, error, stackTrace, t1, color0, ascii0, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, exception, _null = null; + if (!A.isNodeJs()) + A.jsThrow(new self.Error("The compile() method is only available in Node.js.")); + t1 = options == null; + color0 = t1 ? _null : J.get$alertColor$x(options); + color = color0 == null ? A.hasTerminal0() : color0; + ascii0 = t1 ? _null : J.get$alertAscii$x(options); + ascii = ascii0 == null ? $._glyphs === B.C_AsciiGlyphSet : ascii0; + t2 = t1 ? _null : J.get$logger$x(options); + t3 = ascii; + if (t3 == null) + t3 = $._glyphs === B.C_AsciiGlyphSet; + logger = new A.JSToDartLogger(t2, new A.StderrLogger0(color), t3); + try { + t2 = t1 ? _null : J.get$loadPaths$x(options); + t3 = t1 ? _null : J.get$quietDeps$x(options); + if (t3 == null) + t3 = false; + t4 = A._parseOutputStyle0(t1 ? _null : J.get$style$x(options)); + t5 = t1 ? _null : J.get$verbose$x(options); + if (t5 == null) + t5 = false; + t6 = t1 ? _null : J.get$charset$x(options); + if (t6 == null) + t6 = true; + t7 = t1 ? _null : J.get$sourceMap$x(options); + if (t7 == null) + t7 = false; + if (t1) + t8 = _null; + else { + t8 = J.get$importers$x(options); + t8 = t8 == null ? _null : J.map$1$1$ax(t8, A.compile___parseImporter$closure(), type$.Importer); + } + t9 = A._parseFunctions0(t1 ? _null : J.get$functions$x(options), false); + t10 = t1 ? _null : J.get$fatalDeprecations$x(options); + t10 = A.parseDeprecations(logger, t10, true); + t11 = t1 ? _null : J.get$silenceDeprecations$x(options); + t11 = A.parseDeprecations(logger, t11, false); + t12 = t1 ? _null : J.get$futureDeprecations$x(options); + result = A.compile(path, t6, t10, new A.CastList(t9, A._arrayInstanceType(t9)._eval$1("CastList<1,Callable>")), A.parseDeprecations(logger, t12, false), A.ImportCache$0(t8, t2, _null), _null, _null, logger, _null, t3, t11, t7, t4, _null, true, t5); + t1 = t1 ? _null : J.get$sourceMapIncludeSources$x(options); + if (t1 == null) + t1 = false; + t1 = A._convertResult(result, t1); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException0) { + error = t1; + stackTrace = A.getTraceFromException(exception); + A.throwNodeException(error, ascii, color, stackTrace); + } else + throw exception; + } + }, + compileString0(text, options) { + var logger, result, error, stackTrace, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, exception, _null = null, + t1 = options == null, + color0 = t1 ? _null : J.get$alertColor$x(options), + color = color0 == null ? A.hasTerminal0() : color0, + ascii0 = t1 ? _null : J.get$alertAscii$x(options), + ascii = ascii0 == null ? $._glyphs === B.C_AsciiGlyphSet : ascii0, + t2 = t1 ? _null : J.get$logger$x(options), + t3 = ascii; + if (t3 == null) + t3 = $._glyphs === B.C_AsciiGlyphSet; + logger = new A.JSToDartLogger(t2, new A.StderrLogger0(color), t3); + try { + t2 = A.parseSyntax(t1 ? _null : J.get$syntax$x(options)); + t3 = t1 ? _null : A.NullableExtension_andThen0(J.get$url$x(options), A.utils3__jsToDartUrl$closure()); + t4 = t1 ? _null : J.get$loadPaths$x(options); + t5 = t1 ? _null : J.get$quietDeps$x(options); + if (t5 == null) + t5 = false; + t6 = A._parseOutputStyle0(t1 ? _null : J.get$style$x(options)); + t7 = t1 ? _null : J.get$verbose$x(options); + if (t7 == null) + t7 = false; + t8 = t1 ? _null : J.get$charset$x(options); + if (t8 == null) + t8 = true; + t9 = t1 ? _null : J.get$sourceMap$x(options); + if (t9 == null) + t9 = false; + if (t1) + t10 = _null; + else { + t10 = J.get$importers$x(options); + t10 = t10 == null ? _null : J.map$1$1$ax(t10, A.compile___parseImporter$closure(), type$.Importer); + } + t11 = t1 ? _null : A.NullableExtension_andThen0(J.get$importer$x(options), A.compile___parseImporter$closure()); + if (t11 == null) + t11 = (t1 ? _null : J.get$url$x(options)) == null ? new A.NoOpImporter0() : _null; + t12 = A._parseFunctions0(t1 ? _null : J.get$functions$x(options), false); + t13 = t1 ? _null : J.get$fatalDeprecations$x(options); + t13 = A.parseDeprecations(logger, t13, true); + t14 = t1 ? _null : J.get$silenceDeprecations$x(options); + t14 = A.parseDeprecations(logger, t14, false); + t15 = t1 ? _null : J.get$futureDeprecations$x(options); + result = A.compileString(text, t8, t13, new A.CastList(t12, A._arrayInstanceType(t12)._eval$1("CastList<1,Callable>")), A.parseDeprecations(logger, t15, false), A.ImportCache$0(t10, t4, _null), t11, _null, _null, logger, _null, t5, t14, t9, t6, t2, t3, true, t7); + t1 = t1 ? _null : J.get$sourceMapIncludeSources$x(options); + if (t1 == null) + t1 = false; + t1 = A._convertResult(result, t1); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException0) { + error = t1; + stackTrace = A.getTraceFromException(exception); + A.throwNodeException(error, ascii, color, stackTrace); + } else + throw exception; + } + }, + compileAsync1(path, options) { + var t1, color, ascii; + if (!A.isNodeJs()) + A.jsThrow(new self.Error("The compileAsync() method is only available in Node.js.")); + t1 = options == null; + color = t1 ? null : J.get$alertColor$x(options); + if (color == null) + color = A.hasTerminal0(); + ascii = t1 ? null : J.get$alertAscii$x(options); + if (ascii == null) + ascii = $._glyphs === B.C_AsciiGlyphSet; + t1 = t1 ? null : J.get$logger$x(options); + return A._wrapAsyncSassExceptions(A.futureToPromise0(new A.compileAsync_closure(path, color, options, new A.JSToDartLogger(t1, new A.StderrLogger0(color), ascii)).call$0()), ascii, color); + }, + compileStringAsync1(text, options) { + var ascii, + t1 = options == null, + color = t1 ? null : J.get$alertColor$x(options); + if (color == null) + color = A.hasTerminal0(); + ascii = t1 ? null : J.get$alertAscii$x(options); + if (ascii == null) + ascii = $._glyphs === B.C_AsciiGlyphSet; + t1 = t1 ? null : J.get$logger$x(options); + return A._wrapAsyncSassExceptions(A.futureToPromise0(new A.compileStringAsync_closure(text, options, color, new A.JSToDartLogger(t1, new A.StderrLogger0(color), ascii)).call$0()), ascii, color); + }, + _convertResult(result, includeSourceContents) { + var loadedUrls, + t1 = result._compile_result$_serialize, + t2 = t1._1, + sourceMap = t2 == null ? null : t2.toJson$1$includeSourceContents(includeSourceContents); + if (type$.Map_String_dynamic._is(sourceMap) && !sourceMap.containsKey$1("sources")) + sourceMap.$indexSet(0, "sources", A._setArrayType([], type$.JSArray_String)); + loadedUrls = A.toJSArray(result._evaluate._0.map$1$1(0, A.utils3__dartToJSUrl$closure(), type$.nullable_Object)); + t1 = t1._0; + return sourceMap == null ? {css: t1, loadedUrls: loadedUrls} : {css: t1, sourceMap: A.jsify0(sourceMap), loadedUrls: loadedUrls}; + }, + _wrapAsyncSassExceptions(promise, ascii, color) { + return J.then$2$x(promise, null, A.allowInterop(new A._wrapAsyncSassExceptions_closure(color, ascii))); + }, + _parseOutputStyle0(style) { + var t1; + $label0$0: { + if (style == null || "expanded" === style) { + t1 = B.OutputStyle_00; + break $label0$0; + } + if ("compressed" === style) { + t1 = B.OutputStyle_10; + break $label0$0; + } + t1 = A.jsThrow(new self.Error('Unknown output style "' + A.S(style) + '".')); + } + return t1; + }, + _parseAsyncImporter(importer) { + var t1, canonicalize, load, _0_0; + if (importer instanceof A.NodePackageImporter0) + return importer; + if (importer == null) + A.jsThrow(new self.Error("Importers may not be null.")); + type$.JSImporter._as(importer); + t1 = J.getInterceptor$x(importer); + canonicalize = t1.get$canonicalize(importer); + load = t1.get$load(importer); + _0_0 = t1.get$findFileUrl(importer); + if (_0_0 != null) + if (canonicalize != null || load != null) + A.jsThrow(new self.Error(string$.An_impa)); + else + return new A.JSToDartAsyncFileImporter(_0_0); + else if (canonicalize == null || load == null) + A.jsThrow(new self.Error(string$.An_impu)); + else { + t1 = A._normalizeNonCanonicalSchemes(t1.get$nonCanonicalScheme(importer)); + t1 = t1 == null ? B.Set_empty7 : A.Set_Set$unmodifiable(t1, type$.String); + t1.forEach$1(0, A.utils4__validateUrlScheme$closure()); + return new A.JSToDartAsyncImporter(canonicalize, load, t1); + } + }, + _parseImporter0(importer) { + var t1, canonicalize, load, _0_0; + if (importer instanceof A.NodePackageImporter0) + return importer; + if (importer == null) + A.jsThrow(new self.Error("Importers may not be null.")); + type$.JSImporter._as(importer); + t1 = J.getInterceptor$x(importer); + canonicalize = t1.get$canonicalize(importer); + load = t1.get$load(importer); + _0_0 = t1.get$findFileUrl(importer); + if (_0_0 != null) + if (canonicalize != null || load != null) + A.jsThrow(new self.Error(string$.An_impa)); + else + return new A.JSToDartFileImporter(_0_0); + else if (canonicalize == null || load == null) + A.jsThrow(new self.Error(string$.An_impu)); + else { + t1 = A._normalizeNonCanonicalSchemes(t1.get$nonCanonicalScheme(importer)); + t1 = t1 == null ? B.Set_empty7 : A.Set_Set$unmodifiable(t1, type$.String); + t1.forEach$1(0, A.utils4__validateUrlScheme$closure()); + return new A.JSToDartImporter(canonicalize, load, t1); + } + }, + _normalizeNonCanonicalSchemes(schemes) { + var t1; + $label0$0: { + if (typeof schemes == "string") { + t1 = A._setArrayType([schemes], type$.JSArray_String); + break $label0$0; + } + if (type$.List_dynamic._is(schemes)) { + t1 = J.cast$1$0$ax(schemes, type$.String); + break $label0$0; + } + if (schemes == null) { + t1 = null; + break $label0$0; + } + t1 = A.jsThrow(new self.Error('nonCanonicalScheme must be a string or list of strings, was "' + A.S(schemes) + '"')); + } + return t1; + }, + _simplifyValue(value) { + var _0_1, t1, t2, _0_4, _0_3, _0_4_isSet, _0_5, _0_40, _0_8, first, _0_10, min, _null = null; + $label1$1: { + if (value instanceof A.SassCalculation0) { + _0_1 = value.name; + t1 = value.$arguments; + t2 = A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Object>"); + _0_4 = A.List_List$of(new A.MappedListIterable(t1, A.compile___simplifyCalcArg$closure(), t2), true, t2._eval$1("ListIterable.E")); + $label0$0: { + _0_3 = "calc" === _0_1; + _0_4_isSet = _0_3; + _0_5 = _null; + _0_40 = _null; + if (_0_4_isSet) { + _0_5 = _0_4.length; + t1 = _0_5; + _0_40 = _0_4; + t1 = t1 === 1; + } else + t1 = false; + if (t1) { + _0_8 = (_0_4_isSet ? _0_40 : _0_4)[0]; + first = _0_8; + type$.Value_2._as(first); + t1 = first; + break $label0$0; + } + if (_0_3) + A.throwExpression(A.ArgumentError$("calc() requires exactly one argument.", _null)); + _0_10 = "clamp" === _0_1; + t1 = _0_10; + if (t1) { + if (_0_4_isSet) + t1 = _0_5; + else { + _0_5 = _0_4.length; + t1 = _0_5; + _0_40 = _0_4; + _0_4_isSet = true; + } + t1 = t1 === 3; + } else + t1 = false; + if (t1) { + if (_0_4_isSet) + t1 = _0_40; + else { + t1 = _0_4; + _0_40 = t1; + _0_4_isSet = true; + } + _0_8 = t1[0]; + min = _0_8; + if (_0_4_isSet) + t1 = _0_40; + else { + t1 = _0_4; + _0_40 = t1; + _0_4_isSet = true; + } + value = t1[1]; + t1 = A.SassCalculation_clamp0(min, value, (_0_4_isSet ? _0_40 : _0_4)[2]); + break $label0$0; + } + if (_0_10) + A.throwExpression(A.ArgumentError$("clamp() requires exactly 3 arguments.", _null)); + if ("min" === _0_1) { + t1 = A.SassCalculation_min0(_0_4_isSet ? _0_40 : _0_4); + break $label0$0; + } + if ("max" === _0_1) { + t1 = A.SassCalculation_max0(_0_4_isSet ? _0_40 : _0_4); + break $label0$0; + } + t1 = A.throwExpression(A.ArgumentError$('"' + _0_1 + '" is not a recognized calculation type.', _null)); + } + break $label1$1; + } + t1 = value; + break $label1$1; + } + return t1; + }, + _simplifyCalcArg(value) { + var t1; + $label0$0: { + if (value instanceof A.SassCalculation0) { + t1 = A._simplifyValue(value); + break $label0$0; + } + if (value instanceof A.CalculationOperation0) { + t1 = A.SassCalculation_operateInternal0(value._calculation0$_operator, A._simplifyCalcArg(value._calculation0$_left), A._simplifyCalcArg(value._calculation0$_right), null, true, null); + break $label0$0; + } + t1 = value; + break $label0$0; + } + return t1; + }, + _parseFunctions0(functions, asynch) { + var result; + if (functions == null) + return B.List_empty26; + result = A._setArrayType([], type$.JSArray_AsyncCallable_2); + A.jsForEach(functions, new A._parseFunctions_closure0(asynch, result)); + return result; + }, + compileAsync_closure: function compileAsync_closure(t0, t1, t2, t3) { + var _ = this; + _.path = t0; + _.color = t1; + _.options = t2; + _.logger = t3; + }, + compileAsync__closure: function compileAsync__closure() { + }, + compileStringAsync_closure: function compileStringAsync_closure(t0, t1, t2, t3) { + var _ = this; + _.text = t0; + _.options = t1; + _.color = t2; + _.logger = t3; + }, + compileStringAsync__closure: function compileStringAsync__closure() { + }, + compileStringAsync__closure0: function compileStringAsync__closure0() { + }, + _wrapAsyncSassExceptions_closure: function _wrapAsyncSassExceptions_closure(t0, t1) { + this.color = t0; + this.ascii = t1; + }, + _parseFunctions_closure0: function _parseFunctions_closure0(t0, t1) { + this.asynch = t0; + this.result = t1; + }, + _parseFunctions__closure2: function _parseFunctions__closure2(t0, t1) { + this.callback = t0; + this.callable = t1; + }, + _parseFunctions___closure6: function _parseFunctions___closure6(t0, t1) { + this.callback = t0; + this.$arguments = t1; + }, + _parseFunctions__closure3: function _parseFunctions__closure3(t0, t1) { + this.callback = t0; + this.callable = t1; + }, + _parseFunctions___closure5: function _parseFunctions___closure5(t0, t1) { + this.callback = t0; + this.$arguments = t1; + }, + nodePackageImporterClass_closure: function nodePackageImporterClass_closure() { + }, + nodePackageImporterClass__closure: function nodePackageImporterClass__closure() { + }, + compile(path, charset, fatalDeprecations, functions, futureDeprecations, importCache, indentWidth, lineFeed, logger, nodeImporter, quietDeps, silenceDeprecations, sourceMap, style, syntax, useSpaces, verbose) { + var t3, t4, t0, stylesheet, result, _null = null, + t1 = type$.Deprecation_3, + t2 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + if (silenceDeprecations != null) + t2.addAll$1(0, silenceDeprecations); + t3 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + if (fatalDeprecations != null) + t3.addAll$1(0, fatalDeprecations); + t4 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + if (futureDeprecations != null) + t4.addAll$1(0, futureDeprecations); + logger = new A.DeprecationProcessingLogger0(A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.int), logger, t2, t3, t4, !verbose); + logger.validate$0(); + t1 = nodeImporter == null; + if (t1) + t2 = syntax == null || syntax === A.Syntax_forPath0(path); + else + t2 = false; + if (t2) { + if (importCache == null) + importCache = A.ImportCache$none(); + t2 = $.$get$FilesystemImporter_cwd0(); + t3 = A.isNodeJs() ? self.process : _null; + if (!J.$eq$(t3 == null ? _null : J.get$platform$x(t3), "win32")) { + t3 = A.isNodeJs() ? self.process : _null; + t3 = J.$eq$(t3 == null ? _null : J.get$platform$x(t3), "darwin"); + } else + t3 = true; + if (t3) { + t3 = A.absolute(path, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null); + t4 = $.$get$context(); + t3 = A._realCasePath0(t4.normalize$1(t3)); + } else { + t3 = $.$get$context(); + t4 = t3.canonicalize$1(0, path); + t0 = t4; + t4 = t3; + t3 = t0; + } + t4 = importCache.importCanonical$3$originalUrl(t2, t4.toUri$1(t3), t4.toUri$1(path)); + t4.toString; + stylesheet = t4; + } else { + t2 = A.readFile0(path); + t3 = syntax == null ? A.Syntax_forPath0(path) : syntax; + stylesheet = A.Stylesheet_Stylesheet$parse0(t2, t3, $.$get$context().toUri$1(path)); + } + result = A._compileStylesheet1(stylesheet, logger, importCache, nodeImporter, $.$get$FilesystemImporter_cwd0(), functions, style, useSpaces, indentWidth, lineFeed, quietDeps, sourceMap, charset); + logger.summarize$1$js(!t1); + return result; + }, + compileString(source, charset, fatalDeprecations, functions, futureDeprecations, importCache, importer, indentWidth, lineFeed, logger, nodeImporter, quietDeps, silenceDeprecations, sourceMap, style, syntax, url, useSpaces, verbose) { + var t3, t4, stylesheet, result, + t1 = type$.Deprecation_3, + t2 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + if (silenceDeprecations != null) + t2.addAll$1(0, silenceDeprecations); + t3 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + if (fatalDeprecations != null) + t3.addAll$1(0, fatalDeprecations); + t4 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + if (futureDeprecations != null) + t4.addAll$1(0, futureDeprecations); + logger = new A.DeprecationProcessingLogger0(A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.int), logger, t2, t3, t4, !verbose); + logger.validate$0(); + stylesheet = A.Stylesheet_Stylesheet$parse0(source, syntax == null ? B.Syntax_SCSS_scss0 : syntax, url); + if (importer == null) + t1 = A.isBrowser() ? new A.NoOpImporter0() : $.$get$FilesystemImporter_cwd0(); + else + t1 = importer; + result = A._compileStylesheet1(stylesheet, logger, importCache, nodeImporter, t1, functions, style, useSpaces, indentWidth, lineFeed, quietDeps, sourceMap, charset); + logger.summarize$1$js(nodeImporter != null); + return result; + }, + _compileStylesheet1(stylesheet, logger, importCache, nodeImporter, importer, functions, style, useSpaces, indentWidth, lineFeed, quietDeps, sourceMap, charset) { + var evaluateResult, serializeResult, resultSourceMap; + if (nodeImporter != null) + A.WarnForDeprecation_warnForDeprecation0(logger, B.Deprecation_F8y, string$.The_le, null, null); + evaluateResult = A._EvaluateVisitor$1(functions, importCache, logger, nodeImporter, quietDeps, sourceMap).run$2(0, importer, stylesheet); + serializeResult = A.serialize0(evaluateResult._1, charset, indentWidth, false, lineFeed, logger, sourceMap, style, useSpaces); + resultSourceMap = serializeResult._1; + if (resultSourceMap != null && importCache != null) + A.mapInPlace0(resultSourceMap.urls, new A._compileStylesheet_closure1(stylesheet, importCache)); + return new A.CompileResult0(evaluateResult, serializeResult); + }, + _compileStylesheet_closure1: function _compileStylesheet_closure1(t0, t1) { + this.stylesheet = t0; + this.importCache = t1; + }, + CompileOptions: function CompileOptions() { + }, + CompileStringOptions: function CompileStringOptions() { + }, + NodeCompileResult: function NodeCompileResult() { + }, + CompileResult0: function CompileResult0(t0, t1) { + this._evaluate = t0; + this._compile_result$_serialize = t1; + }, + initCompiler() { + return new A.Compiler(); + }, + initAsyncCompiler() { + return A.futureToPromise0(new A.initAsyncCompiler_closure().call$0()); + }, + Compiler: function Compiler() { + this._disposed = false; + }, + AsyncCompiler: function AsyncCompiler(t0) { + this.compilations = t0; + this._disposed = false; + }, + AsyncCompiler_addCompilation_closure: function AsyncCompiler_addCompilation_closure() { + }, + compilerClass_closure: function compilerClass_closure() { + }, + compilerClass__closure: function compilerClass__closure() { + }, + compilerClass__closure0: function compilerClass__closure0() { + }, + compilerClass__closure1: function compilerClass__closure1() { + }, + compilerClass__closure2: function compilerClass__closure2() { + }, + asyncCompilerClass_closure: function asyncCompilerClass_closure() { + }, + asyncCompilerClass__closure: function asyncCompilerClass__closure() { + }, + asyncCompilerClass__closure0: function asyncCompilerClass__closure0() { + }, + asyncCompilerClass__closure1: function asyncCompilerClass__closure1() { + }, + asyncCompilerClass__closure2: function asyncCompilerClass__closure2() { + }, + asyncCompilerClass___closure: function asyncCompilerClass___closure(t0) { + this.self = t0; + }, + initAsyncCompiler_closure: function initAsyncCompiler_closure() { + }, + ComplexSassNumber0: function ComplexSassNumber0(t0, t1, t2, t3) { + var _ = this; + _._complex0$_numeratorUnits = t0; + _._complex0$_denominatorUnits = t1; + _._number1$_value = t2; + _.hashCache = null; + _.asSlash = t3; + }, + ComplexSelector$0(leadingCombinators, components, span, lineBreak) { + var t1 = A.List_List$unmodifiable(leadingCombinators, type$.CssValue_Combinator_2), + t2 = A.List_List$unmodifiable(components, type$.ComplexSelectorComponent_2); + if (t1.length === 0 && t2.length === 0) + A.throwExpression(A.ArgumentError$(string$.leadin, null)); + return new A.ComplexSelector0(t1, t2, lineBreak, span); + }, + ComplexSelector0: function ComplexSelector0(t0, t1, t2, t3) { + var _ = this; + _.leadingCombinators = t0; + _.components = t1; + _.lineBreak = t2; + _._complex$__ComplexSelector_specificity_FI = $; + _.span = t3; + }, + ComplexSelector_specificity_closure0: function ComplexSelector_specificity_closure0() { + }, + ComplexSelectorComponent0: function ComplexSelectorComponent0(t0, t1, t2) { + this.selector = t0; + this.combinators = t1; + this.span = t2; + }, + ComplexSelectorComponent_toString_closure0: function ComplexSelectorComponent_toString_closure0() { + }, + CompoundSelector$0(components, span) { + var t1 = A.List_List$unmodifiable(components, type$.SimpleSelector_2); + if (t1.length === 0) + A.throwExpression(A.ArgumentError$("components may not be empty.", null)); + return new A.CompoundSelector0(t1, span); + }, + CompoundSelector0: function CompoundSelector0(t0, t1) { + var _ = this; + _.components = t0; + _._compound$__CompoundSelector_hasComplicatedSuperselectorSemantics_FI = _._compound$__CompoundSelector_specificity_FI = $; + _.span = t1; + }, + CompoundSelector_specificity_closure0: function CompoundSelector_specificity_closure0() { + }, + CompoundSelector_hasComplicatedSuperselectorSemantics_closure0: function CompoundSelector_hasComplicatedSuperselectorSemantics_closure0() { + }, + Configuration0: function Configuration0(t0, t1) { + this._configuration0$_values = t0; + this._configuration0$__originalConfiguration = t1; + }, + ExplicitConfiguration0: function ExplicitConfiguration0(t0, t1, t2) { + this.nodeWithSpan = t0; + this._configuration0$_values = t1; + this._configuration0$__originalConfiguration = t2; + }, + ConfiguredValue0: function ConfiguredValue0(t0, t1, t2) { + this.value = t0; + this.configurationSpan = t1; + this.assignmentNode = t2; + }, + ConfiguredVariable0: function ConfiguredVariable0(t0, t1, t2, t3) { + var _ = this; + _.name = t0; + _.expression = t1; + _.isGuarded = t2; + _.span = t3; + }, + ContentBlock$0(parameters, children, span) { + var _s8_ = "@content", + t1 = A.stringReplaceAllUnchecked(_s8_, "_", "-"), + t2 = A.List_List$unmodifiable(children, type$.Statement_2), + t3 = B.JSArray_methods.any$1(t2, new A.ParentStatement_closure0()); + return new A.ContentBlock0(t1, _s8_, parameters, span, t2, t3); + }, + ContentBlock0: function ContentBlock0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.name = t0; + _.originalName = t1; + _.parameters = t2; + _.span = t3; + _.children = t4; + _.hasDeclarations = t5; + }, + ContentRule0: function ContentRule0(t0, t1) { + this.$arguments = t0; + this.span = t1; + }, + _disallowedFunctionNames_closure0: function _disallowedFunctionNames_closure0() { + }, + CssParser0: function CssParser0(t0, t1, t2, t3) { + var _ = this; + _._stylesheet0$_isUseAllowed = true; + _._stylesheet0$_inExpression = _._stylesheet0$_inParentheses = _._stylesheet0$_inStyleRule = _._stylesheet0$_inUnknownAtRule = _._stylesheet0$_inControlDirective = _._stylesheet0$_inContentBlock = _._stylesheet0$_inMixin = false; + _._stylesheet0$_globalVariables = t0; + _.warnings = t1; + _.lastSilentComment = null; + _.scanner = t2; + _._parser1$_interpolationMap = t3; + }, + DebugRule0: function DebugRule0(t0, t1) { + this.expression = t0; + this.span = t1; + }, + ModifiableCssDeclaration$0($name, value, span, interleavedRules, parsedAsCustomProperty, trace, valueSpanForMap) { + var t3, + t1 = interleavedRules == null ? B.List_empty23 : A.List_List$unmodifiable(interleavedRules, type$.CssStyleRule_2), + t2 = valueSpanForMap == null ? value.span : valueSpanForMap; + if (parsedAsCustomProperty) + if (!J.startsWith$1$s($name.value, "--")) + A.throwExpression(A.ArgumentError$(string$.parsed, null)); + else { + t3 = value.value; + if (!(t3 instanceof A.SassString0)) + A.throwExpression(A.ArgumentError$(string$.If_par + value.toString$0(0) + "` of type " + A.getRuntimeTypeOfDartObject(t3).toString$0(0) + ").", null)); + } + return new A.ModifiableCssDeclaration0($name, value, parsedAsCustomProperty, t1, trace, t2, span); + }, + ModifiableCssDeclaration0: function ModifiableCssDeclaration0(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.name = t0; + _.value = t1; + _.parsedAsCustomProperty = t2; + _.interleavedRules = t3; + _.trace = t4; + _.valueSpanForMap = t5; + _.span = t6; + _._node$_indexInParent = _._node$_parent = null; + _.isGroupEnd = false; + }, + Declaration$0($name, value, span) { + return new A.Declaration0($name, value, span, null, false); + }, + Declaration$nested0($name, children, span, value) { + var t1 = A.List_List$unmodifiable(children, type$.Statement_2), + t2 = B.JSArray_methods.any$1(t1, new A.ParentStatement_closure0()); + return new A.Declaration0($name, value, span, t1, t2); + }, + Declaration0: function Declaration0(t0, t1, t2, t3, t4) { + var _ = this; + _.name = t0; + _.value = t1; + _.span = t2; + _.children = t3; + _.hasDeclarations = t4; + }, + SupportsDeclaration0: function SupportsDeclaration0(t0, t1, t2) { + this.name = t0; + this.value = t1; + this.span = t2; + }, + Deprecation_fromId0(id) { + return A.IterableExtension_firstWhereOrNull(B.List_MG2, new A.Deprecation_fromId_closure0(id)); + }, + Deprecation_forVersion0(version) { + var t2, _i, deprecation, $self, t3, + t1 = A.LinkedHashSet_LinkedHashSet$_empty(type$.Deprecation_3); + for (t2 = A.VersionRange_VersionRange(true, version).get$allows(), _i = 0; _i < 25; ++_i) { + deprecation = B.List_MG2[_i]; + $self = deprecation._deprecation$_deprecatedIn; + t3 = $self == null ? null : A.Version___parse_tearOff($self); + t3 = t3 == null ? null : t2.call$1(t3); + if (t3 == null ? false : t3) + t1.add$1(0, deprecation); + } + return t1; + }, + Deprecation0: function Deprecation0(t0, t1, t2, t3) { + var _ = this; + _.id = t0; + _._deprecation$_deprecatedIn = t1; + _.description = t2; + _._name = t3; + }, + Deprecation_fromId_closure0: function Deprecation_fromId_closure0(t0) { + this.id = t0; + }, + DeprecationProcessingLogger0: function DeprecationProcessingLogger0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._deprecation_processing$_warningCounts = t0; + _._deprecation_processing$_inner = t1; + _.silenceDeprecations = t2; + _.fatalDeprecations = t3; + _.futureDeprecations = t4; + _.limitRepetition = t5; + }, + DeprecationProcessingLogger_summarize_closure1: function DeprecationProcessingLogger_summarize_closure1() { + }, + DeprecationProcessingLogger_summarize_closure2: function DeprecationProcessingLogger_summarize_closure2() { + }, + parseDeprecations(logger, deprecations, supportVersions) { + if (deprecations == null) + return null; + return new A.parseDeprecations_closure(deprecations, logger, supportVersions).call$0(); + }, + Deprecation1: function Deprecation1() { + }, + deprecations_closure: function deprecations_closure(t0) { + this.deprecation = t0; + }, + parseDeprecations_closure: function parseDeprecations_closure(t0, t1, t2) { + this.deprecations = t0; + this.logger = t1; + this.supportVersions = t2; + }, + versionClass_closure: function versionClass_closure() { + }, + versionClass__closure: function versionClass__closure() { + }, + versionClass__closure0: function versionClass__closure0() { + }, + DisplayP3ColorSpace0: function DisplayP3ColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + DynamicImport0: function DynamicImport0(t0, t1) { + this.urlString = t0; + this.span = t1; + }, + EachRule$0(variables, list, children, span) { + var t1 = A.List_List$unmodifiable(variables, type$.String), + t2 = A.List_List$unmodifiable(children, type$.Statement_2), + t3 = B.JSArray_methods.any$1(t2, new A.ParentStatement_closure0()); + return new A.EachRule0(t1, list, span, t2, t3); + }, + EachRule0: function EachRule0(t0, t1, t2, t3, t4) { + var _ = this; + _.variables = t0; + _.list = t1; + _.span = t2; + _.children = t3; + _.hasDeclarations = t4; + }, + EachRule_toString_closure0: function EachRule_toString_closure0() { + }, + EmptyExtensionStore0: function EmptyExtensionStore0() { + }, + Environment$0() { + var t1 = type$.String, + t2 = type$.Module_Callable_2, + t3 = type$.AstNode_2, + t4 = type$.int, + t5 = type$.Callable_2, + t6 = type$.JSArray_Map_String_Callable_2; + return new A.Environment0(A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), A.LinkedHashMap_LinkedHashMap$_empty(t1, t3), A.LinkedHashMap_LinkedHashMap$_empty(t2, t3), A.LinkedHashMap_LinkedHashMap$_empty(t2, t3), null, null, A._setArrayType([], type$.JSArray_Module_Callable_2), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Value_2)], type$.JSArray_Map_String_Value_2), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, t3)], type$.JSArray_Map_String_AstNode_2), A.LinkedHashMap_LinkedHashMap$_empty(t1, t4), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, t5)], t6), A.LinkedHashMap_LinkedHashMap$_empty(t1, t4), A._setArrayType([A.LinkedHashMap_LinkedHashMap$_empty(t1, t5)], t6), A.LinkedHashMap_LinkedHashMap$_empty(t1, t4), null); + }, + Environment$_0(_modules, _namespaceNodes, _globalModules, _importedModules, _forwardedModules, _nestedForwardedModules, _allModules, _variables, _variableNodes, _functions, _mixins, _content) { + var t1 = type$.String, + t2 = type$.int; + return new A.Environment0(_modules, _namespaceNodes, _globalModules, _importedModules, _forwardedModules, _nestedForwardedModules, _allModules, _variables, _variableNodes, A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), _functions, A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), _mixins, A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), _content); + }, + _EnvironmentModule__EnvironmentModule1(environment, css, preModuleComments, extensionStore, forwarded) { + var t1, t2, t3, t4, t5, t6, module, result, t7; + if (forwarded == null) + forwarded = B.Set_empty4; + t1 = type$.dynamic; + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t2 = type$.Module_Callable_2, t3 = type$.List_CssComment_2, t4 = A.MapExtensions_get_pairs0(preModuleComments, t2, t3), t4 = t4.get$iterator(t4), t5 = type$.CssComment_2; t4.moveNext$0();) { + t6 = t4.get$current(t4); + module = t6._0; + result = A.List_List$from(t6._1, false, t5); + result.$flags = 3; + t1.$indexSet(0, module, result); + } + t1 = A.ConstantMap_ConstantMap$from(t1, t2, t3); + t2 = A._EnvironmentModule__makeModulesByVariable1(forwarded); + t3 = A._EnvironmentModule__memberMap1(B.JSArray_methods.get$first(environment._environment0$_variables), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure11(), type$.Map_String_Value_2), type$.Value_2); + t4 = A._EnvironmentModule__memberMap1(B.JSArray_methods.get$first(environment._environment0$_variableNodes), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure12(), type$.Map_String_AstNode_2), type$.AstNode_2); + t5 = type$.Map_String_Callable_2; + t6 = type$.Callable_2; + t7 = A._EnvironmentModule__memberMap1(B.JSArray_methods.get$first(environment._environment0$_functions), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure13(), t5), t6); + t6 = A._EnvironmentModule__memberMap1(B.JSArray_methods.get$first(environment._environment0$_mixins), forwarded.map$1$1(0, new A._EnvironmentModule__EnvironmentModule_closure14(), t5), t6); + t5 = J.get$isNotEmpty$asx(css.get$children(css)) || preModuleComments.get$isNotEmpty(preModuleComments) || B.JSArray_methods.any$1(environment._environment0$_allModules, new A._EnvironmentModule__EnvironmentModule_closure15()); + return A._EnvironmentModule$_1(environment, css, t1, extensionStore, t2, t3, t4, t7, t6, t5, !extensionStore.get$isEmpty(extensionStore) || B.JSArray_methods.any$1(environment._environment0$_allModules, new A._EnvironmentModule__EnvironmentModule_closure16())); + }, + _EnvironmentModule__makeModulesByVariable1(forwarded) { + var modulesByVariable, t1, t2, t3, t4, t5; + if (forwarded.get$isEmpty(forwarded)) + return B.Map_empty11; + modulesByVariable = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.Module_Callable_2); + for (t1 = forwarded.get$iterator(forwarded); t1.moveNext$0();) { + t2 = t1.get$current(t1); + if (t2 instanceof A._EnvironmentModule1) { + for (t3 = t2._environment0$_modulesByVariable, t3 = t3.get$values(t3), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t5 = t4.get$variables(); + A.setAll0(modulesByVariable, t5.get$keys(t5), t4); + } + A.setAll0(modulesByVariable, J.get$keys$z(B.JSArray_methods.get$first(t2._environment0$_environment._environment0$_variables)), t2); + } else { + t3 = t2.get$variables(); + A.setAll0(modulesByVariable, t3.get$keys(t3), t2); + } + } + return modulesByVariable; + }, + _EnvironmentModule__memberMap1(localMap, otherMaps, $V) { + var t1, t2, t3; + localMap = new A.PublicMemberMapView0(localMap, $V._eval$1("PublicMemberMapView0<0>")); + if (otherMaps.get$isEmpty(otherMaps)) + return localMap; + t1 = A._setArrayType([], $V._eval$1("JSArray>")); + for (t2 = otherMaps.get$iterator(otherMaps); t2.moveNext$0();) { + t3 = t2.get$current(t2); + if (t3.get$isNotEmpty(t3)) + t1.push(t3); + } + t1.push(localMap); + if (t1.length === 1) + return localMap; + return A.MergedMapView$0(t1, type$.String, $V); + }, + _EnvironmentModule$_1(_environment, css, preModuleComments, extensionStore, _modulesByVariable, variables, variableNodes, functions, mixins, transitivelyContainsCss, transitivelyContainsExtensions) { + return new A._EnvironmentModule1(_environment._environment0$_allModules, variables, variableNodes, functions, mixins, extensionStore, css, preModuleComments, transitivelyContainsCss, transitivelyContainsExtensions, _environment, _modulesByVariable); + }, + Environment0: function Environment0(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14) { + var _ = this; + _._environment0$_modules = t0; + _._environment0$_namespaceNodes = t1; + _._environment0$_globalModules = t2; + _._environment0$_importedModules = t3; + _._environment0$_forwardedModules = t4; + _._environment0$_nestedForwardedModules = t5; + _._environment0$_allModules = t6; + _._environment0$_variables = t7; + _._environment0$_variableNodes = t8; + _._environment0$_variableIndices = t9; + _._environment0$_functions = t10; + _._environment0$_functionIndices = t11; + _._environment0$_mixins = t12; + _._environment0$_mixinIndices = t13; + _._environment0$_content = t14; + _._environment0$_inMixin = false; + _._environment0$_inSemiGlobalScope = true; + _._environment0$_lastVariableIndex = _._environment0$_lastVariableName = null; + }, + Environment__getVariableFromGlobalModule_closure0: function Environment__getVariableFromGlobalModule_closure0(t0) { + this.name = t0; + }, + Environment_setVariable_closure2: function Environment_setVariable_closure2(t0, t1) { + this.$this = t0; + this.name = t1; + }, + Environment_setVariable_closure3: function Environment_setVariable_closure3(t0) { + this.name = t0; + }, + Environment_setVariable_closure4: function Environment_setVariable_closure4(t0, t1) { + this.$this = t0; + this.name = t1; + }, + Environment__getFunctionFromGlobalModule_closure0: function Environment__getFunctionFromGlobalModule_closure0(t0) { + this.name = t0; + }, + Environment__getMixinFromGlobalModule_closure0: function Environment__getMixinFromGlobalModule_closure0(t0) { + this.name = t0; + }, + Environment_toModule_closure0: function Environment_toModule_closure0() { + }, + Environment_toDummyModule_closure0: function Environment_toDummyModule_closure0() { + }, + _EnvironmentModule1: function _EnvironmentModule1(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11) { + var _ = this; + _.upstream = t0; + _.variables = t1; + _.variableNodes = t2; + _.functions = t3; + _.mixins = t4; + _.extensionStore = t5; + _.css = t6; + _.preModuleComments = t7; + _.transitivelyContainsCss = t8; + _.transitivelyContainsExtensions = t9; + _._environment0$_environment = t10; + _._environment0$_modulesByVariable = t11; + }, + _EnvironmentModule__EnvironmentModule_closure11: function _EnvironmentModule__EnvironmentModule_closure11() { + }, + _EnvironmentModule__EnvironmentModule_closure12: function _EnvironmentModule__EnvironmentModule_closure12() { + }, + _EnvironmentModule__EnvironmentModule_closure13: function _EnvironmentModule__EnvironmentModule_closure13() { + }, + _EnvironmentModule__EnvironmentModule_closure14: function _EnvironmentModule__EnvironmentModule_closure14() { + }, + _EnvironmentModule__EnvironmentModule_closure15: function _EnvironmentModule__EnvironmentModule_closure15() { + }, + _EnvironmentModule__EnvironmentModule_closure16: function _EnvironmentModule__EnvironmentModule_closure16() { + }, + ErrorRule0: function ErrorRule0(t0, t1) { + this.expression = t0; + this.span = t1; + }, + _EvaluateVisitor$1(functions, importCache, logger, nodeImporter, quietDeps, sourceMap) { + var t4, + t1 = type$.Uri, + t2 = type$.Module_Callable_2, + t3 = A._setArrayType([], type$.JSArray_Record_2_String_and_AstNode_2); + if (importCache == null) + t4 = nodeImporter == null ? A.ImportCache$none() : null; + else + t4 = importCache; + t1 = new A._EvaluateVisitor1(t4, nodeImporter, A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.Callable_2), A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Configuration_2), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.AstNode_2), logger, A.LinkedHashSet_LinkedHashSet$_empty(type$.Record_2_String_and_SourceSpan), quietDeps, sourceMap, A.Environment$0(), A.LinkedHashSet_LinkedHashSet$_empty(t1), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.nullable_AstNode_2), t3, B.Configuration_Map_empty_null0); + t1._EvaluateVisitor$6$functions$importCache$logger$nodeImporter$quietDeps$sourceMap1(functions, importCache, logger, nodeImporter, quietDeps, sourceMap); + return t1; + }, + _EvaluateVisitor1: function _EvaluateVisitor1(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15) { + var _ = this; + _._evaluate0$_importCache = t0; + _._nodeImporter = t1; + _._evaluate0$_builtInFunctions = t2; + _._evaluate0$_builtInModules = t3; + _._evaluate0$_modules = t4; + _._evaluate0$_moduleConfigurations = t5; + _._evaluate0$_moduleNodes = t6; + _._evaluate0$_logger = t7; + _._evaluate0$_warningsEmitted = t8; + _._evaluate0$_quietDeps = t9; + _._evaluate0$_sourceMap = t10; + _._evaluate0$_environment = t11; + _._evaluate0$_declarationName = _._evaluate0$__parent = _._evaluate0$_mediaQuerySources = _._evaluate0$_mediaQueries = _._evaluate0$_styleRuleIgnoringAtRoot = null; + _._evaluate0$_member = "root stylesheet"; + _._evaluate0$_importSpan = _._evaluate0$_callableNode = _._evaluate0$_currentCallable = null; + _._evaluate0$_inSupportsDeclaration = _._evaluate0$_inKeyframes = _._evaluate0$_atRootExcludingStyleRule = _._evaluate0$_inUnknownAtRule = _._evaluate0$_inFunction = false; + _._evaluate0$_loadedUrls = t12; + _._evaluate0$_activeModules = t13; + _._evaluate0$_stack = t14; + _._evaluate0$_importer = null; + _._evaluate0$_inDependency = false; + _._evaluate0$__extensionStore = _._evaluate0$_preModuleComments = _._evaluate0$_outOfOrderImports = _._evaluate0$__endOfImports = _._evaluate0$__root = _._evaluate0$__stylesheet = null; + _._evaluate0$_configuration = t15; + }, + _EvaluateVisitor_closure25: function _EvaluateVisitor_closure25(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure26: function _EvaluateVisitor_closure26(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure27: function _EvaluateVisitor_closure27(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure28: function _EvaluateVisitor_closure28(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure29: function _EvaluateVisitor_closure29(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure30: function _EvaluateVisitor_closure30(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure31: function _EvaluateVisitor_closure31(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure32: function _EvaluateVisitor_closure32(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure33: function _EvaluateVisitor_closure33(t0) { + this.$this = t0; + }, + _EvaluateVisitor__closure10: function _EvaluateVisitor__closure10(t0, t1, t2) { + this.$this = t0; + this.name = t1; + this.module = t2; + }, + _EvaluateVisitor_closure34: function _EvaluateVisitor_closure34(t0) { + this.$this = t0; + }, + _EvaluateVisitor__closure9: function _EvaluateVisitor__closure9(t0, t1, t2) { + this.$this = t0; + this.name = t1; + this.module = t2; + }, + _EvaluateVisitor_closure35: function _EvaluateVisitor_closure35(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure36: function _EvaluateVisitor_closure36(t0) { + this.$this = t0; + }, + _EvaluateVisitor__closure7: function _EvaluateVisitor__closure7(t0, t1, t2) { + this.values = t0; + this.span = t1; + this.callableNode = t2; + }, + _EvaluateVisitor__closure8: function _EvaluateVisitor__closure8(t0) { + this.$this = t0; + }, + _EvaluateVisitor_closure37: function _EvaluateVisitor_closure37(t0) { + this.$this = t0; + }, + _EvaluateVisitor_run_closure1: function _EvaluateVisitor_run_closure1(t0, t1, t2) { + this.$this = t0; + this.node = t1; + this.importer = t2; + }, + _EvaluateVisitor_run__closure1: function _EvaluateVisitor_run__closure1(t0, t1, t2) { + this.$this = t0; + this.importer = t1; + this.node = t2; + }, + _EvaluateVisitor__loadModule_closure3: function _EvaluateVisitor__loadModule_closure3(t0, t1) { + this._box_0 = t0; + this.callback = t1; + }, + _EvaluateVisitor__loadModule_closure4: function _EvaluateVisitor__loadModule_closure4(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.$this = t0; + _.url = t1; + _.nodeWithSpan = t2; + _.baseUrl = t3; + _.namesInErrors = t4; + _.configuration = t5; + _.callback = t6; + }, + _EvaluateVisitor__loadModule__closure3: function _EvaluateVisitor__loadModule__closure3(t0, t1) { + this.$this = t0; + this.message = t1; + }, + _EvaluateVisitor__loadModule__closure4: function _EvaluateVisitor__loadModule__closure4(t0, t1, t2) { + this._box_1 = t0; + this.callback = t1; + this.firstLoad = t2; + }, + _EvaluateVisitor__execute_closure1: function _EvaluateVisitor__execute_closure1(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.$this = t0; + _.importer = t1; + _.stylesheet = t2; + _.extensionStore = t3; + _.configuration = t4; + _.css = t5; + _.preModuleComments = t6; + }, + _EvaluateVisitor__combineCss_closure3: function _EvaluateVisitor__combineCss_closure3() { + }, + _EvaluateVisitor__combineCss_closure4: function _EvaluateVisitor__combineCss_closure4(t0) { + this.selectors = t0; + }, + _EvaluateVisitor__combineCss_visitModule1: function _EvaluateVisitor__combineCss_visitModule1(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.seen = t1; + _.clone = t2; + _.css = t3; + _.imports = t4; + _.sorted = t5; + }, + _EvaluateVisitor__extendModules_closure3: function _EvaluateVisitor__extendModules_closure3(t0) { + this.originalSelectors = t0; + }, + _EvaluateVisitor__extendModules_closure4: function _EvaluateVisitor__extendModules_closure4() { + }, + _EvaluateVisitor_visitAtRootRule_closure3: function _EvaluateVisitor_visitAtRootRule_closure3(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitAtRootRule_closure4: function _EvaluateVisitor_visitAtRootRule_closure4(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure11: function _EvaluateVisitor__scopeForAtRoot_closure11(t0, t1, t2) { + this.$this = t0; + this.newParent = t1; + this.node = t2; + }, + _EvaluateVisitor__scopeForAtRoot_closure12: function _EvaluateVisitor__scopeForAtRoot_closure12(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure13: function _EvaluateVisitor__scopeForAtRoot_closure13(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor__scopeForAtRoot__closure1: function _EvaluateVisitor__scopeForAtRoot__closure1(t0, t1) { + this.innerScope = t0; + this.callback = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure14: function _EvaluateVisitor__scopeForAtRoot_closure14(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor__scopeForAtRoot_closure15: function _EvaluateVisitor__scopeForAtRoot_closure15() { + }, + _EvaluateVisitor__scopeForAtRoot_closure16: function _EvaluateVisitor__scopeForAtRoot_closure16(t0, t1) { + this.$this = t0; + this.innerScope = t1; + }, + _EvaluateVisitor_visitContentRule_closure1: function _EvaluateVisitor_visitContentRule_closure1(t0, t1) { + this.$this = t0; + this.content = t1; + }, + _EvaluateVisitor_visitDeclaration_closure1: function _EvaluateVisitor_visitDeclaration_closure1(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + _EvaluateVisitor_visitEachRule_closure5: function _EvaluateVisitor_visitEachRule_closure5(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.nodeWithSpan = t2; + }, + _EvaluateVisitor_visitEachRule_closure6: function _EvaluateVisitor_visitEachRule_closure6(t0, t1, t2) { + this._box_1 = t0; + this.$this = t1; + this.nodeWithSpan = t2; + }, + _EvaluateVisitor_visitEachRule_closure7: function _EvaluateVisitor_visitEachRule_closure7(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.list = t1; + _.setVariables = t2; + _.node = t3; + }, + _EvaluateVisitor_visitEachRule__closure1: function _EvaluateVisitor_visitEachRule__closure1(t0, t1, t2) { + this.$this = t0; + this.setVariables = t1; + this.node = t2; + }, + _EvaluateVisitor_visitEachRule___closure1: function _EvaluateVisitor_visitEachRule___closure1(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitAtRule_closure5: function _EvaluateVisitor_visitAtRule_closure5(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitAtRule_closure6: function _EvaluateVisitor_visitAtRule_closure6(t0, t1, t2) { + this.$this = t0; + this.name = t1; + this.children = t2; + }, + _EvaluateVisitor_visitAtRule__closure1: function _EvaluateVisitor_visitAtRule__closure1(t0, t1) { + this.$this = t0; + this.children = t1; + }, + _EvaluateVisitor_visitAtRule_closure7: function _EvaluateVisitor_visitAtRule_closure7() { + }, + _EvaluateVisitor_visitForRule_closure9: function _EvaluateVisitor_visitForRule_closure9(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitForRule_closure10: function _EvaluateVisitor_visitForRule_closure10(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitForRule_closure11: function _EvaluateVisitor_visitForRule_closure11(t0) { + this.fromNumber = t0; + }, + _EvaluateVisitor_visitForRule_closure12: function _EvaluateVisitor_visitForRule_closure12(t0, t1) { + this.toNumber = t0; + this.fromNumber = t1; + }, + _EvaluateVisitor_visitForRule_closure13: function _EvaluateVisitor_visitForRule_closure13(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.node = t2; + _.from = t3; + _.direction = t4; + _.fromNumber = t5; + }, + _EvaluateVisitor_visitForRule__closure1: function _EvaluateVisitor_visitForRule__closure1(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitForwardRule_closure3: function _EvaluateVisitor_visitForwardRule_closure3(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitForwardRule_closure4: function _EvaluateVisitor_visitForwardRule_closure4(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__registerCommentsForModule_closure1: function _EvaluateVisitor__registerCommentsForModule_closure1() { + }, + _EvaluateVisitor_visitIfRule_closure1: function _EvaluateVisitor_visitIfRule_closure1(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitIfRule__closure1: function _EvaluateVisitor_visitIfRule__closure1(t0, t1) { + this.$this = t0; + this.clause = t1; + }, + _EvaluateVisitor_visitIfRule___closure1: function _EvaluateVisitor_visitIfRule___closure1(t0) { + this.$this = t0; + }, + _EvaluateVisitor__visitDynamicImport_closure1: function _EvaluateVisitor__visitDynamicImport_closure1(t0, t1) { + this.$this = t0; + this.$import = t1; + }, + _EvaluateVisitor__visitDynamicImport__closure7: function _EvaluateVisitor__visitDynamicImport__closure7(t0) { + this.$this = t0; + }, + _EvaluateVisitor__visitDynamicImport__closure8: function _EvaluateVisitor__visitDynamicImport__closure8() { + }, + _EvaluateVisitor__visitDynamicImport__closure9: function _EvaluateVisitor__visitDynamicImport__closure9() { + }, + _EvaluateVisitor__visitDynamicImport__closure10: function _EvaluateVisitor__visitDynamicImport__closure10(t0, t1, t2, t3, t4) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.loadsUserDefinedModules = t2; + _.environment = t3; + _.children = t4; + }, + _EvaluateVisitor__applyMixin_closure3: function _EvaluateVisitor__applyMixin_closure3(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.$arguments = t1; + _.mixin = t2; + _.nodeWithSpanWithoutContent = t3; + }, + _EvaluateVisitor__applyMixin__closure4: function _EvaluateVisitor__applyMixin__closure4(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.$arguments = t1; + _.mixin = t2; + _.nodeWithSpanWithoutContent = t3; + }, + _EvaluateVisitor__applyMixin_closure4: function _EvaluateVisitor__applyMixin_closure4(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.contentCallable = t1; + _.mixin = t2; + _.nodeWithSpanWithoutContent = t3; + }, + _EvaluateVisitor__applyMixin__closure3: function _EvaluateVisitor__applyMixin__closure3(t0, t1, t2) { + this.$this = t0; + this.mixin = t1; + this.nodeWithSpanWithoutContent = t2; + }, + _EvaluateVisitor__applyMixin___closure1: function _EvaluateVisitor__applyMixin___closure1(t0, t1, t2) { + this.$this = t0; + this.mixin = t1; + this.nodeWithSpanWithoutContent = t2; + }, + _EvaluateVisitor__applyMixin____closure1: function _EvaluateVisitor__applyMixin____closure1(t0, t1) { + this.$this = t0; + this.statement = t1; + }, + _EvaluateVisitor_visitIncludeRule_closure5: function _EvaluateVisitor_visitIncludeRule_closure5(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitIncludeRule_closure6: function _EvaluateVisitor_visitIncludeRule_closure6(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitIncludeRule_closure7: function _EvaluateVisitor_visitIncludeRule_closure7(t0) { + this.node = t0; + }, + _EvaluateVisitor_visitMediaRule_closure5: function _EvaluateVisitor_visitMediaRule_closure5(t0, t1) { + this.$this = t0; + this.queries = t1; + }, + _EvaluateVisitor_visitMediaRule_closure6: function _EvaluateVisitor_visitMediaRule_closure6(t0, t1, t2, t3, t4) { + var _ = this; + _.$this = t0; + _.mergedQueries = t1; + _.queries = t2; + _.mergedSources = t3; + _.node = t4; + }, + _EvaluateVisitor_visitMediaRule__closure1: function _EvaluateVisitor_visitMediaRule__closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitMediaRule___closure1: function _EvaluateVisitor_visitMediaRule___closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitMediaRule_closure7: function _EvaluateVisitor_visitMediaRule_closure7(t0) { + this.mergedSources = t0; + }, + _EvaluateVisitor_visitStyleRule_closure7: function _EvaluateVisitor_visitStyleRule_closure7(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitStyleRule_closure8: function _EvaluateVisitor_visitStyleRule_closure8() { + }, + _EvaluateVisitor_visitStyleRule_closure10: function _EvaluateVisitor_visitStyleRule_closure10(t0, t1, t2) { + this.$this = t0; + this.rule = t1; + this.node = t2; + }, + _EvaluateVisitor_visitStyleRule__closure1: function _EvaluateVisitor_visitStyleRule__closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitStyleRule_closure9: function _EvaluateVisitor_visitStyleRule_closure9() { + }, + _EvaluateVisitor__warnForBogusCombinators_closure1: function _EvaluateVisitor__warnForBogusCombinators_closure1() { + }, + _EvaluateVisitor_visitSupportsRule_closure3: function _EvaluateVisitor_visitSupportsRule_closure3(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitSupportsRule__closure1: function _EvaluateVisitor_visitSupportsRule__closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitSupportsRule_closure4: function _EvaluateVisitor_visitSupportsRule_closure4() { + }, + _EvaluateVisitor__visitSupportsCondition_closure1: function _EvaluateVisitor__visitSupportsCondition_closure1(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + _EvaluateVisitor_visitVariableDeclaration_closure5: function _EvaluateVisitor_visitVariableDeclaration_closure5(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.node = t2; + }, + _EvaluateVisitor_visitVariableDeclaration_closure6: function _EvaluateVisitor_visitVariableDeclaration_closure6(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitVariableDeclaration_closure7: function _EvaluateVisitor_visitVariableDeclaration_closure7(t0, t1, t2) { + this.$this = t0; + this.node = t1; + this.value = t2; + }, + _EvaluateVisitor_visitUseRule_closure1: function _EvaluateVisitor_visitUseRule_closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitWarnRule_closure1: function _EvaluateVisitor_visitWarnRule_closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitWhileRule_closure1: function _EvaluateVisitor_visitWhileRule_closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitWhileRule__closure1: function _EvaluateVisitor_visitWhileRule__closure1(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitBinaryOperationExpression_closure1: function _EvaluateVisitor_visitBinaryOperationExpression_closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__slash_recommendation1: function _EvaluateVisitor__slash_recommendation1() { + }, + _EvaluateVisitor_visitVariableExpression_closure1: function _EvaluateVisitor_visitVariableExpression_closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitUnaryOperationExpression_closure1: function _EvaluateVisitor_visitUnaryOperationExpression_closure1(t0, t1) { + this.node = t0; + this.operand = t1; + }, + _EvaluateVisitor_visitListExpression_closure1: function _EvaluateVisitor_visitListExpression_closure1(t0) { + this.$this = t0; + }, + _EvaluateVisitor_visitFunctionExpression_closure5: function _EvaluateVisitor_visitFunctionExpression_closure5(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitFunctionExpression_closure6: function _EvaluateVisitor_visitFunctionExpression_closure6() { + }, + _EvaluateVisitor_visitFunctionExpression_closure7: function _EvaluateVisitor_visitFunctionExpression_closure7(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.node = t2; + }, + _EvaluateVisitor__visitCalculation_closure1: function _EvaluateVisitor__visitCalculation_closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__checkCalculationArguments_check1: function _EvaluateVisitor__checkCalculationArguments_check1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor__visitCalculationExpression_closure1: function _EvaluateVisitor__visitCalculationExpression_closure1(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.node = t2; + _.inLegacySassFunction = t3; + }, + _EvaluateVisitor__visitCalculationExpression__closure1: function _EvaluateVisitor__visitCalculationExpression__closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitInterpolatedFunctionExpression_closure1: function _EvaluateVisitor_visitInterpolatedFunctionExpression_closure1(t0, t1, t2) { + this.$this = t0; + this.node = t1; + this.$function = t2; + }, + _EvaluateVisitor__runUserDefinedCallable_closure1: function _EvaluateVisitor__runUserDefinedCallable_closure1(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.callable = t1; + _.evaluated = t2; + _.nodeWithSpan = t3; + _.run = t4; + _.V = t5; + }, + _EvaluateVisitor__runUserDefinedCallable__closure1: function _EvaluateVisitor__runUserDefinedCallable__closure1(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.evaluated = t1; + _.callable = t2; + _.nodeWithSpan = t3; + _.run = t4; + _.V = t5; + }, + _EvaluateVisitor__runUserDefinedCallable___closure1: function _EvaluateVisitor__runUserDefinedCallable___closure1(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.evaluated = t1; + _.callable = t2; + _.nodeWithSpan = t3; + _.run = t4; + _.V = t5; + }, + _EvaluateVisitor__runUserDefinedCallable____closure1: function _EvaluateVisitor__runUserDefinedCallable____closure1() { + }, + _EvaluateVisitor__runFunctionCallable_closure1: function _EvaluateVisitor__runFunctionCallable_closure1(t0, t1) { + this.$this = t0; + this.callable = t1; + }, + _EvaluateVisitor__runBuiltInCallable_closure5: function _EvaluateVisitor__runBuiltInCallable_closure5(t0, t1, t2) { + this._box_0 = t0; + this.evaluated = t1; + this.namedSet = t2; + }, + _EvaluateVisitor__runBuiltInCallable_closure6: function _EvaluateVisitor__runBuiltInCallable_closure6(t0, t1) { + this._box_0 = t0; + this.evaluated = t1; + }, + _EvaluateVisitor__runBuiltInCallable_closure7: function _EvaluateVisitor__runBuiltInCallable_closure7() { + }, + _EvaluateVisitor__evaluateArguments_closure7: function _EvaluateVisitor__evaluateArguments_closure7() { + }, + _EvaluateVisitor__evaluateArguments_closure8: function _EvaluateVisitor__evaluateArguments_closure8(t0, t1) { + this.$this = t0; + this.restNodeForSpan = t1; + }, + _EvaluateVisitor__evaluateArguments_closure9: function _EvaluateVisitor__evaluateArguments_closure9(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.named = t1; + _.restNodeForSpan = t2; + _.namedNodes = t3; + }, + _EvaluateVisitor__evaluateArguments_closure10: function _EvaluateVisitor__evaluateArguments_closure10() { + }, + _EvaluateVisitor__evaluateMacroArguments_closure7: function _EvaluateVisitor__evaluateMacroArguments_closure7(t0) { + this.restArgs = t0; + }, + _EvaluateVisitor__evaluateMacroArguments_closure8: function _EvaluateVisitor__evaluateMacroArguments_closure8(t0, t1, t2) { + this.$this = t0; + this.restNodeForSpan = t1; + this.restArgs = t2; + }, + _EvaluateVisitor__evaluateMacroArguments_closure9: function _EvaluateVisitor__evaluateMacroArguments_closure9(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.named = t1; + _.restNodeForSpan = t2; + _.restArgs = t3; + }, + _EvaluateVisitor__evaluateMacroArguments_closure10: function _EvaluateVisitor__evaluateMacroArguments_closure10(t0, t1, t2) { + this.$this = t0; + this.keywordRestNodeForSpan = t1; + this.keywordRestArgs = t2; + }, + _EvaluateVisitor__addRestMap_closure1: function _EvaluateVisitor__addRestMap_closure1(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.values = t1; + _.convert = t2; + _.expressionNode = t3; + _.map = t4; + _.nodeWithSpan = t5; + }, + _EvaluateVisitor__verifyArguments_closure1: function _EvaluateVisitor__verifyArguments_closure1(t0, t1, t2) { + this.parameters = t0; + this.positional = t1; + this.named = t2; + }, + _EvaluateVisitor_visitCssAtRule_closure3: function _EvaluateVisitor_visitCssAtRule_closure3(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssAtRule_closure4: function _EvaluateVisitor_visitCssAtRule_closure4() { + }, + _EvaluateVisitor_visitCssKeyframeBlock_closure3: function _EvaluateVisitor_visitCssKeyframeBlock_closure3(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssKeyframeBlock_closure4: function _EvaluateVisitor_visitCssKeyframeBlock_closure4() { + }, + _EvaluateVisitor_visitCssMediaRule_closure5: function _EvaluateVisitor_visitCssMediaRule_closure5(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssMediaRule_closure6: function _EvaluateVisitor_visitCssMediaRule_closure6(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.mergedQueries = t1; + _.node = t2; + _.mergedSources = t3; + }, + _EvaluateVisitor_visitCssMediaRule__closure1: function _EvaluateVisitor_visitCssMediaRule__closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssMediaRule___closure1: function _EvaluateVisitor_visitCssMediaRule___closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssMediaRule_closure7: function _EvaluateVisitor_visitCssMediaRule_closure7(t0) { + this.mergedSources = t0; + }, + _EvaluateVisitor_visitCssStyleRule_closure4: function _EvaluateVisitor_visitCssStyleRule_closure4(t0, t1, t2) { + this.$this = t0; + this.rule = t1; + this.node = t2; + }, + _EvaluateVisitor_visitCssStyleRule__closure1: function _EvaluateVisitor_visitCssStyleRule__closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssStyleRule_closure3: function _EvaluateVisitor_visitCssStyleRule_closure3() { + }, + _EvaluateVisitor_visitCssSupportsRule_closure3: function _EvaluateVisitor_visitCssSupportsRule_closure3(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssSupportsRule__closure1: function _EvaluateVisitor_visitCssSupportsRule__closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _EvaluateVisitor_visitCssSupportsRule_closure4: function _EvaluateVisitor_visitCssSupportsRule_closure4() { + }, + _EvaluateVisitor__performInterpolationHelper_closure1: function _EvaluateVisitor__performInterpolationHelper_closure1(t0) { + this.interpolation = t0; + }, + _EvaluateVisitor__serialize_closure1: function _EvaluateVisitor__serialize_closure1(t0, t1) { + this.value = t0; + this.quote = t1; + }, + _EvaluateVisitor__expressionNode_closure1: function _EvaluateVisitor__expressionNode_closure1(t0, t1) { + this.$this = t0; + this.expression = t1; + }, + _EvaluateVisitor__withoutSlash_recommendation1: function _EvaluateVisitor__withoutSlash_recommendation1() { + }, + _EvaluateVisitor__stackFrame_closure1: function _EvaluateVisitor__stackFrame_closure1(t0) { + this.$this = t0; + }, + _ImportedCssVisitor1: function _ImportedCssVisitor1(t0) { + this._evaluate0$_visitor = t0; + }, + _ImportedCssVisitor_visitCssAtRule_closure1: function _ImportedCssVisitor_visitCssAtRule_closure1() { + }, + _ImportedCssVisitor_visitCssMediaRule_closure1: function _ImportedCssVisitor_visitCssMediaRule_closure1(t0) { + this.hasBeenMerged = t0; + }, + _ImportedCssVisitor_visitCssStyleRule_closure1: function _ImportedCssVisitor_visitCssStyleRule_closure1() { + }, + _ImportedCssVisitor_visitCssSupportsRule_closure1: function _ImportedCssVisitor_visitCssSupportsRule_closure1() { + }, + _EvaluationContext1: function _EvaluationContext1(t0, t1) { + this._evaluate0$_visitor = t0; + this._evaluate0$_defaultWarnNodeWithSpan = t1; + }, + EveryCssVisitor0: function EveryCssVisitor0() { + }, + EveryCssVisitor_visitCssAtRule_closure0: function EveryCssVisitor_visitCssAtRule_closure0(t0) { + this.$this = t0; + }, + EveryCssVisitor_visitCssKeyframeBlock_closure0: function EveryCssVisitor_visitCssKeyframeBlock_closure0(t0) { + this.$this = t0; + }, + EveryCssVisitor_visitCssMediaRule_closure0: function EveryCssVisitor_visitCssMediaRule_closure0(t0) { + this.$this = t0; + }, + EveryCssVisitor_visitCssStyleRule_closure0: function EveryCssVisitor_visitCssStyleRule_closure0(t0) { + this.$this = t0; + }, + EveryCssVisitor_visitCssStylesheet_closure0: function EveryCssVisitor_visitCssStylesheet_closure0(t0) { + this.$this = t0; + }, + EveryCssVisitor_visitCssSupportsRule_closure0: function EveryCssVisitor_visitCssSupportsRule_closure0(t0) { + this.$this = t0; + }, + throwNodeException(exception, ascii, color, trace) { + var wasAscii, jsException, t1, trace0; + trace = trace; + wasAscii = $._glyphs === B.C_AsciiGlyphSet; + $._glyphs = ascii ? B.C_AsciiGlyphSet : B.C_UnicodeGlyphSet; + try { + t1 = A.callConstructor($.$get$exceptionClass(), [exception, B.JSString_methods.replaceFirst$2(exception.toString$1$color(0, color), "Error: ", "")]); + jsException = type$._NodeException._as(t1); + trace0 = A.getTrace0(exception); + trace = trace0 == null ? trace : trace0; + if (trace != null) + A.attachJsStack(jsException, trace); + A.jsThrow(jsException); + } finally { + $._glyphs = wasAscii ? B.C_AsciiGlyphSet : B.C_UnicodeGlyphSet; + } + }, + _NodeException: function _NodeException() { + }, + exceptionClass_closure: function exceptionClass_closure() { + }, + exceptionClass__closure: function exceptionClass__closure() { + }, + exceptionClass__closure0: function exceptionClass__closure0() { + }, + exceptionClass__closure1: function exceptionClass__closure1() { + }, + SassException$0(message, span, loadedUrls) { + return new A.SassException0(loadedUrls == null ? B.Set_empty : A.Set_Set$unmodifiable(loadedUrls, type$.Uri), message, span); + }, + MultiSpanSassException$0(message, span, primaryLabel, secondarySpans, loadedUrls) { + var t1 = A.ConstantMap_ConstantMap$from(secondarySpans, type$.FileSpan, type$.String); + return new A.MultiSpanSassException0(primaryLabel, t1, loadedUrls == null ? B.Set_empty : A.Set_Set$unmodifiable(loadedUrls, type$.Uri), message, span); + }, + SassRuntimeException$0(message, span, trace, loadedUrls) { + return new A.SassRuntimeException0(trace, loadedUrls == null ? B.Set_empty : A.Set_Set$unmodifiable(loadedUrls, type$.Uri), message, span); + }, + MultiSpanSassRuntimeException$0(message, span, primaryLabel, secondarySpans, trace, loadedUrls) { + var t1 = A.ConstantMap_ConstantMap$from(secondarySpans, type$.FileSpan, type$.String); + return new A.MultiSpanSassRuntimeException0(trace, primaryLabel, t1, loadedUrls == null ? B.Set_empty : A.Set_Set$unmodifiable(loadedUrls, type$.Uri), message, span); + }, + SassFormatException$0(message, span, loadedUrls) { + return new A.SassFormatException0(loadedUrls == null ? B.Set_empty : A.Set_Set$unmodifiable(loadedUrls, type$.Uri), message, span); + }, + MultiSpanSassFormatException$0(message, span, primaryLabel, secondarySpans, loadedUrls) { + var t1 = A.ConstantMap_ConstantMap$from(secondarySpans, type$.FileSpan, type$.String); + return new A.MultiSpanSassFormatException0(primaryLabel, t1, loadedUrls == null ? B.Set_empty : A.Set_Set$unmodifiable(loadedUrls, type$.Uri), message, span); + }, + SassScriptException$0(message, argumentName) { + return new A.SassScriptException0(argumentName == null ? message : "$" + argumentName + ": " + message); + }, + MultiSpanSassScriptException$0(message, primaryLabel, secondarySpans) { + var t1 = A.ConstantMap_ConstantMap$from(secondarySpans, type$.FileSpan, type$.String); + return new A.MultiSpanSassScriptException0(primaryLabel, t1, message); + }, + SassException0: function SassException0(t0, t1, t2) { + this.loadedUrls = t0; + this._span_exception$_message = t1; + this._span = t2; + }, + MultiSpanSassException0: function MultiSpanSassException0(t0, t1, t2, t3, t4) { + var _ = this; + _.primaryLabel = t0; + _.secondarySpans = t1; + _.loadedUrls = t2; + _._span_exception$_message = t3; + _._span = t4; + }, + SassRuntimeException0: function SassRuntimeException0(t0, t1, t2, t3) { + var _ = this; + _.trace = t0; + _.loadedUrls = t1; + _._span_exception$_message = t2; + _._span = t3; + }, + MultiSpanSassRuntimeException0: function MultiSpanSassRuntimeException0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.trace = t0; + _.primaryLabel = t1; + _.secondarySpans = t2; + _.loadedUrls = t3; + _._span_exception$_message = t4; + _._span = t5; + }, + SassFormatException0: function SassFormatException0(t0, t1, t2) { + this.loadedUrls = t0; + this._span_exception$_message = t1; + this._span = t2; + }, + MultiSpanSassFormatException0: function MultiSpanSassFormatException0(t0, t1, t2, t3, t4) { + var _ = this; + _.primaryLabel = t0; + _.secondarySpans = t1; + _.loadedUrls = t2; + _._span_exception$_message = t3; + _._span = t4; + }, + SassScriptException0: function SassScriptException0(t0) { + this.message = t0; + }, + MultiSpanSassScriptException0: function MultiSpanSassScriptException0(t0, t1, t2) { + this.primaryLabel = t0; + this.secondarySpans = t1; + this.message = t2; + }, + Exports: function Exports() { + }, + LoggerNamespace: function LoggerNamespace() { + }, + Expression0: function Expression0() { + }, + JSExpressionVisitor: function JSExpressionVisitor(t0) { + this._expression$_inner = t0; + }, + JSExpressionVisitorObject: function JSExpressionVisitorObject() { + }, + expressionToCalc0(expression) { + var t4, + t1 = A._setArrayType([B.C__MakeExpressionCalculationSafe0.visitBinaryOperationExpression$1(0, expression)], type$.JSArray_Expression_2), + t2 = expression.get$span(0), + t3 = type$.Expression_2; + t1 = A.List_List$unmodifiable(t1, t3); + t3 = A.ConstantMap_ConstantMap$from(B.Map_empty14, type$.String, t3); + t4 = expression.get$span(0); + return new A.FunctionExpression0(null, A.stringReplaceAllUnchecked("calc", "_", "-"), "calc", new A.ArgumentList0(t1, t3, null, null, t2), t4); + }, + _MakeExpressionCalculationSafe0: function _MakeExpressionCalculationSafe0() { + }, + __MakeExpressionCalculationSafe_Object_ReplaceExpressionVisitor0: function __MakeExpressionCalculationSafe_Object_ReplaceExpressionVisitor0() { + }, + ExtendRule0: function ExtendRule0(t0, t1, t2) { + this.selector = t0; + this.isOptional = t1; + this.span = t2; + }, + Extension0: function Extension0(t0, t1, t2, t3, t4) { + var _ = this; + _.extender = t0; + _.target = t1; + _.mediaContext = t2; + _.isOptional = t3; + _.span = t4; + }, + Extender0: function Extender0(t0, t1) { + this.selector = t0; + this.isOriginal = t1; + this._extension$_extension = null; + }, + ExtensionStore__extendOrReplace0(selector, source, targets, mode, span) { + var t1, t2, t3, t4, t5, t6, t7, t8, _i, complex, compound, t9, t10, t11, _i0, simple, t12, _i1, t13, t14, + extender = A.ExtensionStore$_mode0(mode); + if (!selector.accept$1(B._IsInvisibleVisitor_true0)) + extender._extension_store$_originals.addAll$1(0, selector.components); + for (t1 = targets.components, t2 = t1.length, t3 = source.components, t4 = t3.length, t5 = type$.ComplexSelector_2, t6 = type$.Extension_2, t7 = type$.SimpleSelector_2, t8 = type$.Map_ComplexSelector_Extension_2, _i = 0; _i < t2; ++_i) { + complex = t1[_i]; + compound = complex.get$singleCompound(); + if (compound == null) + throw A.wrapException(A.SassScriptException$0("Can't extend complex selector " + complex.toString$0(0) + ".", null)); + t9 = A.LinkedHashMap_LinkedHashMap$_empty(t7, t8); + for (t10 = compound.components, t11 = t10.length, _i0 = 0; _i0 < t11; ++_i0) { + simple = t10[_i0]; + t12 = A.LinkedHashMap_LinkedHashMap$_empty(t5, t6); + for (_i1 = 0; _i1 < t4; ++_i1) { + complex = t3[_i1]; + complex.get$specificity(); + t13 = new A.Extender0(complex, false); + t14 = new A.Extension0(t13, simple, null, true, span); + t13._extension$_extension = t14; + t12.$indexSet(0, complex, t14); + } + t9.$indexSet(0, simple, t12); + } + selector = extender._extension_store$_extendList$2(selector, t9); + } + return selector; + }, + ExtensionStore$0() { + var t1 = type$.SimpleSelector_2; + return new A.ExtensionStore0(A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Set_ModifiableBox_SelectorList_2), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Map_ComplexSelector_Extension_2), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.List_Extension_2), A.LinkedHashMap_LinkedHashMap$_empty(type$.ModifiableBox_SelectorList_2, type$.List_CssMediaQuery_2), new A.JsIdentityLinkedHashMap(type$.JsIdentityLinkedHashMap_SimpleSelector_int_2), new A._LinkedIdentityHashSet(type$._LinkedIdentityHashSet_ComplexSelector_2), B.ExtendMode_normal_normal0); + }, + ExtensionStore$_mode0(_mode) { + var t1 = type$.SimpleSelector_2; + return new A.ExtensionStore0(A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Set_ModifiableBox_SelectorList_2), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Map_ComplexSelector_Extension_2), A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.List_Extension_2), A.LinkedHashMap_LinkedHashMap$_empty(type$.ModifiableBox_SelectorList_2, type$.List_CssMediaQuery_2), new A.JsIdentityLinkedHashMap(type$.JsIdentityLinkedHashMap_SimpleSelector_int_2), new A._LinkedIdentityHashSet(type$._LinkedIdentityHashSet_ComplexSelector_2), _mode); + }, + ExtensionStore0: function ExtensionStore0(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._extension_store$_selectors = t0; + _._extension_store$_extensions = t1; + _._extension_store$_extensionsByExtender = t2; + _._extension_store$_mediaContexts = t3; + _._extension_store$_sourceSpecificity = t4; + _._extension_store$_originals = t5; + _._extension_store$_mode = t6; + }, + ExtensionStore_extensionsWhereTarget_closure0: function ExtensionStore_extensionsWhereTarget_closure0() { + }, + ExtensionStore__registerSelector_closure0: function ExtensionStore__registerSelector_closure0() { + }, + ExtensionStore_addExtension_closure2: function ExtensionStore_addExtension_closure2() { + }, + ExtensionStore_addExtension_closure3: function ExtensionStore_addExtension_closure3() { + }, + ExtensionStore_addExtension_closure4: function ExtensionStore_addExtension_closure4(t0) { + this.complex = t0; + }, + ExtensionStore__extendExistingExtensions_closure1: function ExtensionStore__extendExistingExtensions_closure1() { + }, + ExtensionStore__extendExistingExtensions_closure2: function ExtensionStore__extendExistingExtensions_closure2() { + }, + ExtensionStore_addExtensions_closure0: function ExtensionStore_addExtensions_closure0() { + }, + ExtensionStore__extendComplex_closure0: function ExtensionStore__extendComplex_closure0(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.complex = t2; + }, + ExtensionStore__extendComplex__closure0: function ExtensionStore__extendComplex__closure0(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.complex = t2; + }, + ExtensionStore__extendCompound_closure2: function ExtensionStore__extendCompound_closure2() { + }, + ExtensionStore__extendCompound_closure3: function ExtensionStore__extendCompound_closure3() { + }, + ExtensionStore__extendCompound_closure4: function ExtensionStore__extendCompound_closure4(t0) { + this.original = t0; + }, + ExtensionStore__extendSimple_withoutPseudo0: function ExtensionStore__extendSimple_withoutPseudo0(t0, t1, t2) { + this.$this = t0; + this.extensions = t1; + this.targetsUsed = t2; + }, + ExtensionStore__extendSimple_closure1: function ExtensionStore__extendSimple_closure1(t0, t1) { + this.$this = t0; + this.withoutPseudo = t1; + }, + ExtensionStore__extendSimple_closure2: function ExtensionStore__extendSimple_closure2() { + }, + ExtensionStore__extendPseudo_closure4: function ExtensionStore__extendPseudo_closure4() { + }, + ExtensionStore__extendPseudo_closure5: function ExtensionStore__extendPseudo_closure5() { + }, + ExtensionStore__extendPseudo_closure6: function ExtensionStore__extendPseudo_closure6() { + }, + ExtensionStore__extendPseudo_closure7: function ExtensionStore__extendPseudo_closure7(t0) { + this.pseudo = t0; + }, + ExtensionStore__extendPseudo_closure8: function ExtensionStore__extendPseudo_closure8(t0, t1) { + this.pseudo = t0; + this.selector = t1; + }, + ExtensionStore__trim_closure1: function ExtensionStore__trim_closure1(t0, t1) { + this._box_0 = t0; + this.complex1 = t1; + }, + ExtensionStore__trim_closure2: function ExtensionStore__trim_closure2(t0, t1) { + this._box_0 = t0; + this.complex1 = t1; + }, + ExtensionStore_clone_closure0: function ExtensionStore_clone_closure0(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.newSelectors = t1; + _.oldToNewSelectors = t2; + _.newMediaContexts = t3; + }, + FiberClass: function FiberClass() { + }, + Fiber: function Fiber() { + }, + JSToDartFileImporter: function JSToDartFileImporter(t0) { + this._file0$_findFileUrl = t0; + }, + JSToDartFileImporter_canonicalize_closure: function JSToDartFileImporter_canonicalize_closure(t0, t1) { + this.$this = t0; + this.url = t1; + }, + FilesystemImporter0: function FilesystemImporter0(t0, t1) { + this._filesystem$_loadPath = t0; + this._filesystem$_loadPathDeprecated = t1; + }, + FilesystemImporter_canonicalize_closure0: function FilesystemImporter_canonicalize_closure0() { + }, + ForRule$0(variable, from, to, children, span, exclusive) { + var t1 = A.List_List$unmodifiable(children, type$.Statement_2), + t2 = B.JSArray_methods.any$1(t1, new A.ParentStatement_closure0()); + return new A.ForRule0(variable, from, to, exclusive, span, t1, t2); + }, + ForRule0: function ForRule0(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.variable = t0; + _.from = t1; + _.to = t2; + _.isExclusive = t3; + _.span = t4; + _.children = t5; + _.hasDeclarations = t6; + }, + ForwardRule0: function ForwardRule0(t0, t1, t2, t3, t4, t5, t6, t7) { + var _ = this; + _.url = t0; + _.shownMixinsAndFunctions = t1; + _.shownVariables = t2; + _.hiddenMixinsAndFunctions = t3; + _.hiddenVariables = t4; + _.prefix = t5; + _.configuration = t6; + _.span = t7; + }, + ForwardedModuleView_ifNecessary0(inner, rule, $T) { + var t2, + t1 = false; + if (rule.prefix == null) + if (rule.shownMixinsAndFunctions == null) + if (rule.shownVariables == null) { + t2 = rule.hiddenMixinsAndFunctions; + t2 = t2 == null ? null : t2._base.get$isEmpty(0); + if (t2 === true) { + t1 = rule.hiddenVariables; + t1 = t1 == null ? null : t1._base.get$isEmpty(0); + t1 = t1 === true; + } + } + if (t1) + return inner; + else + return A.ForwardedModuleView$0(inner, rule, $T); + }, + ForwardedModuleView$0(_inner, _rule, $T) { + var t1 = _rule.prefix, + t2 = _rule.shownVariables, + t3 = _rule.hiddenVariables, + t4 = _rule.shownMixinsAndFunctions, + t5 = _rule.hiddenMixinsAndFunctions; + return new A.ForwardedModuleView0(_inner, _rule, A.ForwardedModuleView__forwardedMap0(_inner.get$variables(), t1, t2, t3, type$.Value_2), A.ForwardedModuleView__forwardedMap0(_inner.get$variableNodes(), t1, t2, t3, type$.AstNode_2), A.ForwardedModuleView__forwardedMap0(_inner.get$functions(_inner), t1, t4, t5, $T), A.ForwardedModuleView__forwardedMap0(_inner.get$mixins(), t1, t4, t5, $T), $T._eval$1("ForwardedModuleView0<0>")); + }, + ForwardedModuleView__forwardedMap0(map, prefix, safelist, blocklist, $V) { + var t1 = prefix == null, + t2 = false; + if (t1) + if (safelist == null) + t2 = blocklist == null || blocklist._base.get$isEmpty(0); + if (t2) + return map; + if (!t1) + map = new A.PrefixedMapView0(map, prefix, $V._eval$1("PrefixedMapView0<0>")); + if (safelist != null) + map = new A.LimitedMapView0(map, safelist._base.intersection$1(new A.MapKeySet(map, type$.MapKeySet_nullable_Object)), type$.$env_1_1_String._bind$1($V)._eval$1("LimitedMapView0<1,2>")); + else if (blocklist != null && blocklist._base.get$isNotEmpty(0)) + map = A.LimitedMapView$blocklist0(map, blocklist, type$.String, $V); + return map; + }, + ForwardedModuleView0: function ForwardedModuleView0(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._forwarded_view0$_inner = t0; + _._forwarded_view0$_rule = t1; + _.variables = t2; + _.variableNodes = t3; + _.functions = t4; + _.mixins = t5; + _.$ti = t6; + }, + FunctionExpression0: function FunctionExpression0(t0, t1, t2, t3, t4) { + var _ = this; + _.namespace = t0; + _.name = t1; + _.originalName = t2; + _.$arguments = t3; + _.span = t4; + }, + JSFunction0: function JSFunction0() { + }, + SupportsFunction0: function SupportsFunction0(t0, t1, t2) { + this.name = t0; + this.$arguments = t1; + this.span = t2; + }, + functionClass_closure: function functionClass_closure() { + }, + functionClass__closure: function functionClass__closure() { + }, + functionClass__closure0: function functionClass__closure0() { + }, + SassFunction0: function SassFunction0(t0) { + this.callable = t0; + }, + FunctionRule$0($name, parameters, children, span, comment) { + var t1 = A.stringReplaceAllUnchecked($name, "_", "-"), + t2 = A.List_List$unmodifiable(children, type$.Statement_2), + t3 = B.JSArray_methods.any$1(t2, new A.ParentStatement_closure0()); + return new A.FunctionRule0(t1, $name, parameters, span, t2, t3); + }, + FunctionRule0: function FunctionRule0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.name = t0; + _.originalName = t1; + _.parameters = t2; + _.span = t3; + _.children = t4; + _.hasDeclarations = t5; + }, + unifyComplex0(complexes, span) { + var t2, trailingCombinator, leadingCombinator, unifiedBase, t3, t4, _0_6_isSet, _0_6, t5, newLeadingCombinator, base, _1_1, newTrailingCombinator, unifiedBase0, t6, t7, t8, _null = null, + t1 = J.getInterceptor$asx(complexes); + if (t1.get$length(complexes) === 1) + return complexes; + for (t2 = t1.get$iterator(complexes), trailingCombinator = _null, leadingCombinator = trailingCombinator, unifiedBase = leadingCombinator; t2.moveNext$0();) { + t3 = t2.get$current(t2); + if (t3.accept$1(B.C__IsUselessVisitor0)) + return _null; + t4 = t3.components; + _0_6_isSet = t4.length === 1; + if (_0_6_isSet) { + _0_6 = t3.leadingCombinators; + t5 = _0_6.length === 1; + } else { + _0_6 = _null; + t5 = false; + } + if (t5) { + newLeadingCombinator = (_0_6_isSet ? _0_6 : t3.leadingCombinators)[0]; + if (leadingCombinator == null) + leadingCombinator = newLeadingCombinator; + else if (!(leadingCombinator.$ti._is(newLeadingCombinator) && J.$eq$(newLeadingCombinator.value, leadingCombinator.value))) + return _null; + } + base = B.JSArray_methods.get$last(t4); + _1_1 = base.combinators; + if (_1_1.length === 1) { + newTrailingCombinator = _1_1[0]; + if (trailingCombinator != null) + t3 = !(trailingCombinator.$ti._is(newTrailingCombinator) && J.$eq$(newTrailingCombinator.value, trailingCombinator.value)); + else + t3 = false; + if (t3) + return _null; + trailingCombinator = newTrailingCombinator; + } + unifiedBase0 = base.selector; + if (unifiedBase == null) + unifiedBase = unifiedBase0; + else { + unifiedBase = A.unifyCompound0(unifiedBase, unifiedBase0); + if (unifiedBase == null) + return _null; + } + } + t2 = type$.JSArray_ComplexSelector_2; + t3 = A._setArrayType([], t2); + for (t4 = t1.get$iterator(complexes); t4.moveNext$0();) { + t5 = t4.get$current(t4); + t6 = t5.components; + t7 = t6.length; + if (t7 > 1) { + t8 = t5.leadingCombinators; + t3.push(A.ComplexSelector$0(t8, B.JSArray_methods.take$1(t6, t7 - 1), t5.span, t5.lineBreak)); + } + } + t4 = leadingCombinator == null ? B.List_empty14 : A._setArrayType([leadingCombinator], type$.JSArray_CssValue_Combinator_2); + unifiedBase.toString; + t5 = trailingCombinator == null ? B.List_empty14 : A._setArrayType([trailingCombinator], type$.JSArray_CssValue_Combinator_2); + base = A.ComplexSelector$0(t4, A._setArrayType([new A.ComplexSelectorComponent0(unifiedBase, A.List_List$unmodifiable(t5, type$.CssValue_Combinator_2), span)], type$.JSArray_ComplexSelectorComponent_2), span, t1.any$1(complexes, new A.unifyComplex_closure0())); + if (t3.length === 0) + t1 = A._setArrayType([base], t2); + else { + t1 = A.List_List$of(A.IterableExtension_get_exceptLast0(t3), true, type$.ComplexSelector_2); + t1.push(B.JSArray_methods.get$last(t3).concatenate$2(base, span)); + } + return A.weave0(t1, span, false); + }, + unifyCompound0(compound1, compound2) { + var t1, t2, pseudoElementFound, _i, simple, unified, + result = compound1.components, + pseudoResult = A._setArrayType([], type$.JSArray_SimpleSelector_2); + for (t1 = compound2.components, t2 = t1.length, pseudoElementFound = false, _i = 0; _i < t2; ++_i) { + simple = t1[_i]; + if (pseudoElementFound && simple instanceof A.PseudoSelector0) { + unified = simple.unify$1(pseudoResult); + if (unified == null) + return null; + pseudoResult = unified; + } else { + pseudoElementFound = B.JSBool_methods.$or(pseudoElementFound, simple instanceof A.PseudoSelector0 && !simple.isClass); + unified = simple.unify$1(result); + if (unified == null) + return null; + result = unified; + } + } + t1 = A.List_List$of(result, true, type$.SimpleSelector_2); + B.JSArray_methods.addAll$1(t1, pseudoResult); + return A.CompoundSelector$0(t1, compound1.span); + }, + unifyUniversalAndElement0(selector1, selector2) { + var namespace, $name, t1, + _0_0 = A._namespaceAndName0(selector1, "selector1"), + namespace1 = _0_0._0, + name1 = _0_0._1, + _1_0 = A._namespaceAndName0(selector2, "selector2"), + namespace2 = _1_0._0, + name2 = _1_0._1; + if (namespace1 == namespace2 || namespace2 === "*") + namespace = namespace1; + else { + if (namespace1 !== "*") + return null; + namespace = namespace2; + } + if (name1 == name2 || name2 == null) + $name = name1; + else { + if (!(name1 == null || name1 === "*")) + return null; + $name = name2; + } + t1 = selector1.span; + return $name == null ? new A.UniversalSelector0(namespace, t1) : new A.TypeSelector0(new A.QualifiedName0($name, namespace), t1); + }, + _namespaceAndName0(selector, $name) { + var t1, _0_4; + $label0$0: { + if (selector instanceof A.UniversalSelector0) { + t1 = new A._Record_2(selector.namespace, null); + break $label0$0; + } + if (selector instanceof A.TypeSelector0) { + _0_4 = selector.name; + t1 = new A._Record_2(_0_4.namespace, _0_4.name); + break $label0$0; + } + t1 = A.throwExpression(A.ArgumentError$value(selector, $name, string$.must_b)); + } + return t1; + }, + weave0(complexes, span, forceLineBreak) { + var complex, t2, prefixes, t3, t4, t5, t6, i, t7, t8, _i, t9, t10, _i0, parentPrefix, t11, t12, + t1 = J.getInterceptor$asx(complexes); + if (t1.get$length(complexes) === 1) { + complex = t1.$index(complexes, 0); + if (!forceLineBreak || complex.lineBreak) + return complexes; + return A._setArrayType([A.ComplexSelector$0(complex.leadingCombinators, complex.components, complex.span, true)], type$.JSArray_ComplexSelector_2); + } + t2 = type$.JSArray_ComplexSelector_2; + prefixes = A._setArrayType([t1.get$first(complexes)], t2); + for (t1 = t1.skip$1(complexes, 1), t3 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t3._eval$1("ListIterator")), t4 = type$.ComplexSelectorComponent_2, t3 = t3._eval$1("ListIterable.E"); t1.moveNext$0();) { + t5 = t1.__internal$_current; + if (t5 == null) + t5 = t3._as(t5); + t6 = t5.components; + if (t6.length === 1) { + for (i = 0; i < prefixes.length; ++i) + prefixes[i] = prefixes[i].concatenate$3$forceLineBreak(t5, span, forceLineBreak); + continue; + } + t7 = A._setArrayType([], t2); + for (t8 = prefixes.length, _i = 0; _i < prefixes.length; prefixes.length === t8 || (0, A.throwConcurrentModificationError)(prefixes), ++_i) { + t9 = A._weaveParents0(prefixes[_i], t5, span); + if (t9 == null) + t9 = B.List_empty15; + t10 = t9.length; + _i0 = 0; + for (; _i0 < t9.length; t9.length === t10 || (0, A.throwConcurrentModificationError)(t9), ++_i0) { + parentPrefix = t9[_i0]; + t11 = B.JSArray_methods.get$last(t6); + t12 = A.List_List$of(parentPrefix.components, true, t4); + t12.push(t11); + t11 = parentPrefix.lineBreak || forceLineBreak; + t7.push(A.ComplexSelector$0(parentPrefix.leadingCombinators, t12, span, t11)); + } + } + prefixes = t7; + } + return prefixes; + }, + _weaveParents0(prefix, base, span) { + var t1, queue1, queue2, trailingCombinators, _0_1, _0_3, _0_3_isSet, _0_30, rootish2, t2, rootish1, rootish, t3, rootish_case_0, t0, rootish_case_1, groups1, groups2, lcs, choices, t4, _i, group, t5, t6, t7, _i0, chunk, t8, t9, _null = null, + leadingCombinators = A._mergeLeadingCombinators0(prefix.leadingCombinators, base.leadingCombinators); + if (leadingCombinators == null) + return _null; + t1 = type$.ComplexSelectorComponent_2; + queue1 = A.QueueList_QueueList$from(prefix.components, t1); + queue2 = A.QueueList_QueueList$from(A.IterableExtension_get_exceptLast0(base.components), t1); + trailingCombinators = A._mergeTrailingCombinators0(queue1, queue2, span, _null); + if (trailingCombinators == null) + return _null; + $label0$0: { + _0_1 = A._firstIfRootish0(queue1); + _0_3 = A._firstIfRootish0(queue2); + _0_3_isSet = _0_1 != null; + _0_30 = _null; + rootish2 = _null; + t2 = false; + if (_0_3_isSet) { + rootish1 = _0_1 == null ? t1._as(_0_1) : _0_1; + t2 = _0_3 != null; + if (t2) + rootish2 = _0_3 == null ? t1._as(_0_3) : _0_3; + _0_30 = _0_3; + } else + rootish1 = _null; + if (t2) { + rootish = A.unifyCompound0(rootish1.selector, rootish2.selector); + if (rootish == null) + return _null; + t1 = rootish1.combinators; + t2 = rootish1.span; + t3 = type$.CssValue_Combinator_2; + queue1.addFirst$1(new A.ComplexSelectorComponent0(rootish, A.List_List$unmodifiable(t1, t3), t2)); + queue2.addFirst$1(new A.ComplexSelectorComponent0(rootish, A.List_List$unmodifiable(rootish2.combinators, t3), t2)); + break $label0$0; + } + t2 = _null; + t3 = false; + if (_0_1 != null) { + rootish_case_0 = _0_1; + if (_0_3_isSet) + t2 = _0_30; + else { + t2 = _0_3; + _0_30 = t2; + _0_3_isSet = true; + } + t2 = t2 == null; + t3 = t2 ? rootish_case_0 : _null; + t0 = t3; + t3 = t2; + t2 = t0; + } + if (!t3) + if (_0_1 == null) { + if (_0_3_isSet) + t3 = _0_30; + else { + t3 = _0_3; + _0_30 = t3; + _0_3_isSet = true; + } + t3 = t3 != null; + if (t3) { + rootish_case_1 = _0_3_isSet ? _0_30 : _0_3; + if (rootish_case_1 == null) + rootish_case_1 = t1._as(rootish_case_1); + t1 = rootish_case_1; + } else + t1 = t2; + t2 = t3; + } else { + t1 = t2; + t2 = false; + } + else { + t1 = t2; + t2 = true; + } + if (t2) { + queue1.addFirst$1(t1); + queue2.addFirst$1(t1); + } + } + groups1 = A._groupSelectors0(queue1); + groups2 = A._groupSelectors0(queue2); + t1 = type$.List_ComplexSelectorComponent_2; + lcs = A.longestCommonSubsequence0(groups2, groups1, new A._weaveParents_closure3(span), t1); + choices = A._setArrayType([], type$.JSArray_List_Iterable_ComplexSelectorComponent_2); + for (t2 = lcs.length, t3 = type$.JSArray_Iterable_ComplexSelectorComponent_2, t4 = type$.JSArray_ComplexSelectorComponent_2, _i = 0; _i < lcs.length; lcs.length === t2 || (0, A.throwConcurrentModificationError)(lcs), ++_i) { + group = lcs[_i]; + t5 = A._setArrayType([], t3); + for (t6 = A._chunks0(groups1, groups2, new A._weaveParents_closure4(group), t1), t7 = t6.length, _i0 = 0; _i0 < t6.length; t6.length === t7 || (0, A.throwConcurrentModificationError)(t6), ++_i0) { + chunk = t6[_i0]; + t8 = A._setArrayType([], t4); + for (t9 = B.JSArray_methods.get$iterator(chunk); t9.moveNext$0();) + B.JSArray_methods.addAll$1(t8, t9.get$current(0)); + t5.push(t8); + } + choices.push(t5); + choices.push(A._setArrayType([group], t3)); + groups1.removeFirst$0(); + groups2.removeFirst$0(); + } + t2 = A._setArrayType([], t3); + for (t1 = A._chunks0(groups1, groups2, new A._weaveParents_closure5(), t1), t3 = t1.length, _i = 0; _i < t1.length; t1.length === t3 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + chunk = t1[_i]; + t5 = A._setArrayType([], t4); + for (t6 = B.JSArray_methods.get$iterator(chunk); t6.moveNext$0();) + B.JSArray_methods.addAll$1(t5, t6.get$current(0)); + t2.push(t5); + } + choices.push(t2); + B.JSArray_methods.addAll$1(choices, trailingCombinators); + t1 = A._setArrayType([], type$.JSArray_ComplexSelector_2); + for (t2 = J.get$iterator$ax(A.paths0(new A.WhereIterable(choices, new A._weaveParents_closure6(), type$.WhereIterable_List_Iterable_ComplexSelectorComponent_2), type$.Iterable_ComplexSelectorComponent_2)), t3 = !prefix.lineBreak, t5 = base.lineBreak; t2.moveNext$0();) { + t6 = t2.get$current(t2); + t7 = A._setArrayType([], t4); + for (t6 = J.get$iterator$ax(t6); t6.moveNext$0();) + B.JSArray_methods.addAll$1(t7, t6.get$current(t6)); + t1.push(A.ComplexSelector$0(leadingCombinators, t7, span, !t3 || t5)); + } + return t1; + }, + _firstIfRootish0(queue) { + var first, t1, t2, _i, simple, t3; + if (queue.get$length(0) >= 1) { + first = queue.$index(0, 0); + for (t1 = first.selector.components, t2 = t1.length, _i = 0; _i < t2; ++_i) { + simple = t1[_i]; + t3 = false; + if (simple instanceof A.PseudoSelector0) + if (simple.isClass) + t3 = $._rootishPseudoClasses0.contains$1(0, simple.normalizedName); + if (t3) { + queue.removeFirst$0(); + return first; + } + } + } + return null; + }, + _mergeLeadingCombinators0(combinators1, combinators2) { + var _0_4, t1, t2, _0_7_isSet, _0_7, t3, _0_4_isSet, _0_11, _0_11_isSet, combinators, _null = null; + $label0$0: { + _0_4 = combinators2; + t1 = _null; + t2 = type$.List_CssValue_Combinator_2; + _0_7_isSet = t2._is(combinators1); + _0_7 = _null; + if (_0_7_isSet) { + _0_7 = combinators1.length; + t3 = _0_7; + t3 = t3 > 1; + } else + t3 = false; + _0_4_isSet = true; + _0_11 = _null; + if (!t3) { + t3 = _0_4; + _0_11_isSet = t2._is(t3); + if (_0_11_isSet) { + t3 = _0_4; + _0_11 = (t3 == null ? t2._as(t3) : t3).length; + t3 = _0_11; + t3 = t3 > 1; + } else + t3 = false; + } else { + _0_11_isSet = false; + t3 = true; + } + if (t3) + break $label0$0; + if (t2._is(combinators1)) { + if (_0_7_isSet) + t3 = _0_7; + else { + _0_7 = combinators1.length; + t3 = _0_7; + } + t3 = t3 <= 0; + if (t3) + if (_0_4_isSet) + combinators = _0_4; + else { + combinators = combinators2; + _0_4 = combinators; + _0_4_isSet = true; + } + else + combinators = t1; + t1 = t3; + } else { + combinators = t1; + t1 = false; + } + if (!t1) { + t1 = false; + if (_0_4_isSet) + t3 = _0_4; + else { + t3 = combinators2; + _0_4 = t3; + _0_4_isSet = true; + } + if (t2._is(t3)) { + if (_0_11_isSet) + t1 = _0_11; + else { + t1 = _0_4_isSet ? _0_4 : combinators2; + _0_11 = (t1 == null ? t2._as(t1) : t1).length; + t1 = _0_11; + } + t1 = t1 <= 0; + } + combinators = combinators1; + } else + t1 = true; + if (t1) { + t1 = combinators; + break $label0$0; + } + t1 = B.C_ListEquality.equals$2(0, combinators1, combinators2) ? combinators1 : _null; + break $label0$0; + } + return t1; + }, + _mergeTrailingCombinators0(components1, components2, span, result) { + var _0_1, t1, _1_1, t2, t3, _4_1, _4_3, _4_4_isSet, _4_5, _4_4, component1, component2, t4, t5, choices, _2_0, _4_9, _4_6, _4_7, followingComponents, nextComponents, _4_4_isSet0, _4_6_isSet, _4_7_isSet, _4_10_isSet, _4_10, _4_5_isSet, next, following, _3_0, siblingComponents_case_0, siblingComponents_case_1, combinator1, t6, combinator2, unified, t7, combinator_case_0, combinatorComponents_case_0, descendantComponents_case_0, t0, combinator_case_1, descendantComponents_case_1, combinatorComponents_case_1, _null = null; + if (result == null) + result = A.QueueList$(_null, type$.List_List_ComplexSelectorComponent_2); + $label0$0: { + _0_1 = components1.get$length(0); + if (_0_1 >= 1) { + t1 = components1.$index(0, _0_1 - 1).combinators; + break $label0$0; + } + t1 = B.List_empty14; + break $label0$0; + } + $label1$1: { + _1_1 = components2.get$length(0); + if (_1_1 >= 1) { + t2 = components2.$index(0, _1_1 - 1).combinators; + break $label1$1; + } + t2 = B.List_empty14; + break $label1$1; + } + t3 = t1.length; + if (t3 === 0 && t2.length === 0) + return result; + if (t3 > 1 || t2.length > 1) + return _null; + $label2$2: { + t3 = A.IterableExtension_get_firstOrNull(t1); + t3 = t3 == null ? _null : t3.value; + t2 = A.IterableExtension_get_firstOrNull(t2); + t2 = [t3, t2 == null ? _null : t2.value, components1, components2]; + _4_1 = t2[0]; + _4_3 = B.Combinator_55N0 === _4_1; + _4_4_isSet = _4_3; + _4_5 = _null; + _4_4 = _null; + if (_4_4_isSet) { + _4_4 = t2[1]; + _4_5 = B.Combinator_55N0 === _4_4; + t3 = _4_5; + } else + t3 = false; + if (t3) { + component1 = components1.removeLast$0(0); + component2 = components2.removeLast$0(0); + t2 = component1.selector; + t3 = component2.selector; + if (A.compoundIsSuperselector0(t2, t3, _null)) + result.addFirst$1(A._setArrayType([A._setArrayType([component2], type$.JSArray_ComplexSelectorComponent_2)], type$.JSArray_List_ComplexSelectorComponent_2)); + else { + t4 = type$.JSArray_ComplexSelectorComponent_2; + t5 = type$.JSArray_List_ComplexSelectorComponent_2; + if (A.compoundIsSuperselector0(t3, t2, _null)) + result.addFirst$1(A._setArrayType([A._setArrayType([component1], t4)], t5)); + else { + choices = A._setArrayType([A._setArrayType([component1, component2], t4), A._setArrayType([component2, component1], t4)], t5); + _2_0 = A.unifyCompound0(t2, t3); + if (_2_0 != null) + choices.push(A._setArrayType([new A.ComplexSelectorComponent0(_2_0, A.List_List$unmodifiable(A._setArrayType([B.JSArray_methods.get$first(t1)], type$.JSArray_CssValue_Combinator_2), type$.CssValue_Combinator_2), span)], t4)); + result.addFirst$1(choices); + } + } + break $label2$2; + } + _4_9 = _null; + _4_6 = _null; + _4_7 = _null; + followingComponents = _null; + nextComponents = _null; + if (_4_3) { + if (_4_4_isSet) { + t3 = _4_4; + _4_4_isSet0 = _4_4_isSet; + } else { + _4_4 = t2[1]; + t3 = _4_4; + _4_4_isSet0 = true; + } + _4_9 = B.Combinator_bOP0 === t3; + _4_6_isSet = _4_9; + if (_4_6_isSet) { + _4_6 = t2[2]; + _4_7 = t2[3]; + nextComponents = _4_7; + followingComponents = _4_6; + } + t3 = _4_6_isSet; + _4_7_isSet = t3; + } else { + _4_4_isSet0 = _4_4_isSet; + _4_6_isSet = false; + _4_7_isSet = false; + t3 = false; + } + _4_10_isSet = !t3; + _4_10 = _null; + if (_4_10_isSet) { + _4_10 = B.Combinator_bOP0 === _4_1; + t3 = _4_10; + if (t3) { + if (_4_4_isSet) { + t3 = _4_5; + _4_5_isSet = _4_4_isSet; + _4_4_isSet = _4_4_isSet0; + } else { + if (_4_4_isSet0) { + t3 = _4_4; + _4_4_isSet = _4_4_isSet0; + } else { + _4_4 = t2[1]; + t3 = _4_4; + _4_4_isSet = true; + } + _4_5 = B.Combinator_55N0 === t3; + t3 = _4_5; + _4_5_isSet = true; + } + if (t3) { + if (_4_6_isSet) + nextComponents = _4_6; + else { + _4_6 = t2[2]; + nextComponents = _4_6; + _4_6_isSet = true; + } + if (_4_7_isSet) + followingComponents = _4_7; + else { + _4_7 = t2[3]; + followingComponents = _4_7; + _4_7_isSet = true; + } + } + } else { + _4_5_isSet = _4_4_isSet; + _4_4_isSet = _4_4_isSet0; + t3 = false; + } + } else { + _4_5_isSet = _4_4_isSet; + _4_4_isSet = _4_4_isSet0; + t3 = true; + } + if (t3) { + next = nextComponents.removeLast$0(0); + following = followingComponents.removeLast$0(0); + t1 = following.selector; + t2 = next.selector; + t3 = type$.JSArray_ComplexSelectorComponent_2; + t4 = type$.JSArray_List_ComplexSelectorComponent_2; + if (A.compoundIsSuperselector0(t1, t2, _null)) + result.addFirst$1(A._setArrayType([A._setArrayType([next], t3)], t4)); + else { + t4 = A._setArrayType([A._setArrayType([following, next], t3)], t4); + _3_0 = A.unifyCompound0(t1, t2); + if (_3_0 != null) + t4.push(A._setArrayType([new A.ComplexSelectorComponent0(_3_0, A.List_List$unmodifiable(next.combinators, type$.CssValue_Combinator_2), span)], t3)); + result.addFirst$1(t4); + } + break $label2$2; + } + t3 = _null; + if (B.Combinator_0mp0 === _4_1) { + _4_4_isSet0 = true; + if (_4_3) + t4 = _4_9; + else { + if (_4_4_isSet) + t4 = _4_4; + else { + _4_4 = t2[1]; + t4 = _4_4; + _4_4_isSet = _4_4_isSet0; + } + _4_9 = B.Combinator_bOP0 === t4; + t4 = _4_9; + } + if (!t4) + if (_4_5_isSet) + t4 = _4_5; + else { + if (_4_4_isSet) + t4 = _4_4; + else { + _4_4 = t2[1]; + t4 = _4_4; + _4_4_isSet = _4_4_isSet0; + } + _4_5 = B.Combinator_55N0 === t4; + t4 = _4_5; + } + else + t4 = true; + if (t4) { + if (_4_7_isSet) + siblingComponents_case_0 = _4_7; + else { + _4_7 = t2[3]; + siblingComponents_case_0 = _4_7; + _4_7_isSet = true; + } + t3 = siblingComponents_case_0; + } + } else + t4 = false; + if (!t4) { + if (_4_10_isSet) + t4 = _4_10; + else { + _4_10 = B.Combinator_bOP0 === _4_1; + t4 = _4_10; + } + if (!t4) + t4 = _4_3; + else + t4 = true; + if (t4) { + if (_4_4_isSet) + t4 = _4_4; + else { + _4_4 = t2[1]; + t4 = _4_4; + _4_4_isSet = true; + } + t4 = B.Combinator_0mp0 === t4; + if (t4) { + if (_4_6_isSet) + siblingComponents_case_1 = _4_6; + else { + _4_6 = t2[2]; + siblingComponents_case_1 = _4_6; + _4_6_isSet = true; + } + t3 = siblingComponents_case_1; + } + } else + t4 = false; + } else + t4 = true; + if (t4) { + result.addFirst$1(A._setArrayType([A._setArrayType([t3.removeLast$0(0)], type$.JSArray_ComplexSelectorComponent_2)], type$.JSArray_List_ComplexSelectorComponent_2)); + break $label2$2; + } + t3 = _4_1 == null; + t4 = !t3; + t5 = false; + if (t4) { + _4_4_isSet0 = true; + combinator1 = _4_1; + if (_4_4_isSet) + t6 = _4_4; + else { + _4_4 = t2[1]; + t6 = _4_4; + _4_4_isSet = _4_4_isSet0; + } + if (t6 != null) { + if (_4_4_isSet) + combinator2 = _4_4; + else { + _4_4 = t2[1]; + combinator2 = _4_4; + _4_4_isSet = _4_4_isSet0; + } + t5 = combinator1 === (combinator2 == null ? type$.Combinator_2._as(combinator2) : combinator2); + } + } + if (t5) { + unified = A.unifyCompound0(components1.removeLast$0(0).selector, components2.removeLast$0(0).selector); + if (unified == null) + return _null; + result.addFirst$1(A._setArrayType([A._setArrayType([new A.ComplexSelectorComponent0(unified, A.List_List$unmodifiable(A._setArrayType([B.JSArray_methods.get$first(t1)], type$.JSArray_CssValue_Combinator_2), type$.CssValue_Combinator_2), span)], type$.JSArray_ComplexSelectorComponent_2)], type$.JSArray_List_ComplexSelectorComponent_2)); + break $label2$2; + } + t1 = _null; + t5 = _null; + t6 = _null; + t7 = false; + if (t4) { + combinator_case_0 = _4_1; + if (_4_4_isSet) + t4 = _4_4; + else { + _4_4 = t2[1]; + t4 = _4_4; + _4_4_isSet = true; + } + t4 = t4 == null; + if (t4) { + if (_4_6_isSet) + combinatorComponents_case_0 = _4_6; + else { + _4_6 = t2[2]; + combinatorComponents_case_0 = _4_6; + _4_6_isSet = true; + } + if (_4_7_isSet) + descendantComponents_case_0 = _4_7; + else { + _4_7 = t2[3]; + descendantComponents_case_0 = _4_7; + _4_7_isSet = true; + } + t1 = descendantComponents_case_0; + t6 = t1; + t1 = combinator_case_0; + t5 = combinatorComponents_case_0; + } + t0 = t6; + t6 = t4; + t4 = t5; + t5 = t0; + } else { + t4 = t5; + t5 = t6; + t6 = t7; + } + if (!t6) + if (t3) { + if (_4_4_isSet) + t3 = _4_4; + else { + _4_4 = t2[1]; + t3 = _4_4; + _4_4_isSet = true; + } + t3 = t3 != null; + if (t3) { + combinator_case_1 = _4_4_isSet ? _4_4 : t2[1]; + if (combinator_case_1 == null) + combinator_case_1 = type$.Combinator_2._as(combinator_case_1); + descendantComponents_case_1 = _4_6_isSet ? _4_6 : t2[2]; + combinatorComponents_case_1 = _4_7_isSet ? _4_7 : t2[3]; + t1 = combinatorComponents_case_1; + t2 = descendantComponents_case_1; + t4 = t2; + t2 = t1; + t1 = combinator_case_1; + } else { + t2 = t4; + t4 = t5; + } + t0 = t4; + t4 = t3; + t3 = t0; + } else { + t3 = t5; + t2 = t4; + t4 = false; + } + else { + t3 = t5; + t2 = t4; + t4 = true; + } + if (t4) { + if (t1 === B.Combinator_0mp0) { + t1 = A.IterableExtension_get_lastOrNull(t3); + t1 = t1 == null ? _null : A.compoundIsSuperselector0(t1.selector, t2.get$last(t2).selector, _null); + t1 = t1 === true; + } else + t1 = false; + if (t1) + t3.removeLast$0(0); + result.addFirst$1(A._setArrayType([A._setArrayType([t2.removeLast$0(0)], type$.JSArray_ComplexSelectorComponent_2)], type$.JSArray_List_ComplexSelectorComponent_2)); + break $label2$2; + } + return _null; + } + return A._mergeTrailingCombinators0(components1, components2, span, result); + }, + _mustUnify0(complex1, complex2) { + var t2, t3, t4, + t1 = A.LinkedHashSet_LinkedHashSet$_empty(type$.SimpleSelector_2); + for (t2 = J.get$iterator$ax(complex1); t2.moveNext$0();) + for (t3 = B.JSArray_methods.get$iterator(t2.get$current(t2).selector.components), t4 = new A.WhereIterator(t3, A.functions0___isUnique$closure()); t4.moveNext$0();) + t1.add$1(0, t3.get$current(0)); + if (t1._collection$_length === 0) + return false; + return J.any$1$ax(complex2, new A._mustUnify_closure0(t1)); + }, + _isUnique0(simple) { + var t1; + if (!(simple instanceof A.IDSelector0)) + t1 = simple instanceof A.PseudoSelector0 && !simple.isClass; + else + t1 = true; + return t1; + }, + _chunks0(queue1, queue2, done, $T) { + var chunk2, _0_4, _0_5_isSet, _0_1, _0_7, _0_5, chunk, _0_5_isSet0, t2, _null = null, + t1 = $T._eval$1("JSArray<0>"), + chunk1 = A._setArrayType([], t1); + for (; !done.call$1(queue1);) + chunk1.push(queue1.removeFirst$0()); + chunk2 = A._setArrayType([], t1); + for (; !done.call$1(queue2);) + chunk2.push(queue2.removeFirst$0()); + $label0$0: { + _0_4 = chunk1.length <= 0; + _0_5_isSet = _0_4; + _0_1 = chunk1; + _0_7 = _null; + _0_5 = _null; + if (_0_5_isSet) { + _0_7 = chunk2.length <= 0; + t1 = _0_7; + _0_5 = chunk2; + } else + t1 = false; + if (t1) { + t1 = A._setArrayType([], $T._eval$1("JSArray>")); + break $label0$0; + } + if (_0_4) + if (_0_5_isSet) { + chunk = _0_5; + _0_5_isSet0 = _0_5_isSet; + } else { + chunk = chunk2; + _0_5 = chunk; + _0_5_isSet0 = true; + } + else { + chunk = _null; + _0_5_isSet0 = _0_5_isSet; + } + if (!_0_4) { + if (_0_5_isSet) + t1 = _0_7; + else { + _0_7 = (_0_5_isSet0 ? _0_5 : chunk2).length <= 0; + t1 = _0_7; + } + chunk = _0_1; + } else + t1 = true; + if (t1) { + t1 = A._setArrayType([chunk], $T._eval$1("JSArray>")); + break $label0$0; + } + t1 = A.List_List$of(chunk1, true, $T); + B.JSArray_methods.addAll$1(t1, chunk2); + t2 = A.List_List$of(chunk2, true, $T); + B.JSArray_methods.addAll$1(t2, chunk1); + t2 = A._setArrayType([t1, t2], $T._eval$1("JSArray>")); + t1 = t2; + break $label0$0; + } + return t1; + }, + paths0(choices, $T) { + return J.fold$2$ax(choices, A._setArrayType([A._setArrayType([], $T._eval$1("JSArray<0>"))], $T._eval$1("JSArray>")), new A.paths_closure0($T)); + }, + _groupSelectors0(complex) { + var t2, t3, t4, + groups = A.QueueList$(null, type$.List_ComplexSelectorComponent_2), + t1 = type$.JSArray_ComplexSelectorComponent_2, + group = A._setArrayType([], t1); + for (t2 = complex.$ti, t3 = new A.ListIterator(complex, complex.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"); t3.moveNext$0();) { + t4 = t3.__internal$_current; + if (t4 == null) + t4 = t2._as(t4); + group.push(t4); + if (t4.combinators.length === 0) { + groups._queue_list$_add$1(group); + group = A._setArrayType([], t1); + } + } + if (group.length !== 0) + groups._queue_list$_add$1(group); + return groups; + }, + listIsSuperselector0(list1, list2) { + return B.JSArray_methods.every$1(list2, new A.listIsSuperselector_closure0(list1)); + }, + _complexIsParentSuperselector0(complex1, complex2) { + var t1, base, t2; + if (J.get$length$asx(complex1) > J.get$length$asx(complex2)) + return false; + t1 = $.$get$bogusSpan0(); + base = new A.ComplexSelectorComponent0(A.CompoundSelector$0(A._setArrayType([new A.PlaceholderSelector0("", t1)], type$.JSArray_SimpleSelector_2), t1), A.List_List$unmodifiable(B.List_empty14, type$.CssValue_Combinator_2), t1); + t1 = type$.ComplexSelectorComponent_2; + t2 = A.List_List$of(complex1, true, t1); + t2.push(base); + t1 = A.List_List$of(complex2, true, t1); + t1.push(base); + return A.complexIsSuperselector0(t2, t1); + }, + complexIsSuperselector0(complex1, complex2) { + var t1, t2, previousCombinator, i1, i2, remaining1, remaining2, component1, t3, t4, endOfSubselector, component2, t5, combinator1, _null = null; + if (B.JSArray_methods.get$last(complex1).combinators.length !== 0) + return false; + if (B.JSArray_methods.get$last(complex2).combinators.length !== 0) + return false; + for (t1 = A._arrayInstanceType(complex2), t2 = t1._precomputed1, t1 = t1._eval$1("SubListIterable<1>"), previousCombinator = _null, i1 = 0, i2 = 0; true; previousCombinator = combinator1) { + remaining1 = complex1.length - i1; + remaining2 = complex2.length - i2; + if (remaining1 === 0 || remaining2 === 0) + return false; + if (remaining1 > remaining2) + return false; + component1 = complex1[i1]; + t3 = component1.combinators; + if (t3.length > 1) + return false; + if (remaining1 === 1) + if (B.JSArray_methods.any$1(complex2, new A.complexIsSuperselector_closure1())) + return false; + else { + t1 = component1.selector; + t2 = B.JSArray_methods.get$last(complex2).selector; + return A.compoundIsSuperselector0(t1, t2, t1.get$hasComplicatedSuperselectorSemantics() ? B.JSArray_methods.sublist$2(complex2, i2, complex2.length - 1) : _null); + } + for (t4 = component1.selector, endOfSubselector = i2; true;) { + component2 = complex2[endOfSubselector]; + if (component2.combinators.length > 1) + return false; + t5 = t4.get$hasComplicatedSuperselectorSemantics() ? B.JSArray_methods.sublist$2(complex2, i2, endOfSubselector) : _null; + if (A.compoundIsSuperselector0(t4, component2.selector, t5)) + break; + ++endOfSubselector; + if (endOfSubselector === complex2.length - 1) + return false; + } + t4 = new A.SubListIterable(complex2, 0, endOfSubselector, t1); + t4.SubListIterable$3(complex2, 0, endOfSubselector, t2); + if (!A._compatibleWithPreviousCombinator0(previousCombinator, t4.skip$1(0, i2))) + return false; + component2 = complex2[endOfSubselector]; + combinator1 = A.IterableExtension_get_firstOrNull(t3); + if (!A._isSupercombinator0(combinator1, A.IterableExtension_get_firstOrNull(component2.combinators))) + return false; + ++i1; + i2 = endOfSubselector + 1; + if (complex1.length - i1 === 1) { + t3 = combinator1 == null; + if (J.$eq$(t3 ? _null : combinator1.value, B.Combinator_55N0)) { + t3 = complex2.length - 1; + t4 = new A.SubListIterable(complex2, 0, t3, t1); + t4.SubListIterable$3(complex2, 0, t3, t2); + if (!t4.skip$1(0, i2).every$1(0, new A.complexIsSuperselector_closure2(combinator1))) + return false; + } else if (!t3) + if (complex2.length - i2 > 1) + return false; + } + } + }, + _compatibleWithPreviousCombinator0(previous, parents) { + if (parents.get$isEmpty(parents)) + return true; + if (previous == null) + return true; + if (previous.value !== B.Combinator_55N0) + return false; + return parents.every$1(0, new A._compatibleWithPreviousCombinator_closure0()); + }, + _isSupercombinator0(combinator1, combinator2) { + var t2, t3, + t1 = true; + if (!J.$eq$(combinator1, combinator2)) { + t2 = combinator1 == null; + if (t2) + t3 = J.$eq$(combinator2 == null ? null : combinator2.value, B.Combinator_0mp0); + else + t3 = false; + if (!t3) + if (J.$eq$(t2 ? null : combinator1.value, B.Combinator_55N0)) + t1 = J.$eq$(combinator2 == null ? null : combinator2.value, B.Combinator_bOP0); + else + t1 = false; + } + return t1; + }, + compoundIsSuperselector0(compound1, compound2, parents) { + var t1, _0_1, _0_5, _0_5_isSet, _0_50, index1, pseudo2, index2, t2, t3, pseudo1, t4, t5, _i, simple1, _null = null; + if (!compound1.get$hasComplicatedSuperselectorSemantics() && !compound2.get$hasComplicatedSuperselectorSemantics()) { + t1 = compound1.components; + if (t1.length > compound2.components.length) + return false; + return B.JSArray_methods.every$1(t1, new A.compoundIsSuperselector_closure0(compound2)); + } + _0_1 = A._findPseudoElementIndexed0(compound1); + _0_5 = A._findPseudoElementIndexed0(compound2); + t1 = type$.Record_2_nullable_Object_and_nullable_Object; + _0_5_isSet = t1._is(_0_1); + _0_50 = _null; + index1 = _null; + pseudo2 = _null; + index2 = _null; + t2 = false; + if (_0_5_isSet) { + t3 = _0_1 == null; + pseudo1 = (t3 ? t1._as(_0_1) : _0_1)._0; + index1 = (t3 ? t1._as(_0_1) : _0_1)._1; + t2 = t1._is(_0_5); + if (t2) { + t3 = _0_5 == null; + pseudo2 = (t3 ? t1._as(_0_5) : _0_5)._0; + index2 = (t3 ? t1._as(_0_5) : _0_5)._1; + } + t1 = t2; + _0_50 = _0_5; + } else { + t1 = t2; + pseudo1 = _null; + } + if (t1) { + if (pseudo1.isSuperselector$1(pseudo2)) { + t1 = compound1.components; + t2 = type$.int; + t3 = A._arrayInstanceType(t1)._precomputed1; + t4 = compound2.components; + t5 = A._arrayInstanceType(t4)._precomputed1; + t1 = A._compoundComponentsIsSuperselector0(A.SubListIterable$(t1, 0, A.checkNotNullable(index1, "count", t2), t3), A.SubListIterable$(t4, 0, A.checkNotNullable(index2, "count", t2), t5), parents) && A._compoundComponentsIsSuperselector0(A.SubListIterable$(t1, index1 + 1, _null, t3), A.SubListIterable$(t4, index2 + 1, _null, t5), parents); + } else + t1 = false; + return t1; + } + if (_0_1 == null) + t1 = (_0_5_isSet ? _0_50 : _0_5) != null; + else + t1 = true; + if (t1) + return false; + for (t1 = compound1.components, t2 = t1.length, t3 = compound2.components, _i = 0; _i < t2; ++_i) { + simple1 = t1[_i]; + if (simple1 instanceof A.PseudoSelector0) + t4 = simple1.selector != null; + else + t4 = false; + if (t4) { + if (!A._selectorPseudoIsSuperselector0(simple1, compound2, parents)) + return false; + } else if (!B.JSArray_methods.any$1(t3, simple1.get$isSuperselector())) + return false; + } + return true; + }, + _findPseudoElementIndexed0(compound) { + var t1, t2, i, simple; + for (t1 = compound.components, t2 = t1.length, i = 0; i < t2; ++i) { + simple = t1[i]; + if (simple instanceof A.PseudoSelector0 && !simple.isClass) + return new A._Record_2(simple, i); + } + return null; + }, + _compoundComponentsIsSuperselector0(compound1, compound2, parents) { + var t1; + if (compound1.get$length(0) === 0) + return true; + if (compound2.get$length(0) === 0) + compound2 = A._setArrayType([new A.UniversalSelector0("*", $.$get$bogusSpan0())], type$.JSArray_SimpleSelector_2); + t1 = $.$get$bogusSpan0(); + return A.compoundIsSuperselector0(A.CompoundSelector$0(compound1, t1), A.CompoundSelector$0(compound2, t1), parents); + }, + _selectorPseudoIsSuperselector0(pseudo1, compound2, parents) { + var selector1 = pseudo1.selector; + if (selector1 == null) + throw A.wrapException(A.ArgumentError$("Selector " + pseudo1.toString$0(0) + " must have a selector argument.", null)); + switch (pseudo1.normalizedName) { + case "is": + case "matches": + case "any": + case "where": + return A._selectorPseudoArgs0(compound2, pseudo1.name, true).any$1(0, new A._selectorPseudoIsSuperselector_closure6(selector1)) || B.JSArray_methods.any$1(selector1.components, new A._selectorPseudoIsSuperselector_closure7(parents, compound2)); + case "has": + case "host": + case "host-context": + return A._selectorPseudoArgs0(compound2, pseudo1.name, true).any$1(0, new A._selectorPseudoIsSuperselector_closure8(selector1)); + case "slotted": + return A._selectorPseudoArgs0(compound2, pseudo1.name, false).any$1(0, new A._selectorPseudoIsSuperselector_closure9(selector1)); + case "not": + return B.JSArray_methods.every$1(selector1.components, new A._selectorPseudoIsSuperselector_closure10(compound2, pseudo1)); + case "current": + return A._selectorPseudoArgs0(compound2, pseudo1.name, true).any$1(0, new A._selectorPseudoIsSuperselector_closure11(selector1)); + case "nth-child": + case "nth-last-child": + return B.JSArray_methods.any$1(compound2.components, new A._selectorPseudoIsSuperselector_closure12(pseudo1, selector1)); + default: + throw A.wrapException("unreachable"); + } + }, + _selectorPseudoArgs0(compound, $name, isClass) { + var t1 = type$.WhereTypeIterable_PseudoSelector_2; + return new A.NonNullsIterable(new A.MappedIterable(new A.WhereIterable(new A.WhereTypeIterable(compound.components, t1), new A._selectorPseudoArgs_closure1(isClass, $name), t1._eval$1("WhereIterable")), new A._selectorPseudoArgs_closure2(), t1._eval$1("MappedIterable")), type$.NonNullsIterable_SelectorList_2); + }, + unifyComplex_closure0: function unifyComplex_closure0() { + }, + _weaveParents_closure3: function _weaveParents_closure3(t0) { + this.span = t0; + }, + _weaveParents_closure4: function _weaveParents_closure4(t0) { + this.group = t0; + }, + _weaveParents_closure5: function _weaveParents_closure5() { + }, + _weaveParents_closure6: function _weaveParents_closure6() { + }, + _mustUnify_closure0: function _mustUnify_closure0(t0) { + this.uniqueSelectors = t0; + }, + _mustUnify__closure0: function _mustUnify__closure0(t0) { + this.uniqueSelectors = t0; + }, + paths_closure0: function paths_closure0(t0) { + this.T = t0; + }, + paths__closure0: function paths__closure0(t0, t1) { + this.paths = t0; + this.T = t1; + }, + paths___closure0: function paths___closure0(t0, t1) { + this.option = t0; + this.T = t1; + }, + listIsSuperselector_closure0: function listIsSuperselector_closure0(t0) { + this.list1 = t0; + }, + listIsSuperselector__closure0: function listIsSuperselector__closure0(t0) { + this.complex1 = t0; + }, + complexIsSuperselector_closure1: function complexIsSuperselector_closure1() { + }, + complexIsSuperselector_closure2: function complexIsSuperselector_closure2(t0) { + this.combinator1 = t0; + }, + _compatibleWithPreviousCombinator_closure0: function _compatibleWithPreviousCombinator_closure0() { + }, + compoundIsSuperselector_closure0: function compoundIsSuperselector_closure0(t0) { + this.compound2 = t0; + }, + _selectorPseudoIsSuperselector_closure6: function _selectorPseudoIsSuperselector_closure6(t0) { + this.selector1 = t0; + }, + _selectorPseudoIsSuperselector_closure7: function _selectorPseudoIsSuperselector_closure7(t0, t1) { + this.parents = t0; + this.compound2 = t1; + }, + _selectorPseudoIsSuperselector_closure8: function _selectorPseudoIsSuperselector_closure8(t0) { + this.selector1 = t0; + }, + _selectorPseudoIsSuperselector_closure9: function _selectorPseudoIsSuperselector_closure9(t0) { + this.selector1 = t0; + }, + _selectorPseudoIsSuperselector_closure10: function _selectorPseudoIsSuperselector_closure10(t0, t1) { + this.compound2 = t0; + this.pseudo1 = t1; + }, + _selectorPseudoIsSuperselector__closure0: function _selectorPseudoIsSuperselector__closure0(t0, t1) { + this.complex = t0; + this.pseudo1 = t1; + }, + _selectorPseudoIsSuperselector___closure1: function _selectorPseudoIsSuperselector___closure1(t0) { + this.simple2 = t0; + }, + _selectorPseudoIsSuperselector___closure2: function _selectorPseudoIsSuperselector___closure2(t0) { + this.simple2 = t0; + }, + _selectorPseudoIsSuperselector_closure11: function _selectorPseudoIsSuperselector_closure11(t0) { + this.selector1 = t0; + }, + _selectorPseudoIsSuperselector_closure12: function _selectorPseudoIsSuperselector_closure12(t0, t1) { + this.pseudo1 = t0; + this.selector1 = t1; + }, + _selectorPseudoArgs_closure1: function _selectorPseudoArgs_closure1(t0, t1) { + this.isClass = t0; + this.name = t1; + }, + _selectorPseudoArgs_closure2: function _selectorPseudoArgs_closure2() { + }, + globalFunctions_closure0: function globalFunctions_closure0() { + }, + GamutMapMethod_GamutMapMethod$fromName0($name) { + var t1; + $label0$0: { + if ("clip" === $name) { + t1 = B.ClipGamutMap_clip0; + break $label0$0; + } + if ("local-minde" === $name) { + t1 = B.LocalMindeGamutMap_A2x0; + break $label0$0; + } + t1 = A.throwExpression(A.SassScriptException$0('Unknown gamut map method "' + $name + '".', null)); + } + return t1; + }, + GamutMapMethod0: function GamutMapMethod0() { + }, + HslColorSpace0: function HslColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + HwbColorSpace0: function HwbColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + HwbColorSpace_convert_toRgb0: function HwbColorSpace_convert_toRgb0(t0, t1) { + this._box_0 = t0; + this.factor = t1; + }, + IDSelector0: function IDSelector0(t0, t1) { + this.name = t0; + this.span = t1; + }, + IDSelector_unify_closure0: function IDSelector_unify_closure0(t0) { + this.$this = t0; + }, + IfExpression0: function IfExpression0(t0, t1) { + this.$arguments = t0; + this.span = t1; + }, + IfClause$0(expression, children) { + var t1 = A.List_List$unmodifiable(children, type$.Statement_2); + return new A.IfClause0(expression, t1, B.JSArray_methods.any$1(t1, new A.IfRuleClause$__closure0())); + }, + ElseClause$0(children) { + var t1 = A.List_List$unmodifiable(children, type$.Statement_2); + return new A.ElseClause0(t1, B.JSArray_methods.any$1(t1, new A.IfRuleClause$__closure0())); + }, + IfRule0: function IfRule0(t0, t1, t2) { + this.clauses = t0; + this.lastClause = t1; + this.span = t2; + }, + IfRule_toString_closure0: function IfRule_toString_closure0() { + }, + IfRuleClause0: function IfRuleClause0() { + }, + IfRuleClause$__closure0: function IfRuleClause$__closure0() { + }, + IfRuleClause$___closure0: function IfRuleClause$___closure0() { + }, + IfClause0: function IfClause0(t0, t1, t2) { + this.expression = t0; + this.children = t1; + this.hasDeclarations = t2; + }, + ElseClause0: function ElseClause0(t0, t1) { + this.children = t0; + this.hasDeclarations = t1; + }, + jsToDartList(list) { + return self.immutable.isOrderedMap(list) ? J.toArray$0$x(type$.ImmutableList._as(list)) : type$.List_dynamic._as(list); + }, + dartMapToImmutableMap(dartMap) { + var t1, t2, + immutableMap = J.asMutable$0$x(new self.immutable.OrderedMap()); + for (t1 = A.MapExtensions_get_pairs0(dartMap, type$.Object, type$.nullable_Object), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t2 = t1.get$current(t1); + immutableMap = J.$set$2$x(immutableMap, t2._0, t2._1); + } + return J.asImmutable$0$x(immutableMap); + }, + immutableMapToDartMap(immutableMap) { + var dartMap = A.LinkedHashMap_LinkedHashMap$_empty(type$.Object, type$.nullable_Object); + J.forEach$1$ax(immutableMap, A.allowInterop(new A.immutableMapToDartMap_closure(dartMap))); + return dartMap; + }, + ImmutableList0: function ImmutableList0() { + }, + ImmutableMap0: function ImmutableMap0() { + }, + immutableMapToDartMap_closure: function immutableMapToDartMap_closure(t0) { + this.dartMap = t0; + }, + NodeImporter__addSassPath(includePaths) { + return new A._SyncStarIterable(A.NodeImporter__addSassPath$body(includePaths), type$._SyncStarIterable_String); + }, + NodeImporter__addSassPath$body($async$includePaths) { + return function() { + var includePaths = $async$includePaths; + var $async$goto = 0, $async$handler = 2, $async$errorStack = [], sassPath, t1; + return function $async$NodeImporter__addSassPath($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return $async$iterator._yieldStar$1(includePaths); + case 3: + // after yield + sassPath = A.getEnvironmentVariable0("SASS_PATH"); + if (sassPath == null) { + // goto return + $async$goto = 1; + break; + } + t1 = A.isNodeJs() ? self.process : null; + $async$goto = 4; + return $async$iterator._yieldStar$1(A._setArrayType(sassPath.split(J.$eq$(t1 == null ? null : J.get$platform$x(t1), "win32") ? ";" : ":"), type$.JSArray_String)); + case 4: + // after yield + case 1: + // return + return 0; + case 2: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + }, + NodeImporter: function NodeImporter(t0, t1, t2) { + this._implementation$_options = t0; + this._includePaths = t1; + this._implementation$_importers = t2; + }, + NodeImporter_load_closure: function NodeImporter_load_closure(t0, t1, t2, t3, t4) { + var _ = this; + _.$this = t0; + _.importer = t1; + _.forImport = t2; + _.url = t3; + _.previousString = t4; + }, + NodeImporter__tryPath_closure: function NodeImporter__tryPath_closure(t0) { + this.path = t0; + }, + NodeImporter__tryPath_closure0: function NodeImporter__tryPath_closure0() { + }, + NodeImporter__callImporterAsync_closure: function NodeImporter__callImporterAsync_closure(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.$this = t0; + _.importer = t1; + _.forImport = t2; + _.url = t3; + _.previousString = t4; + _.completer = t5; + }, + ModifiableCssImport0: function ModifiableCssImport0(t0, t1, t2) { + var _ = this; + _.url = t0; + _.modifiers = t1; + _.span = t2; + _._node$_indexInParent = _._node$_parent = null; + _.isGroupEnd = false; + }, + ImportCache$0(importers, loadPaths, packageConfig) { + var t1 = type$.nullable_Record_3_Importer_and_Uri_and_Uri_originalUrl_2, + t2 = type$.Record_3_Importer_and_Uri_and_bool_forImport_2, + t3 = type$.Uri; + return new A.ImportCache0(A.ImportCache__toImporters0(importers, loadPaths, packageConfig), A.LinkedHashMap_LinkedHashMap$_empty(type$.Record_2_Uri_and_bool_forImport, t1), A.LinkedHashMap_LinkedHashMap$_empty(t2, t1), A.LinkedHashMap_LinkedHashMap$_empty(t2, t3), A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.nullable_Stylesheet_2), A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.ImporterResult_2), A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.DateTime)); + }, + ImportCache$none() { + var t1 = type$.nullable_Record_3_Importer_and_Uri_and_Uri_originalUrl_2, + t2 = type$.Record_3_Importer_and_Uri_and_bool_forImport_2, + t3 = type$.Uri; + return new A.ImportCache0(B.List_empty25, A.LinkedHashMap_LinkedHashMap$_empty(type$.Record_2_Uri_and_bool_forImport, t1), A.LinkedHashMap_LinkedHashMap$_empty(t2, t1), A.LinkedHashMap_LinkedHashMap$_empty(t2, t3), A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.nullable_Stylesheet_2), A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.ImporterResult_2), A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.DateTime)); + }, + ImportCache__toImporters0(importers, loadPaths, packageConfig) { + var t1, t2, t3, t4, _i, path, _null = null, + sassPath = A.getEnvironmentVariable0("SASS_PATH"); + if (A.isBrowser()) { + t1 = A._setArrayType([], type$.JSArray_Importer_2); + if (importers != null) + B.JSArray_methods.addAll$1(t1, importers); + return t1; + } + t1 = A._setArrayType([], type$.JSArray_Importer_2); + if (importers != null) + B.JSArray_methods.addAll$1(t1, importers); + if (loadPaths != null) + for (t2 = J.get$iterator$ax(loadPaths); t2.moveNext$0();) { + t3 = t2.get$current(t2); + t1.push(new A.FilesystemImporter0($.$get$context().absolute$15(t3, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null), false)); + } + if (sassPath != null) { + t2 = A.isNodeJs() ? self.process : _null; + t3 = sassPath.split(J.$eq$(t2 == null ? _null : J.get$platform$x(t2), "win32") ? ";" : ":"); + t4 = t3.length; + _i = 0; + for (; _i < t4; ++_i) { + path = t3[_i]; + t1.push(new A.FilesystemImporter0($.$get$context().absolute$15(path, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null), false)); + } + } + return t1; + }, + ImportCache0: function ImportCache0(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._import_cache$_importers = t0; + _._import_cache$_canonicalizeCache = t1; + _._import_cache$_perImporterCanonicalizeCache = t2; + _._import_cache$_nonCanonicalRelativeUrls = t3; + _._import_cache$_importCache = t4; + _._import_cache$_resultsCache = t5; + _._import_cache$_loadTimes = t6; + }, + ImportCache_canonicalize_closure0: function ImportCache_canonicalize_closure0(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.$this = t0; + _.baseImporter = t1; + _.resolvedUrl = t2; + _.baseUrl = t3; + _.forImport = t4; + _.key = t5; + _.url = t6; + }, + ImportCache__canonicalize_closure0: function ImportCache__canonicalize_closure0(t0, t1) { + this.importer = t0; + this.url = t1; + }, + ImportCache_importCanonical_closure0: function ImportCache_importCanonical_closure0(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.importer = t1; + _.canonicalUrl = t2; + _.originalUrl = t3; + }, + ImportCache_humanize_closure3: function ImportCache_humanize_closure3(t0) { + this.canonicalUrl = t0; + }, + ImportCache_humanize_closure4: function ImportCache_humanize_closure4() { + }, + ImportCache_humanize_closure5: function ImportCache_humanize_closure5() { + }, + ImportCache_humanize_closure6: function ImportCache_humanize_closure6(t0) { + this.canonicalUrl = t0; + }, + ImportRule0: function ImportRule0(t0, t1) { + this.imports = t0; + this.span = t1; + }, + JSImporter: function JSImporter() { + }, + JSImporterResult: function JSImporterResult() { + }, + Importer0: function Importer0() { + }, + NodeImporterResult0: function NodeImporterResult0() { + }, + IncludeRule0: function IncludeRule0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.namespace = t0; + _.name = t1; + _.originalName = t2; + _.$arguments = t3; + _.content = t4; + _.span = t5; + }, + InterpolatedFunctionExpression0: function InterpolatedFunctionExpression0(t0, t1, t2) { + this.name = t0; + this.$arguments = t1; + this.span = t2; + }, + Interpolation$0(contents, spans, span) { + var t1 = new A.Interpolation0(A.List_List$unmodifiable(contents, type$.Object), A.List_List$unmodifiable(spans, type$.nullable_FileSpan), span); + t1.Interpolation$30(contents, spans, span); + return t1; + }, + Interpolation0: function Interpolation0(t0, t1, t2) { + this.contents = t0; + this.spans = t1; + this.span = t2; + }, + Interpolation_toString_closure0: function Interpolation_toString_closure0() { + }, + SupportsInterpolation0: function SupportsInterpolation0(t0, t1) { + this.expression = t0; + this.span = t1; + }, + InterpolationBuffer0: function InterpolationBuffer0(t0, t1, t2) { + this._interpolation_buffer0$_text = t0; + this._interpolation_buffer0$_contents = t1; + this._interpolation_buffer0$_spans = t2; + }, + InterpolationMap$0(_interpolation, targetLocations) { + var t1 = A.List_List$unmodifiable(targetLocations, type$.SourceLocation), + t2 = _interpolation.contents.length, + expectedLocations = Math.max(0, t2 - 1); + if (t1.length !== expectedLocations) + A.throwExpression(A.ArgumentError$("InterpolationMap must have " + A.S(expectedLocations) + string$.x20targe + t2 + " components.", null)); + return new A.InterpolationMap0(_interpolation, t1); + }, + InterpolationMap0: function InterpolationMap0(t0, t1) { + this._interpolation_map$_interpolation = t0; + this._interpolation_map$_targetLocations = t1; + }, + InterpolationMap_mapException_closure0: function InterpolationMap_mapException_closure0() { + }, + InterpolationMethod$0(space, hue) { + var t1; + if (space.get$isPolarInternal()) + t1 = hue == null ? B.HueInterpolationMethod_00 : hue; + else + t1 = null; + if (!space.get$isPolarInternal() && hue != null) + A.throwExpression(A.ArgumentError$(string$.Hue_in + space.toString$0(0) + ".", null)); + return new A.InterpolationMethod0(space, t1); + }, + InterpolationMethod_InterpolationMethod$fromValue0(value, $name) { + var t1, space, hueMethod, + list = value.assertCommonListStyle$2$allowSlash($name, false); + if (list.length === 0) + throw A.wrapException(A.SassScriptException$0(string$.Expecta, $name)); + t1 = B.JSArray_methods.get$first(list).assertString$1($name); + t1.assertUnquoted$1($name); + space = A.ColorSpace_fromName0(t1._string0$_text, $name); + if (list.length === 1) + return A.InterpolationMethod$0(space, null); + hueMethod = A.HueInterpolationMethod_HueInterpolationMethod$_fromValue0(list[1], $name); + if (list.length === 2) + throw A.wrapException(A.SassScriptException$0('Expected unquoted string "hue" after ' + value.toString$0(0) + ".", $name)); + else { + t1 = list[2].assertString$1($name); + t1.assertUnquoted$1($name); + if (t1._string0$_text.toLowerCase() !== "hue") + throw A.wrapException(A.SassScriptException$0(string$.Expectu + value.toString$0(0) + ", was " + list[2].toString$0(0) + ".", $name)); + else if (list.length > 3) + throw A.wrapException(A.SassScriptException$0('Expected nothing after "hue" in ' + value.toString$0(0) + ".", $name)); + else if (!space.get$isPolarInternal()) + throw A.wrapException(A.SassScriptException$0('Hue interpolation method "' + hueMethod.toString$0(0) + string$.x20hue__ + space.toString$0(0) + ".", $name)); + } + return A.InterpolationMethod$0(space, hueMethod); + }, + HueInterpolationMethod_HueInterpolationMethod$_fromValue0(value, $name) { + var _0_0, + t1 = value.assertString$1($name); + t1.assertUnquoted$0(); + _0_0 = t1._string0$_text.toLowerCase(); + $label0$0: { + if ("shorter" === _0_0) { + t1 = B.HueInterpolationMethod_00; + break $label0$0; + } + if ("longer" === _0_0) { + t1 = B.HueInterpolationMethod_10; + break $label0$0; + } + if ("increasing" === _0_0) { + t1 = B.HueInterpolationMethod_20; + break $label0$0; + } + if ("decreasing" === _0_0) { + t1 = B.HueInterpolationMethod_30; + break $label0$0; + } + t1 = A.throwExpression(A.SassScriptException$0("Unknown hue interpolation method " + value.toString$0(0) + ".", $name)); + } + return t1; + }, + InterpolationMethod0: function InterpolationMethod0(t0, t1) { + this.space = t0; + this.hue = t1; + }, + HueInterpolationMethod0: function HueInterpolationMethod0(t0) { + this._name = t0; + }, + _realCasePath0(path) { + var prefix, _null = null, + t1 = A.isNodeJs() ? self.process : _null; + if (!J.$eq$(t1 == null ? _null : J.get$platform$x(t1), "win32")) { + t1 = A.isNodeJs() ? self.process : _null; + t1 = J.$eq$(t1 == null ? _null : J.get$platform$x(t1), "darwin"); + } else + t1 = true; + if (!t1) + return path; + t1 = A.isNodeJs() ? self.process : _null; + if (J.$eq$(t1 == null ? _null : J.get$platform$x(t1), "win32")) { + prefix = B.JSString_methods.substring$2(path, 0, $.$get$context().style.rootLength$1(path)); + t1 = prefix.length; + if (t1 !== 0 && A.CharacterExtension_get_isAlphabetic0(prefix.charCodeAt(0))) + path = prefix.toUpperCase() + B.JSString_methods.substring$1(path, t1); + } + return new A._realCasePath_helper0().call$1(path); + }, + _realCasePath_helper0: function _realCasePath_helper0() { + }, + _realCasePath_helper_closure0: function _realCasePath_helper_closure0(t0, t1, t2, t3) { + var _ = this; + _.path = t0; + _.realPath = t1; + _.helper = t2; + _.dirname = t3; + }, + _realCasePath_helper__closure0: function _realCasePath_helper__closure0(t0) { + this.basename = t0; + }, + IsCalculationSafeVisitor0: function IsCalculationSafeVisitor0() { + }, + IsCalculationSafeVisitor_visitListExpression_closure0: function IsCalculationSafeVisitor_visitListExpression_closure0(t0) { + this.$this = t0; + }, + printError0(message) { + var t1 = A.isNodeJs() ? self.process : null; + if (t1 != null) { + t1 = J.get$stderr$x(t1); + J.write$1$x(t1, A.S(message) + "\n"); + } else { + t1 = self.console; + J.error$1$x(t1, message); + } + }, + readFile0(path) { + var contents, sourceFile, t1, i; + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$("readFile() is only supported on Node.js")); + contents = A._asString(A._readFile0(path, "utf8")); + if (!B.JSString_methods.contains$1(contents, "\ufffd")) + return contents; + sourceFile = A.SourceFile$fromString(contents, $.$get$context().toUri$1(path)); + for (t1 = contents.length, i = 0; i < t1; ++i) { + if (contents.charCodeAt(i) !== 65533) + continue; + throw A.wrapException(A.SassException$0("Invalid UTF-8.", A.FileLocation$_(sourceFile, i).pointSpan$0(), null)); + } + return contents; + }, + _readFile0(path, encoding) { + return A._systemErrorToFileSystemException0(new A._readFile_closure0(path, encoding)); + }, + fileExists0(path) { + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$(string$.fileEx)); + return A._systemErrorToFileSystemException0(new A.fileExists_closure0(path)); + }, + dirExists0(path) { + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$("dirExists() is only supported on Node.js")); + return A._systemErrorToFileSystemException0(new A.dirExists_closure0(path)); + }, + linkExists0(path) { + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$(string$.linkEx)); + return A._systemErrorToFileSystemException0(new A.linkExists_closure0(path)); + }, + listDir0(path) { + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$("listDir() is only supported on Node.js")); + return A._systemErrorToFileSystemException0(new A.listDir_closure0(false, path)); + }, + realpath0(path) { + if (!A.isNodeJs()) + throw A.wrapException(A.UnsupportedError$("listDir() is only supported on Node.js")); + return A._systemErrorToFileSystemException0(new A.realpath_closure0(path)); + }, + getEnvironmentVariable0($name) { + var t1 = A.isNodeJs() ? self.process : null, + env = t1 == null ? null : J.get$env$x(t1); + if (env == null) + t1 = null; + else + t1 = A._asStringQ(env[$name]); + return t1; + }, + _systemErrorToFileSystemException0(callback) { + var error, t1, exception, t2; + try { + t1 = callback.call$0(); + return t1; + } catch (exception) { + error = A.unwrapException(exception); + if (!type$.JsSystemError._is(error)) + throw exception; + t1 = error; + t2 = J.getInterceptor$x(t1); + throw A.wrapException(new A.FileSystemException0(J.substring$2$s(t2.get$message(t1), (A.S(t2.get$code(t1)) + ": ").length, J.get$length$asx(t2.get$message(t1)) - (", " + A.S(t2.get$syscall(t1)) + " '" + A.S(t2.get$path(t1)) + "'").length), J.get$path$x(error))); + } + }, + hasTerminal0() { + var t1 = A.isNodeJs() ? self.process : null; + return J.$eq$(t1 == null ? null : J.get$isTTY$x(J.get$stdout$x(t1)), true); + }, + FileSystemException0: function FileSystemException0(t0, t1) { + this.message = t0; + this.path = t1; + }, + _readFile_closure0: function _readFile_closure0(t0, t1) { + this.path = t0; + this.encoding = t1; + }, + fileExists_closure0: function fileExists_closure0(t0) { + this.path = t0; + }, + dirExists_closure0: function dirExists_closure0(t0) { + this.path = t0; + }, + linkExists_closure0: function linkExists_closure0(t0) { + this.path = t0; + }, + listDir_closure0: function listDir_closure0(t0, t1) { + this.recursive = t0; + this.path = t1; + }, + listDir__closure1: function listDir__closure1(t0) { + this.path = t0; + }, + listDir__closure2: function listDir__closure2() { + }, + listDir_closure_list0: function listDir_closure_list0() { + }, + listDir__list_closure0: function listDir__list_closure0(t0, t1) { + this.parent = t0; + this.list = t1; + }, + realpath_closure0: function realpath_closure0(t0) { + this.path = t0; + }, + main() { + J.set$compile$x(self.exports, A.allowInteropNamed("sass.compile", A.compile__compile$closure())); + J.set$compileString$x(self.exports, A.allowInteropNamed("sass.compileString", A.compile__compileString$closure())); + J.set$compileAsync$x(self.exports, A.allowInteropNamed("sass.compileAsync", A.compile__compileAsync$closure())); + J.set$compileStringAsync$x(self.exports, A.allowInteropNamed("sass.compileStringAsync", A.compile__compileStringAsync$closure())); + J.set$initCompiler$x(self.exports, A.allowInteropNamed("sass.initCompiler", A.compiler__initCompiler$closure())); + J.set$initAsyncCompiler$x(self.exports, A.allowInteropNamed("sass.initAsyncCompiler", A.compiler__initAsyncCompiler$closure())); + J.set$Compiler$x(self.exports, $.$get$compilerClass()); + J.set$AsyncCompiler$x(self.exports, $.$get$asyncCompilerClass()); + J.set$Value$x(self.exports, $.$get$valueClass()); + J.set$SassBoolean$x(self.exports, $.$get$booleanClass()); + J.set$SassArgumentList$x(self.exports, $.$get$argumentListClass()); + J.set$SassCalculation$x(self.exports, $.$get$calculationClass()); + J.set$CalculationOperation$x(self.exports, $.$get$calculationOperationClass()); + J.set$CalculationInterpolation$x(self.exports, $.$get$calculationInterpolationClass()); + J.set$SassColor$x(self.exports, $.$get$colorClass()); + J.set$SassFunction$x(self.exports, $.$get$functionClass()); + J.set$SassMixin$x(self.exports, $.$get$mixinClass()); + J.set$SassList$x(self.exports, $.$get$listClass()); + J.set$SassMap$x(self.exports, $.$get$mapClass()); + J.set$SassNumber$x(self.exports, $.$get$numberClass()); + J.set$SassString$x(self.exports, $.$get$stringClass()); + J.set$sassNull$x(self.exports, B.C__SassNull0); + J.set$sassTrue$x(self.exports, B.SassBoolean_true0); + J.set$sassFalse$x(self.exports, B.SassBoolean_false0); + J.set$Exception$x(self.exports, $.$get$exceptionClass()); + J.set$Logger$x(self.exports, {silent: {warn: A.allowInteropNamed("sass.Logger.silent.warn", new A.main_closure()), debug: A.allowInteropNamed("sass.Logger.silent.debug", new A.main_closure0())}}); + J.set$NodePackageImporter$x(self.exports, $.$get$nodePackageImporterClass()); + J.set$deprecations$x(self.exports, A.jsify($.$get$deprecations())); + J.set$Version$x(self.exports, $.$get$versionClass()); + J.set$loadParserExports_$x(self.exports, A.allowInterop(A.parser0__loadParserExports$closure())); + J.set$info$x(self.exports, "dart-sass\t1.86.3\t(Sass Compiler)\t[Dart]\ndart2js\t3.7.2\t(Dart Compiler)\t[Dart]"); + A.updateCanonicalizeContextPrototype(); + A.updateSourceSpanPrototype(); + J.set$render$x(self.exports, A.allowInteropNamed("sass.render", A.legacy__render$closure())); + J.set$renderSync$x(self.exports, A.allowInteropNamed("sass.renderSync", A.legacy__renderSync$closure())); + J.set$types$x(self.exports, {Boolean: $.$get$legacyBooleanClass(), Color: $.$get$legacyColorClass(), List: $.$get$legacyListClass(), Map: $.$get$legacyMapClass(), Null: $.$get$legacyNullClass(), Number: $.$get$legacyNumberClass(), String: $.$get$legacyStringClass(), Error: self.Error}); + J.set$NULL$x(self.exports, B.C__SassNull0); + J.set$TRUE$x(self.exports, B.SassBoolean_true0); + J.set$FALSE$x(self.exports, B.SassBoolean_false0); + }, + main_closure: function main_closure() { + }, + main_closure0: function main_closure0() { + }, + JSToDartLogger: function JSToDartLogger(t0, t1, t2) { + this._node = t0; + this._fallback = t1; + this._ascii = t2; + }, + JSToDartLogger_internalWarn_closure: function JSToDartLogger_internalWarn_closure(t0, t1, t2, t3, t4) { + var _ = this; + _.$this = t0; + _.message = t1; + _.span = t2; + _.trace = t3; + _.deprecation = t4; + }, + JSToDartLogger_debug_closure: function JSToDartLogger_debug_closure(t0, t1, t2) { + this.$this = t0; + this.message = t1; + this.span = t2; + }, + ModifiableCssKeyframeBlock$0(selector, span) { + var t1 = A._setArrayType([], type$.JSArray_ModifiableCssNode_2); + return new A.ModifiableCssKeyframeBlock0(selector, span, new A.UnmodifiableListView(t1, type$.UnmodifiableListView_ModifiableCssNode_2), t1); + }, + ModifiableCssKeyframeBlock0: function ModifiableCssKeyframeBlock0(t0, t1, t2, t3) { + var _ = this; + _.selector = t0; + _.span = t1; + _.children = t2; + _._node$_children = t3; + _._node$_indexInParent = _._node$_parent = null; + _.isGroupEnd = false; + }, + KeyframeSelectorParser0: function KeyframeSelectorParser0(t0, t1) { + this.scanner = t0; + this._parser1$_interpolationMap = t1; + }, + KeyframeSelectorParser_parse_closure0: function KeyframeSelectorParser_parse_closure0(t0) { + this.$this = t0; + }, + LabColorSpace0: function LabColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + LazyFileSpan0: function LazyFileSpan0(t0) { + this._lazy_file_span0$_builder = t0; + this._lazy_file_span0$_span = null; + }, + LchColorSpace0: function LchColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + render(options, callback) { + var _0_0; + if (!A.isNodeJs()) + A.jsThrow(new self.Error("The render() method is only available in Node.js.")); + _0_0 = J.get$fiber$x(options); + if (_0_0 != null) + J.run$0$x(_0_0.call$1(A.allowInterop(new A.render_closure(callback, options)))); + else + A._renderAsync(options).then$1$2$onError(0, new A.render_closure0(callback), new A.render_closure1(callback), type$.Null); + }, + _renderAsync(options) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.RenderResult), + $async$returnValue, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, result, start, t1, file, t2, t3, t4, logger, _0_0; + var $async$_renderAsync = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + start = new A.DateTime(Date.now(), 0, false); + t1 = J.getInterceptor$x(options); + file = A.NullableExtension_andThen0(t1.get$file(options), A.path__absolute$closure()); + t2 = t1.get$logger(options); + t3 = A.hasTerminal0(); + t4 = $._glyphs; + logger = new A.JSToDartLogger(t2, new A.StderrLogger0(t3), t4 === B.C_AsciiGlyphSet); + _0_0 = t1.get$data(options); + $async$goto = _0_0 != null ? 3 : 5; + break; + case 3: + // then + t2 = A._parseImporter(options, start); + t3 = A._parsePackageImportersAsync(options, start); + t4 = A._parseFunctions(options, start, true); + t5 = t1.get$indentedSyntax(options); + t5 = !J.$eq$(t5, false) && t5 != null ? B.Syntax_Sass_sass0 : null; + t6 = A._parseOutputStyle(t1.get$outputStyle(options)); + t7 = J.$eq$(t1.get$indentType(options), "tab"); + t8 = A._parseIndentWidth(t1.get$indentWidth(options)); + t9 = A._parseLineFeed(t1.get$linefeed(options)); + t10 = file == null ? "stdin" : $.$get$context().toUri$1(file).toString$0(0); + t11 = t1.get$quietDeps(options); + if (t11 == null) + t11 = false; + t12 = A.parseDeprecations(logger, t1.get$fatalDeprecations(options), true); + t13 = A.parseDeprecations(logger, t1.get$futureDeprecations(options), false); + t14 = A.parseDeprecations(logger, t1.get$silenceDeprecations(options), false); + t15 = t1.get$verbose(options); + if (t15 == null) + t15 = false; + t1 = t1.get$charset(options); + if (t1 == null) + t1 = true; + $async$goto = 6; + return A._asyncAwait(A.compileStringAsync0(_0_0, t1, t12, t4, t13, t3, null, t8, t9, logger, t2, t11, t14, A._enableSourceMaps(options), t6, t5, t10, !t7, t15), $async$_renderAsync); + case 6: + // returning from await. + result = $async$result; + // goto join + $async$goto = 4; + break; + case 5: + // else + $async$goto = file != null ? 7 : 9; + break; + case 7: + // then + t2 = A._parseImporter(options, start); + t3 = A._parsePackageImportersAsync(options, start); + t4 = A._parseFunctions(options, start, true); + t5 = t1.get$indentedSyntax(options); + t5 = !J.$eq$(t5, false) && t5 != null ? B.Syntax_Sass_sass0 : null; + t6 = A._parseOutputStyle(t1.get$outputStyle(options)); + t7 = J.$eq$(t1.get$indentType(options), "tab"); + t8 = A._parseIndentWidth(t1.get$indentWidth(options)); + t9 = A._parseLineFeed(t1.get$linefeed(options)); + t10 = t1.get$quietDeps(options); + if (t10 == null) + t10 = false; + t11 = A.parseDeprecations(logger, t1.get$fatalDeprecations(options), true); + t12 = A.parseDeprecations(logger, t1.get$futureDeprecations(options), false); + t13 = A.parseDeprecations(logger, t1.get$silenceDeprecations(options), false); + t14 = t1.get$verbose(options); + if (t14 == null) + t14 = false; + t1 = t1.get$charset(options); + if (t1 == null) + t1 = true; + $async$goto = 10; + return A._asyncAwait(A.compileAsync0(file, t1, t11, t4, t12, t3, t8, t9, logger, t2, t10, t13, A._enableSourceMaps(options), t6, t5, !t7, t14), $async$_renderAsync); + case 10: + // returning from await. + result = $async$result; + // goto join + $async$goto = 8; + break; + case 9: + // else + throw A.wrapException(A.ArgumentError$(string$.Either, null)); + case 8: + // join + case 4: + // join + $async$returnValue = A._newRenderResult(options, result, start); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_renderAsync, $async$completer); + }, + renderSync(options) { + var start, result, file, logger, _0_0, data, error, stackTrace, error0, stackTrace0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, exception, _null = null; + if (!A.isNodeJs()) + A.jsThrow(new self.Error("The renderSync() method is only available in Node.js.")); + try { + start = new A.DateTime(Date.now(), 0, false); + result = null; + t1 = J.getInterceptor$x(options); + file = A.NullableExtension_andThen0(t1.get$file(options), A.path__absolute$closure()); + t2 = t1.get$logger(options); + t3 = A.hasTerminal0(); + t4 = $._glyphs; + logger = new A.JSToDartLogger(t2, new A.StderrLogger0(t3), t4 === B.C_AsciiGlyphSet); + _0_0 = t1.get$data(options); + data = null; + if (_0_0 != null) { + data = _0_0; + t2 = data; + t3 = A._parseImporter(options, start); + t4 = A._parsePackageImporters(options, start); + t5 = A._parseFunctions(options, start, false); + t6 = t1.get$indentedSyntax(options); + t6 = !J.$eq$(t6, false) && t6 != null ? B.Syntax_Sass_sass0 : _null; + t7 = A._parseOutputStyle(t1.get$outputStyle(options)); + t8 = J.$eq$(t1.get$indentType(options), "tab"); + t9 = A._parseIndentWidth(t1.get$indentWidth(options)); + t10 = A._parseLineFeed(t1.get$linefeed(options)); + t11 = file == null ? "stdin" : $.$get$context().toUri$1(file).toString$0(0); + t12 = t1.get$quietDeps(options); + if (t12 == null) + t12 = false; + t13 = A.parseDeprecations(logger, t1.get$fatalDeprecations(options), true); + t14 = A.parseDeprecations(logger, t1.get$futureDeprecations(options), false); + t15 = A.parseDeprecations(logger, t1.get$silenceDeprecations(options), false); + t16 = t1.get$verbose(options); + if (t16 == null) + t16 = false; + t1 = t1.get$charset(options); + if (t1 == null) + t1 = true; + result = A.compileString(t2, t1, t13, new A.CastList(t5, A._arrayInstanceType(t5)._eval$1("CastList<1,Callable>")), t14, t4, _null, t9, t10, logger, t3, t12, t15, A._enableSourceMaps(options), t7, t6, t11, !t8, t16); + } else if (file != null) { + t2 = A._parseImporter(options, start); + t3 = A._parsePackageImporters(options, start); + t4 = A._parseFunctions(options, start, false); + t5 = t1.get$indentedSyntax(options); + t5 = !J.$eq$(t5, false) && t5 != null ? B.Syntax_Sass_sass0 : _null; + t6 = A._parseOutputStyle(t1.get$outputStyle(options)); + t7 = J.$eq$(t1.get$indentType(options), "tab"); + t8 = A._parseIndentWidth(t1.get$indentWidth(options)); + t9 = A._parseLineFeed(t1.get$linefeed(options)); + t10 = t1.get$quietDeps(options); + if (t10 == null) + t10 = false; + t11 = A.parseDeprecations(logger, t1.get$fatalDeprecations(options), true); + t12 = A.parseDeprecations(logger, t1.get$futureDeprecations(options), false); + t13 = A.parseDeprecations(logger, t1.get$silenceDeprecations(options), false); + t14 = t1.get$verbose(options); + if (t14 == null) + t14 = false; + t1 = t1.get$charset(options); + if (t1 == null) + t1 = true; + result = A.compile(file, t1, t11, new A.CastList(t4, A._arrayInstanceType(t4)._eval$1("CastList<1,Callable>")), t12, t3, t8, t9, logger, t2, t10, t13, A._enableSourceMaps(options), t6, t5, !t7, t14); + } else { + t1 = A.ArgumentError$(string$.Either, _null); + throw A.wrapException(t1); + } + t1 = A._newRenderResult(options, result, start); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException0) { + error = t1; + stackTrace = A.getTraceFromException(exception); + A.jsThrow(A._wrapException(error, stackTrace)); + } else { + error0 = t1; + stackTrace0 = A.getTraceFromException(exception); + t1 = J.toString$0$(error0); + t2 = A.getTrace0(error0); + A.jsThrow(A._newRenderError(t1, t2 == null ? stackTrace0 : t2, _null, _null, _null, 3)); + } + } + }, + _wrapException(exception, stackTrace) { + var t2, t3, t4, t5, + t1 = A.SourceSpanException.prototype.get$span.call(exception, 0), + _0_0 = t1.get$sourceUrl(t1); + $label0$0: { + if (_0_0 == null) { + t1 = "stdin"; + break $label0$0; + } + if ("file" === _0_0.get$scheme()) { + t1 = $.$get$context().style.pathFromUri$1(A._parseUri(_0_0)); + break $label0$0; + } + t1 = _0_0.toString$0(0); + break $label0$0; + } + t2 = B.JSString_methods.replaceFirst$2(exception.toString$0(0), "Error: ", ""); + t3 = A.getTrace0(exception); + if (t3 == null) + t3 = stackTrace; + t4 = A.SourceSpanException.prototype.get$span.call(exception, 0); + t4 = t4.get$start(t4); + t4 = t4.file.getLine$1(t4.offset); + t5 = A.SourceSpanException.prototype.get$span.call(exception, 0); + t5 = t5.get$start(t5); + return A._newRenderError(t2, t3, t5.file.getColumn$1(t5.offset) + 1, t1, t4 + 1, 1); + }, + _parseFunctions(options, start, asynch) { + var result, + functions = J.get$functions$x(options); + if (functions == null) + return B.List_empty26; + result = A._setArrayType([], type$.JSArray_AsyncCallable_2); + A.jsForEach(functions, new A._parseFunctions_closure(options, start, result, asynch)); + return result; + }, + _parseImporter(options, start) { + var t2, t3, contextOptions, _1_0, t4, importers, + t1 = J.getInterceptor$x(options), + _0_0 = t1.get$importer(options); + $label0$0: { + if (_0_0 == null) { + t2 = A._setArrayType([], type$.JSArray_JSFunction); + break $label0$0; + } + if (type$.List_nullable_Object._is(_0_0)) { + t2 = J.cast$1$0$ax(_0_0, type$.JSFunction); + break $label0$0; + } + t2 = A._setArrayType([type$.JSFunction._as(_0_0)], type$.JSArray_JSFunction); + break $label0$0; + } + t3 = J.getInterceptor$asx(t2); + contextOptions = t3.get$isNotEmpty(t2) ? A._contextOptions(options, start) : new A.Object(); + _1_0 = t1.get$fiber(options); + t4 = {}; + t4.fiber = null; + if (_1_0 != null) { + t4.fiber = _1_0; + t2 = t3.map$1$1(t2, new A._parseImporter_closure(t4), type$.JSFunction); + importers = A.List_List$of(t2, true, t2.$ti._eval$1("ListIterable.E")); + } else + importers = t2; + t1 = t1.get$includePaths(options); + if (t1 == null) + t1 = []; + t2 = type$.String; + return new A.NodeImporter(contextOptions, A.List_List$unmodifiable(A.NodeImporter__addSassPath(A.List_List$from(t1, true, t2)), t2), A.List_List$unmodifiable(J.cast$1$0$ax(importers, type$.dynamic), type$.JSFunction)); + }, + _parsePackageImportersAsync(options, start) { + var t2, t3, t4, + t1 = J.getInterceptor$x(options); + if (t1.get$pkgImporter(options) instanceof A.NodePackageImporter0) { + t1 = t1.get$pkgImporter(options); + t1.toString; + t2 = type$.nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_2; + t3 = type$.Record_3_AsyncImporter_and_Uri_and_bool_forImport_2; + t4 = type$.Uri; + return new A.AsyncImportCache0(A.List_List$unmodifiable(A._setArrayType([t1], type$.JSArray_AsyncImporter), type$.AsyncImporter), A.LinkedHashMap_LinkedHashMap$_empty(type$.Record_2_Uri_and_bool_forImport, t2), A.LinkedHashMap_LinkedHashMap$_empty(t3, t2), A.LinkedHashMap_LinkedHashMap$_empty(t3, t4), A.LinkedHashMap_LinkedHashMap$_empty(t4, type$.nullable_Stylesheet_2), A.LinkedHashMap_LinkedHashMap$_empty(t4, type$.ImporterResult_2), A.LinkedHashMap_LinkedHashMap$_empty(t4, type$.DateTime)); + } + return null; + }, + _parsePackageImporters(options, start) { + var t2, t3, t4, + t1 = J.getInterceptor$x(options); + if (t1.get$pkgImporter(options) instanceof A.NodePackageImporter0) { + t1 = t1.get$pkgImporter(options); + t1.toString; + t2 = type$.nullable_Record_3_Importer_and_Uri_and_Uri_originalUrl_2; + t3 = type$.Record_3_Importer_and_Uri_and_bool_forImport_2; + t4 = type$.Uri; + return new A.ImportCache0(A.List_List$unmodifiable(A._setArrayType([t1], type$.JSArray_Importer_2), type$.Importer), A.LinkedHashMap_LinkedHashMap$_empty(type$.Record_2_Uri_and_bool_forImport, t2), A.LinkedHashMap_LinkedHashMap$_empty(t3, t2), A.LinkedHashMap_LinkedHashMap$_empty(t3, t4), A.LinkedHashMap_LinkedHashMap$_empty(t4, type$.nullable_Stylesheet_2), A.LinkedHashMap_LinkedHashMap$_empty(t4, type$.ImporterResult_2), A.LinkedHashMap_LinkedHashMap$_empty(t4, type$.DateTime)); + } + return null; + }, + _contextOptions(options, start) { + var includePaths, t3, t4, t5, t6, t7, + t1 = J.getInterceptor$x(options), + t2 = t1.get$includePaths(options); + if (t2 == null) + t2 = []; + includePaths = A.List_List$from(t2, true, type$.String); + t2 = t1.get$file(options); + t3 = t1.get$data(options); + t4 = A._setArrayType([A.current()], type$.JSArray_String); + B.JSArray_methods.addAll$1(t4, includePaths); + t5 = A.isNodeJs() ? self.process : null; + t4 = B.JSArray_methods.join$1(t4, J.$eq$(t5 == null ? null : J.get$platform$x(t5), "win32") ? ";" : ":"); + t5 = J.$eq$(t1.get$indentType(options), "tab") ? 1 : 0; + t6 = A._parseIndentWidth(t1.get$indentWidth(options)); + if (t6 == null) + t6 = 2; + t7 = A._parseLineFeed(t1.get$linefeed(options)); + t1 = t1.get$file(options); + if (t1 == null) + t1 = "data"; + return {file: t2, data: t3, includePaths: t4, precision: 10, style: 1, indentType: t5, indentWidth: t6, linefeed: t7.text, result: {stats: {start: start._value, entry: t1}}}; + }, + _parseOutputStyle(style) { + var t1; + $label0$0: { + if (style == null || "expanded" === style) { + t1 = B.OutputStyle_00; + break $label0$0; + } + if ("compressed" === style) { + t1 = B.OutputStyle_10; + break $label0$0; + } + t1 = A.jsThrow(new self.Error('Unknown output style "' + A.S(style) + '".')); + } + return t1; + }, + _parseIndentWidth(width) { + var t1; + $label0$0: { + if (width == null) { + t1 = null; + break $label0$0; + } + if (A._isInt(width)) { + t1 = width; + break $label0$0; + } + t1 = A.int_parse(J.toString$0$(width), null); + break $label0$0; + } + return t1; + }, + _parseLineFeed(str) { + var t1; + $label0$0: { + if ("cr" === str) { + t1 = B.LineFeed_ybQ; + break $label0$0; + } + if ("crlf" === str) { + t1 = B.LineFeed_Pcs; + break $label0$0; + } + if ("lfcr" === str) { + t1 = B.LineFeed_G7N; + break $label0$0; + } + t1 = B.LineFeed_9HY; + break $label0$0; + } + return t1; + }, + _newRenderResult(options, result, start) { + var t2, sourceMapOption, sourceMapPath, t3, sourceMapDir, outFile, _0_0, t4, sourceMapDirUrl, i, source, t5, buffer, indices, url, t6, t7, t8, _null = null, + end = new A.DateTime(Date.now(), 0, false), + t1 = result._compile_result$_serialize, + css = t1._0, + sourceMapBytes = self.undefined; + if (A._enableSourceMaps(options)) { + t2 = J.getInterceptor$x(options); + sourceMapOption = t2.get$sourceMap(options); + if (typeof sourceMapOption == "string") + sourceMapPath = sourceMapOption; + else { + t3 = t2.get$outFile(options); + t3.toString; + sourceMapPath = J.$add$ansx(t3, ".map"); + } + t3 = $.$get$context(); + sourceMapDir = t3.dirname$1(sourceMapPath); + t1 = t1._1; + t1.toString; + t1.sourceRoot = t2.get$sourceMapRoot(options); + outFile = t2.get$outFile(options); + if (outFile == null) { + _0_0 = t2.get$file(options); + $label0$0: { + if (_0_0 != null) { + t4 = t3.toUri$1(t3.withoutExtension$1(_0_0) + ".css").toString$0(0); + break $label0$0; + } + t4 = t1.targetUrl = "stdin.css"; + break $label0$0; + } + t1.targetUrl = t4; + } else + t1.targetUrl = t3.toUri$1(t3.relative$2$from(outFile, sourceMapDir)).toString$0(0); + sourceMapDirUrl = t3.toUri$1(sourceMapDir).toString$0(0); + for (t3 = t1.urls, i = 0; i < t3.length; ++i) { + source = t3[i]; + if (source === "stdin") + continue; + t4 = $.$get$url(); + t5 = t4.style; + if (t5.rootLength$1(source) <= 0 || t5.isRootRelative$1(source)) + continue; + t3[i] = t4.relative$2$from(source, sourceMapDirUrl); + } + t3 = t2.get$sourceMapContents(options); + sourceMapBytes = self.Buffer.from(B.C_JsonCodec.encode$2$toEncodable(t1.toJson$1$includeSourceContents(!J.$eq$(t3, false) && t3 != null), _null), "utf8"); + t1 = t2.get$omitSourceMapUrl(options); + if (!(!J.$eq$(t1, false) && t1 != null)) { + t1 = t2.get$sourceMapEmbed(options); + if (!J.$eq$(t1, false) && t1 != null) { + buffer = new A.StringBuffer(""); + indices = A._setArrayType([-1], type$.JSArray_int); + A.UriData__writeUri("application/json", _null, _null, buffer, indices); + indices.push(buffer._contents.length); + t1 = buffer._contents += ";base64,"; + indices.push(t1.length - 1); + t1 = B.C_Base64Encoder.startChunkedConversion$1(new A._StringSinkConversionSink(buffer)); + t2 = sourceMapBytes.length; + A.RangeError_checkValidRange(0, t2, t2); + t1._convert$_add$4(sourceMapBytes, 0, t2, true); + t1 = buffer._contents; + url = new A.UriData(t1.charCodeAt(0) == 0 ? t1 : t1, indices, _null).get$uri(); + } else { + if (outFile == null) + t1 = sourceMapPath; + else { + t1 = $.$get$context(); + t1 = t1.relative$2$from(sourceMapPath, t1.dirname$1(outFile)); + } + url = $.$get$context().toUri$1(t1); + } + t1 = url.toString$0(0); + css += "\n\n/*# sourceMappingURL=" + A.stringReplaceAllUnchecked(t1, "*/", "%2A/") + " */"; + } + } + t1 = self.Buffer.from(css, "utf8"); + t2 = J.get$file$x(options); + if (t2 == null) + t2 = "data"; + t3 = start._value; + t4 = end._value; + t5 = B.JSInt_methods._tdivFast$1(A.Duration$(end._microsecond - start._microsecond, t4 - t3)._duration, 1000); + t6 = A._setArrayType([], type$.JSArray_String); + for (t7 = result._evaluate._0, t7 = t7.get$iterator(t7); t7.moveNext$0();) { + t8 = t7.get$current(t7); + t6.push(t8.get$scheme() === "file" ? $.$get$context().style.pathFromUri$1(A._parseUri(t8)) : t8.toString$0(0)); + } + return {css: t1, map: sourceMapBytes, stats: {entry: t2, start: t3, end: t4, duration: t5, includedFiles: t6}}; + }, + _enableSourceMaps(options) { + var t2, + t1 = J.getInterceptor$x(options); + if (typeof t1.get$sourceMap(options) != "string") { + t2 = t1.get$sourceMap(options); + t1 = !J.$eq$(t2, false) && t2 != null && t1.get$outFile(options) != null; + } else + t1 = true; + return t1; + }, + _newRenderError(message, stackTrace, column, file, line, $status) { + var error = new self.Error(message); + error.formatted = "Error: " + message; + if (line != null) + error.line = line; + if (column != null) + error.column = column; + if (file != null) + error.file = file; + error.status = $status; + A.attachJsStack(error, stackTrace); + return error; + }, + render_closure: function render_closure(t0, t1) { + this.callback = t0; + this.options = t1; + }, + render_closure0: function render_closure0(t0) { + this.callback = t0; + }, + render_closure1: function render_closure1(t0) { + this.callback = t0; + }, + _parseFunctions_closure: function _parseFunctions_closure(t0, t1, t2, t3) { + var _ = this; + _.options = t0; + _.start = t1; + _.result = t2; + _.asynch = t3; + }, + _parseFunctions__closure: function _parseFunctions__closure(t0, t1, t2) { + this._box_0 = t0; + this.callback = t1; + this.context = t2; + }, + _parseFunctions___closure2: function _parseFunctions___closure2(t0) { + this.currentFiber = t0; + }, + _parseFunctions____closure: function _parseFunctions____closure(t0, t1) { + this.currentFiber = t0; + this.result = t1; + }, + _parseFunctions___closure3: function _parseFunctions___closure3(t0, t1, t2) { + this.callback = t0; + this.context = t1; + this.jsArguments = t2; + }, + _parseFunctions___closure4: function _parseFunctions___closure4(t0) { + this._box_0 = t0; + }, + _parseFunctions__closure0: function _parseFunctions__closure0(t0, t1) { + this.callback = t0; + this.context = t1; + }, + _parseFunctions___closure1: function _parseFunctions___closure1(t0, t1, t2) { + this.callback = t0; + this.context = t1; + this.$arguments = t2; + }, + _parseFunctions__closure1: function _parseFunctions__closure1(t0, t1) { + this.callback = t0; + this.context = t1; + }, + _parseFunctions___closure: function _parseFunctions___closure(t0) { + this.completer = t0; + }, + _parseFunctions___closure0: function _parseFunctions___closure0(t0, t1, t2) { + this.callback = t0; + this.context = t1; + this.jsArguments = t2; + }, + _parseImporter_closure: function _parseImporter_closure(t0) { + this._box_0 = t0; + }, + _parseImporter__closure: function _parseImporter__closure(t0, t1) { + this._box_0 = t0; + this.importer = t1; + }, + _parseImporter___closure: function _parseImporter___closure(t0) { + this.currentFiber = t0; + }, + _parseImporter____closure: function _parseImporter____closure(t0, t1) { + this.currentFiber = t0; + this.result = t1; + }, + _parseImporter___closure0: function _parseImporter___closure0(t0) { + this._box_0 = t0; + }, + LimitedMapView$blocklist0(_map, blocklist, $K, $V) { + var t2, key, + t1 = A.LinkedHashSet_LinkedHashSet$_empty($K); + for (t2 = J.get$iterator$ax(_map.get$keys(_map)); t2.moveNext$0();) { + key = t2.get$current(t2); + if (!blocklist.contains$1(0, key)) + t1.add$1(0, key); + } + return new A.LimitedMapView0(_map, t1, $K._eval$1("@<0>")._bind$1($V)._eval$1("LimitedMapView0<1,2>")); + }, + LimitedMapView0: function LimitedMapView0(t0, t1, t2) { + this._limited_map_view0$_map = t0; + this._limited_map_view0$_keys = t1; + this.$ti = t2; + }, + ListExpression0: function ListExpression0(t0, t1, t2, t3) { + var _ = this; + _.contents = t0; + _.separator = t1; + _.hasBrackets = t2; + _.span = t3; + }, + ListExpression_toString_closure0: function ListExpression_toString_closure0(t0) { + this.$this = t0; + }, + _function11($name, $arguments, callback) { + return A.BuiltInCallable$function0($name, $arguments, callback, "sass:list"); + }, + _length_closure2: function _length_closure2() { + }, + _nth_closure0: function _nth_closure0() { + }, + _setNth_closure0: function _setNth_closure0() { + }, + _join_closure0: function _join_closure0() { + }, + _append_closure2: function _append_closure2() { + }, + _zip_closure0: function _zip_closure0() { + }, + _zip__closure2: function _zip__closure2() { + }, + _zip__closure3: function _zip__closure3(t0) { + this._box_0 = t0; + }, + _zip__closure4: function _zip__closure4(t0) { + this._box_0 = t0; + }, + _index_closure2: function _index_closure2() { + }, + _separator_closure0: function _separator_closure0() { + }, + _isBracketed_closure0: function _isBracketed_closure0() { + }, + _slash_closure0: function _slash_closure0() { + }, + SelectorList$0(components, span) { + var t1 = A.List_List$unmodifiable(components, type$.ComplexSelector_2); + if (t1.length === 0) + A.throwExpression(A.ArgumentError$("components may not be empty.", null)); + return new A.SelectorList0(t1, span); + }, + SelectorList_SelectorList$parse0(contents, allowParent, interpolationMap, plainCss) { + return new A.SelectorParser0(allowParent, plainCss, A.SpanScanner$(contents, null), interpolationMap).parse$0(0); + }, + SelectorList0: function SelectorList0(t0, t1) { + this.components = t0; + this.span = t1; + }, + SelectorList_asSassList_closure0: function SelectorList_asSassList_closure0() { + }, + SelectorList_nestWithin_closure0: function SelectorList_nestWithin_closure0(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.preserveParentSelectors = t1; + _.implicitParent = t2; + _.parent = t3; + }, + SelectorList_nestWithin__closure1: function SelectorList_nestWithin__closure1(t0) { + this.complex = t0; + }, + SelectorList_nestWithin__closure2: function SelectorList_nestWithin__closure2(t0) { + this.complex = t0; + }, + SelectorList__nestWithinCompound_closure2: function SelectorList__nestWithinCompound_closure2() { + }, + SelectorList__nestWithinCompound_closure3: function SelectorList__nestWithinCompound_closure3(t0) { + this.parent = t0; + }, + SelectorList__nestWithinCompound_closure4: function SelectorList__nestWithinCompound_closure4(t0, t1, t2) { + this.parentSelector = t0; + this.resolvedSimples = t1; + this.component = t2; + }, + SelectorList_withAdditionalCombinators_closure0: function SelectorList_withAdditionalCombinators_closure0(t0) { + this.combinators = t0; + }, + _ParentSelectorVisitor0: function _ParentSelectorVisitor0() { + }, + __ParentSelectorVisitor_Object_SelectorSearchVisitor0: function __ParentSelectorVisitor_Object_SelectorSearchVisitor0() { + }, + listClass_closure: function listClass_closure() { + }, + listClass__closure: function listClass__closure() { + }, + listClass__closure0: function listClass__closure0() { + }, + _ConstructorOptions: function _ConstructorOptions() { + }, + _NodeSassList: function _NodeSassList() { + }, + legacyListClass_closure: function legacyListClass_closure() { + }, + legacyListClass__closure: function legacyListClass__closure() { + }, + legacyListClass_closure0: function legacyListClass_closure0() { + }, + legacyListClass_closure1: function legacyListClass_closure1() { + }, + legacyListClass_closure2: function legacyListClass_closure2() { + }, + legacyListClass_closure3: function legacyListClass_closure3() { + }, + legacyListClass_closure4: function legacyListClass_closure4() { + }, + SassList$0(contents, _separator, brackets) { + var t1 = new A.SassList0(A.List_List$unmodifiable(contents, type$.Value_2), _separator, brackets); + t1.SassList$3$brackets0(contents, _separator, brackets); + return t1; + }, + SassList0: function SassList0(t0, t1, t2) { + this._list1$_contents = t0; + this._list1$_separator = t1; + this._list1$_hasBrackets = t2; + }, + SassList_isBlank_closure0: function SassList_isBlank_closure0() { + }, + ListSeparator0: function ListSeparator0(t0, t1, t2) { + this._list1$_name = t0; + this.separator = t1; + this._name = t2; + }, + LmsColorSpace0: function LmsColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + LocalMindeGamutMap0: function LocalMindeGamutMap0(t0) { + this.name = t0; + }, + JSLogger: function JSLogger() { + }, + WarnOptions: function WarnOptions() { + }, + DebugOptions: function DebugOptions() { + }, + WarnForDeprecation_warnForDeprecation0(_this, deprecation, message, span, trace) { + _this.internalWarn$4$deprecation$span$trace(message, deprecation, span, trace); + }, + LoggerWithDeprecationType0: function LoggerWithDeprecationType0() { + }, + LoudComment0: function LoudComment0(t0) { + this.text = t0; + }, + MapExpression0: function MapExpression0(t0, t1) { + this.pairs = t0; + this.span = t1; + }, + _modify0(map, keys, modify, addNesting) { + var keyIterator = J.get$iterator$ax(keys); + return keyIterator.moveNext$0() ? new A._modify_modifyNestedMap0(keyIterator, modify, addNesting).call$1(map) : modify.call$1(map); + }, + _deepMergeImpl0(map1, map2) { + var t2, t3, result, t4, key, value, _1_1, _1_3, _1_3_isSet, _1_30, resultMap, valueMap, merged, + t1 = map1._map0$_contents; + if (t1.get$isEmpty(t1)) + return map2; + t2 = map2._map0$_contents; + if (t2.get$isEmpty(t2)) + return map1; + t3 = type$.Value_2; + result = A.LinkedHashMap_LinkedHashMap$of(t1, t3, t3); + for (t1 = A.MapExtensions_get_pairs0(t2, t3, t3), t1 = t1.get$iterator(t1), t2 = type$.SassMap_2; t1.moveNext$0();) { + t4 = t1.get$current(t1); + key = t4._0; + value = t4._1; + t4 = result.$index(0, key); + _1_1 = t4 == null ? null : t4.tryMap$0(); + _1_3 = value.tryMap$0(); + _1_3_isSet = _1_1 != null; + _1_30 = null; + t4 = false; + if (_1_3_isSet) { + resultMap = _1_1 == null ? t2._as(_1_1) : _1_1; + t4 = _1_3 != null; + _1_30 = _1_3; + } else + resultMap = null; + if (t4) { + valueMap = _1_3_isSet ? _1_30 : _1_3; + merged = A._deepMergeImpl0(resultMap, valueMap == null ? t2._as(valueMap) : valueMap); + if (merged === resultMap) + continue; + result.$indexSet(0, key, merged); + } else + result.$indexSet(0, key, value); + } + return new A.SassMap0(A.ConstantMap_ConstantMap$from(result, t3, t3)); + }, + _function10($name, $arguments, callback) { + return A.BuiltInCallable$function0($name, $arguments, callback, "sass:map"); + }, + _get_closure0: function _get_closure0() { + }, + _set_closure1: function _set_closure1() { + }, + _set__closure2: function _set__closure2(t0) { + this.$arguments = t0; + }, + _set_closure2: function _set_closure2() { + }, + _set__closure1: function _set__closure1(t0) { + this._box_0 = t0; + }, + _merge_closure1: function _merge_closure1() { + }, + _merge_closure2: function _merge_closure2() { + }, + _merge__closure0: function _merge__closure0(t0) { + this.map2 = t0; + }, + _deepMerge_closure0: function _deepMerge_closure0() { + }, + _deepRemove_closure0: function _deepRemove_closure0() { + }, + _deepRemove__closure0: function _deepRemove__closure0(t0) { + this.keys = t0; + }, + _remove_closure1: function _remove_closure1() { + }, + _remove_closure2: function _remove_closure2() { + }, + _keys_closure0: function _keys_closure0() { + }, + _values_closure0: function _values_closure0() { + }, + _hasKey_closure0: function _hasKey_closure0() { + }, + _modify_modifyNestedMap0: function _modify_modifyNestedMap0(t0, t1, t2) { + this.keyIterator = t0; + this.modify = t1; + this.addNesting = t2; + }, + MapExtensions_get_pairs0(_this, $K, $V) { + var t1 = _this.get$entries(_this); + return t1.map$1$1(t1, new A.MapExtensions_get_pairs_closure0($K, $V), $K._eval$1("@<0>")._bind$1($V)._eval$1("+(1,2)")); + }, + MapExtensions_get_pairs_closure0: function MapExtensions_get_pairs_closure0(t0, t1) { + this.K = t0; + this.V = t1; + }, + mapClass_closure: function mapClass_closure() { + }, + mapClass__closure: function mapClass__closure() { + }, + mapClass__closure0: function mapClass__closure0() { + }, + mapClass__closure1: function mapClass__closure1() { + }, + _NodeSassMap: function _NodeSassMap() { + }, + legacyMapClass_closure: function legacyMapClass_closure() { + }, + legacyMapClass__closure: function legacyMapClass__closure() { + }, + legacyMapClass__closure0: function legacyMapClass__closure0() { + }, + legacyMapClass_closure0: function legacyMapClass_closure0() { + }, + legacyMapClass_closure1: function legacyMapClass_closure1() { + }, + legacyMapClass_closure2: function legacyMapClass_closure2() { + }, + legacyMapClass_closure3: function legacyMapClass_closure3() { + }, + legacyMapClass_closure4: function legacyMapClass_closure4() { + }, + SassMap0: function SassMap0(t0) { + this._map0$_contents = t0; + }, + _singleArgumentMathFunc0($name, mathFunc) { + return A.BuiltInCallable$function0($name, "$number", new A._singleArgumentMathFunc_closure0(mathFunc), "sass:math"); + }, + _numberFunction0($name, transform) { + return A.BuiltInCallable$function0($name, "$number", new A._numberFunction_closure0(transform), "sass:math"); + }, + _function9($name, $arguments, callback) { + return A.BuiltInCallable$function0($name, $arguments, callback, "sass:math"); + }, + global_closure43: function global_closure43() { + }, + module_closure26: function module_closure26() { + }, + _ceil_closure0: function _ceil_closure0() { + }, + _clamp_closure0: function _clamp_closure0() { + }, + _floor_closure0: function _floor_closure0() { + }, + _max_closure0: function _max_closure0() { + }, + _min_closure0: function _min_closure0() { + }, + _round_closure0: function _round_closure0() { + }, + _hypot_closure0: function _hypot_closure0() { + }, + _hypot__closure0: function _hypot__closure0() { + }, + _log_closure0: function _log_closure0() { + }, + _pow_closure0: function _pow_closure0() { + }, + _atan2_closure0: function _atan2_closure0() { + }, + _compatible_closure0: function _compatible_closure0() { + }, + _isUnitless_closure0: function _isUnitless_closure0() { + }, + _unit_closure0: function _unit_closure0() { + }, + _percentage_closure0: function _percentage_closure0() { + }, + _randomFunction_closure0: function _randomFunction_closure0() { + }, + _div_closure0: function _div_closure0() { + }, + _singleArgumentMathFunc_closure0: function _singleArgumentMathFunc_closure0(t0) { + this.mathFunc = t0; + }, + _numberFunction_closure0: function _numberFunction_closure0(t0) { + this.transform = t0; + }, + CssMediaQuery$type0(type, conditions, modifier) { + return new A.CssMediaQuery0(modifier, type, true, conditions == null ? B.List_empty : A.List_List$unmodifiable(conditions, type$.String)); + }, + CssMediaQuery$condition0(conditions, conjunction) { + var t1 = A.List_List$unmodifiable(conditions, type$.String); + if (t1.length > 1 && conjunction == null) + A.throwExpression(A.ArgumentError$(string$.If_con, null)); + return new A.CssMediaQuery0(null, null, conjunction !== false, t1); + }, + CssMediaQuery0: function CssMediaQuery0(t0, t1, t2, t3) { + var _ = this; + _.modifier = t0; + _.type = t1; + _.conjunction = t2; + _.conditions = t3; + }, + _SingletonCssMediaQueryMergeResult0: function _SingletonCssMediaQueryMergeResult0(t0) { + this._name = t0; + }, + MediaQuerySuccessfulMergeResult0: function MediaQuerySuccessfulMergeResult0(t0) { + this.query = t0; + }, + MediaQueryParser0: function MediaQueryParser0(t0, t1) { + this.scanner = t0; + this._parser1$_interpolationMap = t1; + }, + MediaQueryParser_parse_closure0: function MediaQueryParser_parse_closure0(t0) { + this.$this = t0; + }, + ModifiableCssMediaRule$0(queries, span) { + var t1 = A.List_List$unmodifiable(queries, type$.CssMediaQuery_2), + t2 = A._setArrayType([], type$.JSArray_ModifiableCssNode_2); + if (J.get$isEmpty$asx(queries)) + A.throwExpression(A.ArgumentError$value(queries, "queries", "may not be empty.")); + return new A.ModifiableCssMediaRule0(t1, span, new A.UnmodifiableListView(t2, type$.UnmodifiableListView_ModifiableCssNode_2), t2); + }, + ModifiableCssMediaRule0: function ModifiableCssMediaRule0(t0, t1, t2, t3) { + var _ = this; + _.queries = t0; + _.span = t1; + _.children = t2; + _._node$_children = t3; + _._node$_indexInParent = _._node$_parent = null; + _.isGroupEnd = false; + }, + MediaRule$0(query, children, span) { + var t1 = A.List_List$unmodifiable(children, type$.Statement_2), + t2 = B.JSArray_methods.any$1(t1, new A.ParentStatement_closure0()); + return new A.MediaRule0(query, span, t1, t2); + }, + MediaRule0: function MediaRule0(t0, t1, t2, t3) { + var _ = this; + _.query = t0; + _.span = t1; + _.children = t2; + _.hasDeclarations = t3; + }, + MergedExtension_merge0(left, right) { + var t2, t3, t4, + t1 = left.extender.selector; + if (!t1.$eq(0, right.extender.selector) || !left.target.$eq(0, right.target)) + throw A.wrapException(A.ArgumentError$(left.toString$0(0) + " and " + right.toString$0(0) + " aren't the same extension.", null)); + t2 = left.mediaContext; + t3 = t2 == null; + if (!t3) { + t4 = right.mediaContext; + t4 = t4 != null && !B.C_ListEquality.equals$2(0, t2, t4); + } else + t4 = false; + if (t4) + throw A.wrapException(A.SassException$0("From " + left.span.message$1(0, "") + string$.x0aYou_m, right.span, null)); + if (right.isOptional && right.mediaContext == null) + return left; + if (left.isOptional && t3) + return right; + if (t3) + t2 = right.mediaContext; + t1.get$specificity(); + t1 = new A.Extender0(t1, false); + return t1._extension$_extension = new A.MergedExtension0(left, right, t1, left.target, t2, true, left.span); + }, + MergedExtension0: function MergedExtension0(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.left = t0; + _.right = t1; + _.extender = t2; + _.target = t3; + _.mediaContext = t4; + _.isOptional = t5; + _.span = t6; + }, + MergedMapView$0(maps, $K, $V) { + var t1 = $K._eval$1("@<0>")._bind$1($V); + t1 = new A.MergedMapView0(A.LinkedHashMap_LinkedHashMap$_empty($K, t1._eval$1("Map<1,2>")), t1._eval$1("MergedMapView0<1,2>")); + t1.MergedMapView$10(maps, $K, $V); + return t1; + }, + MergedMapView0: function MergedMapView0(t0, t1) { + this._merged_map_view$_mapsByKey = t0; + this.$ti = t1; + }, + _function6($name, $arguments, callback) { + return A.BuiltInCallable$function0($name, $arguments, callback, "sass:meta"); + }, + _shared_closure3: function _shared_closure3() { + }, + _shared_closure4: function _shared_closure4() { + }, + _shared_closure5: function _shared_closure5() { + }, + _shared_closure6: function _shared_closure6() { + }, + moduleFunctions_closure2: function moduleFunctions_closure2() { + }, + moduleFunctions_closure3: function moduleFunctions_closure3() { + }, + moduleFunctions__closure0: function moduleFunctions__closure0() { + }, + moduleFunctions_closure4: function moduleFunctions_closure4() { + }, + mixinClass_closure: function mixinClass_closure() { + }, + mixinClass__closure: function mixinClass__closure() { + }, + mixinClass__closure0: function mixinClass__closure0() { + }, + SassMixin0: function SassMixin0(t0) { + this.callable = t0; + }, + MixinRule$0($name, parameters, children, span, comment) { + var t1 = A.stringReplaceAllUnchecked($name, "_", "-"), + t2 = A.List_List$unmodifiable(children, type$.Statement_2), + t3 = B.JSArray_methods.any$1(t2, new A.ParentStatement_closure0()); + return new A.MixinRule0(t1, $name, parameters, span, t2, t3); + }, + MixinRule0: function MixinRule0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._mixin_rule$__MixinRule_hasContent_FI = $; + _.name = t0; + _.originalName = t1; + _.parameters = t2; + _.span = t3; + _.children = t4; + _.hasDeclarations = t5; + }, + _HasContentVisitor0: function _HasContentVisitor0() { + }, + __HasContentVisitor_Object_StatementSearchVisitor0: function __HasContentVisitor_Object_StatementSearchVisitor0() { + }, + ExtendMode0: function ExtendMode0(t0, t1) { + this.name = t0; + this._name = t1; + }, + JSModule0: function JSModule0() { + }, + JSModuleRequire0: function JSModuleRequire0() { + }, + MultiSpan0: function MultiSpan0(t0, t1, t2) { + this._multi_span0$_primary = t0; + this.primaryLabel = t1; + this.secondarySpans = t2; + }, + SupportsNegation0: function SupportsNegation0(t0, t1) { + this.condition = t0; + this.span = t1; + }, + NoOpImporter0: function NoOpImporter0() { + }, + NoSourceMapBuffer0: function NoSourceMapBuffer0(t0) { + this._no_source_map_buffer0$_buffer = t0; + }, + _FakeAstNode0: function _FakeAstNode0(t0) { + this._node0$_callback = t0; + }, + CssNode0: function CssNode0() { + }, + CssParentNode0: function CssParentNode0() { + }, + _IsInvisibleVisitor1: function _IsInvisibleVisitor1(t0, t1) { + this.includeBogus = t0; + this.includeComments = t1; + }, + __IsInvisibleVisitor_Object_EveryCssVisitor0: function __IsInvisibleVisitor_Object_EveryCssVisitor0() { + }, + ModifiableCssNode0: function ModifiableCssNode0() { + }, + ModifiableCssNode_hasFollowingSibling_closure0: function ModifiableCssNode_hasFollowingSibling_closure0() { + }, + ModifiableCssParentNode0: function ModifiableCssParentNode0() { + }, + NodePackageImporter0: function NodePackageImporter0() { + this._node_package$__NodePackageImporter__entryPointDirectory_F = $; + }, + NodePackageImporter__nodePackageExportsResolve_closure3: function NodePackageImporter__nodePackageExportsResolve_closure3() { + }, + NodePackageImporter__nodePackageExportsResolve_closure4: function NodePackageImporter__nodePackageExportsResolve_closure4() { + }, + NodePackageImporter__nodePackageExportsResolve_closure5: function NodePackageImporter__nodePackageExportsResolve_closure5() { + }, + NodePackageImporter__nodePackageExportsResolve_closure6: function NodePackageImporter__nodePackageExportsResolve_closure6(t0, t1, t2) { + this.$this = t0; + this.exports = t1; + this.packageRoot = t2; + }, + NodePackageImporter__nodePackageExportsResolve__closure1: function NodePackageImporter__nodePackageExportsResolve__closure1(t0, t1, t2) { + this.$this = t0; + this.variant = t1; + this.packageRoot = t2; + }, + NodePackageImporter__nodePackageExportsResolve__closure2: function NodePackageImporter__nodePackageExportsResolve__closure2() { + }, + NodePackageImporter__getMainExport_closure0: function NodePackageImporter__getMainExport_closure0() { + }, + NullExpression$(span) { + return new A.NullExpression0(span); + }, + NullExpression0: function NullExpression0(t0) { + this.span = t0; + }, + legacyNullClass_closure: function legacyNullClass_closure() { + }, + legacyNullClass__closure: function legacyNullClass__closure() { + }, + _SassNull0: function _SassNull0() { + }, + NumberExpression0: function NumberExpression0(t0, t1, t2) { + this.value = t0; + this.unit = t1; + this.span = t2; + }, + numberClass_closure: function numberClass_closure() { + }, + numberClass__closure: function numberClass__closure() { + }, + numberClass__closure0: function numberClass__closure0() { + }, + numberClass__closure1: function numberClass__closure1() { + }, + numberClass__closure2: function numberClass__closure2() { + }, + numberClass__closure3: function numberClass__closure3() { + }, + numberClass__closure4: function numberClass__closure4() { + }, + numberClass__closure5: function numberClass__closure5() { + }, + numberClass__closure6: function numberClass__closure6() { + }, + numberClass__closure7: function numberClass__closure7() { + }, + numberClass__closure8: function numberClass__closure8() { + }, + numberClass__closure9: function numberClass__closure9() { + }, + numberClass__closure10: function numberClass__closure10() { + }, + numberClass__closure11: function numberClass__closure11() { + }, + numberClass__closure12: function numberClass__closure12() { + }, + numberClass__closure13: function numberClass__closure13() { + }, + numberClass__closure14: function numberClass__closure14() { + }, + numberClass__closure15: function numberClass__closure15() { + }, + numberClass__closure16: function numberClass__closure16() { + }, + numberClass__closure17: function numberClass__closure17() { + }, + numberClass__closure18: function numberClass__closure18() { + }, + numberClass__closure19: function numberClass__closure19() { + }, + _ConstructorOptions0: function _ConstructorOptions0() { + }, + _parseNumber(value, unit) { + var invalidUnit, operands, t1, numerator, denominator, numeratorUnits, denominatorUnits; + if (unit == null || unit.length === 0) + return A.SassNumber_SassNumber0(value, null); + if (!J.contains$1$asx(unit, "*") && !B.JSString_methods.contains$1(unit, "/")) + return A.SassNumber_SassNumber0(value, unit); + invalidUnit = new A.ArgumentError(true, unit, "unit", "is invalid."); + operands = unit.split("/"); + t1 = operands.length; + if (t1 > 2) + throw A.wrapException(invalidUnit); + numerator = operands[0]; + denominator = t1 === 1 ? null : operands[1]; + t1 = type$.JSArray_String; + numeratorUnits = numerator.length === 0 ? A._setArrayType([], t1) : A._setArrayType(numerator.split("*"), t1); + if (B.JSArray_methods.any$1(numeratorUnits, new A._parseNumber_closure())) + throw A.wrapException(invalidUnit); + denominatorUnits = denominator == null ? A._setArrayType([], t1) : A._setArrayType(denominator.split("*"), t1); + if (B.JSArray_methods.any$1(denominatorUnits, new A._parseNumber_closure0())) + throw A.wrapException(invalidUnit); + return A.SassNumber_SassNumber$withUnits0(value, denominatorUnits, numeratorUnits); + }, + _NodeSassNumber: function _NodeSassNumber() { + }, + legacyNumberClass_closure: function legacyNumberClass_closure() { + }, + legacyNumberClass_closure0: function legacyNumberClass_closure0() { + }, + legacyNumberClass_closure1: function legacyNumberClass_closure1() { + }, + legacyNumberClass_closure2: function legacyNumberClass_closure2() { + }, + legacyNumberClass_closure3: function legacyNumberClass_closure3() { + }, + _parseNumber_closure: function _parseNumber_closure() { + }, + _parseNumber_closure0: function _parseNumber_closure0() { + }, + conversionFactor0(unit1, unit2) { + var _0_0; + if (unit1 === unit2) + return 1; + _0_0 = B.Map_NtHoP.$index(0, unit1); + if (_0_0 != null) + return _0_0.$index(0, unit2); + return null; + }, + SassNumber_SassNumber0(value, unit) { + return unit == null ? new A.UnitlessSassNumber0(value, null) : new A.SingleUnitSassNumber0(unit, value, null); + }, + SassNumber_SassNumber$withUnits0(value, denominatorUnits, numeratorUnits) { + var _0_8_isSet, _0_8, _0_10, _0_10_isSet, _0_7, unit, t2, _0_7_isSet, t3, _0_4_isSet, _0_7_isSet0, numerators, denominators, unsimplifiedDenominators, valueDouble, _i, denominator, simplifiedAway, i, factor, _1_2, _1_7_isSet, _1_7, _null = null, + _0_3 = numeratorUnits == null, + t1 = _0_3, + _0_6_isSet = !t1, + _0_6 = _null, + _0_4 = _null; + if (_0_6_isSet) { + _0_4 = J.get$length$asx(numeratorUnits == null ? type$.List_String._as(numeratorUnits) : numeratorUnits); + t1 = _0_4; + _0_6 = t1 <= 0; + _0_8_isSet = _0_6; + } else + _0_8_isSet = true; + _0_8 = _null; + _0_10 = _null; + if (_0_8_isSet) { + _0_8 = denominatorUnits == null; + t1 = _0_8; + _0_10_isSet = !t1; + if (_0_10_isSet) { + _0_10 = J.get$length$asx(denominatorUnits == null ? type$.List_String._as(denominatorUnits) : denominatorUnits) <= 0; + t1 = _0_10; + } else + t1 = true; + _0_7 = denominatorUnits; + } else { + _0_7 = _null; + _0_10_isSet = false; + t1 = false; + } + if (t1) + return new A.UnitlessSassNumber0(value, _null); + t1 = type$.List_String; + unit = _null; + t2 = false; + if (t1._is(numeratorUnits)) { + _0_7_isSet = true; + if (_0_6_isSet) { + t3 = _0_4; + _0_4_isSet = _0_6_isSet; + } else { + _0_4 = J.get$length$asx(numeratorUnits); + t3 = _0_4; + _0_4_isSet = true; + } + if (t3 === 1) { + unit = J.$index$asx(numeratorUnits, 0); + if (_0_8_isSet) { + t2 = _0_8; + _0_7_isSet0 = _0_8_isSet; + } else { + _0_8 = denominatorUnits == null; + t2 = _0_8; + _0_7_isSet0 = _0_7_isSet; + _0_7 = denominatorUnits; + _0_8_isSet = true; + } + if (!t2) + if (_0_10_isSet) { + t2 = _0_10; + _0_7_isSet = _0_7_isSet0; + } else { + if (_0_7_isSet0) { + t2 = _0_7; + _0_7_isSet = _0_7_isSet0; + } else { + t2 = denominatorUnits; + _0_7 = t2; + } + _0_10 = J.get$length$asx(t2 == null ? t1._as(t2) : t2) <= 0; + t2 = _0_10; + _0_10_isSet = true; + } + else { + _0_7_isSet = _0_7_isSet0; + t2 = true; + } + } else + _0_7_isSet = _0_8_isSet; + } else { + _0_7_isSet = _0_8_isSet; + _0_4_isSet = _0_6_isSet; + } + if (t2) + return new A.SingleUnitSassNumber0(unit, value, _null); + t2 = numeratorUnits == null; + t3 = false; + if (!t2) { + _0_7_isSet0 = true; + numerators = numeratorUnits; + if (_0_8_isSet) + t3 = _0_8; + else { + if (_0_7_isSet) + t3 = _0_7; + else { + t3 = denominatorUnits; + _0_7_isSet = _0_7_isSet0; + _0_7 = t3; + } + _0_8 = t3 == null; + t3 = _0_8; + } + if (!t3) + if (_0_10_isSet) + t3 = _0_10; + else { + if (_0_7_isSet) + t3 = _0_7; + else { + t3 = denominatorUnits; + _0_7_isSet = _0_7_isSet0; + _0_7 = t3; + } + _0_10 = J.get$length$asx(t3 == null ? t1._as(t3) : t3) <= 0; + t3 = _0_10; + } + else + t3 = true; + } else + numerators = _null; + if (t3) + return new A.ComplexSassNumber0(A.List_List$unmodifiable(numerators, type$.String), B.List_empty, value, _null); + if (!_0_3) + if (_0_6_isSet) + t2 = _0_6; + else { + if (_0_4_isSet) + t2 = _0_4; + else { + _0_4 = J.get$length$asx(t2 ? t1._as(numeratorUnits) : numeratorUnits); + t2 = _0_4; + } + _0_6 = t2 <= 0; + t2 = _0_6; + } + else + t2 = true; + denominators = _null; + if (t2) { + if (_0_7_isSet) + t2 = _0_7; + else { + t2 = denominatorUnits; + _0_7 = t2; + _0_7_isSet = true; + } + t2 = t2 != null; + if (t2) { + denominators = _0_7_isSet ? _0_7 : denominatorUnits; + if (denominators == null) + denominators = t1._as(denominators); + } + t1 = t2; + } else + t1 = false; + if (t1) + return new A.ComplexSassNumber0(B.List_empty, A.List_List$unmodifiable(denominators, type$.String), value, _null); + numeratorUnits.toString; + numerators = J.toList$0$ax(numeratorUnits); + denominatorUnits.toString; + unsimplifiedDenominators = J.toList$0$ax(denominatorUnits); + denominators = A._setArrayType([], type$.JSArray_String); + for (t1 = unsimplifiedDenominators.length, valueDouble = value, _i = 0; _i < unsimplifiedDenominators.length; unsimplifiedDenominators.length === t1 || (0, A.throwConcurrentModificationError)(unsimplifiedDenominators), ++_i) { + denominator = unsimplifiedDenominators[_i]; + i = 0; + while (true) { + if (!(i < numerators.length)) { + simplifiedAway = false; + break; + } + c$0: { + factor = A.conversionFactor0(denominator, numerators[i]); + if (factor == null) + break c$0; + valueDouble *= factor; + B.JSArray_methods.removeAt$1(numerators, i); + simplifiedAway = true; + break; + } + ++i; + } + if (!simplifiedAway) + denominators.push(denominator); + } + $label0$1: { + _1_2 = numerators.length; + t1 = _1_2; + _1_7_isSet = t1 <= 0; + if (_1_7_isSet) { + _1_7 = denominators.length <= 0; + t1 = _1_7; + } else { + _1_7 = _null; + t1 = false; + } + if (t1) { + t1 = new A.UnitlessSassNumber0(valueDouble, _null); + break $label0$1; + } + t1 = false; + if (_1_2 === 1) { + unit = numerators[0]; + t1 = _1_7_isSet ? _1_7 : denominators.length <= 0; + } else + unit = _null; + if (t1) { + t1 = new A.SingleUnitSassNumber0(unit, valueDouble, _null); + break $label0$1; + } + t1 = type$.String; + t1 = new A.ComplexSassNumber0(A.List_List$unmodifiable(numerators, t1), A.List_List$unmodifiable(denominators, t1), valueDouble, _null); + break $label0$1; + } + return t1; + }, + SassNumber0: function SassNumber0() { + }, + SassNumber__coerceOrConvertValue_compatibilityException0: function SassNumber__coerceOrConvertValue_compatibilityException0(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.$this = t0; + _.other = t1; + _.otherName = t2; + _.otherHasUnits = t3; + _.name = t4; + _.newNumerators = t5; + _.newDenominators = t6; + }, + SassNumber__coerceOrConvertValue_closure3: function SassNumber__coerceOrConvertValue_closure3(t0, t1) { + this._box_0 = t0; + this.newNumerator = t1; + }, + SassNumber__coerceOrConvertValue_closure4: function SassNumber__coerceOrConvertValue_closure4(t0) { + this.compatibilityException = t0; + }, + SassNumber__coerceOrConvertValue_closure5: function SassNumber__coerceOrConvertValue_closure5(t0, t1) { + this._box_0 = t0; + this.newDenominator = t1; + }, + SassNumber__coerceOrConvertValue_closure6: function SassNumber__coerceOrConvertValue_closure6(t0) { + this.compatibilityException = t0; + }, + SassNumber_plus_closure0: function SassNumber_plus_closure0() { + }, + SassNumber_minus_closure0: function SassNumber_minus_closure0() { + }, + SassNumber_multiplyUnits_closure3: function SassNumber_multiplyUnits_closure3(t0, t1) { + this._box_0 = t0; + this.numerator = t1; + }, + SassNumber_multiplyUnits_closure4: function SassNumber_multiplyUnits_closure4(t0, t1) { + this.newNumerators = t0; + this.numerator = t1; + }, + SassNumber_multiplyUnits_closure5: function SassNumber_multiplyUnits_closure5(t0, t1) { + this._box_0 = t0; + this.numerator = t1; + }, + SassNumber_multiplyUnits_closure6: function SassNumber_multiplyUnits_closure6(t0, t1) { + this.newNumerators = t0; + this.numerator = t1; + }, + SassNumber__areAnyConvertible_closure0: function SassNumber__areAnyConvertible_closure0(t0) { + this.units2 = t0; + }, + SassNumber__canonicalizeUnitList_closure0: function SassNumber__canonicalizeUnitList_closure0() { + }, + SassNumber__canonicalMultiplier_closure0: function SassNumber__canonicalMultiplier_closure0(t0) { + this.$this = t0; + }, + SassNumber_unitSuggestion_closure1: function SassNumber_unitSuggestion_closure1() { + }, + SassNumber_unitSuggestion_closure2: function SassNumber_unitSuggestion_closure2() { + }, + OklabColorSpace0: function OklabColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + OklchColorSpace0: function OklchColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + SupportsOperation$0(left, right, operator, span) { + var lowerOperator = operator.toLowerCase(); + if (lowerOperator !== "and" && lowerOperator !== "or") + A.throwExpression(A.ArgumentError$value(operator, "operator", 'may only be "and" or "or".')); + return new A.SupportsOperation0(left, right, operator, span); + }, + SupportsOperation0: function SupportsOperation0(t0, t1, t2, t3) { + var _ = this; + _.left = t0; + _.right = t1; + _.operator = t2; + _.span = t3; + }, + Parameter0: function Parameter0(t0, t1, t2) { + this.name = t0; + this.defaultValue = t1; + this.span = t2; + }, + ParameterList_ParameterList$parse0(contents, url) { + return A.ScssParser$0(contents, url).parseParameterList$0(); + }, + ParameterList0: function ParameterList0(t0, t1, t2) { + this.parameters = t0; + this.restParameter = t1; + this.span = t2; + }, + ParameterList_verify_closure1: function ParameterList_verify_closure1() { + }, + ParameterList_verify_closure2: function ParameterList_verify_closure2() { + }, + ParentSelector0: function ParentSelector0(t0, t1) { + this.suffix = t0; + this.span = t1; + }, + ParentStatement0: function ParentStatement0() { + }, + ParentStatement_closure0: function ParentStatement_closure0() { + }, + ParentStatement__closure0: function ParentStatement__closure0() { + }, + ParenthesizedExpression0: function ParenthesizedExpression0(t0, t1) { + this.expression = t0; + this.span = t1; + }, + loadParserExports() { + A._updateAstPrototypes(); + return {parse: A.allowInterop(A.parser0___parse$closure()), parseIdentifier: A.allowInterop(A.parser0___parseIdentifier$closure()), toCssIdentifier: A.allowInterop(A.parser0___toCssIdentifier$closure()), createExpressionVisitor: A.allowInterop(new A.loadParserExports_closure()), createStatementVisitor: A.allowInterop(new A.loadParserExports_closure0()), setToJS: A.allowInterop(new A.loadParserExports_closure1()), mapToRecord: A.allowInterop(A.utils3__mapToObject$closure())}; + }, + _updateAstPrototypes() { + var t2, t3, string, t4, t5, $arguments, _i, _null = null, + _s9_ = "arguments", + file = A.SourceFile$fromString("", _null), + t1 = type$.JSClass; + J.get$$prototype$x(t1._as(file.constructor)).getText = A.allowInteropCaptureThisNamed("getText", new A._updateAstPrototypes_closure()); + A.defineGetter(J.get$$prototype$x(t1._as(file.constructor)), "codeUnits", new A._updateAstPrototypes_closure0(), _null); + t2 = $.$get$_interpolation(); + A.defineGetter(J.get$$prototype$x(t1._as(t2.constructor)), "asPlain", new A._updateAstPrototypes_closure1(), _null); + t3 = $.$get$bogusSpan0(); + J.get$$prototype$x(t1._as(self.Object.getPrototypeOf(J.get$$prototype$x(t1._as(new A.ExtendRule0(t2, false, t3).constructor))).constructor)).accept = A.allowInteropCaptureThisNamed("accept", new A._updateAstPrototypes_closure2()); + string = new A.StringExpression0(t2, false); + J.get$$prototype$x(t1._as(self.Object.getPrototypeOf(J.get$$prototype$x(t1._as(string.constructor))).constructor)).accept = A.allowInteropCaptureThisNamed("accept", new A._updateAstPrototypes_closure3()); + t4 = type$.String; + t5 = type$.Expression_2; + $arguments = new A.ArgumentList0(A.List_List$unmodifiable(A._setArrayType([], type$.JSArray_Expression_2), t5), A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_empty(t4, t5), t4, t5), _null, _null, t3); + A.defineGetter(J.get$$prototype$x(t1._as(new A.IncludeRule0(_null, A.stringReplaceAllUnchecked("a", "_", "-"), "a", $arguments, _null, t3).constructor)), _s9_, new A._updateAstPrototypes_closure4(), _null); + A.defineGetter(J.get$$prototype$x(t1._as(new A.ContentRule0($arguments, t3).constructor)), _s9_, new A._updateAstPrototypes_closure5(), _null); + A.defineGetter(J.get$$prototype$x(t1._as(new A.FunctionExpression0(_null, A.stringReplaceAllUnchecked("a", "_", "-"), "a", $arguments, t3).constructor)), _s9_, new A._updateAstPrototypes_closure6(), _null); + A.defineGetter(J.get$$prototype$x(t1._as(new A.IfExpression0($arguments, t3).constructor)), _s9_, new A._updateAstPrototypes_closure7(), _null); + A.defineGetter(J.get$$prototype$x(t1._as(new A.InterpolatedFunctionExpression0(t2, $arguments, t3).constructor)), _s9_, new A._updateAstPrototypes_closure8(), _null); + A._addSupportsConditionToInterpolation(); + for (t2 = [string, new A.BinaryOperationExpression0(B.BinaryOperator_Swh0, string, string, false), new A.SupportsExpression0(new A.SupportsAnything0(t2, t3)), new A.LoudComment0(t2)], _i = 0; _i < 4; ++_i) { + t3 = J.get$$prototype$x(t1._as(t2[_i].constructor)); + t4 = {get: A.allowInteropCaptureThis(new A._updateAstPrototypes_closure9()), enumerable: false}; + self.Object.defineProperty(t3, "span", t4); + } + }, + _addSupportsConditionToInterpolation() { + var t3, _i, $function, t4, + t1 = $.$get$_interpolation(), + t2 = $.$get$bogusSpan0(), + anything = new A.SupportsAnything0(t1, t2); + for (t3 = $.$get$_expression(), t2 = [anything, new A.SupportsDeclaration0(t3, t3, t2), new A.SupportsFunction0(t1, t1, t2), new A.SupportsInterpolation0(t3, t2), new A.SupportsNegation0(anything, t2), A.SupportsOperation$0(anything, anything, "and", t2)], t3 = type$.JSClass, _i = 0; _i < 6; ++_i) { + t1 = J.get$$prototype$x(t3._as(t2[_i].constructor)); + $function = A.allowInteropCaptureThis(new A._addSupportsConditionToInterpolation_closure()); + t4 = {value: "toInterpolation", enumerable: false}; + self.Object.defineProperty($function, "name", t4); + A._hideDartProperties($function); + t1.toInterpolation = $function; + } + }, + _parse(css, syntax, path) { + var t1; + $label0$0: { + if ("scss" === syntax) { + t1 = B.Syntax_SCSS_scss0; + break $label0$0; + } + if ("sass" === syntax) { + t1 = B.Syntax_Sass_sass0; + break $label0$0; + } + if ("css" === syntax) { + t1 = B.Syntax_CSS_css0; + break $label0$0; + } + t1 = A.throwExpression(A.UnsupportedError$('Unknown syntax "' + syntax + '"')); + } + return A.Stylesheet_Stylesheet$parse0(css, t1, A.NullableExtension_andThen0(path, A.path__toUri$closure())); + }, + _parseIdentifier(identifier) { + var t1, exception; + try { + t1 = new A.Parser1(A.SpanScanner$(identifier, null), null)._parser1$_parseIdentifier$0(); + return t1; + } catch (exception) { + if (type$.SassFormatException_2._is(A.unwrapException(exception))) + return null; + else + throw exception; + } + }, + _toCssIdentifier(text) { + return A.StringExtension_toCssIdentifier(text); + }, + ParserExports: function ParserExports() { + }, + loadParserExports_closure: function loadParserExports_closure() { + }, + loadParserExports_closure0: function loadParserExports_closure0() { + }, + loadParserExports_closure1: function loadParserExports_closure1() { + }, + _updateAstPrototypes_closure: function _updateAstPrototypes_closure() { + }, + _updateAstPrototypes_closure0: function _updateAstPrototypes_closure0() { + }, + _updateAstPrototypes_closure1: function _updateAstPrototypes_closure1() { + }, + _updateAstPrototypes_closure2: function _updateAstPrototypes_closure2() { + }, + _updateAstPrototypes_closure3: function _updateAstPrototypes_closure3() { + }, + _updateAstPrototypes_closure4: function _updateAstPrototypes_closure4() { + }, + _updateAstPrototypes_closure5: function _updateAstPrototypes_closure5() { + }, + _updateAstPrototypes_closure6: function _updateAstPrototypes_closure6() { + }, + _updateAstPrototypes_closure7: function _updateAstPrototypes_closure7() { + }, + _updateAstPrototypes_closure8: function _updateAstPrototypes_closure8() { + }, + _updateAstPrototypes_closure9: function _updateAstPrototypes_closure9() { + }, + _addSupportsConditionToInterpolation_closure: function _addSupportsConditionToInterpolation_closure() { + }, + Parser_isIdentifier0(text) { + var exception; + try { + new A.Parser1(A.SpanScanner$(text, null), null)._parser1$_parseIdentifier$0(); + return true; + } catch (exception) { + if (type$.SassFormatException_2._is(A.unwrapException(exception))) + return false; + else + throw exception; + } + }, + Parser1: function Parser1(t0, t1) { + this.scanner = t0; + this._parser1$_interpolationMap = t1; + }, + Parser__parseIdentifier_closure0: function Parser__parseIdentifier_closure0(t0) { + this.$this = t0; + }, + Parser_escape_closure0: function Parser_escape_closure0() { + }, + Parser_scanIdentChar_matches0: function Parser_scanIdentChar_matches0(t0, t1) { + this.caseSensitive = t0; + this.char = t1; + }, + Parser_spanFrom_closure0: function Parser_spanFrom_closure0(t0, t1) { + this.$this = t0; + this.span = t1; + }, + PlaceholderSelector0: function PlaceholderSelector0(t0, t1) { + this.name = t0; + this.span = t1; + }, + PlainCssCallable0: function PlainCssCallable0(t0) { + this.name = t0; + }, + PrefixedMapView0: function PrefixedMapView0(t0, t1, t2) { + this._prefixed_map_view0$_map = t0; + this._prefixed_map_view0$_prefix = t1; + this.$ti = t2; + }, + _PrefixedKeys0: function _PrefixedKeys0(t0) { + this._prefixed_map_view0$_view = t0; + }, + _PrefixedKeys_iterator_closure0: function _PrefixedKeys_iterator_closure0(t0) { + this.$this = t0; + }, + ProphotoRgbColorSpace0: function ProphotoRgbColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + PseudoSelector$0($name, span, argument, element, selector) { + var t1 = !element, + t2 = t1 && !A.PseudoSelector__isFakePseudoElement0($name); + return new A.PseudoSelector0($name, A.unvendor0($name), t2, t1, argument, selector, span); + }, + PseudoSelector__isFakePseudoElement0($name) { + switch ($name.charCodeAt(0)) { + case 97: + case 65: + return A.equalsIgnoreCase0($name, "after"); + case 98: + case 66: + return A.equalsIgnoreCase0($name, "before"); + case 102: + case 70: + return A.equalsIgnoreCase0($name, "first-line") || A.equalsIgnoreCase0($name, "first-letter"); + default: + return false; + } + }, + PseudoSelector0: function PseudoSelector0(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.name = t0; + _.normalizedName = t1; + _.isClass = t2; + _.isSyntacticClass = t3; + _.argument = t4; + _.selector = t5; + _._pseudo$__PseudoSelector_specificity_FI = $; + _.span = t6; + }, + PseudoSelector_specificity_closure0: function PseudoSelector_specificity_closure0(t0) { + this.$this = t0; + }, + PseudoSelector_specificity__closure1: function PseudoSelector_specificity__closure1() { + }, + PseudoSelector_specificity__closure2: function PseudoSelector_specificity__closure2() { + }, + PseudoSelector_unify_closure0: function PseudoSelector_unify_closure0() { + }, + PublicMemberMapView0: function PublicMemberMapView0(t0, t1) { + this._public_member_map_view0$_inner = t0; + this.$ti = t1; + }, + QualifiedName0: function QualifiedName0(t0, t1) { + this.name = t0; + this.namespace = t1; + }, + Rec2020ColorSpace0: function Rec2020ColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + createJSClass($name, $constructor) { + return type$.JSClass._as(A.allowInteropCaptureThisNamed($name, $constructor)); + }, + JSClassExtension_injectSuperclass(_this, superclass) { + var t1 = J.getInterceptor$x(superclass), + t2 = J.getInterceptor$x(_this); + self.Object.setPrototypeOf(t1.get$$prototype(superclass), J.get$$prototype$x(type$.JSClass._as(self.Object.getPrototypeOf(t2.get$$prototype(_this)).constructor))); + self.Object.setPrototypeOf(t2.get$$prototype(_this), self.Object.create(t1.get$$prototype(superclass))); + }, + JSClassExtension_setCustomInspect(_this, inspect) { + if (self.util == null) + return; + J.get$$prototype$x(_this)[self.util.inspect.custom] = A.allowInteropCaptureThis(new A.JSClassExtension_setCustomInspect_closure(inspect)); + }, + JSClassExtension_get_defineStaticMethod(_this) { + return new A.JSClassExtension_get_defineStaticMethod_closure(_this); + }, + JSClassExtension_get_defineMethod(_this) { + return new A.JSClassExtension_get_defineMethod_closure(_this); + }, + JSClassExtension_defineMethods(_this, methods) { + methods.forEach$1(0, A.JSClassExtension_get_defineMethod(_this)); + }, + JSClassExtension_get_defineGetter(_this) { + return new A.JSClassExtension_get_defineGetter_closure(_this); + }, + JSClass0: function JSClass0() { + }, + JSClassExtension_setCustomInspect_closure: function JSClassExtension_setCustomInspect_closure(t0) { + this.inspect = t0; + }, + JSClassExtension_get_defineStaticMethod_closure: function JSClassExtension_get_defineStaticMethod_closure(t0) { + this._this = t0; + }, + JSClassExtension_get_defineMethod_closure: function JSClassExtension_get_defineMethod_closure(t0) { + this._this = t0; + }, + JSClassExtension_get_defineGetter_closure: function JSClassExtension_get_defineGetter_closure(t0) { + this._this = t0; + }, + RenderContext0: function RenderContext0() { + }, + RenderContextOptions0: function RenderContextOptions0() { + }, + RenderContextResult0: function RenderContextResult0() { + }, + RenderContextResultStats0: function RenderContextResultStats0() { + }, + RenderOptions: function RenderOptions() { + }, + RenderResult: function RenderResult() { + }, + RenderResultStats: function RenderResultStats() { + }, + ReplaceExpressionVisitor0: function ReplaceExpressionVisitor0() { + }, + ReplaceExpressionVisitor_visitListExpression_closure0: function ReplaceExpressionVisitor_visitListExpression_closure0(t0) { + this.$this = t0; + }, + ReplaceExpressionVisitor_visitArgumentList_closure0: function ReplaceExpressionVisitor_visitArgumentList_closure0(t0) { + this.$this = t0; + }, + ReplaceExpressionVisitor_visitInterpolation_closure0: function ReplaceExpressionVisitor_visitInterpolation_closure0(t0) { + this.$this = t0; + }, + ImporterResult$(contents, sourceMapUrl, syntax) { + if ((sourceMapUrl == null ? null : sourceMapUrl.get$scheme()) === "") + A.throwExpression(A.ArgumentError$value(sourceMapUrl, "sourceMapUrl", "must be absolute")); + return new A.ImporterResult0(contents, sourceMapUrl, syntax); + }, + ImporterResult0: function ImporterResult0(t0, t1, t2) { + this.contents = t0; + this._result$_sourceMapUrl = t1; + this.syntax = t2; + }, + ReturnRule0: function ReturnRule0(t0, t1) { + this.expression = t0; + this.span = t1; + }, + RgbColorSpace0: function RgbColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + SassParser0: function SassParser0(t0, t1, t2, t3) { + var _ = this; + _._sass0$_currentIndentation = 0; + _._sass0$_spaces = _._sass0$_nextIndentationEnd = _._sass0$_nextIndentation = null; + _._stylesheet0$_isUseAllowed = true; + _._stylesheet0$_inExpression = _._stylesheet0$_inParentheses = _._stylesheet0$_inStyleRule = _._stylesheet0$_inUnknownAtRule = _._stylesheet0$_inControlDirective = _._stylesheet0$_inContentBlock = _._stylesheet0$_inMixin = false; + _._stylesheet0$_globalVariables = t0; + _.warnings = t1; + _.lastSilentComment = null; + _.scanner = t2; + _._parser1$_interpolationMap = t3; + }, + SassParser_styleRuleSelector_closure0: function SassParser_styleRuleSelector_closure0() { + }, + SassParser_children_closure0: function SassParser_children_closure0(t0, t1, t2) { + this.$this = t0; + this.child = t1; + this.children = t2; + }, + SassParser__peekIndentation_closure1: function SassParser__peekIndentation_closure1() { + }, + SassParser__peekIndentation_closure2: function SassParser__peekIndentation_closure2() { + }, + SassParser__tryTrailingSemicolon_closure0: function SassParser__tryTrailingSemicolon_closure0() { + }, + _translateReturnValue(val) { + if (val instanceof A._Future) + return A.futureToPromise(val, type$.dynamic); + else + return val; + }, + main2() { + new Uint8Array(0); + A.main(); + J.set$cli_pkg_main_0_$x(self.exports, A._wrapMain(A.sass__main$closure())); + }, + _wrapMain(main) { + if (type$.dynamic_Function._is(main)) + return A.allowInterop(new A._wrapMain_closure(main)); + else + return A.allowInterop(new A._wrapMain_closure0(main)); + }, + _Exports: function _Exports() { + }, + _wrapMain_closure: function _wrapMain_closure(t0) { + this.main = t0; + }, + _wrapMain_closure0: function _wrapMain_closure0(t0) { + this.main = t0; + }, + ScssParser$0(contents, url) { + return new A.ScssParser0(A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.FileSpan), A._setArrayType([], type$.JSArray_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span_2), A.SpanScanner$(contents, url), null); + }, + ScssParser0: function ScssParser0(t0, t1, t2, t3) { + var _ = this; + _._stylesheet0$_isUseAllowed = true; + _._stylesheet0$_inExpression = _._stylesheet0$_inParentheses = _._stylesheet0$_inStyleRule = _._stylesheet0$_inUnknownAtRule = _._stylesheet0$_inControlDirective = _._stylesheet0$_inContentBlock = _._stylesheet0$_inMixin = false; + _._stylesheet0$_globalVariables = t0; + _.warnings = t1; + _.lastSilentComment = null; + _.scanner = t2; + _._parser1$_interpolationMap = t3; + }, + Selector0: function Selector0() { + }, + _IsInvisibleVisitor2: function _IsInvisibleVisitor2(t0) { + this.includeBogus = t0; + }, + _IsBogusVisitor0: function _IsBogusVisitor0(t0) { + this.includeLeadingCombinator = t0; + }, + _IsBogusVisitor_visitComplexSelector_closure0: function _IsBogusVisitor_visitComplexSelector_closure0(t0) { + this.$this = t0; + }, + _IsUselessVisitor0: function _IsUselessVisitor0() { + }, + _IsUselessVisitor_visitComplexSelector_closure0: function _IsUselessVisitor_visitComplexSelector_closure0(t0) { + this.$this = t0; + }, + __IsBogusVisitor_Object_AnySelectorVisitor0: function __IsBogusVisitor_Object_AnySelectorVisitor0() { + }, + __IsInvisibleVisitor_Object_AnySelectorVisitor0: function __IsInvisibleVisitor_Object_AnySelectorVisitor0() { + }, + __IsUselessVisitor_Object_AnySelectorVisitor0: function __IsUselessVisitor_Object_AnySelectorVisitor0() { + }, + SelectorExpression0: function SelectorExpression0(t0) { + this.span = t0; + }, + _prependParent0(compound) { + var _0_3, _0_4, t2, _0_4_isSet, t3, rest, + t1 = A.EvaluationContext_currentOrNull0(), + span = (t1 == null ? A.throwExpression(A.StateError$(string$.No_Sass)) : t1).get$currentCallableSpan(), + _0_0 = compound.components; + $label0$0: { + _0_3 = _0_0.length >= 1; + if (_0_3) { + _0_4 = _0_0[0]; + t1 = _0_4 instanceof A.UniversalSelector0; + } else { + _0_4 = null; + t1 = false; + } + t2 = null; + if (t1) { + t1 = t2; + break $label0$0; + } + t1 = false; + if (_0_3) { + _0_4_isSet = true; + t3 = _0_4; + if (t3 instanceof A.TypeSelector0) { + t1 = _0_4; + t1 = type$.TypeSelector_2._as(t1).name.namespace != null; + } + } else + _0_4_isSet = _0_3; + if (t1) { + t1 = t2; + break $label0$0; + } + if (_0_3) { + if (_0_4_isSet) + t1 = _0_4; + else { + _0_4 = _0_0[0]; + t1 = _0_4; + _0_4_isSet = true; + } + t1 = t1 instanceof A.TypeSelector0; + } else + t1 = false; + if (t1) { + t1 = _0_4_isSet ? _0_4 : _0_0[0]; + type$.TypeSelector_2._as(t1); + rest = B.JSArray_methods.sublist$1(_0_0, 1); + t1 = A._setArrayType([new A.ParentSelector0(t1.name.name, span)], type$.JSArray_SimpleSelector_2); + B.JSArray_methods.addAll$1(t1, rest); + t1 = A.CompoundSelector$0(t1, span); + break $label0$0; + } + t1 = A._setArrayType([new A.ParentSelector0(null, span)], type$.JSArray_SimpleSelector_2); + B.JSArray_methods.addAll$1(t1, _0_0); + t1 = A.CompoundSelector$0(t1, span); + break $label0$0; + } + return t1; + }, + _function8($name, $arguments, callback) { + return A.BuiltInCallable$function0($name, $arguments, callback, "sass:selector"); + }, + _nest_closure0: function _nest_closure0() { + }, + _nest__closure1: function _nest__closure1(t0) { + this._box_0 = t0; + }, + _nest__closure2: function _nest__closure2() { + }, + _append_closure1: function _append_closure1() { + }, + _append__closure1: function _append__closure1() { + }, + _append__closure2: function _append__closure2(t0) { + this.span = t0; + }, + _append___closure0: function _append___closure0(t0, t1) { + this.parent = t0; + this.span = t1; + }, + _extend_closure0: function _extend_closure0() { + }, + _replace_closure0: function _replace_closure0() { + }, + _unify_closure0: function _unify_closure0() { + }, + _isSuperselector_closure0: function _isSuperselector_closure0() { + }, + _simpleSelectors_closure0: function _simpleSelectors_closure0() { + }, + _simpleSelectors__closure0: function _simpleSelectors__closure0() { + }, + _parse_closure0: function _parse_closure0() { + }, + SelectorParser0: function SelectorParser0(t0, t1, t2, t3) { + var _ = this; + _._selector$_allowParent = t0; + _._selector$_plainCss = t1; + _.scanner = t2; + _._parser1$_interpolationMap = t3; + }, + SelectorParser_parse_closure0: function SelectorParser_parse_closure0(t0) { + this.$this = t0; + }, + SelectorParser_parseCompoundSelector_closure0: function SelectorParser_parseCompoundSelector_closure0(t0) { + this.$this = t0; + }, + SelectorSearchVisitor0: function SelectorSearchVisitor0() { + }, + SelectorSearchVisitor_visitComplexSelector_closure0: function SelectorSearchVisitor_visitComplexSelector_closure0(t0) { + this.$this = t0; + }, + SelectorSearchVisitor_visitCompoundSelector_closure0: function SelectorSearchVisitor_visitCompoundSelector_closure0(t0) { + this.$this = t0; + }, + serialize0(node, charset, indentWidth, inspect, lineFeed, logger, sourceMap, style, useSpaces) { + var t1, css, t2, prefix, + visitor = A._SerializeVisitor$0(indentWidth == null ? 2 : indentWidth, inspect, lineFeed, logger, true, sourceMap, style, useSpaces); + node.accept$1(visitor); + t1 = visitor._serialize0$_buffer; + css = t1.toString$0(0); + if (charset) { + t2 = new A.CodeUnits(css); + t2 = t2.any$1(t2, new A.serialize_closure0()); + } else + t2 = false; + if (t2) + prefix = style === B.OutputStyle_10 ? "\ufeff" : '@charset "UTF-8";\n'; + else + prefix = ""; + t1 = sourceMap ? t1.buildSourceMap$1$prefix(prefix) : null; + return new A._Record_2_sourceMap(prefix + css, t1); + }, + serializeValue0(value, inspect, quote) { + var _null = null, + visitor = A._SerializeVisitor$0(_null, inspect, _null, _null, quote, false, _null, true); + value.accept$1(visitor); + return visitor._serialize0$_buffer.toString$0(0); + }, + serializeSelector0(selector, inspect) { + var _null = null, + visitor = A._SerializeVisitor$0(_null, true, _null, _null, true, false, _null, true); + selector.accept$1(visitor); + return visitor._serialize0$_buffer.toString$0(0); + }, + _SerializeVisitor$0(indentWidth, inspect, lineFeed, logger, quote, sourceMap, style, useSpaces) { + var t1 = sourceMap ? new A.SourceMapBuffer0(new A.StringBuffer(""), A._setArrayType([], type$.JSArray_Entry)) : new A.NoSourceMapBuffer0(new A.StringBuffer("")), + t2 = style == null ? B.OutputStyle_00 : style, + t3 = useSpaces ? 32 : 9, + t4 = indentWidth == null ? 2 : indentWidth, + t5 = lineFeed == null ? B.LineFeed_9HY : lineFeed, + t6 = logger == null ? B.StderrLogger_false0 : logger; + A.RangeError_checkValueInInterval(t4, 0, 10, "indentWidth"); + return new A._SerializeVisitor0(t1, t2, inspect, quote, t3, t4, t5, t6); + }, + serialize_closure0: function serialize_closure0() { + }, + _SerializeVisitor0: function _SerializeVisitor0(t0, t1, t2, t3, t4, t5, t6, t7) { + var _ = this; + _._serialize0$_buffer = t0; + _._serialize0$_indentation = 0; + _._serialize0$_style = t1; + _._serialize0$_inspect = t2; + _._serialize0$_quote = t3; + _._serialize0$_indentCharacter = t4; + _._serialize0$_indentWidth = t5; + _._lineFeed = t6; + _._serialize0$_logger = t7; + }, + _SerializeVisitor_visitCssComment_closure0: function _SerializeVisitor_visitCssComment_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssAtRule_closure0: function _SerializeVisitor_visitCssAtRule_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssMediaRule_closure0: function _SerializeVisitor_visitCssMediaRule_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssImport_closure0: function _SerializeVisitor_visitCssImport_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssImport__closure0: function _SerializeVisitor_visitCssImport__closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssKeyframeBlock_closure0: function _SerializeVisitor_visitCssKeyframeBlock_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssStyleRule_closure0: function _SerializeVisitor_visitCssStyleRule_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssSupportsRule_closure0: function _SerializeVisitor_visitCssSupportsRule_closure0(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssDeclaration_closure1: function _SerializeVisitor_visitCssDeclaration_closure1(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitCssDeclaration_closure2: function _SerializeVisitor_visitCssDeclaration_closure2(t0, t1) { + this.$this = t0; + this.node = t1; + }, + _SerializeVisitor_visitList_closure2: function _SerializeVisitor_visitList_closure2() { + }, + _SerializeVisitor_visitList_closure3: function _SerializeVisitor_visitList_closure3(t0, t1) { + this.$this = t0; + this.value = t1; + }, + _SerializeVisitor_visitList_closure4: function _SerializeVisitor_visitList_closure4(t0) { + this.$this = t0; + }, + _SerializeVisitor_visitMap_closure0: function _SerializeVisitor_visitMap_closure0(t0) { + this.$this = t0; + }, + _SerializeVisitor_visitSelectorList_closure0: function _SerializeVisitor_visitSelectorList_closure0() { + }, + _SerializeVisitor__write_closure0: function _SerializeVisitor__write_closure0(t0, t1) { + this.$this = t0; + this.value = t1; + }, + _SerializeVisitor__visitChildren_closure1: function _SerializeVisitor__visitChildren_closure1(t0, t1) { + this.$this = t0; + this.child = t1; + }, + _SerializeVisitor__visitChildren_closure2: function _SerializeVisitor__visitChildren_closure2(t0, t1) { + this.$this = t0; + this.child = t1; + }, + OutputStyle0: function OutputStyle0(t0) { + this._name = t0; + }, + LineFeed0: function LineFeed0(t0, t1, t2) { + this.name = t0; + this.text = t1; + this._name = t2; + }, + JSSet: function JSSet() { + }, + ShadowedModuleView_ifNecessary0(inner, functions, mixins, variables, $T) { + return A.ShadowedModuleView__needsBlocklist0(inner.get$variables(), variables) || A.ShadowedModuleView__needsBlocklist0(inner.get$functions(inner), functions) || A.ShadowedModuleView__needsBlocklist0(inner.get$mixins(), mixins) ? new A.ShadowedModuleView0(inner, A.ShadowedModuleView__shadowedMap0(inner.get$variables(), variables, type$.Value_2), A.ShadowedModuleView__shadowedMap0(inner.get$variableNodes(), variables, type$.AstNode_2), A.ShadowedModuleView__shadowedMap0(inner.get$functions(inner), functions, $T), A.ShadowedModuleView__shadowedMap0(inner.get$mixins(), mixins, $T), $T._eval$1("ShadowedModuleView0<0>")) : null; + }, + ShadowedModuleView__shadowedMap0(map, blocklist, $V) { + var t1 = A.ShadowedModuleView__needsBlocklist0(map, blocklist); + return !t1 ? map : A.LimitedMapView$blocklist0(map, blocklist, type$.String, $V); + }, + ShadowedModuleView__needsBlocklist0(map, blocklist) { + return map.get$isNotEmpty(map) && blocklist.any$1(0, map.get$containsKey()); + }, + ShadowedModuleView0: function ShadowedModuleView0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._shadowed_view0$_inner = t0; + _.variables = t1; + _.variableNodes = t2; + _.functions = t3; + _.mixins = t4; + _.$ti = t5; + }, + SilentComment0: function SilentComment0(t0, t1) { + this.text = t0; + this.span = t1; + }, + SimpleSelector0: function SimpleSelector0() { + }, + SimpleSelector_isSuperselector_closure0: function SimpleSelector_isSuperselector_closure0(t0) { + this.$this = t0; + }, + SimpleSelector_isSuperselector__closure0: function SimpleSelector_isSuperselector__closure0(t0) { + this.$this = t0; + }, + SingleUnitSassNumber0: function SingleUnitSassNumber0(t0, t1, t2) { + var _ = this; + _._single_unit$_unit = t0; + _._number1$_value = t1; + _.hashCache = null; + _.asSlash = t2; + }, + SingleUnitSassNumber__coerceToUnit_closure0: function SingleUnitSassNumber__coerceToUnit_closure0(t0, t1) { + this.$this = t0; + this.unit = t1; + }, + SingleUnitSassNumber__coerceValueToUnit_closure0: function SingleUnitSassNumber__coerceValueToUnit_closure0(t0) { + this.$this = t0; + }, + SingleUnitSassNumber_multiplyUnits_closure1: function SingleUnitSassNumber_multiplyUnits_closure1(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + SingleUnitSassNumber_multiplyUnits_closure2: function SingleUnitSassNumber_multiplyUnits_closure2(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + SourceInterpolationVisitor: function SourceInterpolationVisitor(t0) { + this.buffer = t0; + }, + SourceMapBuffer0: function SourceMapBuffer0(t0, t1) { + var _ = this; + _._source_map_buffer0$_buffer = t0; + _._source_map_buffer0$_entries = t1; + _._source_map_buffer0$_column = _._source_map_buffer0$_line = 0; + _._source_map_buffer0$_inSpan = false; + }, + SourceMapBuffer_buildSourceMap_closure0: function SourceMapBuffer_buildSourceMap_closure0(t0, t1) { + this._box_0 = t0; + this.prefixLength = t1; + }, + updateSourceSpanPrototype() { + var t3, t4, _i, t5, + span = A.SourceFile$fromString("", null).span$1(0, 0), + t1 = type$.SourceSpan, + t2 = type$.String; + for (t1 = [span, new A.MultiSpan0(span, "", A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_empty(t1, t2), t1, t2)), new A.LazyFileSpan0(new A.updateSourceSpanPrototype_closure(span))], t3 = type$.JSClass, t4 = type$.Function, _i = 0; _i < 3; ++_i) { + t5 = t3._as(t1[_i].constructor); + A.LinkedHashMap_LinkedHashMap$_literal(["start", new A.updateSourceSpanPrototype_closure0(), "end", new A.updateSourceSpanPrototype_closure1(), "url", new A.updateSourceSpanPrototype_closure2(), "text", new A.updateSourceSpanPrototype_closure3(), "context", new A.updateSourceSpanPrototype_closure4()], t2, t4).forEach$1(0, A.JSClassExtension_get_defineGetter(t5)); + } + t1 = t3._as(A.FileLocation$_(span.file, span._file$_start).constructor); + A.LinkedHashMap_LinkedHashMap$_literal(["line", new A.updateSourceSpanPrototype_closure5(), "column", new A.updateSourceSpanPrototype_closure6()], t2, t4).forEach$1(0, A.JSClassExtension_get_defineGetter(t1)); + }, + updateSourceSpanPrototype_closure: function updateSourceSpanPrototype_closure(t0) { + this.span = t0; + }, + updateSourceSpanPrototype_closure0: function updateSourceSpanPrototype_closure0() { + }, + updateSourceSpanPrototype_closure1: function updateSourceSpanPrototype_closure1() { + }, + updateSourceSpanPrototype_closure2: function updateSourceSpanPrototype_closure2() { + }, + updateSourceSpanPrototype__closure: function updateSourceSpanPrototype__closure() { + }, + updateSourceSpanPrototype_closure3: function updateSourceSpanPrototype_closure3() { + }, + updateSourceSpanPrototype_closure4: function updateSourceSpanPrototype_closure4() { + }, + updateSourceSpanPrototype_closure5: function updateSourceSpanPrototype_closure5() { + }, + updateSourceSpanPrototype_closure6: function updateSourceSpanPrototype_closure6() { + }, + ColorSpace_fromName0($name, argumentName) { + var t1, + _0_0 = $name.toLowerCase(); + $label0$0: { + if ("rgb" === _0_0) { + t1 = B.RgbColorSpace_i0P0; + break $label0$0; + } + if ("hwb" === _0_0) { + t1 = B.HwbColorSpace_guQ0; + break $label0$0; + } + if ("hsl" === _0_0) { + t1 = B.HslColorSpace_JQ20; + break $label0$0; + } + if ("srgb" === _0_0) { + t1 = B.SrgbColorSpace_thf0; + break $label0$0; + } + if ("srgb-linear" === _0_0) { + t1 = B.SrgbLinearColorSpace_kUj0; + break $label0$0; + } + if ("display-p3" === _0_0) { + t1 = B.DisplayP3ColorSpace_MmT0; + break $label0$0; + } + if ("a98-rgb" === _0_0) { + t1 = B.A98RgbColorSpace_lf20; + break $label0$0; + } + if ("prophoto-rgb" === _0_0) { + t1 = B.ProphotoRgbColorSpace_BDz0; + break $label0$0; + } + if ("rec2020" === _0_0) { + t1 = B.Rec2020ColorSpace_6oo0; + break $label0$0; + } + if ("xyz" === _0_0 || "xyz-d65" === _0_0) { + t1 = B.XyzD65ColorSpace_WiJ0; + break $label0$0; + } + if ("xyz-d50" === _0_0) { + t1 = B.XyzD50ColorSpace_2OB0; + break $label0$0; + } + if ("lab" === _0_0) { + t1 = B.LabColorSpace_2nT0; + break $label0$0; + } + if ("lch" === _0_0) { + t1 = B.LchColorSpace_Bpv0; + break $label0$0; + } + if ("oklab" === _0_0) { + t1 = B.OklabColorSpace_5400; + break $label0$0; + } + if ("oklch" === _0_0) { + t1 = B.OklchColorSpace_9Gj0; + break $label0$0; + } + t1 = A.throwExpression(A.SassScriptException$0('Unknown color space "' + $name + '".', argumentName)); + } + return t1; + }, + ColorSpace0: function ColorSpace0() { + }, + SrgbColorSpace0: function SrgbColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + SrgbLinearColorSpace0: function SrgbLinearColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + Statement0: function Statement0() { + }, + JSStatementVisitor: function JSStatementVisitor(t0) { + this._statement$_inner = t0; + }, + JSStatementVisitorObject: function JSStatementVisitorObject() { + }, + StatementSearchVisitor0: function StatementSearchVisitor0() { + }, + StatementSearchVisitor_visitIfRule_closure1: function StatementSearchVisitor_visitIfRule_closure1(t0) { + this.$this = t0; + }, + StatementSearchVisitor_visitIfRule__closure2: function StatementSearchVisitor_visitIfRule__closure2(t0) { + this.$this = t0; + }, + StatementSearchVisitor_visitIfRule_closure2: function StatementSearchVisitor_visitIfRule_closure2(t0) { + this.$this = t0; + }, + StatementSearchVisitor_visitIfRule__closure1: function StatementSearchVisitor_visitIfRule__closure1(t0) { + this.$this = t0; + }, + StatementSearchVisitor_visitChildren_closure0: function StatementSearchVisitor_visitChildren_closure0(t0) { + this.$this = t0; + }, + StaticImport0: function StaticImport0(t0, t1, t2) { + this.url = t0; + this.modifiers = t1; + this.span = t2; + }, + StderrLogger0: function StderrLogger0(t0) { + this.color = t0; + }, + StringExpression_quoteText0(text) { + var t1, + quote = A.StringExpression__bestQuote0(A._setArrayType([text], type$.JSArray_String)), + buffer = new A.StringBuffer(""); + buffer._contents = "" + A.Primitives_stringFromCharCode(quote); + A.StringExpression__quoteInnerText0(text, quote, buffer, true); + t1 = A.Primitives_stringFromCharCode(quote); + t1 = buffer._contents += t1; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + StringExpression__quoteInnerText0(text, quote, buffer, $static) { + var t1, t2, i, _1_0, _0_0, t3, t4, t5, t0; + for (t1 = text.length, t2 = t1 - 1, i = 0; i < t1; ++i) { + _1_0 = text.charCodeAt(i); + if (_1_0 === 10 || _1_0 === 13 || _1_0 === 12) { + buffer.writeCharCode$1(92); + buffer.writeCharCode$1(97); + if (i !== t2) { + _0_0 = text.charCodeAt(i + 1); + t3 = true; + if (!(_0_0 === 32 || _0_0 === 9 || _0_0 === 10 || _0_0 === 13 || _0_0 === 12)) + if (!(_0_0 >= 48 && _0_0 <= 57)) + if (!(_0_0 >= 97 && _0_0 <= 102)) + t3 = _0_0 >= 65 && _0_0 <= 70; + if (t3) + buffer.writeCharCode$1(32); + } + continue; + } + t3 = 92 === _1_0; + if (t3) + t4 = _1_0; + else + t4 = null; + if (!t3) { + t3 = false; + t5 = _1_0 === quote; + if (t5) + t4 = _1_0; + if (!t5) + if (35 === _1_0) + if ($static) + if (i < t2) { + t3 = text.charCodeAt(i + 1) === 123; + if (t3) + t4 = _1_0; + t0 = t4; + t4 = t3; + t3 = t0; + } else { + t0 = t4; + t4 = t3; + t3 = t0; + } + else { + t0 = t4; + t4 = t3; + t3 = t0; + } + else { + t0 = t4; + t4 = t3; + t3 = t0; + } + else { + t3 = t4; + t4 = true; + } + } else { + t3 = t4; + t4 = true; + } + if (t4) { + buffer.writeCharCode$1(92); + buffer.writeCharCode$1(t3); + continue; + } + buffer.writeCharCode$1(_1_0); + } + }, + StringExpression__bestQuote0(strings) { + var t1, t2, t3, containsDoubleQuote, t4, t5; + for (t1 = J.get$iterator$ax(strings), t2 = type$.CodeUnits, t3 = t2._eval$1("ListIterator"), t2 = t2._eval$1("ListBase.E"), containsDoubleQuote = false; t1.moveNext$0();) + for (t4 = new A.CodeUnits(t1.get$current(t1)), t4 = new A.ListIterator(t4, t4.get$length(0), t3); t4.moveNext$0();) { + t5 = t4.__internal$_current; + if (t5 == null) + t5 = t2._as(t5); + if (t5 === 39) + return 34; + if (t5 === 34) + containsDoubleQuote = true; + } + return containsDoubleQuote ? 39 : 34; + }, + StringExpression0: function StringExpression0(t0, t1) { + this.text = t0; + this.hasQuotes = t1; + }, + _codepointForIndex0(index, lengthInCodepoints, allowNegative) { + var result; + if (index === 0) + return 0; + if (index > 0) + return Math.min(index - 1, lengthInCodepoints); + result = lengthInCodepoints + index; + if (result < 0 && !allowNegative) + return 0; + return result; + }, + _function7($name, $arguments, callback) { + return A.BuiltInCallable$function0($name, $arguments, callback, "sass:string"); + }, + module_closure25: function module_closure25() { + }, + module__closure3: function module__closure3(t0) { + this.string = t0; + }, + module__closure4: function module__closure4(t0) { + this.string = t0; + }, + _unquote_closure0: function _unquote_closure0() { + }, + _quote_closure0: function _quote_closure0() { + }, + _length_closure1: function _length_closure1() { + }, + _insert_closure0: function _insert_closure0() { + }, + _index_closure1: function _index_closure1() { + }, + _slice_closure0: function _slice_closure0() { + }, + _toUpperCase_closure0: function _toUpperCase_closure0() { + }, + _toLowerCase_closure0: function _toLowerCase_closure0() { + }, + _uniqueId_closure0: function _uniqueId_closure0() { + }, + StringExtension_toCssIdentifier(_this) { + var t1, doubleDash, _2_0, character, _3_0, + _s52_ = "The U+0000 can't be represented as a CSS identifier.", + _s65_ = "An individual surrogate can't be represented as a CSS identifier.", + buffer = new A.StringBuffer(""), + scanner = A.SpanScanner$(_this, null), + writeEscape = new A.StringExtension_toCssIdentifier_writeEscape(buffer, scanner), + consumeSurrogatePair = new A.StringExtension_toCssIdentifier_consumeSurrogatePair(scanner, writeEscape, buffer); + if (scanner.scanChar$1(45)) { + if (scanner._string_scanner$_position === scanner.string.length) + return "\\2d"; + t1 = A.Primitives_stringFromCharCode(45); + buffer._contents += t1; + doubleDash = scanner.scanChar$1(45); + if (doubleDash) { + t1 = A.Primitives_stringFromCharCode(45); + buffer._contents += t1; + } + } else + doubleDash = false; + if (!doubleDash) + $label0$0: { + _2_0 = scanner.peekChar$0(); + if (_2_0 == null) + scanner.error$1(0, "The empty string can't be represented as a CSS identifier."); + if (0 === _2_0) + scanner.error$1(0, _s52_); + if (A._isInt(_2_0)) { + t1 = _2_0 >>> 10 === 54; + character = _2_0; + } else { + character = null; + t1 = false; + } + if (t1) { + consumeSurrogatePair.call$1(character); + break $label0$0; + } + if (_2_0 >>> 10 === 55) + scanner.error$2$length(0, _s65_, 1); + if (_2_0 === 95 || A.CharacterExtension_get_isAlphabetic0(_2_0) || _2_0 >= 128) + t1 = !(_2_0 >= 57344 && _2_0 <= 63743); + else + t1 = false; + if (t1) { + t1 = A.Primitives_stringFromCharCode(scanner.readChar$0()); + buffer._contents += t1; + break $label0$0; + } + writeEscape.call$1(scanner.readChar$0()); + } + for (; true;) { + _3_0 = scanner.peekChar$0(); + if (_3_0 == null) + break; + if (0 === _3_0) + scanner.error$1(0, _s52_); + t1 = _3_0 >>> 10 === 54; + if (t1) { + consumeSurrogatePair.call$1(_3_0); + continue; + } + if (_3_0 >>> 10 === 55) + scanner.error$2$length(0, _s65_, 1); + if (_3_0 !== 95) { + if (!(_3_0 >= 97 && _3_0 <= 122)) + t1 = _3_0 >= 65 && _3_0 <= 90; + else + t1 = true; + t1 = t1 || _3_0 >= 128; + } else + t1 = true; + if (!t1) + t1 = _3_0 >= 48 && _3_0 <= 57 || _3_0 === 45; + else + t1 = true; + if (t1) + t1 = !(_3_0 >= 57344 && _3_0 <= 63743); + else + t1 = false; + if (t1) { + t1 = A.Primitives_stringFromCharCode(scanner.readChar$0()); + buffer._contents += t1; + continue; + } + writeEscape.call$1(scanner.readChar$0()); + } + t1 = buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + StringExtension_toCssIdentifier_writeEscape: function StringExtension_toCssIdentifier_writeEscape(t0, t1) { + this.buffer = t0; + this.scanner = t1; + }, + StringExtension_toCssIdentifier_consumeSurrogatePair: function StringExtension_toCssIdentifier_consumeSurrogatePair(t0, t1, t2) { + this.scanner = t0; + this.writeEscape = t1; + this.buffer = t2; + }, + stringClass_closure: function stringClass_closure() { + }, + stringClass__closure: function stringClass__closure() { + }, + stringClass__closure0: function stringClass__closure0() { + }, + stringClass__closure1: function stringClass__closure1() { + }, + stringClass__closure2: function stringClass__closure2() { + }, + stringClass__closure3: function stringClass__closure3() { + }, + _ConstructorOptions1: function _ConstructorOptions1() { + }, + _NodeSassString: function _NodeSassString() { + }, + legacyStringClass_closure: function legacyStringClass_closure() { + }, + legacyStringClass_closure0: function legacyStringClass_closure0() { + }, + legacyStringClass_closure1: function legacyStringClass_closure1() { + }, + SassString$0(_text, quotes) { + return new A.SassString0(_text, quotes); + }, + SassString0: function SassString0(t0, t1) { + var _ = this; + _._string0$_text = t0; + _._string0$_hasQuotes = t1; + _._string0$__SassString__sassLength_FI = $; + _._string0$_hashCache = null; + }, + ModifiableCssStyleRule$0(_selector, span, fromPlainCss, originalSelector) { + var t1 = A._setArrayType([], type$.JSArray_ModifiableCssNode_2); + return new A.ModifiableCssStyleRule0(_selector, originalSelector, span, fromPlainCss, new A.UnmodifiableListView(t1, type$.UnmodifiableListView_ModifiableCssNode_2), t1); + }, + ModifiableCssStyleRule0: function ModifiableCssStyleRule0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._style_rule0$_selector = t0; + _.originalSelector = t1; + _.span = t2; + _.fromPlainCss = t3; + _.children = t4; + _._node$_children = t5; + _._node$_indexInParent = _._node$_parent = null; + _.isGroupEnd = false; + }, + StyleRule$0(selector, children, span) { + var t1 = A.List_List$unmodifiable(children, type$.Statement_2), + t2 = B.JSArray_methods.any$1(t1, new A.ParentStatement_closure0()); + return new A.StyleRule0(selector, span, t1, t2); + }, + StyleRule0: function StyleRule0(t0, t1, t2, t3) { + var _ = this; + _.selector = t0; + _.span = t1; + _.children = t2; + _.hasDeclarations = t3; + }, + CssStylesheet0: function CssStylesheet0(t0, t1) { + this.children = t0; + this.span = t1; + }, + ModifiableCssStylesheet$0(span) { + var t1 = A._setArrayType([], type$.JSArray_ModifiableCssNode_2); + return new A.ModifiableCssStylesheet0(span, new A.UnmodifiableListView(t1, type$.UnmodifiableListView_ModifiableCssNode_2), t1); + }, + ModifiableCssStylesheet0: function ModifiableCssStylesheet0(t0, t1, t2) { + var _ = this; + _.span = t0; + _.children = t1; + _._node$_children = t2; + _._node$_indexInParent = _._node$_parent = null; + _.isGroupEnd = false; + }, + StylesheetParser0: function StylesheetParser0() { + }, + StylesheetParser_parse_closure0: function StylesheetParser_parse_closure0(t0) { + this.$this = t0; + }, + StylesheetParser_parse__closure0: function StylesheetParser_parse__closure0(t0) { + this.$this = t0; + }, + StylesheetParser_parseParameterList_closure0: function StylesheetParser_parseParameterList_closure0(t0) { + this.$this = t0; + }, + StylesheetParser__parseSingleProduction_closure0: function StylesheetParser__parseSingleProduction_closure0(t0, t1, t2) { + this.$this = t0; + this.production = t1; + this.T = t2; + }, + StylesheetParser_parseSignature_closure: function StylesheetParser_parseSignature_closure(t0, t1) { + this.$this = t0; + this.requireParens = t1; + }, + StylesheetParser__statement_closure0: function StylesheetParser__statement_closure0(t0) { + this.$this = t0; + }, + StylesheetParser_variableDeclarationWithoutNamespace_closure1: function StylesheetParser_variableDeclarationWithoutNamespace_closure1(t0, t1) { + this.$this = t0; + this.start = t1; + }, + StylesheetParser_variableDeclarationWithoutNamespace_closure2: function StylesheetParser_variableDeclarationWithoutNamespace_closure2(t0) { + this.declaration = t0; + }, + StylesheetParser__declarationOrBuffer_closure2: function StylesheetParser__declarationOrBuffer_closure2(t0) { + this.$this = t0; + }, + StylesheetParser__declarationOrBuffer_closure3: function StylesheetParser__declarationOrBuffer_closure3(t0) { + this.$this = t0; + }, + StylesheetParser__declarationOrBuffer_closure4: function StylesheetParser__declarationOrBuffer_closure4(t0) { + this.$this = t0; + }, + StylesheetParser__styleRule_closure0: function StylesheetParser__styleRule_closure0(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.wasInStyleRule = t2; + _.start = t3; + }, + StylesheetParser__propertyOrVariableDeclaration_closure0: function StylesheetParser__propertyOrVariableDeclaration_closure0(t0) { + this.$this = t0; + }, + StylesheetParser__tryDeclarationChildren_closure0: function StylesheetParser__tryDeclarationChildren_closure0(t0, t1) { + this.name = t0; + this.value = t1; + }, + StylesheetParser__atRootRule_closure1: function StylesheetParser__atRootRule_closure1(t0) { + this.query = t0; + }, + StylesheetParser__atRootRule_closure2: function StylesheetParser__atRootRule_closure2() { + }, + StylesheetParser__eachRule_closure0: function StylesheetParser__eachRule_closure0(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.wasInControlDirective = t1; + _.variables = t2; + _.list = t3; + }, + StylesheetParser__functionRule_closure0: function StylesheetParser__functionRule_closure0(t0, t1, t2) { + this.name = t0; + this.parameters = t1; + this.precedingComment = t2; + }, + StylesheetParser__forRule_closure1: function StylesheetParser__forRule_closure1(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + StylesheetParser__forRule_closure2: function StylesheetParser__forRule_closure2(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.wasInControlDirective = t2; + _.variable = t3; + _.from = t4; + _.to = t5; + }, + StylesheetParser__memberList_closure0: function StylesheetParser__memberList_closure0(t0, t1, t2) { + this.$this = t0; + this.variables = t1; + this.identifiers = t2; + }, + StylesheetParser__includeRule_closure0: function StylesheetParser__includeRule_closure0(t0) { + this.contentParameters_ = t0; + }, + StylesheetParser_mediaRule_closure0: function StylesheetParser_mediaRule_closure0(t0) { + this.query = t0; + }, + StylesheetParser__mixinRule_closure0: function StylesheetParser__mixinRule_closure0(t0, t1, t2, t3) { + var _ = this; + _.$this = t0; + _.name = t1; + _.parameters = t2; + _.precedingComment = t3; + }, + StylesheetParser_mozDocumentRule_closure1: function StylesheetParser_mozDocumentRule_closure1(t0) { + this.$this = t0; + }, + StylesheetParser_mozDocumentRule_closure2: function StylesheetParser_mozDocumentRule_closure2(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.name = t2; + _.value = t3; + }, + StylesheetParser_supportsRule_closure0: function StylesheetParser_supportsRule_closure0(t0) { + this.condition = t0; + }, + StylesheetParser__whileRule_closure0: function StylesheetParser__whileRule_closure0(t0, t1, t2) { + this.$this = t0; + this.wasInControlDirective = t1; + this.condition = t2; + }, + StylesheetParser_unknownAtRule_closure0: function StylesheetParser_unknownAtRule_closure0(t0, t1) { + this._box_0 = t0; + this.name = t1; + }, + StylesheetParser__expression_resetState0: function StylesheetParser__expression_resetState0(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.start = t2; + }, + StylesheetParser__expression_resolveOneOperation0: function StylesheetParser__expression_resolveOneOperation0(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + StylesheetParser__expression_resolveOperations0: function StylesheetParser__expression_resolveOperations0(t0, t1) { + this._box_0 = t0; + this.resolveOneOperation = t1; + }, + StylesheetParser__expression_addSingleExpression0: function StylesheetParser__expression_addSingleExpression0(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.resetState = t2; + _.resolveOperations = t3; + }, + StylesheetParser__expression_addOperator0: function StylesheetParser__expression_addOperator0(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.$this = t1; + _.resolveOneOperation = t2; + _.addSingleExpression = t3; + }, + StylesheetParser__expression_resolveSpaceExpressions0: function StylesheetParser__expression_resolveSpaceExpressions0(t0, t1, t2) { + this._box_0 = t0; + this.$this = t1; + this.resolveOperations = t2; + }, + StylesheetParser_expressionUntilComma_closure0: function StylesheetParser_expressionUntilComma_closure0(t0) { + this.$this = t0; + }, + StylesheetParser__isHexColor_closure0: function StylesheetParser__isHexColor_closure0() { + }, + StylesheetParser__unicodeRange_closure1: function StylesheetParser__unicodeRange_closure1() { + }, + StylesheetParser__unicodeRange_closure2: function StylesheetParser__unicodeRange_closure2() { + }, + StylesheetParser_namespacedExpression_closure0: function StylesheetParser_namespacedExpression_closure0(t0, t1) { + this.$this = t0; + this.start = t1; + }, + StylesheetParser_trySpecialFunction_closure0: function StylesheetParser_trySpecialFunction_closure0() { + }, + StylesheetParser__expressionUntilComparison_closure0: function StylesheetParser__expressionUntilComparison_closure0(t0) { + this.$this = t0; + }, + StylesheetParser__publicIdentifier_closure0: function StylesheetParser__publicIdentifier_closure0(t0, t1) { + this.$this = t0; + this.start = t1; + }, + Stylesheet$internal0(children, span, parseTimeWarnings, globalVariables, plainCss) { + var t1 = A._setArrayType([], type$.JSArray_UseRule_2), + t2 = A._setArrayType([], type$.JSArray_ForwardRule_2), + t3 = A.ConstantMap_ConstantMap$from(globalVariables, type$.String, type$.FileSpan), + t4 = A.List_List$unmodifiable(children, type$.Statement_2), + t5 = B.JSArray_methods.any$1(t4, new A.ParentStatement_closure0()); + t1 = new A.Stylesheet0(span, plainCss, t1, t2, new A.UnmodifiableListView(parseTimeWarnings, type$.UnmodifiableListView_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span_2), t3, t4, t5); + t1.Stylesheet$internal$5$globalVariables$plainCss0(children, span, parseTimeWarnings, globalVariables, plainCss); + return t1; + }, + Stylesheet_Stylesheet$parse0(contents, syntax, url) { + var error, stackTrace, url0, t1, exception, t2; + try { + switch (syntax) { + case B.Syntax_Sass_sass0: + t1 = new A.SassParser0(A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.FileSpan), A._setArrayType([], type$.JSArray_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span_2), A.SpanScanner$(contents, url), null).parse$0(0); + return t1; + case B.Syntax_SCSS_scss0: + t1 = A.ScssParser$0(contents, url).parse$0(0); + return t1; + case B.Syntax_CSS_css0: + t1 = new A.CssParser0(A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.FileSpan), A._setArrayType([], type$.JSArray_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span_2), A.SpanScanner$(contents, url), null).parse$0(0); + return t1; + } + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException0) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = error; + t2 = J.getInterceptor$z(t1); + t1 = A.SourceSpanException.prototype.get$span.call(t2, t1); + url0 = t1.get$sourceUrl(t1); + if (url0 == null || J.toString$0$(url0) === "stdin") + throw exception; + t1 = type$.Uri; + throw A.wrapException(A.throwWithTrace0(error.withLoadedUrls$1(A.Set_Set$unmodifiable(A.LinkedHashSet_LinkedHashSet$_literal([url0], t1), t1)), error, stackTrace)); + } else + throw exception; + } + }, + Stylesheet0: function Stylesheet0(t0, t1, t2, t3, t4, t5, t6, t7) { + var _ = this; + _.span = t0; + _.plainCss = t1; + _._stylesheet1$_uses = t2; + _._stylesheet1$_forwards = t3; + _.parseTimeWarnings = t4; + _.globalVariables = t5; + _.children = t6; + _.hasDeclarations = t7; + }, + SupportsExpression0: function SupportsExpression0(t0) { + this.condition = t0; + }, + ModifiableCssSupportsRule$0(condition, span) { + var t1 = A._setArrayType([], type$.JSArray_ModifiableCssNode_2); + return new A.ModifiableCssSupportsRule0(condition, span, new A.UnmodifiableListView(t1, type$.UnmodifiableListView_ModifiableCssNode_2), t1); + }, + ModifiableCssSupportsRule0: function ModifiableCssSupportsRule0(t0, t1, t2, t3) { + var _ = this; + _.condition = t0; + _.span = t1; + _.children = t2; + _._node$_children = t3; + _._node$_indexInParent = _._node$_parent = null; + _.isGroupEnd = false; + }, + SupportsRule$0(condition, children, span) { + var t1 = A.List_List$unmodifiable(children, type$.Statement_2), + t2 = B.JSArray_methods.any$1(t1, new A.ParentStatement_closure0()); + return new A.SupportsRule0(condition, span, t1, t2); + }, + SupportsRule0: function SupportsRule0(t0, t1, t2, t3) { + var _ = this; + _.condition = t0; + _.span = t1; + _.children = t2; + _.hasDeclarations = t3; + }, + JSToDartImporter: function JSToDartImporter(t0, t1, t2) { + this._sync$_canonicalize = t0; + this._sync$_load = t1; + this._sync$_nonCanonicalSchemes = t2; + }, + JSToDartImporter_canonicalize_closure: function JSToDartImporter_canonicalize_closure(t0, t1) { + this.$this = t0; + this.url = t1; + }, + JSToDartImporter_load_closure: function JSToDartImporter_load_closure(t0, t1) { + this.$this = t0; + this.url = t1; + }, + Syntax_forPath0(path) { + var t1, + _0_0 = A.ParsedPath_ParsedPath$parse(path, $.$get$context().style)._splitExtension$1(1)[1]; + $label0$0: { + if (".sass" === _0_0) { + t1 = B.Syntax_Sass_sass0; + break $label0$0; + } + if (".css" === _0_0) { + t1 = B.Syntax_CSS_css0; + break $label0$0; + } + t1 = B.Syntax_SCSS_scss0; + break $label0$0; + } + return t1; + }, + Syntax0: function Syntax0(t0, t1) { + this._syntax0$_name = t0; + this._name = t1; + }, + TypeSelector0: function TypeSelector0(t0, t1) { + this.name = t0; + this.span = t1; + }, + Types: function Types() { + }, + UnaryOperationExpression0: function UnaryOperationExpression0(t0, t1, t2) { + this.operator = t0; + this.operand = t1; + this.span = t2; + }, + UnaryOperator0: function UnaryOperator0(t0, t1, t2) { + this.name = t0; + this.operator = t1; + this._name = t2; + }, + UnitlessSassNumber0: function UnitlessSassNumber0(t0, t1) { + this._number1$_value = t0; + this.hashCache = null; + this.asSlash = t1; + }, + UniversalSelector0: function UniversalSelector0(t0, t1) { + this.namespace = t0; + this.span = t1; + }, + UnprefixedMapView0: function UnprefixedMapView0(t0, t1, t2) { + this._unprefixed_map_view0$_map = t0; + this._unprefixed_map_view0$_prefix = t1; + this.$ti = t2; + }, + _UnprefixedKeys0: function _UnprefixedKeys0(t0) { + this._unprefixed_map_view0$_view = t0; + }, + _UnprefixedKeys_iterator_closure1: function _UnprefixedKeys_iterator_closure1(t0) { + this.$this = t0; + }, + _UnprefixedKeys_iterator_closure2: function _UnprefixedKeys_iterator_closure2(t0) { + this.$this = t0; + }, + JSUrl0: function JSUrl0() { + }, + UseRule0: function UseRule0(t0, t1, t2, t3) { + var _ = this; + _.url = t0; + _.namespace = t1; + _.configuration = t2; + _.span = t3; + }, + UserDefinedCallable0: function UserDefinedCallable0(t0, t1, t2, t3) { + var _ = this; + _.declaration = t0; + _.environment = t1; + _.inDependency = t2; + _.$ti = t3; + }, + fromImport0() { + var t1 = type$.nullable_CanonicalizeContext_2._as($.Zone__current.$index(0, B.Symbol__canonicalizeContext)); + t1 = t1 == null ? null : t1._canonicalize_context$_fromImport; + return t1 === true; + }, + canonicalizeContext0() { + var t1, + _0_0 = $.Zone__current.$index(0, B.Symbol__canonicalizeContext); + $label0$0: { + if (_0_0 == null) + A.throwExpression(A.StateError$(string$.canoni)); + if (_0_0 instanceof A.CanonicalizeContext0) { + t1 = _0_0; + break $label0$0; + } + t1 = A.throwExpression(A.StateError$(string$.Unexpe + A.S(_0_0) + ".")); + } + return t1; + }, + inImportRule(callback, $T) { + var t1, + _0_0 = $.Zone__current.$index(0, B.Symbol__canonicalizeContext); + $label0$0: { + if (_0_0 == null) { + t1 = type$.nullable_Object; + t1 = A.runZoned(callback, A.LinkedHashMap_LinkedHashMap$_literal([B.Symbol__canonicalizeContext, new A.CanonicalizeContext0(true, null)], t1, t1), $T); + break $label0$0; + } + if (_0_0 instanceof A.CanonicalizeContext0) { + t1 = _0_0.withFromImport$2(true, callback); + break $label0$0; + } + t1 = A.throwExpression(A.StateError$(string$.Unexpe + A.S(_0_0) + ".")); + } + return t1; + }, + resolveImportPath0(path) { + var t1, + extension = A.ParsedPath_ParsedPath$parse(path, $.$get$context().style)._splitExtension$1(1)[1]; + if (extension === ".sass" || extension === ".scss" || extension === ".css") { + t1 = A.fromImport0() ? new A.resolveImportPath_closure1(path, extension).call$0() : null; + return t1 == null ? A._exactlyOne0(A._tryPath0(path)) : t1; + } + t1 = A.fromImport0() ? new A.resolveImportPath_closure2(path).call$0() : null; + if (t1 == null) + t1 = A._exactlyOne0(A._tryPathWithExtensions0(path)); + return t1 == null ? A._tryPathAsDirectory0(path) : t1; + }, + _tryPathWithExtensions0(path) { + var result = A._tryPath0(path + ".sass"); + B.JSArray_methods.addAll$1(result, A._tryPath0(path + ".scss")); + return result.length !== 0 ? result : A._tryPath0(path + ".css"); + }, + _tryPath0(path) { + var t1 = $.$get$context(), + partial = A.join(t1.dirname$1(path), "_" + A.ParsedPath_ParsedPath$parse(path, t1.style).get$basename(), null); + t1 = A._setArrayType([], type$.JSArray_String); + if (A.fileExists0(partial)) + t1.push(partial); + if (A.fileExists0(path)) + t1.push(path); + return t1; + }, + _tryPathAsDirectory0(path) { + var t1; + if (!A.dirExists0(path)) + return null; + t1 = A.fromImport0() ? new A._tryPathAsDirectory_closure0(path).call$0() : null; + return t1 == null ? A._exactlyOne0(A._tryPathWithExtensions0(A.join(path, "index", null))) : t1; + }, + _exactlyOne0(paths) { + var _0_1, t1, path; + $label0$0: { + _0_1 = paths.length; + if (_0_1 <= 0) { + t1 = null; + break $label0$0; + } + if (_0_1 === 1) { + path = paths[0]; + t1 = path; + break $label0$0; + } + t1 = A.throwExpression(string$.It_s_n + B.JSArray_methods.map$1$1(paths, new A._exactlyOne_closure0(), type$.String).join$1(0, "\n")); + } + return t1; + }, + resolveImportPath_closure1: function resolveImportPath_closure1(t0, t1) { + this.path = t0; + this.extension = t1; + }, + resolveImportPath_closure2: function resolveImportPath_closure2(t0) { + this.path = t0; + }, + _tryPathAsDirectory_closure0: function _tryPathAsDirectory_closure0(t0) { + this.path = t0; + }, + _exactlyOne_closure0: function _exactlyOne_closure0() { + }, + jsThrow(error) { + return type$.Never._as($.$get$_jsThrow().call$1(error)); + }, + attachJsStack(error, trace) { + var traceString = trace.toString$0(0), + firstRealLine = B.JSString_methods.indexOf$1(traceString, "\n at"); + if (firstRealLine !== -1) + traceString = B.JSString_methods.substring$1(traceString, firstRealLine + 1); + error.stack = "Error: " + A.S(J.get$message$x(error)) + "\n" + traceString; + }, + jsForEach(object, callback) { + var t1, t2; + for (t1 = J.get$iterator$ax(self.Object.keys(object)); t1.moveNext$0();) { + t2 = t1.get$current(t1); + callback.call$2(t2, object[t2]); + } + }, + jsType(value) { + var typeOf = A._asString(new self.Function("value", "return typeof value").call$1(value)); + return typeOf !== "object" ? typeOf : A._asString(new self.Function("value", ' if (value && value.constructor && value.constructor.name) {\n return value.constructor.name;\n }\n return "object";\n ').call$1(value)); + }, + defineGetter(object, $name, get, value) { + self.Object.defineProperty(object, $name, get == null ? {value: value, enumerable: false} : {get: A.allowInteropCaptureThis(get), enumerable: false}); + }, + allowInteropNamed($name, $function) { + $function = A.allowInterop($function); + A.defineGetter($function, "name", null, $name); + A._hideDartProperties($function); + return $function; + }, + allowInteropCaptureThisNamed($name, $function) { + $function = A.allowInteropCaptureThis($function); + A.defineGetter($function, "name", null, $name); + A._hideDartProperties($function); + return $function; + }, + _hideDartProperties(object) { + var t1, t2, t3, t4; + for (t1 = J.cast$1$0$ax(self.Object.getOwnPropertyNames(object), type$.String), t2 = A._instanceType(t1), t1 = new A.ListIterator(t1, t1.get$length(t1), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t3 = t1.__internal$_current; + if (t3 == null) + t3 = t2._as(t3); + if (B.JSString_methods.startsWith$1(t3, "_")) { + t4 = {value: object[t3], enumerable: false}; + self.Object.defineProperty(object, t3, t4); + } + } + }, + futureToPromise0(future) { + return new self.Promise(A.allowInterop(new A.futureToPromise_closure0(future))); + }, + jsToDartUrl(url) { + return A.Uri_parse(J.toString$0$(url)); + }, + dartToJSUrl(url) { + return new self.URL(url.toString$0(0)); + }, + toJSArray(iterable) { + var t1, t2, + array = new self.Array(); + for (t1 = J.get$iterator$ax(iterable), t2 = J.getInterceptor$x(array); t1.moveNext$0();) + t2.push$1(array, t1.get$current(t1)); + return array; + }, + objectToMap(object) { + var map = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.nullable_Object); + A.jsForEach(object, new A.objectToMap_closure(map)); + return map; + }, + mapToObject(map) { + var t1, t2, + result = new self.Object(); + for (t1 = A.MapExtensions_get_pairs0(map, type$.String, type$.nullable_Object), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t2 = t1.get$current(t1); + result[t2._0] = t2._1; + } + return result; + }, + jsToDartSeparator(separator) { + var t1; + $label0$0: { + if (" " === separator) { + t1 = B.ListSeparator_qSL0; + break $label0$0; + } + if ("," === separator) { + t1 = B.ListSeparator_qVN0; + break $label0$0; + } + if ("/" === separator) { + t1 = B.ListSeparator_bRz0; + break $label0$0; + } + if (separator == null) { + t1 = B.ListSeparator_undecided_null_undecided0; + break $label0$0; + } + t1 = A.jsThrow(new self.Error('Unknown separator "' + separator + '".')); + } + return t1; + }, + parseSyntax(syntax) { + var t1; + $label0$0: { + if (syntax == null || "scss" === syntax) { + t1 = B.Syntax_SCSS_scss0; + break $label0$0; + } + if ("indented" === syntax) { + t1 = B.Syntax_Sass_sass0; + break $label0$0; + } + if ("css" === syntax) { + t1 = B.Syntax_CSS_css0; + break $label0$0; + } + t1 = A.jsThrow(new self.Error('Unknown syntax "' + A.S(syntax) + '".')); + } + return t1; + }, + entrypointFilename() { + var _1_0, _1_5_isSet, _1_5, t2, path, + t1 = self.require.main, + _0_0 = t1 == null ? null : J.get$filename$x(t1); + if (_0_0 != null) + return _0_0; + else { + _1_0 = J.get$argv$x(self.process); + t1 = J.getInterceptor$asx(_1_0); + _1_5_isSet = t1.get$length(_1_0) >= 2; + if (_1_5_isSet) { + _1_5 = t1.$index(_1_0, 1); + t2 = typeof _1_5 == "string"; + } else { + _1_5 = null; + t2 = false; + } + if (t2) { + path = A._asString(_1_5_isSet ? _1_5 : t1.$index(_1_0, 1)); + return J.resolve$1$x(J.createRequire$1$x(self.nodeModule, path), path); + } else + return null; + } + }, + _PropertyDescriptor0: function _PropertyDescriptor0() { + }, + futureToPromise_closure0: function futureToPromise_closure0(t0) { + this.future = t0; + }, + futureToPromise__closure0: function futureToPromise__closure0(t0) { + this.resolve = t0; + }, + futureToPromise__closure1: function futureToPromise__closure1(t0) { + this.reject = t0; + }, + objectToMap_closure: function objectToMap_closure(t0) { + this.map = t0; + }, + _RequireMain0: function _RequireMain0() { + }, + toSentence0(iter, conjunction) { + if (iter.get$length(iter) === 1) + return J.toString$0$(iter.get$first(iter)); + return A.IterableExtension_get_exceptLast0(iter).join$1(0, ", ") + (" " + conjunction + " " + A.S(iter.get$last(iter))); + }, + indent0(string, indentation) { + return new A.MappedListIterable(A._setArrayType(string.split("\n"), type$.JSArray_String), new A.indent_closure0(indentation), type$.MappedListIterable_String_String).join$1(0, "\n"); + }, + pluralize0($name, number, plural) { + if (number === 1) + return $name; + if (plural != null) + return plural; + return $name + "s"; + }, + trimAscii0(string, excludeEscape) { + var t1, + start = A._firstNonWhitespace0(string); + if (start == null) + t1 = ""; + else { + t1 = A._lastNonWhitespace0(string, true); + t1.toString; + t1 = B.JSString_methods.substring$2(string, start, t1 + 1); + } + return t1; + }, + trimAsciiRight0(string, excludeEscape) { + var end = A._lastNonWhitespace0(string, excludeEscape); + return end == null ? "" : B.JSString_methods.substring$2(string, 0, end + 1); + }, + _firstNonWhitespace0(string) { + var t1, i, t2; + for (t1 = string.length, i = 0; i < t1; ++i) { + t2 = string.charCodeAt(i); + if (!(t2 === 32 || t2 === 9 || t2 === 10 || t2 === 13 || t2 === 12)) + return i; + } + return null; + }, + _lastNonWhitespace0(string, excludeEscape) { + var i, i0, codeUnit; + for (i = string.length - 1, i0 = i; i0 >= 0; --i0) { + codeUnit = string.charCodeAt(i0); + if (!(codeUnit === 32 || codeUnit === 9 || codeUnit === 10 || codeUnit === 13 || codeUnit === 12)) + if (excludeEscape && i0 !== 0 && i0 !== i && codeUnit === 92) + return i0 + 1; + else + return i0; + } + return null; + }, + isPublic0(member) { + var start = member.charCodeAt(0); + return start !== 45 && start !== 95; + }, + flattenVertically0(iterable, $T) { + var result, flags, + t1 = iterable.$ti._eval$1("@")._bind$1($T._eval$1("QueueList<0>"))._eval$1("MappedListIterable<1,2>"), + queues = A.List_List$of(new A.MappedListIterable(iterable, new A.flattenVertically_closure1($T), t1), true, t1._eval$1("ListIterable.E")); + if (queues.length === 1) + return B.JSArray_methods.get$first(queues); + result = A._setArrayType([], $T._eval$1("JSArray<0>")); + for (flags = queues.$flags | 0; queues.length !== 0;) { + flags & 1 && A.throwUnsupportedOperation(queues, 16); + B.JSArray_methods._removeWhere$2(queues, new A.flattenVertically_closure2(result, $T), true); + } + return result; + }, + codepointIndexToCodeUnitIndex0(string, codepointIndex) { + var codeUnitIndex, i, codeUnitIndex0; + for (codeUnitIndex = 0, i = 0; i < codepointIndex; ++i) { + codeUnitIndex0 = codeUnitIndex + 1; + codeUnitIndex = string.charCodeAt(codeUnitIndex) >>> 10 === 54 ? codeUnitIndex0 + 1 : codeUnitIndex0; + } + return codeUnitIndex; + }, + codeUnitIndexToCodepointIndex0(string, codeUnitIndex) { + var codepointIndex, i; + for (codepointIndex = 0, i = 0; i < codeUnitIndex; i = (string.charCodeAt(i) >>> 10 === 54 ? i + 1 : i) + 1) + ++codepointIndex; + return codepointIndex; + }, + frameForSpan0(span, member, url) { + var t2, t3, + t1 = url == null ? span.get$sourceUrl(span) : url; + if (t1 == null) + t1 = $.$get$_noSourceUrl0(); + t2 = span.get$start(span); + t2 = t2.file.getLine$1(t2.offset); + t3 = span.get$start(span); + return new A.Frame(t1, t2 + 1, t3.file.getColumn$1(t3.offset) + 1, member); + }, + declarationName0(span) { + var text = span.get$text(); + return A.trimAsciiRight0(B.JSString_methods.substring$2(text, 0, B.JSString_methods.indexOf$1(text, ":")), false); + }, + unvendor0($name) { + var i, + t1 = $name.length; + if (t1 < 2) + return $name; + if ($name.charCodeAt(0) !== 45) + return $name; + if ($name.charCodeAt(1) === 45) + return $name; + for (i = 2; i < t1; ++i) + if ($name.charCodeAt(i) === 45) + return B.JSString_methods.substring$1($name, i + 1); + return $name; + }, + equalsIgnoreCase0(string1, string2) { + var t1, i; + if (string1 === string2) + return true; + if (string1 == null) + return false; + t1 = string1.length; + if (t1 !== string2.length) + return false; + for (i = 0; i < t1; ++i) + if (!A.characterEqualsIgnoreCase0(string1.charCodeAt(i), string2.charCodeAt(i))) + return false; + return true; + }, + startsWithIgnoreCase0(string, prefix) { + var i, + t1 = prefix.length; + if (string.length < t1) + return false; + for (i = 0; i < t1; ++i) + if (!A.characterEqualsIgnoreCase0(string.charCodeAt(i), prefix.charCodeAt(i))) + return false; + return true; + }, + mapInPlace0(list, $function) { + var i; + for (i = 0; i < list.length; ++i) + list[i] = $function.call$1(list[i]); + }, + longestCommonSubsequence0(list1, list2, select, $T) { + var t1, _i, selections, i, i0, j, selection, j0, + _length = list1.get$length(0) + 1, + lengths = J.JSArray_JSArray$allocateFixed(_length, type$.List_int); + for (t1 = type$.int, _i = 0; _i < _length; ++_i) + lengths[_i] = A.List_List$filled(((list2._queue_list$_tail - list2._queue_list$_head & J.get$length$asx(list2._queue_list$_table) - 1) >>> 0) + 1, 0, false, t1); + _length = list1.get$length(0); + selections = J.JSArray_JSArray$allocateFixed(_length, $T._eval$1("List<0?>")); + for (t1 = $T._eval$1("0?"), _i = 0; _i < _length; ++_i) + selections[_i] = A.List_List$filled((list2._queue_list$_tail - list2._queue_list$_head & J.get$length$asx(list2._queue_list$_table) - 1) >>> 0, null, false, t1); + for (i = 0; i < (list1._queue_list$_tail - list1._queue_list$_head & J.get$length$asx(list1._queue_list$_table) - 1) >>> 0; i = i0) + for (i0 = i + 1, j = 0; j < (list2._queue_list$_tail - list2._queue_list$_head & J.get$length$asx(list2._queue_list$_table) - 1) >>> 0; j = j0) { + selection = select.call$2(list1.$index(0, i), list2.$index(0, j)); + selections[i][j] = selection; + t1 = lengths[i0]; + j0 = j + 1; + t1[j0] = selection == null ? Math.max(t1[j], lengths[i][j0]) : lengths[i][j] + 1; + } + return new A.longestCommonSubsequence_backtrack0(selections, lengths, $T).call$2(list1.get$length(0) - 1, list2.get$length(0) - 1); + }, + removeFirstWhere0(list, test, orElse) { + var i; + for (i = 0; i < list.length; ++i) { + if (!test.call$1(list[i])) + continue; + B.JSArray_methods.removeAt$1(list, i); + return; + } + orElse.call$0(); + }, + mapAddAll20(destination, source, K1, K2, $V) { + source.forEach$1(0, new A.mapAddAll2_closure0(destination, K1, K2, $V)); + }, + setAll0(map, keys, value) { + var t1; + for (t1 = J.get$iterator$ax(keys); t1.moveNext$0();) + map.$indexSet(0, t1.get$current(t1), value); + }, + rotateSlice0(list, start, end) { + var i, next, + element = list.$index(0, end - 1); + for (i = start; i < end; ++i, element = next) { + next = list.$index(0, i); + list.$indexSet(0, i, element); + } + }, + mapAsync0(iterable, callback, $E, $F) { + return A.mapAsync$body0(iterable, callback, $E, $F, $F._eval$1("Iterable<0>")); + }, + mapAsync$body0(iterable, callback, $E, $F, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, t2, _i, t1, $async$temp1; + var $async$mapAsync0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = A._setArrayType([], $F._eval$1("JSArray<0>")); + t2 = iterable.length, _i = 0; + case 3: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 5; + break; + } + $async$temp1 = t1; + $async$goto = 6; + return A._asyncAwait(callback.call$1(iterable[_i]), $async$mapAsync0); + case 6: + // returning from await. + $async$temp1.push($async$result); + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$mapAsync0, $async$completer); + }, + putIfAbsentAsync0(map, key, ifAbsent, $K, $V) { + return A.putIfAbsentAsync$body0(map, key, ifAbsent, $K, $V, $V); + }, + putIfAbsentAsync$body0(map, key, ifAbsent, $K, $V, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, t1, value; + var $async$putIfAbsentAsync0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if (map.containsKey$1(key)) { + t1 = map.$index(0, key); + $async$returnValue = t1 == null ? $V._as(t1) : t1; + // goto return + $async$goto = 1; + break; + } + $async$goto = 3; + return A._asyncAwait(ifAbsent.call$0(), $async$putIfAbsentAsync0); + case 3: + // returning from await. + value = $async$result; + map.$indexSet(0, key, value); + $async$returnValue = value; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$putIfAbsentAsync0, $async$completer); + }, + copyMapOfMap0(map, K1, K2, $V) { + var t3, key, child, + t1 = K2._eval$1("@<0>")._bind$1($V)._eval$1("Map<1,2>"), + t2 = A.LinkedHashMap_LinkedHashMap$_empty(K1, t1); + for (t1 = A.MapExtensions_get_pairs0(map, K1, t1), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t3 = t1.get$current(t1); + key = t3._0; + child = t3._1; + t3 = A.LinkedHashMap_LinkedHashMap(null, null, null, K2, $V); + t3.addAll$1(0, child); + t2.$indexSet(0, key, t3); + } + return t2; + }, + copyMapOfList0(map, $K, $E) { + var t3, + t1 = $E._eval$1("List<0>"), + t2 = A.LinkedHashMap_LinkedHashMap$_empty($K, t1); + for (t1 = A.MapExtensions_get_pairs0(map, $K, t1), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t3 = t1.get$current(t1); + t2.$indexSet(0, t3._0, J.toList$0$ax(t3._1)); + } + return t2; + }, + consumeEscapedCharacter0(scanner) { + var _1_0, value, i, next, t1; + scanner.expectChar$1(92); + _1_0 = scanner.peekChar$0(); + if (_1_0 == null) + return 65533; + if (_1_0 === 10 || _1_0 === 13 || _1_0 === 12) + scanner.error$1(0, "Expected escape sequence."); + if (A.CharacterExtension_get_isHex0(_1_0)) { + for (value = 0, i = 0; i < 6; ++i) { + next = scanner.peekChar$0(); + if (next != null) { + t1 = true; + if (!(next >= 48 && next <= 57)) + if (!(next >= 97 && next <= 102)) + t1 = next >= 65 && next <= 70; + t1 = !t1; + } else + t1 = true; + if (t1) + break; + value = (value << 4 >>> 0) + A.asHex0(scanner.readChar$0()); + } + t1 = scanner.peekChar$0(); + if (t1 === 32 || t1 === 9 || t1 === 10 || t1 === 13 || t1 === 12) + scanner.readChar$0(); + $label0$1: { + if (0 !== value) + t1 = value >= 55296 && value <= 57343 || value >= 1114111; + else + t1 = true; + if (t1) { + t1 = 65533; + break $label0$1; + } + t1 = value; + break $label0$1; + } + return t1; + } + return scanner.readChar$0(); + }, + throwWithTrace0(error, originalError, trace) { + var t1 = A.getTrace0(originalError); + A.attachTrace0(error, t1 == null ? trace : t1); + throw A.wrapException(error); + }, + attachTrace0(error, trace) { + var t1; + if (typeof error == "string" || typeof error == "number" || A._isBool(error)) + return; + if (trace.toString$0(0).length === 0) + return; + t1 = $.$get$_traces0(); + A.Expando__checkType(error); + if (t1._jsWeakMap.get(error) == null) + t1.$indexSet(0, error, trace); + }, + getTrace0(error) { + var t1; + if (typeof error == "string" || typeof error == "number" || A._isBool(error)) + t1 = null; + else { + t1 = $.$get$_traces0(); + A.Expando__checkType(error); + t1 = t1._jsWeakMap.get(error); + } + return t1; + }, + parseSignature(signature, requireParens) { + var error, stackTrace, t1, exception, t2; + try { + t1 = A.ScssParser$0(signature, null).parseSignature$1$requireParens(requireParens); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.SassFormatException_2._is(t1)) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = error._span_exception$_message; + t2 = J.get$span$z(error); + A.throwWithTrace0(new A.SassFormatException0(B.Set_empty, 'Invalid signature "' + signature + '": ' + t1, t2), error, stackTrace); + } else + throw exception; + } + }, + indent_closure0: function indent_closure0(t0) { + this.indentation = t0; + }, + flattenVertically_closure1: function flattenVertically_closure1(t0) { + this.T = t0; + }, + flattenVertically_closure2: function flattenVertically_closure2(t0, t1) { + this.result = t0; + this.T = t1; + }, + longestCommonSubsequence_backtrack0: function longestCommonSubsequence_backtrack0(t0, t1, t2) { + this.selections = t0; + this.lengths = t1; + this.T = t2; + }, + mapAddAll2_closure0: function mapAddAll2_closure0(t0, t1, t2, t3) { + var _ = this; + _.destination = t0; + _.K1 = t1; + _.K2 = t2; + _.V = t3; + }, + CssValue0: function CssValue0(t0, t1, t2) { + this.value = t0; + this.span = t1; + this.$ti = t2; + }, + ValueExpression0: function ValueExpression0(t0, t1) { + this.value = t0; + this.span = t1; + }, + valueClass_closure: function valueClass_closure() { + }, + valueClass__closure: function valueClass__closure() { + }, + valueClass__closure0: function valueClass__closure0() { + }, + valueClass__closure1: function valueClass__closure1() { + }, + valueClass__closure2: function valueClass__closure2() { + }, + valueClass__closure3: function valueClass__closure3() { + }, + valueClass__closure4: function valueClass__closure4() { + }, + valueClass__closure5: function valueClass__closure5() { + }, + valueClass__closure6: function valueClass__closure6() { + }, + valueClass__closure7: function valueClass__closure7() { + }, + valueClass__closure8: function valueClass__closure8() { + }, + valueClass__closure9: function valueClass__closure9() { + }, + valueClass__closure10: function valueClass__closure10() { + }, + valueClass__closure11: function valueClass__closure11() { + }, + valueClass__closure12: function valueClass__closure12() { + }, + valueClass__closure13: function valueClass__closure13() { + }, + valueClass__closure14: function valueClass__closure14() { + }, + valueClass__closure15: function valueClass__closure15() { + }, + valueClass__closure16: function valueClass__closure16() { + }, + valueClass__closure17: function valueClass__closure17() { + }, + valueClass__closure18: function valueClass__closure18() { + }, + SassApiValue_assertSelector0(_this, allowParent, $name) { + var error, stackTrace, t1, exception, + string = _this._value$_selectorString$1($name); + try { + t1 = A.SelectorList_SelectorList$parse0(string, allowParent, null, false); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.SassFormatException_2._is(t1)) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = B.JSString_methods.replaceFirst$2(J.toString$0$(error), "Error: ", ""); + A.throwWithTrace0(new A.SassScriptException0($name == null ? t1 : "$" + $name + ": " + t1), error, stackTrace); + } else + throw exception; + } + }, + SassApiValue_assertCompoundSelector0(_this, $name) { + var error, stackTrace, t1, exception, + allowParent = false, + string = _this._value$_selectorString$1($name); + try { + t1 = new A.SelectorParser0(allowParent, false, A.SpanScanner$(string, null), null).parseCompoundSelector$0(); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.SassFormatException_2._is(t1)) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = B.JSString_methods.replaceFirst$2(J.toString$0$(error), "Error: ", ""); + A.throwWithTrace0(new A.SassScriptException0("$" + $name + ": " + t1), error, stackTrace); + } else + throw exception; + } + }, + Value0: function Value0() { + }, + VariableExpression0: function VariableExpression0(t0, t1, t2) { + this.namespace = t0; + this.name = t1; + this.span = t2; + }, + VariableDeclaration$0($name, expression, span, comment, global, guarded, namespace) { + if (namespace != null && global) + A.throwExpression(A.ArgumentError$(string$.Other_, null)); + return new A.VariableDeclaration0(namespace, $name, expression, guarded, global, span); + }, + VariableDeclaration0: function VariableDeclaration0(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.namespace = t0; + _.name = t1; + _.expression = t2; + _.isGuarded = t3; + _.isGlobal = t4; + _.span = t5; + }, + WarnRule0: function WarnRule0(t0, t1) { + this.expression = t0; + this.span = t1; + }, + WhileRule$0(condition, children, span) { + var t1 = A.List_List$unmodifiable(children, type$.Statement_2), + t2 = B.JSArray_methods.any$1(t1, new A.ParentStatement_closure0()); + return new A.WhileRule0(condition, span, t1, t2); + }, + WhileRule0: function WhileRule0(t0, t1, t2, t3) { + var _ = this; + _.condition = t0; + _.span = t1; + _.children = t2; + _.hasDeclarations = t3; + }, + XyzD50ColorSpace0: function XyzD50ColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + XyzD65ColorSpace0: function XyzD65ColorSpace0(t0, t1) { + this.name = t0; + this._space$_channels = t1; + }, + AsyncCallable_AsyncCallable$fromSignature(signature, callback, requireParens) { + var _0_0 = A.parseSignature(signature, requireParens); + return new A.AsyncBuiltInCallable0(_0_0._0, _0_0._1, callback, false); + }, + Callable_Callable$fromSignature(signature, callback, requireParens) { + var _0_0 = A.parseSignature(signature, requireParens); + return new A.BuiltInCallable0(_0_0._0, A._setArrayType([new A._Record_2(_0_0._1, callback)], type$.JSArray_Record_2_ParameterList_and_Value_Function_List_Value_2), false); + }, + printString(string) { + if (typeof dartPrint == "function") { + dartPrint(string); + return; + } + if (typeof console == "object" && typeof console.log != "undefined") { + console.log(string); + return; + } + if (typeof print == "function") { + print(string); + return; + } + throw "Unable to print message: " + String(string); + }, + mergeMaps(map1, map2, $K, $V) { + var result = A.LinkedHashMap_LinkedHashMap$of(map1, $K, $V); + result.addAll$1(0, map2); + return result; + }, + groupBy(values, key, $S, $T) { + var t1, t2, _i, element, t3, t4, + map = A.LinkedHashMap_LinkedHashMap$_empty($T, $S._eval$1("List<0>")); + for (t1 = values.length, t2 = $S._eval$1("JSArray<0>"), _i = 0; _i < values.length; values.length === t1 || (0, A.throwConcurrentModificationError)(values), ++_i) { + element = values[_i]; + t3 = key.call$1(element); + t4 = map.$index(0, t3); + if (t4 == null) { + t4 = A._setArrayType([], t2); + map.$indexSet(0, t3, t4); + t3 = t4; + } else + t3 = t4; + J.add$1$ax(t3, element); + } + return map; + }, + minBy(values, orderBy) { + var t1, t2, minValue, minOrderBy, element, elementOrderBy; + for (t1 = values.$ti, t2 = new A.MappedIterator(J.get$iterator$ax(values.__internal$_iterable), values._f, t1._eval$1("MappedIterator<1,2>")), t1 = t1._rest[1], minValue = null, minOrderBy = null; t2.moveNext$0();) { + element = t2.__internal$_current; + if (element == null) + element = t1._as(element); + elementOrderBy = orderBy.call$1(element); + if (minOrderBy == null || A.defaultCompare(elementOrderBy, minOrderBy) < 0) { + minOrderBy = elementOrderBy; + minValue = element; + } + } + return minValue; + }, + IterableExtension_firstWhereOrNull(_this, test) { + var t1, element; + for (t1 = J.get$iterator$ax(_this); t1.moveNext$0();) { + element = t1.get$current(t1); + if (test.call$1(element)) + return element; + } + return null; + }, + IterableExtension_get_firstOrNull(_this) { + var iterator = J.get$iterator$ax(_this); + if (iterator.moveNext$0()) + return iterator.get$current(iterator); + return null; + }, + IterableExtension_get_lastOrNull(_this) { + if (_this.get$length(0) === 0) + return null; + return _this.get$last(_this); + }, + IterableExtension_get_singleOrNull(_this) { + var result, + iterator = J.get$iterator$ax(_this); + if (iterator.moveNext$0()) { + result = iterator.get$current(iterator); + if (!iterator.moveNext$0()) + return result; + } + return null; + }, + IterableIntegerExtension_get_maxOrNull(_this) { + var value, newValue, + iterator = _this.get$iterator(_this); + if (iterator.moveNext$0()) { + value = iterator.get$current(iterator); + for (; iterator.moveNext$0();) { + newValue = iterator.get$current(iterator); + if (newValue > value) + value = newValue; + } + return value; + } + return null; + }, + IterableIntegerExtension_get_max(_this) { + var t1 = A.IterableIntegerExtension_get_maxOrNull(_this); + return t1 == null ? A.throwExpression(A.StateError$("No element")) : t1; + }, + IterableIntegerExtension_get_sum(_this) { + var t1, t2, result, t3; + for (t1 = _this.$ti, t2 = new A.MappedIterator(J.get$iterator$ax(_this.__internal$_iterable), _this._f, t1._eval$1("MappedIterator<1,2>")), t1 = t1._rest[1], result = 0; t2.moveNext$0();) { + t3 = t2.__internal$_current; + result += t3 == null ? t1._as(t3) : t3; + } + return result; + }, + ListExtensions_mapIndexed(_this, convert, $E, $R) { + return new A._SyncStarIterable(A.ListExtensions_mapIndexed$body(_this, convert, $E, $R), $R._eval$1("_SyncStarIterable<0>")); + }, + ListExtensions_mapIndexed$body($async$_this, $async$convert, $async$$E, $async$$R) { + return function() { + var _this = $async$_this, + convert = $async$convert, + $E = $async$$E, + $R = $async$$R; + var $async$goto = 0, $async$handler = 1, $async$errorStack = [], t1, index; + return function $async$ListExtensions_mapIndexed($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = _this.length, index = 0; + case 2: + // for condition + if (!(index < t1)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return $async$iterator._async$_current = convert.call$2(index, _this[index]), 1; + case 5: + // after yield + case 3: + // for update + ++index; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return 0; + case 1: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + }, + ListExtensions_elementAtOrNull(_this, index) { + var t1 = J.getInterceptor$asx(_this); + return index < t1.get$length(_this) ? t1.$index(_this, index) : null; + }, + defaultCompare(value1, value2) { + return J.compareTo$1$ns(type$.Comparable_nullable_Object._as(value1), value2); + }, + current() { + var exception, t1, path, lastIndex, uri = null; + try { + uri = A.Uri_base(); + } catch (exception) { + if (type$.Exception._is(A.unwrapException(exception))) { + t1 = $._current; + if (t1 != null) + return t1; + throw exception; + } else + throw exception; + } + if (J.$eq$(uri, $._currentUriBase)) { + t1 = $._current; + t1.toString; + return t1; + } + $._currentUriBase = uri; + if ($.$get$Style_platform() === $.$get$Style_url()) + t1 = $._current = J.resolve$1$x(uri, ".").toString$0(0); + else { + path = uri.toFilePath$0(); + lastIndex = path.length - 1; + t1 = $._current = lastIndex === 0 ? path : B.JSString_methods.substring$2(path, 0, lastIndex); + } + return t1; + }, + absolute(part1, part2, part3, part4, part5, part6, part7, part8, part9, part10, part11, part12, part13, part14, part15) { + return $.$get$context().absolute$15(part1, part2, part3, part4, part5, part6, part7, part8, part9, part10, part11, part12, part13, part14, part15); + }, + join(part1, part2, part3) { + var _null = null; + return $.$get$context().join$16(0, part1, part2, part3, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null); + }, + toUri(path) { + return $.$get$context().toUri$1(path); + }, + prettyUri(uri) { + var t1 = $.$get$context(); + uri.toString; + return t1.prettyUri$1(uri); + }, + isAlphabetic(char) { + var t1; + if (!(char >= 65 && char <= 90)) + t1 = char >= 97 && char <= 122; + else + t1 = true; + return t1; + }, + driveLetterEnd(path, index) { + var t2, t3, _null = null, + t1 = path.length, + index0 = index + 2; + if (t1 < index0) + return _null; + if (!A.isAlphabetic(path.charCodeAt(index))) + return _null; + t2 = index + 1; + if (path.charCodeAt(t2) !== 58) { + t3 = index + 4; + if (t1 < t3) + return _null; + if (B.JSString_methods.substring$2(path, t2, t3).toLowerCase() !== "%3a") + return _null; + index = index0; + } + t2 = index + 2; + if (t1 === t2) + return t2; + if (path.charCodeAt(t2) !== 47) + return _null; + return index + 3; + }, + main0(args) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + t1; + var $async$main0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + A.printError("sass --embedded is unavailable in pure JS mode."); + t1 = A.isNodeJs() ? self.process : null; + if (t1 != null) + J.set$exitCode$x(t1, 1); + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$main0, $async$completer); + }, + EvaluationContext_currentOrNull() { + var t1, + _0_0 = $.Zone__current.$index(0, B.Symbol__evaluationContext); + $label0$0: { + if (type$.EvaluationContext._is(_0_0)) { + t1 = _0_0; + break $label0$0; + } + t1 = null; + break $label0$0; + } + return t1; + }, + warn(message) { + var t1, _null = null, + _0_0 = A.EvaluationContext_currentOrNull(); + $label0$0: { + if (_0_0 != null) { + t1 = _0_0.warn$2(0, message, _null); + break $label0$0; + } + B.StderrLogger_false.internalWarn$4$deprecation$span$trace(message, _null, _null, _null); + t1 = _null; + break $label0$0; + } + return t1; + }, + warnForDeprecation(message, deprecation) { + var t1, + _0_0 = A.EvaluationContext_currentOrNull(); + $label0$0: { + if (_0_0 != null) { + t1 = _0_0.warn$2(0, message, deprecation); + break $label0$0; + } + t1 = A.WarnForDeprecation_warnForDeprecation(B.StderrLogger_false, deprecation, message, null, null); + break $label0$0; + } + return t1; + }, + compileStylesheets(options, graph, sourcesToDestinations, ifModified) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.bool), + $async$returnValue, t2, _1_4, t3, _i, t4, printedError, errorWithStackTrace, code, error, stackTrace, buffer, t1, $async$temp1; + var $async$compileStylesheets = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = type$.nullable_String; + t1 = A.List_List$of(A.MapExtensions_get_pairs(sourcesToDestinations, t1, t1), true, type$.Record_2_nullable_String_and_nullable_String); + t2 = t1.length; + $async$goto = t2 === 1 ? 4 : 5; + break; + case 4: + // then + _1_4 = t1[0]; + $async$temp1 = A; + $async$goto = 6; + return A._asyncAwait(A.compileStylesheet(options, graph, _1_4._0, _1_4._1, ifModified), $async$compileStylesheets); + case 6: + // returning from await. + t1 = $async$temp1._setArrayType([$async$result], type$.JSArray_nullable_Record_3_int_and_String_and_nullable_String); + // goto break $label0$0 + $async$goto = 3; + break; + case 5: + // join + t3 = A._setArrayType([], type$.JSArray_Future_nullable_Record_3_int_and_String_and_nullable_String); + for (_i = 0; _i < t2; ++_i) { + t4 = t1[_i]; + t3.push(A.compileStylesheet(options, graph, t4._0, t4._1, ifModified)); + } + $async$goto = 7; + return A._asyncAwait(A.Future_wait(t3, A._asBool(options._options.$index(0, "stop-on-error")), type$.nullable_Record_3_int_and_String_and_nullable_String), $async$compileStylesheets); + case 7: + // returning from await. + t1 = $async$result; + // goto break $label0$0 + $async$goto = 3; + break; + case 3: + // break $label0$0 + for (t1 = J.get$iterator$ax(t1), printedError = false; t1.moveNext$0();) { + errorWithStackTrace = t1.get$current(t1); + if (errorWithStackTrace == null) + continue; + code = errorWithStackTrace._0; + error = errorWithStackTrace._1; + stackTrace = errorWithStackTrace._2; + t2 = self.process; + if (t2 == null) + t2 = null; + else { + t2 = J.get$release$x(t2); + t2 = t2 == null ? null : J.get$name$x(t2); + } + t2 = J.$eq$(t2, "node") ? self.process : null; + t2 = t2 == null ? null : J.get$exitCode$x(t2); + if (t2 == null) + t2 = 0; + t2 = Math.max(t2, code); + t3 = self.process; + if (t3 == null) + t3 = null; + else { + t3 = J.get$release$x(t3); + t3 = t3 == null ? null : J.get$name$x(t3); + } + t3 = J.$eq$(t3, "node") ? self.process : null; + if (t3 != null) + J.set$exitCode$x(t3, t2); + buffer = new A.StringBuffer(""); + t2 = (printedError ? buffer._contents = "" + "\n" : "") + error; + buffer._contents = t2; + if (stackTrace != null) { + t2 += "\n"; + buffer._contents = t2; + t2 += "\n"; + buffer._contents = t2; + buffer._contents = t2 + stackTrace; + } + A.printError(buffer); + printedError = true; + } + $async$returnValue = !printedError; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$compileStylesheets, $async$completer); + }, + CharacterExtension_get_isAlphabetic(_this) { + var t1; + if (!(_this >= 97 && _this <= 122)) + t1 = _this >= 65 && _this <= 90; + else + t1 = true; + return t1; + }, + CharacterExtension_get_isHex(_this) { + var t1 = true; + if (!(_this >= 48 && _this <= 57)) + if (!(_this >= 97 && _this <= 102)) + t1 = _this >= 65 && _this <= 70; + return t1; + }, + asHex(character) { + var t1; + $label0$0: { + if (character <= 57) { + t1 = character - 48; + break $label0$0; + } + if (character <= 70) { + t1 = 10 + character - 65; + break $label0$0; + } + t1 = 10 + character - 97; + break $label0$0; + } + return t1; + }, + hexCharFor(number) { + return number < 10 ? 48 + number : 87 + number; + }, + opposite(character) { + var t1; + $label0$0: { + if (40 === character) { + t1 = 41; + break $label0$0; + } + if (123 === character) { + t1 = 125; + break $label0$0; + } + if (91 === character) { + t1 = 93; + break $label0$0; + } + t1 = A.throwExpression(A.ArgumentError$('"' + A.String_String$fromCharCode(character) + "\" isn't a brace-like character.", null)); + } + return t1; + }, + characterEqualsIgnoreCase(character1, character2) { + var upperCase1; + if (character1 === character2) + return true; + if ((character1 ^ character2) >>> 0 !== 32) + return false; + upperCase1 = (character1 & 4294967263) >>> 0; + return upperCase1 >= 65 && upperCase1 <= 90; + }, + IterableExtension_search(_this, callback) { + var t1, _0_0; + for (t1 = J.get$iterator$ax(_this); t1.moveNext$0();) { + _0_0 = callback.call$1(t1.get$current(t1)); + if (_0_0 != null) + return _0_0; + } + return null; + }, + IterableExtension_get_exceptLast(_this) { + var t1 = J.getInterceptor$asx(_this), + size = t1.get$length(_this) - 1; + if (size < 0) + throw A.wrapException(A.StateError$("Iterable may not be empty")); + return t1.take$1(_this, size); + }, + NullableExtension_andThen(_this, fn) { + return _this == null ? null : fn.call$1(_this); + }, + SetExtension_removeNull(_this, $T) { + _this.remove$1(0, null); + return A.Set_castFrom(_this, _this.get$_newSimilarSet(), A._instanceType(_this)._precomputed1, $T); + }, + fuzzyEquals(number1, number2) { + var t1; + if (number1 === number2) + return true; + if (Math.abs(number1 - number2) <= $.$get$_epsilon()) { + t1 = $.$get$_inverseEpsilon(); + t1 = B.JSNumber_methods.round$0(number1 * t1) === B.JSNumber_methods.round$0(number2 * t1); + } else + t1 = false; + return t1; + }, + fuzzyEqualsNullable(number1, number2) { + var t1; + if (number1 == number2) + return true; + if (number1 == null || number2 == null) + return false; + if (Math.abs(number1 - number2) <= $.$get$_epsilon()) { + t1 = $.$get$_inverseEpsilon(); + t1 = B.JSNumber_methods.round$0(number1 * t1) === B.JSNumber_methods.round$0(number2 * t1); + } else + t1 = false; + return t1; + }, + fuzzyHashCode(number) { + if (!isFinite(number)) + return B.JSNumber_methods.get$hashCode(number); + return B.JSInt_methods.get$hashCode(B.JSNumber_methods.round$0(number * $.$get$_inverseEpsilon())); + }, + fuzzyLessThan(number1, number2) { + return number1 < number2 && !A.fuzzyEquals(number1, number2); + }, + fuzzyLessThanOrEquals(number1, number2) { + return number1 < number2 || A.fuzzyEquals(number1, number2); + }, + fuzzyGreaterThan(number1, number2) { + return number1 > number2 && !A.fuzzyEquals(number1, number2); + }, + fuzzyGreaterThanOrEquals(number1, number2) { + return number1 > number2 || A.fuzzyEquals(number1, number2); + }, + fuzzyIsInt(number) { + if (number == 1 / 0 || number == -1 / 0 || isNaN(number)) + return false; + return A.fuzzyEquals(number, B.JSNumber_methods.round$0(number)); + }, + fuzzyAsInt(number) { + var rounded; + if (number == 1 / 0 || number == -1 / 0 || isNaN(number)) + return null; + rounded = B.JSNumber_methods.round$0(number); + return A.fuzzyEquals(number, rounded) ? rounded : null; + }, + fuzzyRound(number) { + var t1; + if (number > 0) { + t1 = B.JSNumber_methods.$mod(number, 1); + return t1 < 0.5 && !A.fuzzyEquals(t1, 0.5) ? B.JSNumber_methods.floor$0(number) : B.JSNumber_methods.ceil$0(number); + } else { + t1 = B.JSNumber_methods.$mod(number, 1); + return t1 < 0.5 || A.fuzzyEquals(t1, 0.5) ? B.JSNumber_methods.floor$0(number) : B.JSNumber_methods.ceil$0(number); + } + }, + fuzzyCheckRange(number, min, max) { + if (A.fuzzyEquals(number, min)) + return min; + if (A.fuzzyEquals(number, max)) + return max; + if (number > min && number < max) + return number; + return null; + }, + fuzzyAssertRange(number, min, max, $name) { + var result = A.fuzzyCheckRange(number, min, max); + if (result != null) + return result; + throw A.wrapException(A.RangeError$range(number, min, max, $name, "must be between " + min + " and " + max)); + }, + moduloLikeSass(num1, num2) { + var result; + if (num1 == 1 / 0 || num1 == -1 / 0) + return 0 / 0; + if (num2 == 1 / 0 || num2 == -1 / 0) + return A.DoubleWithSignedZero_get_signIncludingZero(num1) === J.get$sign$in(num2) ? num1 : 0 / 0; + if (num2 > 0) + return B.JSNumber_methods.$mod(num1, num2); + if (num2 === 0) + return 0 / 0; + result = B.JSNumber_methods.$mod(num1, num2); + return result === 0 ? 0 : result + num2; + }, + sqrt(number) { + number.assertNoUnits$1("number"); + return A.SassNumber_SassNumber(Math.sqrt(number._number$_value), null); + }, + sin(number) { + return A.SassNumber_SassNumber(Math.sin(number.coerceValueToUnit$2("rad", "number")), null); + }, + cos(number) { + return A.SassNumber_SassNumber(Math.cos(number.coerceValueToUnit$2("rad", "number")), null); + }, + tan(number) { + return A.SassNumber_SassNumber(Math.tan(number.coerceValueToUnit$2("rad", "number")), null); + }, + atan(number) { + number.assertNoUnits$1("number"); + return A.SassNumber_SassNumber$withUnits(Math.atan(number._number$_value) * 57.29577951308232, null, A._setArrayType(["deg"], type$.JSArray_String)); + }, + asin(number) { + number.assertNoUnits$1("number"); + return A.SassNumber_SassNumber$withUnits(Math.asin(number._number$_value) * 57.29577951308232, null, A._setArrayType(["deg"], type$.JSArray_String)); + }, + acos(number) { + number.assertNoUnits$1("number"); + return A.SassNumber_SassNumber$withUnits(Math.acos(number._number$_value) * 57.29577951308232, null, A._setArrayType(["deg"], type$.JSArray_String)); + }, + log(number, base) { + if (base != null) + return A.SassNumber_SassNumber(Math.log(number._number$_value) / Math.log(base._number$_value), null); + return A.SassNumber_SassNumber(Math.log(number._number$_value), null); + }, + pow0(base, exponent) { + base.assertNoUnits$1("base"); + exponent.assertNoUnits$1("exponent"); + return A.SassNumber_SassNumber(Math.pow(base._number$_value, exponent._number$_value), null); + }, + DoubleWithSignedZero_get_signIncludingZero(_this) { + if (_this === -0.0) + return -1; + if (_this === 0) + return 1; + return J.get$sign$in(_this); + }, + SpanExtensions_trimLeft(_this) { + var t1, start = 0; + while (true) { + t1 = _this.get$text().charCodeAt(start); + if (!(t1 === 32 || t1 === 9 || t1 === 10 || t1 === 13 || t1 === 12)) + break; + ++start; + } + return A.FileSpanExtension_subspan(_this, start, null); + }, + SpanExtensions_trimRight(_this) { + var t1, + end = _this.get$text().length - 1; + while (true) { + t1 = _this.get$text().charCodeAt(end); + if (!(t1 === 32 || t1 === 9 || t1 === 10 || t1 === 13 || t1 === 12)) + break; + --end; + } + return A.FileSpanExtension_subspan(_this, 0, end + 1); + }, + SpanExtensions_initialIdentifier(_this) { + var i, + scanner = A.StringScanner$(_this.get$text(), null, null); + for (i = 0; false; ++i) + scanner.readChar$0(); + A._scanIdentifier(scanner); + return A.FileSpanExtension_subspan(_this, 0, scanner._string_scanner$_position); + }, + SpanExtensions_withoutInitialIdentifier(_this) { + var scanner = A.StringScanner$(_this.get$text(), null, null); + A._scanIdentifier(scanner); + return A.FileSpanExtension_subspan(_this, scanner._string_scanner$_position, null); + }, + _scanIdentifier(scanner) { + var t1, _0_0, t2; + for (t1 = scanner.string.length; scanner._string_scanner$_position !== t1;) { + _0_0 = scanner.peekChar$0(); + if (92 === _0_0) { + A.consumeEscapedCharacter(scanner); + continue; + } + if (A._isInt(_0_0)) { + if (_0_0 !== 95) { + if (!(_0_0 >= 97 && _0_0 <= 122)) + t2 = _0_0 >= 65 && _0_0 <= 90; + else + t2 = true; + t2 = t2 || _0_0 >= 128; + } else + t2 = true; + if (!t2) + t2 = _0_0 >= 48 && _0_0 <= 57 || _0_0 === 45; + else + t2 = true; + } else + t2 = false; + if (t2) { + scanner.readChar$0(); + continue; + } + break; + } + }, + hueToRgb(m1, m2, hue) { + var t1; + if (hue < 0) + ++hue; + if (hue > 1) + --hue; + $label0$0: { + if (hue < 0.16666666666666666) { + t1 = m1 + (m2 - m1) * hue * 6; + break $label0$0; + } + if (hue < 0.5) { + t1 = m2; + break $label0$0; + } + if (hue < 0.6666666666666666) { + t1 = m1 + (m2 - m1) * (0.6666666666666666 - hue) * 6; + break $label0$0; + } + t1 = m1; + break $label0$0; + } + return t1; + }, + srgbAndDisplayP3ToLinear(channel) { + var abs = Math.abs(channel); + return abs <= 0.04045 ? channel / 12.92 : J.get$sign$in(channel) * Math.pow((abs + 0.055) / 1.055, 2.4); + }, + srgbAndDisplayP3FromLinear(channel) { + var abs = Math.abs(channel); + return abs <= 0.0031308 ? channel * 12.92 : J.get$sign$in(channel) * (1.055 * Math.pow(abs, 0.4166666666666667) - 0.055); + }, + labToLch(dest, lightness, a, b, alpha, missingChroma, missingHue) { + var t3, t4, chroma, hue, + t1 = a == null, + t2 = t1 ? 0 : a; + t2 = Math.pow(t2, 2); + t3 = b == null; + t4 = t3 ? 0 : b; + chroma = Math.sqrt(t2 + Math.pow(t4, 2)); + if (missingHue || A.fuzzyEquals(chroma, 0)) + hue = null; + else { + t2 = t3 ? 0 : b; + t1 = t1 ? 0 : a; + hue = Math.atan2(t2, t1) * 180 / 3.141592653589793; + } + t1 = missingChroma ? null : chroma; + return A.SassColor_SassColor$forSpaceInternal(dest, lightness, t1, hue == null || hue >= 0 ? hue : hue + 360, alpha); + }, + encodeVlq(value) { + var res, signBit, digit, t1; + if (value < $.$get$minInt32() || value > $.$get$maxInt32()) + throw A.wrapException(A.ArgumentError$("expected 32 bit int, got: " + value, null)); + res = A._setArrayType([], type$.JSArray_String); + if (value < 0) { + value = -value; + signBit = 1; + } else + signBit = 0; + value = value << 1 | signBit; + do { + digit = value & 31; + value = value >>> 5; + t1 = value > 0; + res.push(string$.ABCDEF[t1 ? digit | 32 : digit]); + } while (t1); + return res; + }, + isAllTheSame(iter) { + var firstValue, t1, t2, value; + if (iter.get$length(0) === 0) + return true; + firstValue = iter.get$first(0); + for (t1 = A.SubListIterable$(iter, 1, null, iter.$ti._eval$1("ListIterable.E")), t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListIterable.E"); t1.moveNext$0();) { + value = t1.__internal$_current; + if (!J.$eq$(value == null ? t2._as(value) : value, firstValue)) + return false; + } + return true; + }, + replaceFirstNull(list, element) { + var index = B.JSArray_methods.indexOf$1(list, null); + if (index < 0) + throw A.wrapException(A.ArgumentError$(A.S(list) + " contains no null elements.", null)); + list[index] = element; + }, + replaceWithNull(list, element) { + var index = B.JSArray_methods.indexOf$1(list, element); + if (index < 0) + throw A.wrapException(A.ArgumentError$(A.S(list) + " contains no elements matching " + element.toString$0(0) + ".", null)); + list[index] = null; + }, + countCodeUnits(string, codeUnit) { + var t1, t2, count, t3; + for (t1 = new A.CodeUnits(string), t2 = type$.CodeUnits, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"), count = 0; t1.moveNext$0();) { + t3 = t1.__internal$_current; + if ((t3 == null ? t2._as(t3) : t3) === codeUnit) + ++count; + } + return count; + }, + findLineStart(context, text, column) { + var beginningOfLine, index, lineStart; + if (text.length === 0) + for (beginningOfLine = 0; true;) { + index = B.JSString_methods.indexOf$2(context, "\n", beginningOfLine); + if (index === -1) + return context.length - beginningOfLine >= column ? beginningOfLine : null; + if (index - beginningOfLine >= column) + return beginningOfLine; + beginningOfLine = index + 1; + } + index = B.JSString_methods.indexOf$1(context, text); + for (; index !== -1;) { + lineStart = index === 0 ? 0 : B.JSString_methods.lastIndexOf$2(context, "\n", index - 1) + 1; + if (column === index - lineStart) + return lineStart; + index = B.JSString_methods.indexOf$2(context, text, index + 1); + } + return null; + }, + validateErrorArgs(string, match, position, $length) { + var t2, + t1 = position != null; + if (t1) + if (position < 0) + throw A.wrapException(A.RangeError$("position must be greater than or equal to 0.")); + else if (position > string.length) + throw A.wrapException(A.RangeError$("position must be less than or equal to the string length.")); + t2 = $length != null; + if (t2 && $length < 0) + throw A.wrapException(A.RangeError$("length must be greater than or equal to 0.")); + if (t1 && t2 && position + $length > string.length) + throw A.wrapException(A.RangeError$("position plus length must not go beyond the end of the string.")); + }, + CharacterExtension_get_isAlphabetic0(_this) { + var t1; + if (!(_this >= 97 && _this <= 122)) + t1 = _this >= 65 && _this <= 90; + else + t1 = true; + return t1; + }, + CharacterExtension_get_isHex0(_this) { + var t1 = true; + if (!(_this >= 48 && _this <= 57)) + if (!(_this >= 97 && _this <= 102)) + t1 = _this >= 65 && _this <= 70; + return t1; + }, + combineSurrogates(highSurrogate, lowSurrogate) { + return 65536 + ((highSurrogate & 1023) << 10) + (lowSurrogate & 1023); + }, + asHex0(character) { + var t1; + $label0$0: { + if (character <= 57) { + t1 = character - 48; + break $label0$0; + } + if (character <= 70) { + t1 = 10 + character - 65; + break $label0$0; + } + t1 = 10 + character - 97; + break $label0$0; + } + return t1; + }, + hexCharFor0(number) { + return number < 10 ? 48 + number : 87 + number; + }, + opposite0(character) { + var t1; + $label0$0: { + if (40 === character) { + t1 = 41; + break $label0$0; + } + if (123 === character) { + t1 = 125; + break $label0$0; + } + if (91 === character) { + t1 = 93; + break $label0$0; + } + t1 = A.throwExpression(A.ArgumentError$('"' + A.String_String$fromCharCode(character) + "\" isn't a brace-like character.", null)); + } + return t1; + }, + characterEqualsIgnoreCase0(character1, character2) { + var upperCase1; + if (character1 === character2) + return true; + if ((character1 ^ character2) >>> 0 !== 32) + return false; + upperCase1 = (character1 & 4294967263) >>> 0; + return upperCase1 >= 65 && upperCase1 <= 90; + }, + EvaluationContext_currentOrNull0() { + var t1, + _0_0 = $.Zone__current.$index(0, B.Symbol__evaluationContext); + $label0$0: { + if (type$.EvaluationContext_2._is(_0_0)) { + t1 = _0_0; + break $label0$0; + } + t1 = null; + break $label0$0; + } + return t1; + }, + EvaluationContext__currentOrNull() { + var _0_0 = $.Zone__current.$index(0, B.Symbol__evaluationContext); + if (type$.EvaluationContext_2._is(_0_0)) + return _0_0; + else + return null; + }, + warn0(message) { + var t1, _null = null, + _0_0 = A.EvaluationContext_currentOrNull0(); + $label0$0: { + if (_0_0 != null) { + t1 = _0_0.warn$2(0, message, _null); + break $label0$0; + } + B.StderrLogger_false0.internalWarn$4$deprecation$span$trace(message, _null, _null, _null); + t1 = _null; + break $label0$0; + } + return t1; + }, + warnForDeprecation0(message, deprecation) { + var t1, + _0_0 = A.EvaluationContext_currentOrNull0(); + $label0$0: { + if (_0_0 != null) { + t1 = _0_0.warn$2(0, message, deprecation); + break $label0$0; + } + t1 = A.WarnForDeprecation_warnForDeprecation0(B.StderrLogger_false0, deprecation, message, null, null); + break $label0$0; + } + return t1; + }, + warnForDeprecationFromApi(message, deprecation) { + var _0_0 = A.EvaluationContext__currentOrNull(); + if (_0_0 != null) + _0_0.warn$2(0, message, deprecation); + else + A.WarnForDeprecation_warnForDeprecation0(new A.StderrLogger0(false), deprecation, message, null, null); + }, + IterableExtension_search0(_this, callback) { + var t1, _0_0; + for (t1 = J.get$iterator$ax(_this); t1.moveNext$0();) { + _0_0 = callback.call$1(t1.get$current(t1)); + if (_0_0 != null) + return _0_0; + } + return null; + }, + IterableExtension_get_exceptLast0(_this) { + var t1 = J.getInterceptor$asx(_this), + size = t1.get$length(_this) - 1; + if (size < 0) + throw A.wrapException(A.StateError$("Iterable may not be empty")); + return t1.take$1(_this, size); + }, + NullableExtension_andThen0(_this, fn) { + return _this == null ? null : fn.call$1(_this); + }, + fuzzyEquals0(number1, number2) { + var t1; + if (number1 === number2) + return true; + if (Math.abs(number1 - number2) <= $.$get$_epsilon0()) { + t1 = $.$get$_inverseEpsilon0(); + t1 = B.JSNumber_methods.round$0(number1 * t1) === B.JSNumber_methods.round$0(number2 * t1); + } else + t1 = false; + return t1; + }, + fuzzyEqualsNullable0(number1, number2) { + var t1; + if (number1 == number2) + return true; + if (number1 == null || number2 == null) + return false; + if (Math.abs(number1 - number2) <= $.$get$_epsilon0()) { + t1 = $.$get$_inverseEpsilon0(); + t1 = B.JSNumber_methods.round$0(number1 * t1) === B.JSNumber_methods.round$0(number2 * t1); + } else + t1 = false; + return t1; + }, + fuzzyHashCode0(number) { + if (!isFinite(number)) + return B.JSNumber_methods.get$hashCode(number); + return B.JSInt_methods.get$hashCode(B.JSNumber_methods.round$0(number * $.$get$_inverseEpsilon0())); + }, + fuzzyLessThan0(number1, number2) { + return number1 < number2 && !A.fuzzyEquals0(number1, number2); + }, + fuzzyLessThanOrEquals0(number1, number2) { + return number1 < number2 || A.fuzzyEquals0(number1, number2); + }, + fuzzyGreaterThan0(number1, number2) { + return number1 > number2 && !A.fuzzyEquals0(number1, number2); + }, + fuzzyGreaterThanOrEquals0(number1, number2) { + return number1 > number2 || A.fuzzyEquals0(number1, number2); + }, + fuzzyIsInt0(number) { + if (number == 1 / 0 || number == -1 / 0 || isNaN(number)) + return false; + return A.fuzzyEquals0(number, B.JSNumber_methods.round$0(number)); + }, + fuzzyAsInt0(number) { + var rounded; + if (number == 1 / 0 || number == -1 / 0 || isNaN(number)) + return null; + rounded = B.JSNumber_methods.round$0(number); + return A.fuzzyEquals0(number, rounded) ? rounded : null; + }, + fuzzyRound0(number) { + var t1; + if (number > 0) { + t1 = B.JSNumber_methods.$mod(number, 1); + return t1 < 0.5 && !A.fuzzyEquals0(t1, 0.5) ? B.JSNumber_methods.floor$0(number) : B.JSNumber_methods.ceil$0(number); + } else { + t1 = B.JSNumber_methods.$mod(number, 1); + return t1 < 0.5 || A.fuzzyEquals0(t1, 0.5) ? B.JSNumber_methods.floor$0(number) : B.JSNumber_methods.ceil$0(number); + } + }, + fuzzyCheckRange0(number, min, max) { + if (A.fuzzyEquals0(number, min)) + return min; + if (A.fuzzyEquals0(number, max)) + return max; + if (number > min && number < max) + return number; + return null; + }, + fuzzyAssertRange0(number, min, max, $name) { + var result = A.fuzzyCheckRange0(number, min, max); + if (result != null) + return result; + throw A.wrapException(A.RangeError$range(number, min, max, $name, "must be between " + min + " and " + max)); + }, + moduloLikeSass0(num1, num2) { + var result; + if (num1 == 1 / 0 || num1 == -1 / 0) + return 0 / 0; + if (num2 == 1 / 0 || num2 == -1 / 0) + return A.DoubleWithSignedZero_get_signIncludingZero0(num1) === J.get$sign$in(num2) ? num1 : 0 / 0; + if (num2 > 0) + return B.JSNumber_methods.$mod(num1, num2); + if (num2 === 0) + return 0 / 0; + result = B.JSNumber_methods.$mod(num1, num2); + return result === 0 ? 0 : result + num2; + }, + sqrt0(number) { + number.assertNoUnits$1("number"); + return A.SassNumber_SassNumber0(Math.sqrt(number._number1$_value), null); + }, + sin0(number) { + return A.SassNumber_SassNumber0(Math.sin(number.coerceValueToUnit$2("rad", "number")), null); + }, + cos0(number) { + return A.SassNumber_SassNumber0(Math.cos(number.coerceValueToUnit$2("rad", "number")), null); + }, + tan0(number) { + return A.SassNumber_SassNumber0(Math.tan(number.coerceValueToUnit$2("rad", "number")), null); + }, + atan0(number) { + number.assertNoUnits$1("number"); + return A.SassNumber_SassNumber$withUnits0(Math.atan(number._number1$_value) * 57.29577951308232, null, A._setArrayType(["deg"], type$.JSArray_String)); + }, + asin0(number) { + number.assertNoUnits$1("number"); + return A.SassNumber_SassNumber$withUnits0(Math.asin(number._number1$_value) * 57.29577951308232, null, A._setArrayType(["deg"], type$.JSArray_String)); + }, + acos0(number) { + number.assertNoUnits$1("number"); + return A.SassNumber_SassNumber$withUnits0(Math.acos(number._number1$_value) * 57.29577951308232, null, A._setArrayType(["deg"], type$.JSArray_String)); + }, + log0(number, base) { + if (base != null) + return A.SassNumber_SassNumber0(Math.log(number._number1$_value) / Math.log(base._number1$_value), null); + return A.SassNumber_SassNumber0(Math.log(number._number1$_value), null); + }, + pow1(base, exponent) { + base.assertNoUnits$1("base"); + exponent.assertNoUnits$1("exponent"); + return A.SassNumber_SassNumber0(Math.pow(base._number1$_value, exponent._number1$_value), null); + }, + DoubleWithSignedZero_get_signIncludingZero0(_this) { + if (_this === -0.0) + return -1; + if (_this === 0) + return 1; + return J.get$sign$in(_this); + }, + main1(args) { + return A.main$body(args); + }, + main$body(args) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$returnValue, $async$handler = 2, $async$errorStack = [], options, t1, graph, error, error0, stackTrace, buffer, t2, exception, $async$exception, $async$temp1; + var $async$main1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + if (args.length >= 1 && "--embedded" === args[0]) { + A.main0(B.JSArray_methods.sublist$1(args, 1)); + // goto return + $async$goto = 1; + break; + } + options = null; + $async$handler = 4; + options = A.ExecutableOptions_ExecutableOptions$parse(args); + t2 = options._options; + $._glyphs = !(t2.wasParsed$1("unicode") ? A._asBool(t2.$index(0, "unicode")) : $._glyphs !== B.C_AsciiGlyphSet) ? B.C_AsciiGlyphSet : B.C_UnicodeGlyphSet; + $async$goto = A._asBool(options._options.$index(0, "version")) ? 7 : 8; + break; + case 7: + // then + $async$temp1 = A; + $async$goto = 9; + return A._asyncAwait(A._loadVersion(), $async$main1); + case 9: + // returning from await. + $async$temp1.print($async$result); + t1 = A.isNodeJs() ? self.process : null; + if (t1 != null) + J.set$exitCode$x(t1, 0); + // goto return + $async$goto = 1; + break; + case 8: + // join + $async$goto = options.get$interactive() ? 10 : 11; + break; + case 10: + // then + $async$goto = 12; + return A._asyncAwait(A.repl(options), $async$main1); + case 12: + // returning from await. + // goto return + $async$goto = 1; + break; + case 11: + // join + J.get$silenceDeprecations$x(options); + J.get$futureDeprecations$x(options); + J.get$fatalDeprecations$x(options); + t1 = A.List_List$of(options.get$pkgImporters(), true, type$.Importer_2); + J.add$1$ax(t1, $.$get$FilesystemImporter_noLoadPath()); + t2 = type$.Uri; + graph = new A.StylesheetGraph(A.LinkedHashMap_LinkedHashMap$_empty(t2, type$.StylesheetNode), A.ImportCache$(t1, type$.List_String._as(options._options.$index(0, "load-path"))), A.LinkedHashMap_LinkedHashMap$_empty(t2, type$.DateTime)); + $async$goto = A._asBool(options._options.$index(0, "watch")) ? 13 : 14; + break; + case 13: + // then + $async$goto = 15; + return A._asyncAwait(A.watch(options, graph), $async$main1); + case 15: + // returning from await. + // goto return + $async$goto = 1; + break; + case 14: + // join + t1 = options; + t2 = options; + t2._ensureSources$0(); + t2 = t2._sourcesToDestinations; + t2.toString; + $async$goto = 16; + return A._asyncAwait(A.compileStylesheets(t1, graph, t2, A._asBool(options._options.$index(0, "update"))), $async$main1); + case 16: + // returning from await. + $async$handler = 2; + // goto after finally + $async$goto = 6; + break; + case 4: + // catch + $async$handler = 3; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (t1 instanceof A.UsageException) { + error = t1; + A.print(error.message + "\n"); + A.print("Usage: sass [output.css]\n sass : : \n"); + t1 = $.$get$ExecutableOptions__parser(); + A.print(new A._Usage(t1._optionsAndSeparators, new A.StringBuffer(""), t1.usageLineLength).generate$0()); + t1 = A.isNodeJs() ? self.process : null; + if (t1 != null) + J.set$exitCode$x(t1, 64); + } else { + error0 = t1; + stackTrace = A.getTraceFromException($async$exception); + buffer = new A.StringBuffer(""); + t1 = options; + t1 = t1 == null ? null : t1.get$color(); + if (t1 === true) + buffer._contents += "\x1b[31m\x1b[1m"; + buffer._contents += "Unexpected exception:"; + t1 = options; + t1 = t1 == null ? null : t1.get$color(); + if (t1 === true) + buffer._contents += "\x1b[0m"; + buffer._contents += "\n"; + t1 = buffer; + t2 = A.S(error0) + "\n"; + t1._contents += t2; + buffer._contents += "\n"; + buffer._contents += "\n"; + t2 = buffer; + t1 = A.getTrace(error0); + t1 = B.JSString_methods.trimRight$0(A.Trace_Trace$from(t1 == null ? stackTrace : t1).get$terse().toString$0(0)); + t2._contents += t1; + A.printError(buffer); + t1 = A.isNodeJs() ? self.process : null; + if (t1 != null) + J.set$exitCode$x(t1, 255); + } + // goto after finally + $async$goto = 6; + break; + case 3: + // uncaught + // goto rethrow + $async$goto = 2; + break; + case 6: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$main1, $async$completer); + }, + _loadVersion() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.String), + $async$returnValue; + var $async$_loadVersion = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$returnValue = "1.86.3 compiled with dart2js 3.7.2"; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_loadVersion, $async$completer); + }, + SpanExtensions_trimLeft0(_this) { + var t1, start = 0; + while (true) { + t1 = _this.get$text().charCodeAt(start); + if (!(t1 === 32 || t1 === 9 || t1 === 10 || t1 === 13 || t1 === 12)) + break; + ++start; + } + return A.FileSpanExtension_subspan(_this, start, null); + }, + SpanExtensions_trimRight0(_this) { + var t1, + end = _this.get$text().length - 1; + while (true) { + t1 = _this.get$text().charCodeAt(end); + if (!(t1 === 32 || t1 === 9 || t1 === 10 || t1 === 13 || t1 === 12)) + break; + --end; + } + return A.FileSpanExtension_subspan(_this, 0, end + 1); + }, + SpanExtensions_initialIdentifier0(_this) { + var i, + scanner = A.StringScanner$(_this.get$text(), null, null); + for (i = 0; false; ++i) + scanner.readChar$0(); + A._scanIdentifier0(scanner); + return A.FileSpanExtension_subspan(_this, 0, scanner._string_scanner$_position); + }, + SpanExtensions_withoutInitialIdentifier0(_this) { + var scanner = A.StringScanner$(_this.get$text(), null, null); + A._scanIdentifier0(scanner); + return A.FileSpanExtension_subspan(_this, scanner._string_scanner$_position, null); + }, + SpanExtensions_between(_this, other) { + if (!J.$eq$(_this.get$sourceUrl(_this), other.get$sourceUrl(other))) + throw A.wrapException(A.ArgumentError$(_this.toString$0(0) + " and " + other.toString$0(0) + " are in different files.", null)); + else if (_this.get$end(_this).offset > other.get$start(other).offset) + throw A.wrapException(A.ArgumentError$(_this.toString$0(0) + " isn't before " + other.toString$0(0) + ".", null)); + return _this.get$file(_this).span$2(0, _this.get$end(_this).offset, other.get$start(other).offset); + }, + SpanExtensions_before(_this, inner) { + if (!J.$eq$(_this.get$sourceUrl(_this), inner.get$sourceUrl(inner))) + throw A.wrapException(A.ArgumentError$(_this.toString$0(0) + " and " + inner.toString$0(0) + " are in different files.", null)); + else if (inner.get$start(inner).offset < _this.get$start(_this).offset || inner.get$end(inner).offset > _this.get$end(_this).offset) + throw A.wrapException(A.ArgumentError$(inner.toString$0(0) + " isn't inside " + _this.toString$0(0) + ".", null)); + return _this.get$file(_this).span$2(0, _this.get$start(_this).offset, inner.get$start(inner).offset); + }, + SpanExtensions_after(_this, inner) { + if (!J.$eq$(_this.get$sourceUrl(_this), inner.get$sourceUrl(inner))) + throw A.wrapException(A.ArgumentError$(_this.toString$0(0) + " and " + inner.toString$0(0) + " are in different files.", null)); + else if (inner.get$start(inner).offset < _this.get$start(_this).offset || inner.get$end(inner).offset > _this.get$end(_this).offset) + throw A.wrapException(A.ArgumentError$(inner.toString$0(0) + " isn't inside " + _this.toString$0(0) + ".", null)); + return _this.get$file(_this).span$2(0, inner.get$end(inner).offset, _this.get$end(_this).offset); + }, + _scanIdentifier0(scanner) { + var t1, _0_0, t2; + for (t1 = scanner.string.length; scanner._string_scanner$_position !== t1;) { + _0_0 = scanner.peekChar$0(); + if (92 === _0_0) { + A.consumeEscapedCharacter0(scanner); + continue; + } + if (A._isInt(_0_0)) { + if (_0_0 !== 95) { + if (!(_0_0 >= 97 && _0_0 <= 122)) + t2 = _0_0 >= 65 && _0_0 <= 90; + else + t2 = true; + t2 = t2 || _0_0 >= 128; + } else + t2 = true; + if (!t2) + t2 = _0_0 >= 48 && _0_0 <= 57 || _0_0 === 45; + else + t2 = true; + } else + t2 = false; + if (t2) { + scanner.readChar$0(); + continue; + } + break; + } + }, + validateUrlScheme(scheme) { + var t1 = $.$get$_urlSchemeRegExp(); + if (!t1._nativeRegExp.test(scheme)) + A.jsThrow(new self.Error('"' + scheme + '" isn\'t a valid URL scheme (for example "file").')); + }, + hueToRgb0(m1, m2, hue) { + var t1; + if (hue < 0) + ++hue; + if (hue > 1) + --hue; + $label0$0: { + if (hue < 0.16666666666666666) { + t1 = m1 + (m2 - m1) * hue * 6; + break $label0$0; + } + if (hue < 0.5) { + t1 = m2; + break $label0$0; + } + if (hue < 0.6666666666666666) { + t1 = m1 + (m2 - m1) * (0.6666666666666666 - hue) * 6; + break $label0$0; + } + t1 = m1; + break $label0$0; + } + return t1; + }, + srgbAndDisplayP3ToLinear0(channel) { + var abs = Math.abs(channel); + return abs <= 0.04045 ? channel / 12.92 : J.get$sign$in(channel) * Math.pow((abs + 0.055) / 1.055, 2.4); + }, + srgbAndDisplayP3FromLinear0(channel) { + var abs = Math.abs(channel); + return abs <= 0.0031308 ? channel * 12.92 : J.get$sign$in(channel) * (1.055 * Math.pow(abs, 0.4166666666666667) - 0.055); + }, + labToLch0(dest, lightness, a, b, alpha, missingChroma, missingHue) { + var t3, t4, chroma, hue, + t1 = a == null, + t2 = t1 ? 0 : a; + t2 = Math.pow(t2, 2); + t3 = b == null; + t4 = t3 ? 0 : b; + chroma = Math.sqrt(t2 + Math.pow(t4, 2)); + if (missingHue || A.fuzzyEquals0(chroma, 0)) + hue = null; + else { + t2 = t3 ? 0 : b; + t1 = t1 ? 0 : a; + hue = Math.atan2(t2, t1) * 180 / 3.141592653589793; + } + t1 = missingChroma ? null : chroma; + return A.SassColor_SassColor$forSpaceInternal0(dest, lightness, t1, hue == null || hue >= 0 ? hue : hue + 360, alpha); + }, + unwrapValue(object) { + var value; + if (object != null) { + if (object instanceof A.Value0) + return object; + value = object.dartValue; + if (value != null && value instanceof A.Value0) + return value; + if (object instanceof self.Error) + throw A.wrapException(object); + } + throw A.wrapException(A.S(object) + " must be a Sass value type."); + }, + wrapValue(value) { + var t1; + $label0$0: { + if (value instanceof A.SassColor0) { + t1 = A.callConstructor($.$get$legacyColorClass(), [null, null, null, null, value]); + break $label0$0; + } + if (value instanceof A.SassList0) { + t1 = A.callConstructor($.$get$legacyListClass(), [null, null, value]); + break $label0$0; + } + if (value instanceof A.SassMap0) { + t1 = A.callConstructor($.$get$legacyMapClass(), [null, value]); + break $label0$0; + } + if (value instanceof A.SassNumber0) { + t1 = A.callConstructor($.$get$legacyNumberClass(), [null, null, value]); + break $label0$0; + } + if (value instanceof A.SassString0) { + t1 = A.callConstructor($.$get$legacyStringClass(), [null, value]); + break $label0$0; + } + t1 = value; + break $label0$0; + } + return t1; + } + }, + B = {}; + var holders = [A, J, B]; + var $ = {}; + A.JS_CONST.prototype = {}; + J.Interceptor.prototype = { + $eq(receiver, other) { + return receiver === other; + }, + get$hashCode(receiver) { + return A.Primitives_objectHashCode(receiver); + }, + toString$0(receiver) { + return "Instance of '" + A.Primitives_objectTypeName(receiver) + "'"; + }, + noSuchMethod$1(receiver, invocation) { + throw A.wrapException(A.NoSuchMethodError_NoSuchMethodError$withInvocation(receiver, invocation)); + }, + get$runtimeType(receiver) { + return A.createRuntimeType(A._instanceTypeFromConstructor(this)); + } + }; + J.JSBool.prototype = { + toString$0(receiver) { + return String(receiver); + }, + $or(receiver, other) { + return other || receiver; + }, + get$hashCode(receiver) { + return receiver ? 519018 : 218159; + }, + get$runtimeType(receiver) { + return A.createRuntimeType(type$.bool); + }, + $isTrustedGetRuntimeType: 1, + $isbool: 1 + }; + J.JSNull.prototype = { + $eq(receiver, other) { + return null == other; + }, + toString$0(receiver) { + return "null"; + }, + get$hashCode(receiver) { + return 0; + }, + get$runtimeType(receiver) { + return A.createRuntimeType(type$.Null); + }, + $isTrustedGetRuntimeType: 1, + $isNull: 1 + }; + J.JavaScriptObject.prototype = {$isJSObject: 1}; + J.LegacyJavaScriptObject.prototype = { + get$hashCode(receiver) { + return 0; + }, + toString$0(receiver) { + return String(receiver); + }, + $isPromise: 1, + $isJsSystemError: 1, + $isImmutableList: 1, + $is_ConstructionOptions: 1, + $is_ChannelOptions: 1, + $is_ToGamutOptions: 1, + $is_InterpolationOptions: 1, + $is_NodeSassColor: 1, + $isCompileOptions: 1, + $isCompileStringOptions: 1, + $isNodeCompileResult: 1, + $isDeprecation1: 1, + $is_NodeException: 1, + $isJSExpressionVisitorObject: 1, + $isFiber: 1, + $isJSFunction0: 1, + $isImmutableList0: 1, + $isImmutableMap0: 1, + $isJSImporter: 1, + $isJSImporterResult: 1, + $isNodeImporterResult0: 1, + $is_ConstructorOptions: 1, + $is_NodeSassList: 1, + $isWarnOptions: 1, + $isDebugOptions: 1, + $is_NodeSassMap: 1, + $is_ConstructorOptions0: 1, + $is_NodeSassNumber: 1, + $isParserExports: 1, + $isJSClass0: 1, + $isRenderContextOptions0: 1, + $isRenderOptions: 1, + $isRenderResult: 1, + $isJSSet: 1, + $isJSStatementVisitorObject: 1, + $is_ConstructorOptions1: 1, + $is_NodeSassString: 1, + $isJSUrl0: 1, + get$isTTY(obj) { + return obj.isTTY; + }, + get$write(obj) { + return obj.write; + }, + write$1(receiver, p0) { + return receiver.write(p0); + }, + createInterface$1(receiver, p0) { + return receiver.createInterface(p0); + }, + on$2(receiver, p0, p1) { + return receiver.on(p0, p1); + }, + get$close(obj) { + return obj.close; + }, + close$0(receiver) { + return receiver.close(); + }, + setPrompt$1(receiver, p0) { + return receiver.setPrompt(p0); + }, + get$length(obj) { + return obj.length; + }, + toString$0(receiver) { + return receiver.toString(); + }, + get$debug(obj) { + return obj.debug; + }, + debug$2(receiver, p0, p1) { + return receiver.debug(p0, p1); + }, + get$error(obj) { + return obj.error; + }, + error$1(receiver, p0) { + return receiver.error(p0); + }, + error$2(receiver, p0, p1) { + return receiver.error(p0, p1); + }, + log$1(receiver, p0) { + return receiver.log(p0); + }, + get$warn(obj) { + return obj.warn; + }, + warn$1(receiver, p0) { + return receiver.warn(p0); + }, + warn$2(receiver, p0, p1) { + return receiver.warn(p0, p1); + }, + existsSync$1(receiver, p0) { + return receiver.existsSync(p0); + }, + lstatSync$1(receiver, p0) { + return receiver.lstatSync(p0); + }, + mkdirSync$1(receiver, p0) { + return receiver.mkdirSync(p0); + }, + readdirSync$1(receiver, p0) { + return receiver.readdirSync(p0); + }, + readFileSync$2(receiver, p0, p1) { + return receiver.readFileSync(p0, p1); + }, + get$realpathSync(obj) { + return obj.realpathSync; + }, + statSync$1(receiver, p0) { + return receiver.statSync(p0); + }, + unlinkSync$1(receiver, p0) { + return receiver.unlinkSync(p0); + }, + watch$2(receiver, p0, p1) { + return receiver.watch(p0, p1); + }, + writeFileSync$2(receiver, p0, p1) { + return receiver.writeFileSync(p0, p1); + }, + call$1(receiver, p0) { + return receiver.call(p0); + }, + call$2(receiver, p0, p1) { + return receiver.call(p0, p1); + }, + call$3$1(receiver, p0) { + return receiver.call(p0); + }, + call$2$1(receiver, p0) { + return receiver.call(p0); + }, + call$1$1(receiver, p0) { + return receiver.call(p0); + }, + call$3(receiver, p0, p1, p2) { + return receiver.call(p0, p1, p2); + }, + call$3$3(receiver, p0, p1, p2) { + return receiver.call(p0, p1, p2); + }, + call$2$2(receiver, p0, p1) { + return receiver.call(p0, p1); + }, + call$1$2(receiver, p0, p1) { + return receiver.call(p0, p1); + }, + call$2$3(receiver, p0, p1, p2) { + return receiver.call(p0, p1, p2); + }, + native$1(receiver, p0) { + return receiver.native(p0); + }, + get$path(obj) { + return obj.path; + }, + isDirectory$0(receiver) { + return receiver.isDirectory(); + }, + isFile$0(receiver) { + return receiver.isFile(); + }, + isSymbolicLink$0(receiver) { + return receiver.isSymbolicLink(); + }, + get$mtime(obj) { + return obj.mtime; + }, + then$2(receiver, p0, p1) { + return receiver.then(p0, p1); + }, + then$1$1(receiver, p0) { + return receiver.then(p0); + }, + getTime$0(receiver) { + return receiver.getTime(); + }, + get$message(obj) { + return obj.message; + }, + message$1(receiver, p0) { + return receiver.message(p0); + }, + get$filename(obj) { + return obj.filename; + }, + get$id(obj) { + return obj.id; + }, + get$code(obj) { + return obj.code; + }, + get$syscall(obj) { + return obj.syscall; + }, + get$argv(obj) { + return obj.argv; + }, + get$env(obj) { + return obj.env; + }, + get$exitCode(obj) { + return obj.exitCode; + }, + set$exitCode(obj, v) { + return obj.exitCode = v; + }, + get$platform(obj) { + return obj.platform; + }, + get$release(obj) { + return obj.release; + }, + get$stderr(obj) { + return obj.stderr; + }, + get$stdin(obj) { + return obj.stdin; + }, + get$stdout(obj) { + return obj.stdout; + }, + get$name(obj) { + return obj.name; + }, + push$1(receiver, p0) { + return receiver.push(p0); + }, + call$0(receiver) { + return receiver.call(); + }, + call$2$0(receiver) { + return receiver.call(); + }, + call$1$0(receiver) { + return receiver.call(); + }, + apply$2(receiver, p0, p1) { + return receiver.apply(p0, p1); + }, + toArray$0(receiver) { + return receiver.toArray(); + }, + asMutable$0(receiver) { + return receiver.asMutable(); + }, + asImmutable$0(receiver) { + return receiver.asImmutable(); + }, + $set$2(receiver, p0, p1) { + return receiver.set(p0, p1); + }, + forEach$1(receiver, p0) { + return receiver.forEach(p0); + }, + get$file(obj) { + return obj.file; + }, + get$contents(obj) { + return obj.contents; + }, + get$options(obj) { + return obj.options; + }, + get$data(obj) { + return obj.data; + }, + get$includePaths(obj) { + return obj.includePaths; + }, + get$style(obj) { + return obj.style; + }, + get$indentType(obj) { + return obj.indentType; + }, + get$indentWidth(obj) { + return obj.indentWidth; + }, + get$linefeed(obj) { + return obj.linefeed; + }, + set$context(obj, v) { + return obj.context = v; + }, + createRequire$1(receiver, p0) { + return receiver.createRequire(p0); + }, + resolve$1(receiver, p0) { + return receiver.resolve(p0); + }, + get$$prototype(obj) { + return obj.prototype; + }, + get$red(obj) { + return obj.red; + }, + get$green(obj) { + return obj.green; + }, + get$blue(obj) { + return obj.blue; + }, + get$hue(obj) { + return obj.hue; + }, + get$saturation(obj) { + return obj.saturation; + }, + get$lightness(obj) { + return obj.lightness; + }, + get$whiteness(obj) { + return obj.whiteness; + }, + get$blackness(obj) { + return obj.blackness; + }, + get$alpha(obj) { + return obj.alpha; + }, + get$a(obj) { + return obj.a; + }, + get$b(obj) { + return obj.b; + }, + get$x(obj) { + return obj.x; + }, + get$y(obj) { + return obj.y; + }, + get$z(obj) { + return obj.z; + }, + get$chroma(obj) { + return obj.chroma; + }, + get$space(obj) { + return obj.space; + }, + get$method(obj) { + return obj.method; + }, + get$weight(obj) { + return obj.weight; + }, + get$dartValue(obj) { + return obj.dartValue; + }, + set$dartValue(obj, v) { + return obj.dartValue = v; + }, + get$alertAscii(obj) { + return obj.alertAscii; + }, + get$alertColor(obj) { + return obj.alertColor; + }, + get$loadPaths(obj) { + return obj.loadPaths; + }, + get$quietDeps(obj) { + return obj.quietDeps; + }, + get$verbose(obj) { + return obj.verbose; + }, + get$charset(obj) { + return obj.charset; + }, + get$sourceMap(obj) { + return obj.sourceMap; + }, + get$sourceMapIncludeSources(obj) { + return obj.sourceMapIncludeSources; + }, + get$logger(obj) { + return obj.logger; + }, + get$importers(obj) { + return obj.importers; + }, + get$functions(obj) { + return obj.functions; + }, + get$fatalDeprecations(obj) { + return obj.fatalDeprecations; + }, + get$silenceDeprecations(obj) { + return obj.silenceDeprecations; + }, + get$futureDeprecations(obj) { + return obj.futureDeprecations; + }, + get$syntax(obj) { + return obj.syntax; + }, + get$url(obj) { + return obj.url; + }, + get$importer(obj) { + return obj.importer; + }, + get$_dartException(obj) { + return obj._dartException; + }, + set$renderSync(obj, v) { + return obj.renderSync = v; + }, + set$compileString(obj, v) { + return obj.compileString = v; + }, + set$compileStringAsync(obj, v) { + return obj.compileStringAsync = v; + }, + set$compile(obj, v) { + return obj.compile = v; + }, + set$compileAsync(obj, v) { + return obj.compileAsync = v; + }, + set$initCompiler(obj, v) { + return obj.initCompiler = v; + }, + set$initAsyncCompiler(obj, v) { + return obj.initAsyncCompiler = v; + }, + set$Compiler(obj, v) { + return obj.Compiler = v; + }, + set$AsyncCompiler(obj, v) { + return obj.AsyncCompiler = v; + }, + set$info(obj, v) { + return obj.info = v; + }, + set$Exception(obj, v) { + return obj.Exception = v; + }, + set$Logger(obj, v) { + return obj.Logger = v; + }, + set$NodePackageImporter(obj, v) { + return obj.NodePackageImporter = v; + }, + set$deprecations(obj, v) { + return obj.deprecations = v; + }, + set$Version(obj, v) { + return obj.Version = v; + }, + set$Value(obj, v) { + return obj.Value = v; + }, + set$SassArgumentList(obj, v) { + return obj.SassArgumentList = v; + }, + set$SassCalculation(obj, v) { + return obj.SassCalculation = v; + }, + set$CalculationOperation(obj, v) { + return obj.CalculationOperation = v; + }, + set$CalculationInterpolation(obj, v) { + return obj.CalculationInterpolation = v; + }, + set$SassBoolean(obj, v) { + return obj.SassBoolean = v; + }, + set$SassColor(obj, v) { + return obj.SassColor = v; + }, + set$SassFunction(obj, v) { + return obj.SassFunction = v; + }, + set$SassMixin(obj, v) { + return obj.SassMixin = v; + }, + set$SassList(obj, v) { + return obj.SassList = v; + }, + set$SassMap(obj, v) { + return obj.SassMap = v; + }, + set$SassNumber(obj, v) { + return obj.SassNumber = v; + }, + set$SassString(obj, v) { + return obj.SassString = v; + }, + set$sassNull(obj, v) { + return obj.sassNull = v; + }, + set$sassTrue(obj, v) { + return obj.sassTrue = v; + }, + set$sassFalse(obj, v) { + return obj.sassFalse = v; + }, + set$render(obj, v) { + return obj.render = v; + }, + set$types(obj, v) { + return obj.types = v; + }, + set$NULL(obj, v) { + return obj.NULL = v; + }, + set$TRUE(obj, v) { + return obj.TRUE = v; + }, + set$FALSE(obj, v) { + return obj.FALSE = v; + }, + set$loadParserExports_(obj, v) { + return obj.loadParserExports_ = v; + }, + visitBinaryOperationExpression$1(receiver, p0) { + return receiver.visitBinaryOperationExpression(p0); + }, + visitBooleanExpression$1(receiver, p0) { + return receiver.visitBooleanExpression(p0); + }, + visitColorExpression$1(receiver, p0) { + return receiver.visitColorExpression(p0); + }, + visitInterpolatedFunctionExpression$1(receiver, p0) { + return receiver.visitInterpolatedFunctionExpression(p0); + }, + visitFunctionExpression$1(receiver, p0) { + return receiver.visitFunctionExpression(p0); + }, + visitIfExpression$1(receiver, p0) { + return receiver.visitIfExpression(p0); + }, + visitListExpression$1(receiver, p0) { + return receiver.visitListExpression(p0); + }, + visitMapExpression$1(receiver, p0) { + return receiver.visitMapExpression(p0); + }, + visitNullExpression$1(receiver, p0) { + return receiver.visitNullExpression(p0); + }, + visitNumberExpression$1(receiver, p0) { + return receiver.visitNumberExpression(p0); + }, + visitParenthesizedExpression$1(receiver, p0) { + return receiver.visitParenthesizedExpression(p0); + }, + visitSelectorExpression$1(receiver, p0) { + return receiver.visitSelectorExpression(p0); + }, + visitStringExpression$1(receiver, p0) { + return receiver.visitStringExpression(p0); + }, + visitSupportsExpression$1(receiver, p0) { + return receiver.visitSupportsExpression(p0); + }, + visitUnaryOperationExpression$1(receiver, p0) { + return receiver.visitUnaryOperationExpression(p0); + }, + visitValueExpression$1(receiver, p0) { + return receiver.visitValueExpression(p0); + }, + visitVariableExpression$1(receiver, p0) { + return receiver.visitVariableExpression(p0); + }, + get$current(obj) { + return obj.current; + }, + yield$0(receiver) { + return receiver.yield(); + }, + run$1$1(receiver, p0) { + return receiver.run(p0); + }, + run$1(receiver, p0) { + return receiver.run(p0); + }, + run$0(receiver) { + return receiver.run(); + }, + get$canonicalize(obj) { + return obj.canonicalize; + }, + canonicalize$1(receiver, p0) { + return receiver.canonicalize(p0); + }, + get$load(obj) { + return obj.load; + }, + load$1(receiver, p0) { + return receiver.load(p0); + }, + get$findFileUrl(obj) { + return obj.findFileUrl; + }, + get$nonCanonicalScheme(obj) { + return obj.nonCanonicalScheme; + }, + get$sourceMapUrl(obj) { + return obj.sourceMapUrl; + }, + get$separator(obj) { + return obj.separator; + }, + get$brackets(obj) { + return obj.brackets; + }, + get$numeratorUnits(obj) { + return obj.numeratorUnits; + }, + get$denominatorUnits(obj) { + return obj.denominatorUnits; + }, + get$pkgImporter(obj) { + return obj.pkgImporter; + }, + get$indentedSyntax(obj) { + return obj.indentedSyntax; + }, + get$omitSourceMapUrl(obj) { + return obj.omitSourceMapUrl; + }, + get$outFile(obj) { + return obj.outFile; + }, + get$outputStyle(obj) { + return obj.outputStyle; + }, + get$fiber(obj) { + return obj.fiber; + }, + get$sourceMapContents(obj) { + return obj.sourceMapContents; + }, + get$sourceMapEmbed(obj) { + return obj.sourceMapEmbed; + }, + get$sourceMapRoot(obj) { + return obj.sourceMapRoot; + }, + set$cli_pkg_main_0_(obj, v) { + return obj.cli_pkg_main_0_ = v; + }, + visitAtRootRule$1(receiver, p0) { + return receiver.visitAtRootRule(p0); + }, + visitAtRule$1(receiver, p0) { + return receiver.visitAtRule(p0); + }, + get$visitContentBlock(obj) { + return obj.visitContentBlock; + }, + visitContentBlock$1(receiver, p0) { + return receiver.visitContentBlock(p0); + }, + visitContentRule$1(receiver, p0) { + return receiver.visitContentRule(p0); + }, + visitDebugRule$1(receiver, p0) { + return receiver.visitDebugRule(p0); + }, + visitDeclaration$1(receiver, p0) { + return receiver.visitDeclaration(p0); + }, + visitEachRule$1(receiver, p0) { + return receiver.visitEachRule(p0); + }, + visitErrorRule$1(receiver, p0) { + return receiver.visitErrorRule(p0); + }, + visitExtendRule$1(receiver, p0) { + return receiver.visitExtendRule(p0); + }, + visitForRule$1(receiver, p0) { + return receiver.visitForRule(p0); + }, + visitForwardRule$1(receiver, p0) { + return receiver.visitForwardRule(p0); + }, + visitFunctionRule$1(receiver, p0) { + return receiver.visitFunctionRule(p0); + }, + visitIfRule$1(receiver, p0) { + return receiver.visitIfRule(p0); + }, + visitImportRule$1(receiver, p0) { + return receiver.visitImportRule(p0); + }, + visitIncludeRule$1(receiver, p0) { + return receiver.visitIncludeRule(p0); + }, + visitLoudComment$1(receiver, p0) { + return receiver.visitLoudComment(p0); + }, + visitMediaRule$1(receiver, p0) { + return receiver.visitMediaRule(p0); + }, + visitMixinRule$1(receiver, p0) { + return receiver.visitMixinRule(p0); + }, + visitReturnRule$1(receiver, p0) { + return receiver.visitReturnRule(p0); + }, + visitSilentComment$1(receiver, p0) { + return receiver.visitSilentComment(p0); + }, + visitStyleRule$1(receiver, p0) { + return receiver.visitStyleRule(p0); + }, + visitStylesheet$1(receiver, p0) { + return receiver.visitStylesheet(p0); + }, + visitSupportsRule$1(receiver, p0) { + return receiver.visitSupportsRule(p0); + }, + visitUseRule$1(receiver, p0) { + return receiver.visitUseRule(p0); + }, + visitVariableDeclaration$1(receiver, p0) { + return receiver.visitVariableDeclaration(p0); + }, + visitWarnRule$1(receiver, p0) { + return receiver.visitWarnRule(p0); + }, + visitWhileRule$1(receiver, p0) { + return receiver.visitWhileRule(p0); + }, + get$quotes(obj) { + return obj.quotes; + } + }; + J.PlainJavaScriptObject.prototype = {}; + J.UnknownJavaScriptObject.prototype = {}; + J.JavaScriptFunction.prototype = { + toString$0(receiver) { + var dartClosure = receiver[$.$get$DART_CLOSURE_PROPERTY_NAME()]; + if (dartClosure == null) + return this.super$LegacyJavaScriptObject$toString(receiver); + return "JavaScript function for " + A.S(J.toString$0$(dartClosure)); + }, + $isFunction: 1 + }; + J.JavaScriptBigInt.prototype = { + get$hashCode(receiver) { + return 0; + }, + toString$0(receiver) { + return String(receiver); + } + }; + J.JavaScriptSymbol.prototype = { + get$hashCode(receiver) { + return 0; + }, + toString$0(receiver) { + return String(receiver); + } + }; + J.JSArray.prototype = { + cast$1$0(receiver, $R) { + return new A.CastList(receiver, A._arrayInstanceType(receiver)._eval$1("@<1>")._bind$1($R)._eval$1("CastList<1,2>")); + }, + add$1(receiver, value) { + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, 29); + receiver.push(value); + }, + removeAt$1(receiver, index) { + var t1; + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, "removeAt", 1); + t1 = receiver.length; + if (index >= t1) + throw A.wrapException(A.RangeError$value(index, null, null)); + return receiver.splice(index, 1)[0]; + }, + insert$2(receiver, index, value) { + var t1; + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, "insert", 2); + t1 = receiver.length; + if (index > t1) + throw A.wrapException(A.RangeError$value(index, null, null)); + receiver.splice(index, 0, value); + }, + insertAll$2(receiver, index, iterable) { + var insertionLength, end; + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, "insertAll", 2); + A.RangeError_checkValueInInterval(index, 0, receiver.length, "index"); + if (!type$.EfficientLengthIterable_dynamic._is(iterable)) + iterable = J.toList$0$ax(iterable); + insertionLength = J.get$length$asx(iterable); + receiver.length = receiver.length + insertionLength; + end = index + insertionLength; + this.setRange$4(receiver, end, receiver.length, receiver, index); + this.setRange$3(receiver, index, end, iterable); + }, + removeLast$0(receiver) { + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, "removeLast", 1); + if (receiver.length === 0) + throw A.wrapException(A.diagnoseIndexError(receiver, -1)); + return receiver.pop(); + }, + _removeWhere$2(receiver, test, removeMatching) { + var i, element, t1, retained = [], + end = receiver.length; + for (i = 0; i < end; ++i) { + element = receiver[i]; + if (!test.call$1(element)) + retained.push(element); + if (receiver.length !== end) + throw A.wrapException(A.ConcurrentModificationError$(receiver)); + } + t1 = retained.length; + if (t1 === end) + return; + this.set$length(receiver, t1); + for (i = 0; i < retained.length; ++i) + receiver[i] = retained[i]; + }, + where$1(receiver, f) { + return new A.WhereIterable(receiver, f, A._arrayInstanceType(receiver)._eval$1("WhereIterable<1>")); + }, + expand$1$1(receiver, f, $T) { + return new A.ExpandIterable(receiver, f, A._arrayInstanceType(receiver)._eval$1("@<1>")._bind$1($T)._eval$1("ExpandIterable<1,2>")); + }, + addAll$1(receiver, collection) { + var t1; + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, "addAll", 2); + if (Array.isArray(collection)) { + this._addAllFromArray$1(receiver, collection); + return; + } + for (t1 = J.get$iterator$ax(collection); t1.moveNext$0();) + receiver.push(t1.get$current(t1)); + }, + _addAllFromArray$1(receiver, array) { + var i, + len = array.length; + if (len === 0) + return; + if (receiver === array) + throw A.wrapException(A.ConcurrentModificationError$(receiver)); + for (i = 0; i < len; ++i) + receiver.push(array[i]); + }, + clear$0(receiver) { + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, "clear", "clear"); + receiver.length = 0; + }, + forEach$1(receiver, f) { + var i, + end = receiver.length; + for (i = 0; i < end; ++i) { + f.call$1(receiver[i]); + if (receiver.length !== end) + throw A.wrapException(A.ConcurrentModificationError$(receiver)); + } + }, + map$1$1(receiver, f, $T) { + return new A.MappedListIterable(receiver, f, A._arrayInstanceType(receiver)._eval$1("@<1>")._bind$1($T)._eval$1("MappedListIterable<1,2>")); + }, + join$1(receiver, separator) { + var i, + list = A.List_List$filled(receiver.length, "", false, type$.String); + for (i = 0; i < receiver.length; ++i) + list[i] = A.S(receiver[i]); + return list.join(separator); + }, + join$0(receiver) { + return this.join$1(receiver, ""); + }, + take$1(receiver, n) { + return A.SubListIterable$(receiver, 0, A.checkNotNullable(n, "count", type$.int), A._arrayInstanceType(receiver)._precomputed1); + }, + skip$1(receiver, n) { + return A.SubListIterable$(receiver, n, null, A._arrayInstanceType(receiver)._precomputed1); + }, + fold$1$2(receiver, initialValue, combine) { + var value, i, + $length = receiver.length; + for (value = initialValue, i = 0; i < $length; ++i) { + value = combine.call$2(value, receiver[i]); + if (receiver.length !== $length) + throw A.wrapException(A.ConcurrentModificationError$(receiver)); + } + return value; + }, + fold$2(receiver, initialValue, combine) { + return this.fold$1$2(receiver, initialValue, combine, type$.dynamic); + }, + firstWhere$1(receiver, test) { + var i, element, + end = receiver.length; + for (i = 0; i < end; ++i) { + element = receiver[i]; + if (test.call$1(element)) + return element; + if (receiver.length !== end) + throw A.wrapException(A.ConcurrentModificationError$(receiver)); + } + throw A.wrapException(A.IterableElementError_noElement()); + }, + elementAt$1(receiver, index) { + return receiver[index]; + }, + sublist$2(receiver, start, end) { + var end0 = receiver.length; + if (start > end0) + throw A.wrapException(A.RangeError$range(start, 0, end0, "start", null)); + if (end == null) + end = end0; + else if (end < start || end > end0) + throw A.wrapException(A.RangeError$range(end, start, end0, "end", null)); + if (start === end) + return A._setArrayType([], A._arrayInstanceType(receiver)); + return A._setArrayType(receiver.slice(start, end), A._arrayInstanceType(receiver)); + }, + sublist$1(receiver, start) { + return this.sublist$2(receiver, start, null); + }, + getRange$2(receiver, start, end) { + A.RangeError_checkValidRange(start, end, receiver.length); + return A.SubListIterable$(receiver, start, end, A._arrayInstanceType(receiver)._precomputed1); + }, + get$first(receiver) { + if (receiver.length > 0) + return receiver[0]; + throw A.wrapException(A.IterableElementError_noElement()); + }, + get$last(receiver) { + var t1 = receiver.length; + if (t1 > 0) + return receiver[t1 - 1]; + throw A.wrapException(A.IterableElementError_noElement()); + }, + get$single(receiver) { + var t1 = receiver.length; + if (t1 === 1) + return receiver[0]; + if (t1 === 0) + throw A.wrapException(A.IterableElementError_noElement()); + throw A.wrapException(A.IterableElementError_tooMany()); + }, + removeRange$2(receiver, start, end) { + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, 18); + A.RangeError_checkValidRange(start, end, receiver.length); + receiver.splice(start, end - start); + }, + setRange$4(receiver, start, end, iterable, skipCount) { + var $length, otherList, otherStart, t1, i; + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver, 5); + A.RangeError_checkValidRange(start, end, receiver.length); + $length = end - start; + if ($length === 0) + return; + A.RangeError_checkNotNegative(skipCount, "skipCount"); + if (type$.List_dynamic._is(iterable)) { + otherList = iterable; + otherStart = skipCount; + } else { + otherList = J.skip$1$ax(iterable, skipCount).toList$1$growable(0, false); + otherStart = 0; + } + t1 = J.getInterceptor$asx(otherList); + if (otherStart + $length > t1.get$length(otherList)) + throw A.wrapException(A.IterableElementError_tooFew()); + if (otherStart < start) + for (i = $length - 1; i >= 0; --i) + receiver[start + i] = t1.$index(otherList, otherStart + i); + else + for (i = 0; i < $length; ++i) + receiver[start + i] = t1.$index(otherList, otherStart + i); + }, + setRange$3(receiver, start, end, iterable) { + return this.setRange$4(receiver, start, end, iterable, 0); + }, + fillRange$3(receiver, start, end, fillValue) { + var i; + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver, "fillRange"); + A.RangeError_checkValidRange(start, end, receiver.length); + A._arrayInstanceType(receiver)._precomputed1._as(fillValue); + for (i = start; i < end; ++i) + receiver[i] = fillValue; + }, + any$1(receiver, test) { + var i, + end = receiver.length; + for (i = 0; i < end; ++i) { + if (test.call$1(receiver[i])) + return true; + if (receiver.length !== end) + throw A.wrapException(A.ConcurrentModificationError$(receiver)); + } + return false; + }, + every$1(receiver, test) { + var i, + end = receiver.length; + for (i = 0; i < end; ++i) { + if (!test.call$1(receiver[i])) + return false; + if (receiver.length !== end) + throw A.wrapException(A.ConcurrentModificationError$(receiver)); + } + return true; + }, + get$reversed(receiver) { + return new A.ReversedListIterable(receiver, A._arrayInstanceType(receiver)._eval$1("ReversedListIterable<1>")); + }, + sort$1(receiver, compare) { + var len, a, b, undefineds, i; + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver, "sort"); + len = receiver.length; + if (len < 2) + return; + if (compare == null) + compare = J._interceptors_JSArray__compareAny$closure(); + if (len === 2) { + a = receiver[0]; + b = receiver[1]; + if (compare.call$2(a, b) > 0) { + receiver[0] = b; + receiver[1] = a; + } + return; + } + undefineds = 0; + if (A._arrayInstanceType(receiver)._precomputed1._is(null)) + for (i = 0; i < receiver.length; ++i) + if (receiver[i] === void 0) { + receiver[i] = null; + ++undefineds; + } + receiver.sort(A.convertDartClosureToJS(compare, 2)); + if (undefineds > 0) + this._replaceSomeNullsWithUndefined$1(receiver, undefineds); + }, + sort$0(receiver) { + return this.sort$1(receiver, null); + }, + _replaceSomeNullsWithUndefined$1(receiver, count) { + var i0, + i = receiver.length; + for (; i0 = i - 1, i > 0; i = i0) + if (receiver[i0] === null) { + receiver[i0] = void 0; + --count; + if (count === 0) + break; + } + }, + indexOf$1(receiver, element) { + var i, + $length = receiver.length; + if (0 >= $length) + return -1; + for (i = 0; i < $length; ++i) + if (J.$eq$(receiver[i], element)) + return i; + return -1; + }, + contains$1(receiver, other) { + var i; + for (i = 0; i < receiver.length; ++i) + if (J.$eq$(receiver[i], other)) + return true; + return false; + }, + get$isEmpty(receiver) { + return receiver.length === 0; + }, + get$isNotEmpty(receiver) { + return receiver.length !== 0; + }, + toString$0(receiver) { + return A.Iterable_iterableToFullString(receiver, "[", "]"); + }, + toList$1$growable(receiver, growable) { + var t1 = A._setArrayType(receiver.slice(0), A._arrayInstanceType(receiver)); + return t1; + }, + toList$0(receiver) { + return this.toList$1$growable(receiver, true); + }, + toSet$0(receiver) { + return A.LinkedHashSet_LinkedHashSet$from(receiver, A._arrayInstanceType(receiver)._precomputed1); + }, + get$iterator(receiver) { + return new J.ArrayIterator(receiver, receiver.length, A._arrayInstanceType(receiver)._eval$1("ArrayIterator<1>")); + }, + get$hashCode(receiver) { + return A.Primitives_objectHashCode(receiver); + }, + get$length(receiver) { + return receiver.length; + }, + set$length(receiver, newLength) { + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, "set length", "change the length of"); + if (newLength < 0) + throw A.wrapException(A.RangeError$range(newLength, 0, null, "newLength", null)); + if (newLength > receiver.length) + A._arrayInstanceType(receiver)._precomputed1._as(null); + receiver.length = newLength; + }, + $index(receiver, index) { + if (!(index >= 0 && index < receiver.length)) + throw A.wrapException(A.diagnoseIndexError(receiver, index)); + return receiver[index]; + }, + $indexSet(receiver, index, value) { + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver); + if (!(index >= 0 && index < receiver.length)) + throw A.wrapException(A.diagnoseIndexError(receiver, index)); + receiver[index] = value; + }, + $add(receiver, other) { + var t1 = A.List_List$of(receiver, true, A._arrayInstanceType(receiver)._precomputed1); + this.addAll$1(t1, other); + return t1; + }, + indexWhere$1(receiver, test) { + var i; + if (0 >= receiver.length) + return -1; + for (i = 0; i < receiver.length; ++i) + if (test.call$1(receiver[i])) + return i; + return -1; + }, + $isEfficientLengthIterable: 1, + $isIterable: 1, + $isList: 1 + }; + J.JSUnmodifiableArray.prototype = {}; + J.ArrayIterator.prototype = { + get$current(_) { + var t1 = this._current; + return t1 == null ? this.$ti._precomputed1._as(t1) : t1; + }, + moveNext$0() { + var t2, _this = this, + t1 = _this._iterable, + $length = t1.length; + if (_this._length !== $length) + throw A.wrapException(A.throwConcurrentModificationError(t1)); + t2 = _this._index; + if (t2 >= $length) { + _this._current = null; + return false; + } + _this._current = t1[t2]; + _this._index = t2 + 1; + return true; + } + }; + J.JSNumber.prototype = { + compareTo$1(receiver, b) { + var bIsNegative; + if (receiver < b) + return -1; + else if (receiver > b) + return 1; + else if (receiver === b) { + if (receiver === 0) { + bIsNegative = this.get$isNegative(b); + if (this.get$isNegative(receiver) === bIsNegative) + return 0; + if (this.get$isNegative(receiver)) + return -1; + return 1; + } + return 0; + } else if (isNaN(receiver)) { + if (isNaN(b)) + return 0; + return 1; + } else + return -1; + }, + get$isNegative(receiver) { + return receiver === 0 ? 1 / receiver < 0 : receiver < 0; + }, + get$sign(receiver) { + var t1; + if (receiver > 0) + t1 = 1; + else + t1 = receiver < 0 ? -1 : receiver; + return t1; + }, + ceil$0(receiver) { + var truncated, d; + if (receiver >= 0) { + if (receiver <= 2147483647) { + truncated = receiver | 0; + return receiver === truncated ? truncated : truncated + 1; + } + } else if (receiver >= -2147483648) + return receiver | 0; + d = Math.ceil(receiver); + if (isFinite(d)) + return d; + throw A.wrapException(A.UnsupportedError$("" + receiver + ".ceil()")); + }, + floor$0(receiver) { + var truncated, d; + if (receiver >= 0) { + if (receiver <= 2147483647) + return receiver | 0; + } else if (receiver >= -2147483648) { + truncated = receiver | 0; + return receiver === truncated ? truncated : truncated - 1; + } + d = Math.floor(receiver); + if (isFinite(d)) + return d; + throw A.wrapException(A.UnsupportedError$("" + receiver + ".floor()")); + }, + round$0(receiver) { + if (receiver > 0) { + if (receiver !== 1 / 0) + return Math.round(receiver); + } else if (receiver > -1 / 0) + return 0 - Math.round(0 - receiver); + throw A.wrapException(A.UnsupportedError$("" + receiver + ".round()")); + }, + clamp$2(receiver, lowerLimit, upperLimit) { + if (this.compareTo$1(lowerLimit, upperLimit) > 0) + throw A.wrapException(A.argumentErrorValue(lowerLimit)); + if (this.compareTo$1(receiver, lowerLimit) < 0) + return lowerLimit; + if (this.compareTo$1(receiver, upperLimit) > 0) + return upperLimit; + return receiver; + }, + toRadixString$1(receiver, radix) { + var result, match, exponent, t1; + if (radix < 2 || radix > 36) + throw A.wrapException(A.RangeError$range(radix, 2, 36, "radix", null)); + result = receiver.toString(radix); + if (result.charCodeAt(result.length - 1) !== 41) + return result; + match = /^([\da-z]+)(?:\.([\da-z]+))?\(e\+(\d+)\)$/.exec(result); + if (match == null) + A.throwExpression(A.UnsupportedError$("Unexpected toString result: " + result)); + result = match[1]; + exponent = +match[3]; + t1 = match[2]; + if (t1 != null) { + result += t1; + exponent -= t1.length; + } + return result + B.JSString_methods.$mul("0", exponent); + }, + toString$0(receiver) { + if (receiver === 0 && 1 / receiver < 0) + return "-0.0"; + else + return "" + receiver; + }, + get$hashCode(receiver) { + var absolute, floorLog2, factor, scaled, + intValue = receiver | 0; + if (receiver === intValue) + return intValue & 536870911; + absolute = Math.abs(receiver); + floorLog2 = Math.log(absolute) / 0.6931471805599453 | 0; + factor = Math.pow(2, floorLog2); + scaled = absolute < 1 ? absolute / factor : factor / absolute; + return ((scaled * 9007199254740992 | 0) + (scaled * 3542243181176521 | 0)) * 599197 + floorLog2 * 1259 & 536870911; + }, + $mod(receiver, other) { + var result = receiver % other; + if (result === 0) + return 0; + if (result > 0) + return result; + if (other < 0) + return result - other; + else + return result + other; + }, + $tdiv(receiver, other) { + if ((receiver | 0) === receiver) + if (other >= 1 || other < -1) + return receiver / other | 0; + return this._tdivSlow$1(receiver, other); + }, + _tdivFast$1(receiver, other) { + return (receiver | 0) === receiver ? receiver / other | 0 : this._tdivSlow$1(receiver, other); + }, + _tdivSlow$1(receiver, other) { + var quotient = receiver / other; + if (quotient >= -2147483648 && quotient <= 2147483647) + return quotient | 0; + if (quotient > 0) { + if (quotient !== 1 / 0) + return Math.floor(quotient); + } else if (quotient > -1 / 0) + return Math.ceil(quotient); + throw A.wrapException(A.UnsupportedError$("Result of truncating division is " + A.S(quotient) + ": " + A.S(receiver) + " ~/ " + other)); + }, + _shrOtherPositive$1(receiver, other) { + var t1; + if (receiver > 0) + t1 = this._shrBothPositive$1(receiver, other); + else { + t1 = other > 31 ? 31 : other; + t1 = receiver >> t1 >>> 0; + } + return t1; + }, + _shrReceiverPositive$1(receiver, other) { + if (0 > other) + throw A.wrapException(A.argumentErrorValue(other)); + return this._shrBothPositive$1(receiver, other); + }, + _shrBothPositive$1(receiver, other) { + return other > 31 ? 0 : receiver >>> other; + }, + get$runtimeType(receiver) { + return A.createRuntimeType(type$.num); + }, + $isComparable: 1, + $isdouble: 1, + $isnum: 1 + }; + J.JSInt.prototype = { + get$sign(receiver) { + var t1; + if (receiver > 0) + t1 = 1; + else + t1 = receiver < 0 ? -1 : receiver; + return t1; + }, + get$runtimeType(receiver) { + return A.createRuntimeType(type$.int); + }, + $isTrustedGetRuntimeType: 1, + $isint: 1 + }; + J.JSNumNotInt.prototype = { + get$runtimeType(receiver) { + return A.createRuntimeType(type$.double); + }, + $isTrustedGetRuntimeType: 1 + }; + J.JSString.prototype = { + codeUnitAt$1(receiver, index) { + if (index < 0) + throw A.wrapException(A.diagnoseIndexError(receiver, index)); + if (index >= receiver.length) + A.throwExpression(A.diagnoseIndexError(receiver, index)); + return receiver.charCodeAt(index); + }, + allMatches$2(receiver, string, start) { + var t1 = string.length; + if (start > t1) + throw A.wrapException(A.RangeError$range(start, 0, t1, null, null)); + return new A._StringAllMatchesIterable(string, receiver, start); + }, + allMatches$1(receiver, string) { + return this.allMatches$2(receiver, string, 0); + }, + matchAsPrefix$2(receiver, string, start) { + var t1, i, _null = null; + if (start < 0 || start > string.length) + throw A.wrapException(A.RangeError$range(start, 0, string.length, _null, _null)); + t1 = receiver.length; + if (start + t1 > string.length) + return _null; + for (i = 0; i < t1; ++i) + if (string.charCodeAt(start + i) !== receiver.charCodeAt(i)) + return _null; + return new A.StringMatch(start, receiver); + }, + $add(receiver, other) { + return receiver + other; + }, + endsWith$1(receiver, other) { + var otherLength = other.length, + t1 = receiver.length; + if (otherLength > t1) + return false; + return other === this.substring$1(receiver, t1 - otherLength); + }, + replaceFirst$2(receiver, from, to) { + A.RangeError_checkValueInInterval(0, 0, receiver.length, "startIndex"); + return A.stringReplaceFirstUnchecked(receiver, from, to, 0); + }, + split$1(receiver, pattern) { + var nativeAnchoredRegExp, t1; + if (typeof pattern == "string") + return A._setArrayType(receiver.split(pattern), type$.JSArray_String); + else { + if (pattern instanceof A.JSSyntaxRegExp) { + nativeAnchoredRegExp = pattern.get$_nativeAnchoredVersion(); + nativeAnchoredRegExp.lastIndex = 0; + t1 = nativeAnchoredRegExp.exec("").length - 2 === 0; + } else + t1 = false; + if (t1) + return A._setArrayType(receiver.split(pattern._nativeRegExp), type$.JSArray_String); + else + return this._defaultSplit$1(receiver, pattern); + } + }, + replaceRange$3(receiver, start, end, replacement) { + var e = A.RangeError_checkValidRange(start, end, receiver.length); + return A.stringReplaceRangeUnchecked(receiver, start, e, replacement); + }, + _defaultSplit$1(receiver, pattern) { + var t1, start, $length, match, matchStart, matchEnd, + result = A._setArrayType([], type$.JSArray_String); + for (t1 = J.allMatches$1$s(pattern, receiver), t1 = t1.get$iterator(t1), start = 0, $length = 1; t1.moveNext$0();) { + match = t1.get$current(t1); + matchStart = match.get$start(match); + matchEnd = match.get$end(match); + $length = matchEnd - matchStart; + if ($length === 0 && start === matchStart) + continue; + result.push(this.substring$2(receiver, start, matchStart)); + start = matchEnd; + } + if (start < receiver.length || $length > 0) + result.push(this.substring$1(receiver, start)); + return result; + }, + startsWith$2(receiver, pattern, index) { + var endIndex; + if (index < 0 || index > receiver.length) + throw A.wrapException(A.RangeError$range(index, 0, receiver.length, null, null)); + if (typeof pattern == "string") { + endIndex = index + pattern.length; + if (endIndex > receiver.length) + return false; + return pattern === receiver.substring(index, endIndex); + } + return J.matchAsPrefix$2$s(pattern, receiver, index) != null; + }, + startsWith$1(receiver, pattern) { + return this.startsWith$2(receiver, pattern, 0); + }, + substring$2(receiver, start, end) { + return receiver.substring(start, A.RangeError_checkValidRange(start, end, receiver.length)); + }, + substring$1(receiver, start) { + return this.substring$2(receiver, start, null); + }, + trim$0(receiver) { + var startIndex, t1, endIndex0, + result = receiver.trim(), + endIndex = result.length; + if (endIndex === 0) + return result; + if (result.charCodeAt(0) === 133) { + startIndex = J.JSString__skipLeadingWhitespace(result, 1); + if (startIndex === endIndex) + return ""; + } else + startIndex = 0; + t1 = endIndex - 1; + endIndex0 = result.charCodeAt(t1) === 133 ? J.JSString__skipTrailingWhitespace(result, t1) : endIndex; + if (startIndex === 0 && endIndex0 === endIndex) + return result; + return result.substring(startIndex, endIndex0); + }, + trimLeft$0(receiver) { + var result = receiver.trimStart(); + if (result.length === 0) + return result; + if (result.charCodeAt(0) !== 133) + return result; + return result.substring(J.JSString__skipLeadingWhitespace(result, 1)); + }, + trimRight$0(receiver) { + var t1, + result = receiver.trimEnd(), + endIndex = result.length; + if (endIndex === 0) + return result; + t1 = endIndex - 1; + if (result.charCodeAt(t1) !== 133) + return result; + return result.substring(0, J.JSString__skipTrailingWhitespace(result, t1)); + }, + $mul(receiver, times) { + var s, result; + if (0 >= times) + return ""; + if (times === 1 || receiver.length === 0) + return receiver; + if (times !== times >>> 0) + throw A.wrapException(B.C_OutOfMemoryError); + for (s = receiver, result = ""; true;) { + if ((times & 1) === 1) + result = s + result; + times = times >>> 1; + if (times === 0) + break; + s += s; + } + return result; + }, + padLeft$2(receiver, width, padding) { + var delta = width - receiver.length; + if (delta <= 0) + return receiver; + return this.$mul(padding, delta) + receiver; + }, + padRight$1(receiver, width) { + var delta = width - receiver.length; + if (delta <= 0) + return receiver; + return receiver + this.$mul(" ", delta); + }, + indexOf$2(receiver, pattern, start) { + var t1; + if (start < 0 || start > receiver.length) + throw A.wrapException(A.RangeError$range(start, 0, receiver.length, null, null)); + t1 = receiver.indexOf(pattern, start); + return t1; + }, + indexOf$1(receiver, pattern) { + return this.indexOf$2(receiver, pattern, 0); + }, + lastIndexOf$2(receiver, pattern, start) { + var t1, t2, i; + if (start == null) + start = receiver.length; + else if (start < 0 || start > receiver.length) + throw A.wrapException(A.RangeError$range(start, 0, receiver.length, null, null)); + if (typeof pattern == "string") { + t1 = pattern.length; + t2 = receiver.length; + if (start + t1 > t2) + start = t2 - t1; + return receiver.lastIndexOf(pattern, start); + } + for (t1 = J.getInterceptor$s(pattern), i = start; i >= 0; --i) + if (t1.matchAsPrefix$2(pattern, receiver, i) != null) + return i; + return -1; + }, + lastIndexOf$1(receiver, pattern) { + return this.lastIndexOf$2(receiver, pattern, null); + }, + contains$2(receiver, other, startIndex) { + var t1 = receiver.length; + if (startIndex > t1) + throw A.wrapException(A.RangeError$range(startIndex, 0, t1, null, null)); + return A.stringContainsUnchecked(receiver, other, startIndex); + }, + contains$1(receiver, other) { + return this.contains$2(receiver, other, 0); + }, + compareTo$1(receiver, other) { + var t1; + if (receiver === other) + t1 = 0; + else + t1 = receiver < other ? -1 : 1; + return t1; + }, + toString$0(receiver) { + return receiver; + }, + get$hashCode(receiver) { + var t1, hash, i; + for (t1 = receiver.length, hash = 0, i = 0; i < t1; ++i) { + hash = hash + receiver.charCodeAt(i) & 536870911; + hash = hash + ((hash & 524287) << 10) & 536870911; + hash ^= hash >> 6; + } + hash = hash + ((hash & 67108863) << 3) & 536870911; + hash ^= hash >> 11; + return hash + ((hash & 16383) << 15) & 536870911; + }, + get$runtimeType(receiver) { + return A.createRuntimeType(type$.String); + }, + get$length(receiver) { + return receiver.length; + }, + $isTrustedGetRuntimeType: 1, + $isComparable: 1, + $isString: 1 + }; + A._CastIterableBase.prototype = { + get$iterator(_) { + return new A.CastIterator(J.get$iterator$ax(this.get$_source()), A._instanceType(this)._eval$1("CastIterator<1,2>")); + }, + get$length(_) { + return J.get$length$asx(this.get$_source()); + }, + get$isEmpty(_) { + return J.get$isEmpty$asx(this.get$_source()); + }, + get$isNotEmpty(_) { + return J.get$isNotEmpty$asx(this.get$_source()); + }, + skip$1(_, count) { + var t1 = A._instanceType(this); + return A.CastIterable_CastIterable(J.skip$1$ax(this.get$_source(), count), t1._precomputed1, t1._rest[1]); + }, + take$1(_, count) { + var t1 = A._instanceType(this); + return A.CastIterable_CastIterable(J.take$1$ax(this.get$_source(), count), t1._precomputed1, t1._rest[1]); + }, + elementAt$1(_, index) { + return A._instanceType(this)._rest[1]._as(J.elementAt$1$ax(this.get$_source(), index)); + }, + get$first(_) { + return A._instanceType(this)._rest[1]._as(J.get$first$ax(this.get$_source())); + }, + get$last(_) { + return A._instanceType(this)._rest[1]._as(J.get$last$ax(this.get$_source())); + }, + get$single(_) { + return A._instanceType(this)._rest[1]._as(J.get$single$ax(this.get$_source())); + }, + contains$1(_, other) { + return J.contains$1$asx(this.get$_source(), other); + }, + toString$0(_) { + return J.toString$0$(this.get$_source()); + } + }; + A.CastIterator.prototype = { + moveNext$0() { + return this._source.moveNext$0(); + }, + get$current(_) { + var t1 = this._source; + return this.$ti._rest[1]._as(t1.get$current(t1)); + } + }; + A.CastIterable.prototype = { + get$_source() { + return this._source; + } + }; + A._EfficientLengthCastIterable.prototype = {$isEfficientLengthIterable: 1}; + A._CastListBase.prototype = { + $index(_, index) { + return this.$ti._rest[1]._as(J.$index$asx(this._source, index)); + }, + $indexSet(_, index, value) { + J.$indexSet$ax(this._source, index, this.$ti._precomputed1._as(value)); + }, + set$length(_, $length) { + J.set$length$asx(this._source, $length); + }, + add$1(_, value) { + J.add$1$ax(this._source, this.$ti._precomputed1._as(value)); + }, + addAll$1(_, values) { + var t1 = this.$ti; + J.addAll$1$ax(this._source, A.CastIterable_CastIterable(values, t1._rest[1], t1._precomputed1)); + }, + sort$1(_, compare) { + var t1 = compare == null ? null : new A._CastListBase_sort_closure(this, compare); + J.sort$1$ax(this._source, t1); + }, + getRange$2(_, start, end) { + var t1 = this.$ti; + return A.CastIterable_CastIterable(J.getRange$2$ax(this._source, start, end), t1._precomputed1, t1._rest[1]); + }, + setRange$4(_, start, end, iterable, skipCount) { + var t1 = this.$ti; + J.setRange$4$ax(this._source, start, end, A.CastIterable_CastIterable(iterable, t1._rest[1], t1._precomputed1), skipCount); + }, + removeRange$2(_, start, end) { + J.removeRange$2$ax(this._source, start, end); + }, + fillRange$3(_, start, end, fillValue) { + J.fillRange$3$ax(this._source, start, end, this.$ti._precomputed1._as(fillValue)); + }, + $isEfficientLengthIterable: 1, + $isList: 1 + }; + A._CastListBase_sort_closure.prototype = { + call$2(v1, v2) { + var t1 = this.$this.$ti._rest[1]; + return this.compare.call$2(t1._as(v1), t1._as(v2)); + }, + $signature() { + return this.$this.$ti._eval$1("int(1,1)"); + } + }; + A.CastList.prototype = { + cast$1$0(_, $R) { + return new A.CastList(this._source, this.$ti._eval$1("@<1>")._bind$1($R)._eval$1("CastList<1,2>")); + }, + get$_source() { + return this._source; + } + }; + A.CastSet.prototype = { + add$1(_, value) { + return this._source.add$1(0, this.$ti._precomputed1._as(value)); + }, + addAll$1(_, elements) { + var t1 = this.$ti; + this._source.addAll$1(0, A.CastIterable_CastIterable(elements, t1._rest[1], t1._precomputed1)); + }, + difference$1(other) { + var _this = this; + if (_this._emptySet != null) + return _this._conditionalAdd$2(other, false); + return new A.CastSet(_this._source.difference$1(other), null, _this.$ti); + }, + _conditionalAdd$2(other, otherContains) { + var t3, castElement, + emptySet = this._emptySet, + t1 = this.$ti, + t2 = t1._rest[1], + result = emptySet == null ? A.LinkedHashSet_LinkedHashSet(t2) : emptySet.call$1$0(t2); + for (t2 = this._source, t2 = t2.get$iterator(t2), t3 = other._source, t1 = t1._rest[1]; t2.moveNext$0();) { + castElement = t1._as(t2.get$current(t2)); + if (otherContains === t3.contains$1(0, castElement)) + result.add$1(0, castElement); + } + return result; + }, + toSet$0(_) { + var emptySet = this._emptySet, + t1 = this.$ti._rest[1], + result = emptySet == null ? A.LinkedHashSet_LinkedHashSet(t1) : emptySet.call$1$0(t1); + result.addAll$1(0, this); + return result; + }, + $isEfficientLengthIterable: 1, + $isSet: 1, + get$_source() { + return this._source; + } + }; + A.CastMap.prototype = { + cast$2$0(_, RK, RV) { + return new A.CastMap(this._source, this.$ti._eval$1("@<1,2>")._bind$1(RK)._bind$1(RV)._eval$1("CastMap<1,2,3,4>")); + }, + containsKey$1(key) { + return this._source.containsKey$1(key); + }, + $index(_, key) { + return this.$ti._eval$1("4?")._as(this._source.$index(0, key)); + }, + $indexSet(_, key, value) { + var t1 = this.$ti; + this._source.$indexSet(0, t1._precomputed1._as(key), t1._rest[1]._as(value)); + }, + addAll$1(_, other) { + this._source.addAll$1(0, new A.CastMap(other, this.$ti._eval$1("CastMap<3,4,1,2>"))); + }, + remove$1(_, key) { + return this.$ti._eval$1("4?")._as(this._source.remove$1(0, key)); + }, + forEach$1(_, f) { + this._source.forEach$1(0, new A.CastMap_forEach_closure(this, f)); + }, + get$keys(_) { + var t1 = this._source, + t2 = this.$ti; + return A.CastIterable_CastIterable(t1.get$keys(t1), t2._precomputed1, t2._rest[2]); + }, + get$values(_) { + var t1 = this._source, + t2 = this.$ti; + return A.CastIterable_CastIterable(t1.get$values(t1), t2._rest[1], t2._rest[3]); + }, + get$length(_) { + var t1 = this._source; + return t1.get$length(t1); + }, + get$isEmpty(_) { + var t1 = this._source; + return t1.get$isEmpty(t1); + }, + get$isNotEmpty(_) { + var t1 = this._source; + return t1.get$isNotEmpty(t1); + }, + get$entries(_) { + var t1 = this._source; + t1 = t1.get$entries(t1); + return t1.map$1$1(t1, new A.CastMap_entries_closure(this), this.$ti._eval$1("MapEntry<3,4>")); + } + }; + A.CastMap_forEach_closure.prototype = { + call$2(key, value) { + var t1 = this.$this.$ti; + this.f.call$2(t1._rest[2]._as(key), t1._rest[3]._as(value)); + }, + $signature() { + return this.$this.$ti._eval$1("~(1,2)"); + } + }; + A.CastMap_entries_closure.prototype = { + call$1(e) { + var t1 = this.$this.$ti; + return new A.MapEntry(t1._rest[2]._as(e.key), t1._rest[3]._as(e.value), t1._eval$1("MapEntry<3,4>")); + }, + $signature() { + return this.$this.$ti._eval$1("MapEntry<3,4>(MapEntry<1,2>)"); + } + }; + A.LateError.prototype = { + toString$0(_) { + return "LateInitializationError: " + this._message; + } + }; + A.CodeUnits.prototype = { + get$length(_) { + return this._string.length; + }, + $index(_, i) { + return this._string.charCodeAt(i); + } + }; + A.nullFuture_closure.prototype = { + call$0() { + return A.Future_Future$value(null, type$.void); + }, + $signature: 32 + }; + A.SentinelValue.prototype = {}; + A.EfficientLengthIterable.prototype = {}; + A.ListIterable.prototype = { + get$iterator(_) { + var _this = this; + return new A.ListIterator(_this, _this.get$length(_this), A._instanceType(_this)._eval$1("ListIterator")); + }, + get$isEmpty(_) { + return this.get$length(this) === 0; + }, + get$first(_) { + if (this.get$length(this) === 0) + throw A.wrapException(A.IterableElementError_noElement()); + return this.elementAt$1(0, 0); + }, + get$last(_) { + var _this = this; + if (_this.get$length(_this) === 0) + throw A.wrapException(A.IterableElementError_noElement()); + return _this.elementAt$1(0, _this.get$length(_this) - 1); + }, + get$single(_) { + var _this = this; + if (_this.get$length(_this) === 0) + throw A.wrapException(A.IterableElementError_noElement()); + if (_this.get$length(_this) > 1) + throw A.wrapException(A.IterableElementError_tooMany()); + return _this.elementAt$1(0, 0); + }, + contains$1(_, element) { + var i, _this = this, + $length = _this.get$length(_this); + for (i = 0; i < $length; ++i) { + if (J.$eq$(_this.elementAt$1(0, i), element)) + return true; + if ($length !== _this.get$length(_this)) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + } + return false; + }, + every$1(_, test) { + var i, _this = this, + $length = _this.get$length(_this); + for (i = 0; i < $length; ++i) { + if (!test.call$1(_this.elementAt$1(0, i))) + return false; + if ($length !== _this.get$length(_this)) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + } + return true; + }, + any$1(_, test) { + var i, _this = this, + $length = _this.get$length(_this); + for (i = 0; i < $length; ++i) { + if (test.call$1(_this.elementAt$1(0, i))) + return true; + if ($length !== _this.get$length(_this)) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + } + return false; + }, + join$1(_, separator) { + var first, t1, i, _this = this, + $length = _this.get$length(_this); + if (separator.length !== 0) { + if ($length === 0) + return ""; + first = A.S(_this.elementAt$1(0, 0)); + if ($length !== _this.get$length(_this)) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + for (t1 = first, i = 1; i < $length; ++i) { + t1 = t1 + separator + A.S(_this.elementAt$1(0, i)); + if ($length !== _this.get$length(_this)) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + } + return t1.charCodeAt(0) == 0 ? t1 : t1; + } else { + for (i = 0, t1 = ""; i < $length; ++i) { + t1 += A.S(_this.elementAt$1(0, i)); + if ($length !== _this.get$length(_this)) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + } + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + }, + join$0(_) { + return this.join$1(0, ""); + }, + where$1(_, test) { + return this.super$Iterable$where(0, test); + }, + map$1$1(_, toElement, $T) { + return new A.MappedListIterable(this, toElement, A._instanceType(this)._eval$1("@")._bind$1($T)._eval$1("MappedListIterable<1,2>")); + }, + reduce$1(_, combine) { + var value, i, _this = this, + $length = _this.get$length(_this); + if ($length === 0) + throw A.wrapException(A.IterableElementError_noElement()); + value = _this.elementAt$1(0, 0); + for (i = 1; i < $length; ++i) { + value = combine.call$2(value, _this.elementAt$1(0, i)); + if ($length !== _this.get$length(_this)) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + } + return value; + }, + fold$1$2(_, initialValue, combine) { + var value, i, _this = this, + $length = _this.get$length(_this); + for (value = initialValue, i = 0; i < $length; ++i) { + value = combine.call$2(value, _this.elementAt$1(0, i)); + if ($length !== _this.get$length(_this)) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + } + return value; + }, + fold$2(_, initialValue, combine) { + return this.fold$1$2(0, initialValue, combine, type$.dynamic); + }, + skip$1(_, count) { + return A.SubListIterable$(this, count, null, A._instanceType(this)._eval$1("ListIterable.E")); + }, + take$1(_, count) { + return A.SubListIterable$(this, 0, A.checkNotNullable(count, "count", type$.int), A._instanceType(this)._eval$1("ListIterable.E")); + }, + toList$1$growable(_, growable) { + return A.List_List$of(this, true, A._instanceType(this)._eval$1("ListIterable.E")); + }, + toList$0(_) { + return this.toList$1$growable(0, true); + }, + toSet$0(_) { + var i, _this = this, + result = A.LinkedHashSet_LinkedHashSet(A._instanceType(_this)._eval$1("ListIterable.E")); + for (i = 0; i < _this.get$length(_this); ++i) + result.add$1(0, _this.elementAt$1(0, i)); + return result; + } + }; + A.SubListIterable.prototype = { + SubListIterable$3(_iterable, _start, _endOrLength, $E) { + var endOrLength, + t1 = this._start; + A.RangeError_checkNotNegative(t1, "start"); + endOrLength = this._endOrLength; + if (endOrLength != null) { + A.RangeError_checkNotNegative(endOrLength, "end"); + if (t1 > endOrLength) + throw A.wrapException(A.RangeError$range(t1, 0, endOrLength, "start", null)); + } + }, + get$_endIndex() { + var $length = J.get$length$asx(this.__internal$_iterable), + endOrLength = this._endOrLength; + if (endOrLength == null || endOrLength > $length) + return $length; + return endOrLength; + }, + get$_startIndex() { + var $length = J.get$length$asx(this.__internal$_iterable), + t1 = this._start; + if (t1 > $length) + return $length; + return t1; + }, + get$length(_) { + var endOrLength, + $length = J.get$length$asx(this.__internal$_iterable), + t1 = this._start; + if (t1 >= $length) + return 0; + endOrLength = this._endOrLength; + if (endOrLength == null || endOrLength >= $length) + return $length - t1; + return endOrLength - t1; + }, + elementAt$1(_, index) { + var _this = this, + realIndex = _this.get$_startIndex() + index; + if (index < 0 || realIndex >= _this.get$_endIndex()) + throw A.wrapException(A.IndexError$withLength(index, _this.get$length(0), _this, null, "index")); + return J.elementAt$1$ax(_this.__internal$_iterable, realIndex); + }, + skip$1(_, count) { + var newStart, endOrLength, _this = this; + A.RangeError_checkNotNegative(count, "count"); + newStart = _this._start + count; + endOrLength = _this._endOrLength; + if (endOrLength != null && newStart >= endOrLength) + return new A.EmptyIterable(_this.$ti._eval$1("EmptyIterable<1>")); + return A.SubListIterable$(_this.__internal$_iterable, newStart, endOrLength, _this.$ti._precomputed1); + }, + take$1(_, count) { + var endOrLength, t1, newEnd, _this = this; + A.RangeError_checkNotNegative(count, "count"); + endOrLength = _this._endOrLength; + t1 = _this._start; + newEnd = t1 + count; + if (endOrLength == null) + return A.SubListIterable$(_this.__internal$_iterable, t1, newEnd, _this.$ti._precomputed1); + else { + if (endOrLength < newEnd) + return _this; + return A.SubListIterable$(_this.__internal$_iterable, t1, newEnd, _this.$ti._precomputed1); + } + }, + toList$1$growable(_, growable) { + var $length, result, i, _this = this, + start = _this._start, + t1 = _this.__internal$_iterable, + t2 = J.getInterceptor$asx(t1), + end = t2.get$length(t1), + endOrLength = _this._endOrLength; + if (endOrLength != null && endOrLength < end) + end = endOrLength; + $length = end - start; + if ($length <= 0) { + t1 = _this.$ti._precomputed1; + return growable ? J.JSArray_JSArray$growable(0, t1) : J.JSArray_JSArray$fixed(0, t1); + } + result = A.List_List$filled($length, t2.elementAt$1(t1, start), growable, _this.$ti._precomputed1); + for (i = 1; i < $length; ++i) { + result[i] = t2.elementAt$1(t1, start + i); + if (t2.get$length(t1) < end) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + } + return result; + }, + toList$0(_) { + return this.toList$1$growable(0, true); + } + }; + A.ListIterator.prototype = { + get$current(_) { + var t1 = this.__internal$_current; + return t1 == null ? this.$ti._precomputed1._as(t1) : t1; + }, + moveNext$0() { + var t3, _this = this, + t1 = _this.__internal$_iterable, + t2 = J.getInterceptor$asx(t1), + $length = t2.get$length(t1); + if (_this.__internal$_length !== $length) + throw A.wrapException(A.ConcurrentModificationError$(t1)); + t3 = _this.__internal$_index; + if (t3 >= $length) { + _this.__internal$_current = null; + return false; + } + _this.__internal$_current = t2.elementAt$1(t1, t3); + ++_this.__internal$_index; + return true; + } + }; + A.MappedIterable.prototype = { + get$iterator(_) { + return new A.MappedIterator(J.get$iterator$ax(this.__internal$_iterable), this._f, A._instanceType(this)._eval$1("MappedIterator<1,2>")); + }, + get$length(_) { + return J.get$length$asx(this.__internal$_iterable); + }, + get$isEmpty(_) { + return J.get$isEmpty$asx(this.__internal$_iterable); + }, + get$first(_) { + return this._f.call$1(J.get$first$ax(this.__internal$_iterable)); + }, + get$last(_) { + return this._f.call$1(J.get$last$ax(this.__internal$_iterable)); + }, + get$single(_) { + return this._f.call$1(J.get$single$ax(this.__internal$_iterable)); + }, + elementAt$1(_, index) { + return this._f.call$1(J.elementAt$1$ax(this.__internal$_iterable, index)); + } + }; + A.EfficientLengthMappedIterable.prototype = {$isEfficientLengthIterable: 1}; + A.MappedIterator.prototype = { + moveNext$0() { + var _this = this, + t1 = _this._iterator; + if (t1.moveNext$0()) { + _this.__internal$_current = _this._f.call$1(t1.get$current(t1)); + return true; + } + _this.__internal$_current = null; + return false; + }, + get$current(_) { + var t1 = this.__internal$_current; + return t1 == null ? this.$ti._rest[1]._as(t1) : t1; + } + }; + A.MappedListIterable.prototype = { + get$length(_) { + return J.get$length$asx(this._source); + }, + elementAt$1(_, index) { + return this._f.call$1(J.elementAt$1$ax(this._source, index)); + } + }; + A.WhereIterable.prototype = { + get$iterator(_) { + return new A.WhereIterator(J.get$iterator$ax(this.__internal$_iterable), this._f); + }, + map$1$1(_, toElement, $T) { + return new A.MappedIterable(this, toElement, this.$ti._eval$1("@<1>")._bind$1($T)._eval$1("MappedIterable<1,2>")); + } + }; + A.WhereIterator.prototype = { + moveNext$0() { + var t1, t2; + for (t1 = this._iterator, t2 = this._f; t1.moveNext$0();) + if (t2.call$1(t1.get$current(t1))) + return true; + return false; + }, + get$current(_) { + var t1 = this._iterator; + return t1.get$current(t1); + } + }; + A.ExpandIterable.prototype = { + get$iterator(_) { + return new A.ExpandIterator(J.get$iterator$ax(this.__internal$_iterable), this._f, B.C_EmptyIterator, this.$ti._eval$1("ExpandIterator<1,2>")); + } + }; + A.ExpandIterator.prototype = { + get$current(_) { + var t1 = this.__internal$_current; + return t1 == null ? this.$ti._rest[1]._as(t1) : t1; + }, + moveNext$0() { + var t2, t3, _this = this, + t1 = _this._currentExpansion; + if (t1 == null) + return false; + for (t2 = _this._iterator, t3 = _this._f; !t1.moveNext$0();) { + _this.__internal$_current = null; + if (t2.moveNext$0()) { + _this._currentExpansion = null; + t1 = J.get$iterator$ax(t3.call$1(t2.get$current(t2))); + _this._currentExpansion = t1; + } else + return false; + } + t1 = _this._currentExpansion; + _this.__internal$_current = t1.get$current(t1); + return true; + } + }; + A.TakeIterable.prototype = { + get$iterator(_) { + return new A.TakeIterator(J.get$iterator$ax(this.__internal$_iterable), this._takeCount, A._instanceType(this)._eval$1("TakeIterator<1>")); + } + }; + A.EfficientLengthTakeIterable.prototype = { + get$length(_) { + var iterableLength = J.get$length$asx(this.__internal$_iterable), + t1 = this._takeCount; + if (iterableLength > t1) + return t1; + return iterableLength; + }, + $isEfficientLengthIterable: 1 + }; + A.TakeIterator.prototype = { + moveNext$0() { + if (--this._remaining >= 0) + return this._iterator.moveNext$0(); + this._remaining = -1; + return false; + }, + get$current(_) { + var t1; + if (this._remaining < 0) { + this.$ti._precomputed1._as(null); + return null; + } + t1 = this._iterator; + return t1.get$current(t1); + } + }; + A.SkipIterable.prototype = { + skip$1(_, count) { + A.ArgumentError_checkNotNull(count, "count"); + A.RangeError_checkNotNegative(count, "count"); + return new A.SkipIterable(this.__internal$_iterable, this._skipCount + count, A._instanceType(this)._eval$1("SkipIterable<1>")); + }, + get$iterator(_) { + return new A.SkipIterator(J.get$iterator$ax(this.__internal$_iterable), this._skipCount); + } + }; + A.EfficientLengthSkipIterable.prototype = { + get$length(_) { + var $length = J.get$length$asx(this.__internal$_iterable) - this._skipCount; + if ($length >= 0) + return $length; + return 0; + }, + skip$1(_, count) { + A.ArgumentError_checkNotNull(count, "count"); + A.RangeError_checkNotNegative(count, "count"); + return new A.EfficientLengthSkipIterable(this.__internal$_iterable, this._skipCount + count, this.$ti); + }, + $isEfficientLengthIterable: 1 + }; + A.SkipIterator.prototype = { + moveNext$0() { + var t1, i; + for (t1 = this._iterator, i = 0; i < this._skipCount; ++i) + t1.moveNext$0(); + this._skipCount = 0; + return t1.moveNext$0(); + }, + get$current(_) { + var t1 = this._iterator; + return t1.get$current(t1); + } + }; + A.SkipWhileIterable.prototype = { + get$iterator(_) { + return new A.SkipWhileIterator(J.get$iterator$ax(this.__internal$_iterable), this._f); + } + }; + A.SkipWhileIterator.prototype = { + moveNext$0() { + var t1, t2, _this = this; + if (!_this._hasSkipped) { + _this._hasSkipped = true; + for (t1 = _this._iterator, t2 = _this._f; t1.moveNext$0();) + if (!t2.call$1(t1.get$current(t1))) + return true; + } + return _this._iterator.moveNext$0(); + }, + get$current(_) { + var t1 = this._iterator; + return t1.get$current(t1); + } + }; + A.EmptyIterable.prototype = { + get$iterator(_) { + return B.C_EmptyIterator; + }, + get$isEmpty(_) { + return true; + }, + get$length(_) { + return 0; + }, + get$first(_) { + throw A.wrapException(A.IterableElementError_noElement()); + }, + get$last(_) { + throw A.wrapException(A.IterableElementError_noElement()); + }, + get$single(_) { + throw A.wrapException(A.IterableElementError_noElement()); + }, + elementAt$1(_, index) { + throw A.wrapException(A.RangeError$range(index, 0, 0, "index", null)); + }, + contains$1(_, element) { + return false; + }, + every$1(_, test) { + return true; + }, + any$1(_, test) { + return false; + }, + join$1(_, separator) { + return ""; + }, + where$1(_, test) { + return this; + }, + map$1$1(_, toElement, $T) { + return new A.EmptyIterable($T._eval$1("EmptyIterable<0>")); + }, + skip$1(_, count) { + A.RangeError_checkNotNegative(count, "count"); + return this; + }, + take$1(_, count) { + A.RangeError_checkNotNegative(count, "count"); + return this; + }, + toList$1$growable(_, growable) { + var t1 = J.JSArray_JSArray$growable(0, this.$ti._precomputed1); + return t1; + }, + toList$0(_) { + return this.toList$1$growable(0, true); + }, + toSet$0(_) { + return A.LinkedHashSet_LinkedHashSet(this.$ti._precomputed1); + } + }; + A.EmptyIterator.prototype = { + moveNext$0() { + return false; + }, + get$current(_) { + throw A.wrapException(A.IterableElementError_noElement()); + } + }; + A.FollowedByIterable.prototype = { + get$iterator(_) { + return new A.FollowedByIterator(J.get$iterator$ax(this.__internal$_first), this._second); + }, + get$length(_) { + var t1 = this._second; + return J.get$length$asx(this.__internal$_first) + t1.get$length(t1); + }, + get$isEmpty(_) { + var t1; + if (J.get$isEmpty$asx(this.__internal$_first)) { + t1 = this._second; + t1 = t1.get$isEmpty(t1); + } else + t1 = false; + return t1; + }, + get$isNotEmpty(_) { + var t1; + if (!J.get$isNotEmpty$asx(this.__internal$_first)) { + t1 = this._second; + t1 = t1.get$isNotEmpty(t1); + } else + t1 = true; + return t1; + }, + contains$1(_, value) { + var t1; + if (!J.contains$1$asx(this.__internal$_first, value)) { + t1 = this._second; + t1 = t1.contains$1(t1, value); + } else + t1 = true; + return t1; + }, + get$first(_) { + var t1, + iterator = J.get$iterator$ax(this.__internal$_first); + if (iterator.moveNext$0()) + return iterator.get$current(iterator); + t1 = this._second; + return t1.get$first(t1); + }, + get$last(_) { + var last, + t1 = this._second, + iterator = t1.get$iterator(t1); + if (iterator.moveNext$0()) { + last = iterator.get$current(iterator); + for (; iterator.moveNext$0();) + last = iterator.get$current(iterator); + return last; + } + return J.get$last$ax(this.__internal$_first); + } + }; + A.EfficientLengthFollowedByIterable.prototype = { + elementAt$1(_, index) { + var t1 = this.__internal$_first, + t2 = J.getInterceptor$asx(t1), + firstLength = t2.get$length(t1); + if (index < firstLength) + return t2.elementAt$1(t1, index); + t1 = this._second; + return t1.elementAt$1(t1, index - firstLength); + }, + get$first(_) { + var t1 = this.__internal$_first, + t2 = J.getInterceptor$asx(t1); + if (t2.get$isNotEmpty(t1)) + return t2.get$first(t1); + t1 = this._second; + return t1.get$first(t1); + }, + get$last(_) { + var t1 = this._second; + if (t1.get$isNotEmpty(t1)) + return t1.get$last(t1); + return J.get$last$ax(this.__internal$_first); + }, + $isEfficientLengthIterable: 1 + }; + A.FollowedByIterator.prototype = { + moveNext$0() { + var t1, _this = this; + if (_this._currentIterator.moveNext$0()) + return true; + t1 = _this._nextIterable; + if (t1 != null) { + t1 = t1.get$iterator(t1); + _this._currentIterator = t1; + _this._nextIterable = null; + return t1.moveNext$0(); + } + return false; + }, + get$current(_) { + var t1 = this._currentIterator; + return t1.get$current(t1); + } + }; + A.WhereTypeIterable.prototype = { + get$iterator(_) { + return new A.WhereTypeIterator(J.get$iterator$ax(this._source), this.$ti._eval$1("WhereTypeIterator<1>")); + } + }; + A.WhereTypeIterator.prototype = { + moveNext$0() { + var t1, t2; + for (t1 = this._source, t2 = this.$ti._precomputed1; t1.moveNext$0();) + if (t2._is(t1.get$current(t1))) + return true; + return false; + }, + get$current(_) { + var t1 = this._source; + return this.$ti._precomputed1._as(t1.get$current(t1)); + } + }; + A.NonNullsIterable.prototype = { + get$_firstNonNull() { + var t1, element; + for (t1 = J.get$iterator$ax(this._source); t1.moveNext$0();) { + element = t1.get$current(t1); + if (element != null) + return element; + } + return null; + }, + get$isEmpty(_) { + return this.get$_firstNonNull() == null; + }, + get$isNotEmpty(_) { + return this.get$_firstNonNull() != null; + }, + get$first(_) { + var t1 = this.get$_firstNonNull(); + return t1 == null ? A.throwExpression(A.IterableElementError_noElement()) : t1; + }, + get$iterator(_) { + return new A.NonNullsIterator(J.get$iterator$ax(this._source)); + } + }; + A.NonNullsIterator.prototype = { + moveNext$0() { + var t1, next; + this.__internal$_current = null; + for (t1 = this._source; t1.moveNext$0();) { + next = t1.get$current(t1); + if (next != null) { + this.__internal$_current = next; + return true; + } + } + return false; + }, + get$current(_) { + var t1 = this.__internal$_current; + return t1 == null ? A.throwExpression(A.IterableElementError_noElement()) : t1; + } + }; + A.FixedLengthListMixin.prototype = { + set$length(receiver, newLength) { + throw A.wrapException(A.UnsupportedError$("Cannot change the length of a fixed-length list")); + }, + add$1(receiver, value) { + throw A.wrapException(A.UnsupportedError$("Cannot add to a fixed-length list")); + }, + addAll$1(receiver, iterable) { + throw A.wrapException(A.UnsupportedError$("Cannot add to a fixed-length list")); + }, + removeRange$2(receiver, start, end) { + throw A.wrapException(A.UnsupportedError$("Cannot remove from a fixed-length list")); + } + }; + A.UnmodifiableListMixin.prototype = { + $indexSet(_, index, value) { + throw A.wrapException(A.UnsupportedError$("Cannot modify an unmodifiable list")); + }, + set$length(_, newLength) { + throw A.wrapException(A.UnsupportedError$("Cannot change the length of an unmodifiable list")); + }, + add$1(_, value) { + throw A.wrapException(A.UnsupportedError$("Cannot add to an unmodifiable list")); + }, + addAll$1(_, iterable) { + throw A.wrapException(A.UnsupportedError$("Cannot add to an unmodifiable list")); + }, + sort$1(_, compare) { + throw A.wrapException(A.UnsupportedError$("Cannot modify an unmodifiable list")); + }, + setRange$4(_, start, end, iterable, skipCount) { + throw A.wrapException(A.UnsupportedError$("Cannot modify an unmodifiable list")); + }, + removeRange$2(_, start, end) { + throw A.wrapException(A.UnsupportedError$("Cannot remove from an unmodifiable list")); + }, + fillRange$3(_, start, end, fillValue) { + throw A.wrapException(A.UnsupportedError$("Cannot modify an unmodifiable list")); + } + }; + A.UnmodifiableListBase.prototype = {}; + A.ReversedListIterable.prototype = { + get$length(_) { + return J.get$length$asx(this._source); + }, + elementAt$1(_, index) { + var t1 = this._source, + t2 = J.getInterceptor$asx(t1); + return t2.elementAt$1(t1, t2.get$length(t1) - 1 - index); + } + }; + A.Symbol.prototype = { + get$hashCode(_) { + var hash = this._hashCode; + if (hash != null) + return hash; + hash = 664597 * B.JSString_methods.get$hashCode(this.__internal$_name) & 536870911; + this._hashCode = hash; + return hash; + }, + toString$0(_) { + return 'Symbol("' + this.__internal$_name + '")'; + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.Symbol && this.__internal$_name === other.__internal$_name; + }, + $isSymbol0: 1 + }; + A.__CastListBase__CastIterableBase_ListMixin.prototype = {}; + A._Record_1.prototype = {$recipe: "+(1)", $shape: 1}; + A._Record_2.prototype = {$recipe: "+(1,2)", $shape: 2}; + A._Record_2_forImport.prototype = {$recipe: "+forImport(1,2)", $shape: 3}; + A._Record_2_imports_modules.prototype = {$recipe: "+imports,modules(1,2)", $shape: 5}; + A._Record_2_loadedUrls_stylesheet.prototype = {$recipe: "+loadedUrls,stylesheet(1,2)", $shape: 6}; + A._Record_2_sourceMap.prototype = {$recipe: "+sourceMap(1,2)", $shape: 4}; + A._Record_3.prototype = {$recipe: "+(1,2,3)", $shape: 7}; + A._Record_3_deprecation_message_span.prototype = { + get$message(_) { + return this._1; + }, + $recipe: "+deprecation,message,span(1,2,3)", + $shape: 11 + }; + A._Record_3_forImport.prototype = {$recipe: "+forImport(1,2,3)", $shape: 8}; + A._Record_3_importer_isDependency.prototype = {$recipe: "+importer,isDependency(1,2,3)", $shape: 10}; + A._Record_3_originalUrl.prototype = {$recipe: "+originalUrl(1,2,3)", $shape: 9}; + A._Record_5_named_namedNodes_positional_positionalNodes_separator.prototype = {$recipe: "+named,namedNodes,positional,positionalNodes,separator(1,2,3,4,5)", $shape: 13}; + A.ConstantMapView.prototype = {}; + A.ConstantMap.prototype = { + cast$2$0(_, RK, RV) { + var t1 = A._instanceType(this); + return A.Map_castFrom(this, t1._precomputed1, t1._rest[1], RK, RV); + }, + get$isEmpty(_) { + return this.get$length(this) === 0; + }, + get$isNotEmpty(_) { + return this.get$length(this) !== 0; + }, + toString$0(_) { + return A.MapBase_mapToString(this); + }, + $indexSet(_, key, value) { + A.ConstantMap__throwUnmodifiable(); + }, + remove$1(_, key) { + A.ConstantMap__throwUnmodifiable(); + }, + addAll$1(_, other) { + A.ConstantMap__throwUnmodifiable(); + }, + get$entries(_) { + return new A._SyncStarIterable(this.entries$body$ConstantMap(0), A._instanceType(this)._eval$1("_SyncStarIterable>")); + }, + entries$body$ConstantMap($async$_) { + var $async$self = this; + return function() { + var _ = $async$_; + var $async$goto = 0, $async$handler = 1, $async$errorStack = [], t1, t2, key; + return function $async$get$entries($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.get$keys($async$self), t1 = t1.get$iterator(t1), t2 = A._instanceType($async$self)._eval$1("MapEntry<1,2>"); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + key = t1.get$current(t1); + $async$goto = 4; + return $async$iterator._async$_current = new A.MapEntry(key, $async$self.$index(0, key), t2), 1; + case 4: + // after yield + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return 0; + case 1: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + }, + $isMap: 1 + }; + A.ConstantStringMap.prototype = { + get$length(_) { + return this._values.length; + }, + get$_keys() { + var keys = this.$keys; + if (keys == null) { + keys = Object.keys(this._jsIndex); + this.$keys = keys; + } + return keys; + }, + containsKey$1(key) { + if (typeof key != "string") + return false; + if ("__proto__" === key) + return false; + return this._jsIndex.hasOwnProperty(key); + }, + $index(_, key) { + if (!this.containsKey$1(key)) + return null; + return this._values[this._jsIndex[key]]; + }, + forEach$1(_, f) { + var t1, i, + keys = this.get$_keys(), + values = this._values; + for (t1 = keys.length, i = 0; i < t1; ++i) + f.call$2(keys[i], values[i]); + }, + get$keys(_) { + return new A._KeysOrValues(this.get$_keys(), this.$ti._eval$1("_KeysOrValues<1>")); + }, + get$values(_) { + return new A._KeysOrValues(this._values, this.$ti._eval$1("_KeysOrValues<2>")); + } + }; + A._KeysOrValues.prototype = { + get$length(_) { + return this._elements.length; + }, + get$isEmpty(_) { + return 0 === this._elements.length; + }, + get$isNotEmpty(_) { + return 0 !== this._elements.length; + }, + get$iterator(_) { + var t1 = this._elements; + return new A._KeysOrValuesOrElementsIterator(t1, t1.length, this.$ti._eval$1("_KeysOrValuesOrElementsIterator<1>")); + } + }; + A._KeysOrValuesOrElementsIterator.prototype = { + get$current(_) { + var t1 = this.__js_helper$_current; + return t1 == null ? this.$ti._precomputed1._as(t1) : t1; + }, + moveNext$0() { + var _this = this, + t1 = _this.__js_helper$_index; + if (t1 >= _this.__js_helper$_length) { + _this.__js_helper$_current = null; + return false; + } + _this.__js_helper$_current = _this._elements[t1]; + _this.__js_helper$_index = t1 + 1; + return true; + } + }; + A.ConstantSet.prototype = { + add$1(_, value) { + A.ConstantSet__throwUnmodifiable(); + }, + addAll$1(_, elements) { + A.ConstantSet__throwUnmodifiable(); + }, + remove$1(_, value) { + A.ConstantSet__throwUnmodifiable(); + } + }; + A.ConstantStringSet.prototype = { + get$length(_) { + return this.__js_helper$_length; + }, + get$isEmpty(_) { + return this.__js_helper$_length === 0; + }, + get$isNotEmpty(_) { + return this.__js_helper$_length !== 0; + }, + get$iterator(_) { + var t1, _this = this, + keys = _this.$keys; + if (keys == null) { + keys = Object.keys(_this._jsIndex); + _this.$keys = keys; + } + t1 = keys; + return new A._KeysOrValuesOrElementsIterator(t1, t1.length, _this.$ti._eval$1("_KeysOrValuesOrElementsIterator<1>")); + }, + contains$1(_, key) { + if (typeof key != "string") + return false; + if ("__proto__" === key) + return false; + return this._jsIndex.hasOwnProperty(key); + }, + toSet$0(_) { + return A.LinkedHashSet_LinkedHashSet$of(this, this.$ti._precomputed1); + } + }; + A.GeneralConstantSet.prototype = { + get$length(_) { + return this._elements.length; + }, + get$isEmpty(_) { + return this._elements.length === 0; + }, + get$isNotEmpty(_) { + return this._elements.length !== 0; + }, + get$iterator(_) { + var t1 = this._elements; + return new A._KeysOrValuesOrElementsIterator(t1, t1.length, this.$ti._eval$1("_KeysOrValuesOrElementsIterator<1>")); + }, + _getMap$0() { + var t1, t2, _i, key, _this = this, + backingMap = _this.$map; + if (backingMap == null) { + backingMap = new A.JsConstantLinkedHashMap(_this.$ti._eval$1("JsConstantLinkedHashMap<1,1>")); + for (t1 = _this._elements, t2 = t1.length, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + key = t1[_i]; + backingMap.$indexSet(0, key, key); + } + _this.$map = backingMap; + } + return backingMap; + }, + contains$1(_, key) { + return this._getMap$0().containsKey$1(key); + }, + toSet$0(_) { + return A.LinkedHashSet_LinkedHashSet$of(this, this.$ti._precomputed1); + } + }; + A.Instantiation.prototype = { + Instantiation$1(_genericClosure) { + if (false) + A.instantiatedGenericFunctionType(0, 0); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.Instantiation1 && this._genericClosure.$eq(0, other._genericClosure) && A.getRuntimeTypeOfClosure(this) === A.getRuntimeTypeOfClosure(other); + }, + get$hashCode(_) { + return A.Object_hash(this._genericClosure, A.getRuntimeTypeOfClosure(this), B.C_SentinelValue, B.C_SentinelValue); + }, + toString$0(_) { + var t1 = B.JSArray_methods.join$1([A.createRuntimeType(this.$ti._precomputed1)], ", "); + return this._genericClosure.toString$0(0) + " with " + ("<" + t1 + ">"); + } + }; + A.Instantiation1.prototype = { + call$0() { + return this._genericClosure.call$1$0(this.$ti._rest[0]); + }, + call$2(a0, a1) { + return this._genericClosure.call$1$2(a0, a1, this.$ti._rest[0]); + }, + call$3(a0, a1, a2) { + return this._genericClosure.call$1$3(a0, a1, a2, this.$ti._rest[0]); + }, + call$4(a0, a1, a2, a3) { + return this._genericClosure.call$1$4(a0, a1, a2, a3, this.$ti._rest[0]); + }, + $signature() { + return A.instantiatedGenericFunctionType(A.closureFunctionType(this._genericClosure), this.$ti); + } + }; + A.JSInvocationMirror.prototype = { + get$memberName() { + var t1 = this.__js_helper$_memberName; + if (t1 instanceof A.Symbol) + return t1; + return this.__js_helper$_memberName = new A.Symbol(t1); + }, + get$positionalArguments() { + var t1, t2, argumentCount, list, index, _this = this; + if (_this.__js_helper$_kind === 1) + return B.List_empty6; + t1 = _this._arguments; + t2 = J.getInterceptor$asx(t1); + argumentCount = t2.get$length(t1) - J.get$length$asx(_this._namedArgumentNames) - _this._typeArgumentCount; + if (argumentCount === 0) + return B.List_empty6; + list = []; + for (index = 0; index < argumentCount; ++index) + list.push(t2.$index(t1, index)); + list.$flags = 3; + return list; + }, + get$namedArguments() { + var t1, t2, namedArgumentCount, t3, t4, namedArgumentsStartIndex, map, i, _this = this; + if (_this.__js_helper$_kind !== 0) + return B.Map_empty3; + t1 = _this._namedArgumentNames; + t2 = J.getInterceptor$asx(t1); + namedArgumentCount = t2.get$length(t1); + t3 = _this._arguments; + t4 = J.getInterceptor$asx(t3); + namedArgumentsStartIndex = t4.get$length(t3) - namedArgumentCount - _this._typeArgumentCount; + if (namedArgumentCount === 0) + return B.Map_empty3; + map = new A.JsLinkedHashMap(type$.JsLinkedHashMap_Symbol_dynamic); + for (i = 0; i < namedArgumentCount; ++i) + map.$indexSet(0, new A.Symbol(t2.$index(t1, i)), t4.$index(t3, namedArgumentsStartIndex + i)); + return new A.ConstantMapView(map, type$.ConstantMapView_Symbol_dynamic); + } + }; + A.Primitives_functionNoSuchMethod_closure.prototype = { + call$2($name, argument) { + var t1 = this._box_0; + t1.names = t1.names + "$" + $name; + this.namedArgumentList.push($name); + this.$arguments.push(argument); + ++t1.argumentCount; + }, + $signature: 139 + }; + A.TypeErrorDecoder.prototype = { + matchTypeError$1(message) { + var result, t1, _this = this, + match = new RegExp(_this._pattern).exec(message); + if (match == null) + return null; + result = Object.create(null); + t1 = _this._arguments; + if (t1 !== -1) + result.arguments = match[t1 + 1]; + t1 = _this._argumentsExpr; + if (t1 !== -1) + result.argumentsExpr = match[t1 + 1]; + t1 = _this._expr; + if (t1 !== -1) + result.expr = match[t1 + 1]; + t1 = _this._method; + if (t1 !== -1) + result.method = match[t1 + 1]; + t1 = _this._receiver; + if (t1 !== -1) + result.receiver = match[t1 + 1]; + return result; + } + }; + A.NullError.prototype = { + toString$0(_) { + return "Null check operator used on a null value"; + } + }; + A.JsNoSuchMethodError.prototype = { + toString$0(_) { + var t2, _this = this, + _s38_ = "NoSuchMethodError: method not found: '", + t1 = _this._method; + if (t1 == null) + return "NoSuchMethodError: " + _this.__js_helper$_message; + t2 = _this._receiver; + if (t2 == null) + return _s38_ + t1 + "' (" + _this.__js_helper$_message + ")"; + return _s38_ + t1 + "' on '" + t2 + "' (" + _this.__js_helper$_message + ")"; + } + }; + A.UnknownJsTypeError.prototype = { + toString$0(_) { + var t1 = this.__js_helper$_message; + return t1.length === 0 ? "Error" : "Error: " + t1; + } + }; + A.NullThrownFromJavaScriptException.prototype = { + toString$0(_) { + return "Throw of null ('" + (this._irritant === null ? "null" : "undefined") + "' from JavaScript)"; + }, + $isException: 1 + }; + A.ExceptionAndStackTrace.prototype = {}; + A._StackTrace.prototype = { + toString$0(_) { + var trace, + t1 = this._trace; + if (t1 != null) + return t1; + t1 = this._exception; + trace = t1 !== null && typeof t1 === "object" ? t1.stack : null; + return this._trace = trace == null ? "" : trace; + }, + $isStackTrace: 1 + }; + A.Closure.prototype = { + toString$0(_) { + var $constructor = this.constructor, + $name = $constructor == null ? null : $constructor.name; + return "Closure '" + A.unminifyOrTag($name == null ? "unknown" : $name) + "'"; + }, + $isFunction: 1, + get$$call() { + return this; + }, + "call*": "call$1", + $requiredArgCount: 1, + $defaultValues: null + }; + A.Closure0Args.prototype = {"call*": "call$0", $requiredArgCount: 0}; + A.Closure2Args.prototype = {"call*": "call$2", $requiredArgCount: 2}; + A.TearOffClosure.prototype = {}; + A.StaticClosure.prototype = { + toString$0(_) { + var $name = this.$static_name; + if ($name == null) + return "Closure of unknown static method"; + return "Closure '" + A.unminifyOrTag($name) + "'"; + } + }; + A.BoundClosure.prototype = { + $eq(_, other) { + if (other == null) + return false; + if (this === other) + return true; + if (!(other instanceof A.BoundClosure)) + return false; + return this.$_target === other.$_target && this._receiver === other._receiver; + }, + get$hashCode(_) { + return (A.objectHashCode(this._receiver) ^ A.Primitives_objectHashCode(this.$_target)) >>> 0; + }, + toString$0(_) { + return "Closure '" + this.$_name + "' of " + ("Instance of '" + A.Primitives_objectTypeName(this._receiver) + "'"); + } + }; + A._CyclicInitializationError.prototype = { + toString$0(_) { + return "Reading static variable '" + this.variableName + "' during its initialization"; + } + }; + A.RuntimeError.prototype = { + toString$0(_) { + return "RuntimeError: " + this.message; + }, + get$message(receiver) { + return this.message; + } + }; + A._Required.prototype = {}; + A.JsLinkedHashMap.prototype = { + get$length(_) { + return this.__js_helper$_length; + }, + get$isEmpty(_) { + return this.__js_helper$_length === 0; + }, + get$isNotEmpty(_) { + return this.__js_helper$_length !== 0; + }, + get$keys(_) { + return new A.LinkedHashMapKeysIterable(this, A._instanceType(this)._eval$1("LinkedHashMapKeysIterable<1>")); + }, + get$values(_) { + return new A.LinkedHashMapValuesIterable(this, A._instanceType(this)._eval$1("LinkedHashMapValuesIterable<2>")); + }, + get$entries(_) { + return new A.LinkedHashMapEntriesIterable(this, A._instanceType(this)._eval$1("LinkedHashMapEntriesIterable<1,2>")); + }, + containsKey$1(key) { + var strings, nums; + if (typeof key == "string") { + strings = this.__js_helper$_strings; + if (strings == null) + return false; + return strings[key] != null; + } else if (typeof key == "number" && (key & 0x3fffffff) === key) { + nums = this.__js_helper$_nums; + if (nums == null) + return false; + return nums[key] != null; + } else + return this.internalContainsKey$1(key); + }, + internalContainsKey$1(key) { + var rest = this.__js_helper$_rest; + if (rest == null) + return false; + return this.internalFindBucketIndex$2(rest[this.internalComputeHashCode$1(key)], key) >= 0; + }, + addAll$1(_, other) { + other.forEach$1(0, new A.JsLinkedHashMap_addAll_closure(this)); + }, + $index(_, key) { + var strings, cell, t1, nums, _null = null; + if (typeof key == "string") { + strings = this.__js_helper$_strings; + if (strings == null) + return _null; + cell = strings[key]; + t1 = cell == null ? _null : cell.hashMapCellValue; + return t1; + } else if (typeof key == "number" && (key & 0x3fffffff) === key) { + nums = this.__js_helper$_nums; + if (nums == null) + return _null; + cell = nums[key]; + t1 = cell == null ? _null : cell.hashMapCellValue; + return t1; + } else + return this.internalGet$1(key); + }, + internalGet$1(key) { + var bucket, index, + rest = this.__js_helper$_rest; + if (rest == null) + return null; + bucket = rest[this.internalComputeHashCode$1(key)]; + index = this.internalFindBucketIndex$2(bucket, key); + if (index < 0) + return null; + return bucket[index].hashMapCellValue; + }, + $indexSet(_, key, value) { + var strings, nums, _this = this; + if (typeof key == "string") { + strings = _this.__js_helper$_strings; + _this.__js_helper$_addHashTableEntry$3(strings == null ? _this.__js_helper$_strings = _this._newHashTable$0() : strings, key, value); + } else if (typeof key == "number" && (key & 0x3fffffff) === key) { + nums = _this.__js_helper$_nums; + _this.__js_helper$_addHashTableEntry$3(nums == null ? _this.__js_helper$_nums = _this._newHashTable$0() : nums, key, value); + } else + _this.internalSet$2(key, value); + }, + internalSet$2(key, value) { + var hash, bucket, index, _this = this, + rest = _this.__js_helper$_rest; + if (rest == null) + rest = _this.__js_helper$_rest = _this._newHashTable$0(); + hash = _this.internalComputeHashCode$1(key); + bucket = rest[hash]; + if (bucket == null) + rest[hash] = [_this.__js_helper$_newLinkedCell$2(key, value)]; + else { + index = _this.internalFindBucketIndex$2(bucket, key); + if (index >= 0) + bucket[index].hashMapCellValue = value; + else + bucket.push(_this.__js_helper$_newLinkedCell$2(key, value)); + } + }, + putIfAbsent$2(key, ifAbsent) { + var t1, value, _this = this; + if (_this.containsKey$1(key)) { + t1 = _this.$index(0, key); + return t1 == null ? A._instanceType(_this)._rest[1]._as(t1) : t1; + } + value = ifAbsent.call$0(); + _this.$indexSet(0, key, value); + return value; + }, + remove$1(_, key) { + var _this = this; + if (typeof key == "string") + return _this.__js_helper$_removeHashTableEntry$2(_this.__js_helper$_strings, key); + else if (typeof key == "number" && (key & 0x3fffffff) === key) + return _this.__js_helper$_removeHashTableEntry$2(_this.__js_helper$_nums, key); + else + return _this.internalRemove$1(key); + }, + internalRemove$1(key) { + var hash, bucket, index, cell, _this = this, + rest = _this.__js_helper$_rest; + if (rest == null) + return null; + hash = _this.internalComputeHashCode$1(key); + bucket = rest[hash]; + index = _this.internalFindBucketIndex$2(bucket, key); + if (index < 0) + return null; + cell = bucket.splice(index, 1)[0]; + _this.__js_helper$_unlinkCell$1(cell); + if (bucket.length === 0) + delete rest[hash]; + return cell.hashMapCellValue; + }, + clear$0(_) { + var _this = this; + if (_this.__js_helper$_length > 0) { + _this.__js_helper$_strings = _this.__js_helper$_nums = _this.__js_helper$_rest = _this.__js_helper$_first = _this.__js_helper$_last = null; + _this.__js_helper$_length = 0; + _this.__js_helper$_modified$0(); + } + }, + forEach$1(_, action) { + var _this = this, + cell = _this.__js_helper$_first, + modifications = _this.__js_helper$_modifications; + for (; cell != null;) { + action.call$2(cell.hashMapCellKey, cell.hashMapCellValue); + if (modifications !== _this.__js_helper$_modifications) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + cell = cell.__js_helper$_next; + } + }, + __js_helper$_addHashTableEntry$3(table, key, value) { + var cell = table[key]; + if (cell == null) + table[key] = this.__js_helper$_newLinkedCell$2(key, value); + else + cell.hashMapCellValue = value; + }, + __js_helper$_removeHashTableEntry$2(table, key) { + var cell; + if (table == null) + return null; + cell = table[key]; + if (cell == null) + return null; + this.__js_helper$_unlinkCell$1(cell); + delete table[key]; + return cell.hashMapCellValue; + }, + __js_helper$_modified$0() { + this.__js_helper$_modifications = this.__js_helper$_modifications + 1 & 1073741823; + }, + __js_helper$_newLinkedCell$2(key, value) { + var t1, _this = this, + cell = new A.LinkedHashMapCell(key, value); + if (_this.__js_helper$_first == null) + _this.__js_helper$_first = _this.__js_helper$_last = cell; + else { + t1 = _this.__js_helper$_last; + t1.toString; + cell.__js_helper$_previous = t1; + _this.__js_helper$_last = t1.__js_helper$_next = cell; + } + ++_this.__js_helper$_length; + _this.__js_helper$_modified$0(); + return cell; + }, + __js_helper$_unlinkCell$1(cell) { + var _this = this, + previous = cell.__js_helper$_previous, + next = cell.__js_helper$_next; + if (previous == null) + _this.__js_helper$_first = next; + else + previous.__js_helper$_next = next; + if (next == null) + _this.__js_helper$_last = previous; + else + next.__js_helper$_previous = previous; + --_this.__js_helper$_length; + _this.__js_helper$_modified$0(); + }, + internalComputeHashCode$1(key) { + return J.get$hashCode$(key) & 1073741823; + }, + internalFindBucketIndex$2(bucket, key) { + var $length, i; + if (bucket == null) + return -1; + $length = bucket.length; + for (i = 0; i < $length; ++i) + if (J.$eq$(bucket[i].hashMapCellKey, key)) + return i; + return -1; + }, + toString$0(_) { + return A.MapBase_mapToString(this); + }, + _newHashTable$0() { + var table = Object.create(null); + table[""] = table; + delete table[""]; + return table; + } + }; + A.JsLinkedHashMap_addAll_closure.prototype = { + call$2(key, value) { + this.$this.$indexSet(0, key, value); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("~(1,2)"); + } + }; + A.LinkedHashMapCell.prototype = {}; + A.LinkedHashMapKeysIterable.prototype = { + get$length(_) { + return this.__js_helper$_map.__js_helper$_length; + }, + get$isEmpty(_) { + return this.__js_helper$_map.__js_helper$_length === 0; + }, + get$iterator(_) { + var t1 = this.__js_helper$_map; + return new A.LinkedHashMapKeyIterator(t1, t1.__js_helper$_modifications, t1.__js_helper$_first); + }, + contains$1(_, element) { + return this.__js_helper$_map.containsKey$1(element); + } + }; + A.LinkedHashMapKeyIterator.prototype = { + get$current(_) { + return this.__js_helper$_current; + }, + moveNext$0() { + var cell, _this = this, + t1 = _this.__js_helper$_map; + if (_this.__js_helper$_modifications !== t1.__js_helper$_modifications) + throw A.wrapException(A.ConcurrentModificationError$(t1)); + cell = _this.__js_helper$_cell; + if (cell == null) { + _this.__js_helper$_current = null; + return false; + } else { + _this.__js_helper$_current = cell.hashMapCellKey; + _this.__js_helper$_cell = cell.__js_helper$_next; + return true; + } + } + }; + A.LinkedHashMapValuesIterable.prototype = { + get$length(_) { + return this.__js_helper$_map.__js_helper$_length; + }, + get$isEmpty(_) { + return this.__js_helper$_map.__js_helper$_length === 0; + }, + get$iterator(_) { + var t1 = this.__js_helper$_map; + return new A.LinkedHashMapValueIterator(t1, t1.__js_helper$_modifications, t1.__js_helper$_first); + } + }; + A.LinkedHashMapValueIterator.prototype = { + get$current(_) { + return this.__js_helper$_current; + }, + moveNext$0() { + var cell, _this = this, + t1 = _this.__js_helper$_map; + if (_this.__js_helper$_modifications !== t1.__js_helper$_modifications) + throw A.wrapException(A.ConcurrentModificationError$(t1)); + cell = _this.__js_helper$_cell; + if (cell == null) { + _this.__js_helper$_current = null; + return false; + } else { + _this.__js_helper$_current = cell.hashMapCellValue; + _this.__js_helper$_cell = cell.__js_helper$_next; + return true; + } + } + }; + A.LinkedHashMapEntriesIterable.prototype = { + get$length(_) { + return this.__js_helper$_map.__js_helper$_length; + }, + get$isEmpty(_) { + return this.__js_helper$_map.__js_helper$_length === 0; + }, + get$iterator(_) { + var t1 = this.__js_helper$_map; + return new A.LinkedHashMapEntryIterator(t1, t1.__js_helper$_modifications, t1.__js_helper$_first, this.$ti._eval$1("LinkedHashMapEntryIterator<1,2>")); + } + }; + A.LinkedHashMapEntryIterator.prototype = { + get$current(_) { + var t1 = this.__js_helper$_current; + t1.toString; + return t1; + }, + moveNext$0() { + var cell, _this = this, + t1 = _this.__js_helper$_map; + if (_this.__js_helper$_modifications !== t1.__js_helper$_modifications) + throw A.wrapException(A.ConcurrentModificationError$(t1)); + cell = _this.__js_helper$_cell; + if (cell == null) { + _this.__js_helper$_current = null; + return false; + } else { + _this.__js_helper$_current = new A.MapEntry(cell.hashMapCellKey, cell.hashMapCellValue, _this.$ti._eval$1("MapEntry<1,2>")); + _this.__js_helper$_cell = cell.__js_helper$_next; + return true; + } + } + }; + A.JsIdentityLinkedHashMap.prototype = { + internalComputeHashCode$1(key) { + return A.objectHashCode(key) & 1073741823; + }, + internalFindBucketIndex$2(bucket, key) { + var $length, i, t1; + if (bucket == null) + return -1; + $length = bucket.length; + for (i = 0; i < $length; ++i) { + t1 = bucket[i].hashMapCellKey; + if (t1 == null ? key == null : t1 === key) + return i; + } + return -1; + } + }; + A.JsConstantLinkedHashMap.prototype = { + internalComputeHashCode$1(key) { + return A.constantHashCode(key) & 1073741823; + }, + internalFindBucketIndex$2(bucket, key) { + var $length, i; + if (bucket == null) + return -1; + $length = bucket.length; + for (i = 0; i < $length; ++i) + if (J.$eq$(bucket[i].hashMapCellKey, key)) + return i; + return -1; + } + }; + A.initHooks_closure.prototype = { + call$1(o) { + return this.getTag(o); + }, + $signature: 90 + }; + A.initHooks_closure0.prototype = { + call$2(o, tag) { + return this.getUnknownTag(o, tag); + }, + $signature: 387 + }; + A.initHooks_closure1.prototype = { + call$1(tag) { + return this.prototypeForTag(tag); + }, + $signature: 199 + }; + A._Record.prototype = { + toString$0(_) { + return this._toString$1(false); + }, + _toString$1(safe) { + var t2, separator, i, key, value, + keys = this._fieldKeys$0(), + values = this._getFieldValues$0(), + t1 = (safe ? "" + "Record " : "") + "("; + for (t2 = keys.length, separator = "", i = 0; i < t2; ++i, separator = ", ") { + t1 += separator; + key = keys[i]; + if (typeof key == "string") + t1 = t1 + key + ": "; + value = values[i]; + t1 = safe ? t1 + A.Primitives_safeToString(value) : t1 + A.S(value); + } + t1 += ")"; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _fieldKeys$0() { + var t1, + shapeTag = this.$shape; + for (; $._Record__computedFieldKeys.length <= shapeTag;) + $._Record__computedFieldKeys.push(null); + t1 = $._Record__computedFieldKeys[shapeTag]; + if (t1 == null) { + t1 = this._computeFieldKeys$0(); + $._Record__computedFieldKeys[shapeTag] = t1; + } + return t1; + }, + _computeFieldKeys$0() { + var i, names, last, + recipe = this.$recipe, + position = recipe.indexOf("("), + joinedNames = recipe.substring(1, position), + fields = recipe.substring(position), + arity = fields === "()" ? 0 : fields.replace(/[^,]/g, "").length + 1, + t1 = type$.Object, + result = J.JSArray_JSArray$allocateGrowable(arity, t1); + for (i = 0; i < arity; ++i) + result[i] = i; + if (joinedNames !== "") { + names = joinedNames.split(","); + i = names.length; + for (last = arity; i > 0;) { + --last; + --i; + result[last] = names[i]; + } + } + return A.List_List$unmodifiable(result, t1); + } + }; + A._Record2.prototype = { + _getFieldValues$0() { + return [this._0, this._1]; + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A._Record2 && this.$shape === other.$shape && J.$eq$(this._0, other._0) && J.$eq$(this._1, other._1); + }, + get$hashCode(_) { + return A.Object_hash(this.$shape, this._0, this._1, B.C_SentinelValue); + } + }; + A._Record1.prototype = { + _getFieldValues$0() { + return [this._0]; + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A._Record1 && this.$shape === other.$shape && J.$eq$(this._0, other._0); + }, + get$hashCode(_) { + return A.Object_hash(this.$shape, this._0, B.C_SentinelValue, B.C_SentinelValue); + } + }; + A._Record3.prototype = { + _getFieldValues$0() { + return [this._0, this._1, this._2]; + }, + $eq(_, other) { + var _this = this; + if (other == null) + return false; + return other instanceof A._Record3 && _this.$shape === other.$shape && J.$eq$(_this._0, other._0) && J.$eq$(_this._1, other._1) && J.$eq$(_this._2, other._2); + }, + get$hashCode(_) { + var _this = this; + return A.Object_hash(_this.$shape, _this._0, _this._1, _this._2); + } + }; + A._RecordN.prototype = { + _getFieldValues$0() { + return this._values; + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A._RecordN && this.$shape === other.$shape && A._RecordN__equalValues(this._values, other._values); + }, + get$hashCode(_) { + return A.Object_hash(this.$shape, A.Object_hashAll(this._values), B.C_SentinelValue, B.C_SentinelValue); + } + }; + A.JSSyntaxRegExp.prototype = { + toString$0(_) { + return "RegExp/" + this.pattern + "/" + this._nativeRegExp.flags; + }, + get$_nativeGlobalVersion() { + var _this = this, + t1 = _this._nativeGlobalRegExp; + if (t1 != null) + return t1; + t1 = _this._nativeRegExp; + return _this._nativeGlobalRegExp = A.JSSyntaxRegExp_makeNative(_this.pattern, t1.multiline, !t1.ignoreCase, t1.unicode, t1.dotAll, true); + }, + get$_nativeAnchoredVersion() { + var _this = this, + t1 = _this._nativeAnchoredRegExp; + if (t1 != null) + return t1; + t1 = _this._nativeRegExp; + return _this._nativeAnchoredRegExp = A.JSSyntaxRegExp_makeNative(_this.pattern + "|()", t1.multiline, !t1.ignoreCase, t1.unicode, t1.dotAll, true); + }, + firstMatch$1(string) { + var m = this._nativeRegExp.exec(string); + if (m == null) + return null; + return new A._MatchImplementation(m); + }, + allMatches$2(_, string, start) { + var t1 = string.length; + if (start > t1) + throw A.wrapException(A.RangeError$range(start, 0, t1, null, null)); + return new A._AllMatchesIterable(this, string, start); + }, + allMatches$1(_, string) { + return this.allMatches$2(0, string, 0); + }, + _execGlobal$2(string, start) { + var match, + regexp = this.get$_nativeGlobalVersion(); + regexp.lastIndex = start; + match = regexp.exec(string); + if (match == null) + return null; + return new A._MatchImplementation(match); + }, + _execAnchored$2(string, start) { + var match, + regexp = this.get$_nativeAnchoredVersion(); + regexp.lastIndex = start; + match = regexp.exec(string); + if (match == null) + return null; + if (match.pop() != null) + return null; + return new A._MatchImplementation(match); + }, + matchAsPrefix$2(_, string, start) { + if (start < 0 || start > string.length) + throw A.wrapException(A.RangeError$range(start, 0, string.length, null, null)); + return this._execAnchored$2(string, start); + } + }; + A._MatchImplementation.prototype = { + get$start(_) { + return this._match.index; + }, + get$end(_) { + var t1 = this._match; + return t1.index + t1[0].length; + }, + namedGroup$1($name) { + var result, + groups = this._match.groups; + if (groups != null) { + result = groups[$name]; + if (result != null || $name in groups) + return result; + } + throw A.wrapException(A.ArgumentError$value($name, "name", "Not a capture group name")); + }, + $isMatch: 1, + $isRegExpMatch: 1 + }; + A._AllMatchesIterable.prototype = { + get$iterator(_) { + return new A._AllMatchesIterator(this._re, this.__js_helper$_string, this.__js_helper$_start); + } + }; + A._AllMatchesIterator.prototype = { + get$current(_) { + var t1 = this.__js_helper$_current; + return t1 == null ? type$.RegExpMatch._as(t1) : t1; + }, + moveNext$0() { + var t1, t2, t3, match, nextIndex, t4, _this = this, + string = _this.__js_helper$_string; + if (string == null) + return false; + t1 = _this._nextIndex; + t2 = string.length; + if (t1 <= t2) { + t3 = _this._regExp; + match = t3._execGlobal$2(string, t1); + if (match != null) { + _this.__js_helper$_current = match; + nextIndex = match.get$end(0); + if (match._match.index === nextIndex) { + t1 = false; + if (t3._nativeRegExp.unicode) { + t3 = _this._nextIndex; + t4 = t3 + 1; + if (t4 < t2) { + t2 = string.charCodeAt(t3); + if (t2 >= 55296 && t2 <= 56319) { + t1 = string.charCodeAt(t4); + t1 = t1 >= 56320 && t1 <= 57343; + } + } + } + nextIndex = (t1 ? nextIndex + 1 : nextIndex) + 1; + } + _this._nextIndex = nextIndex; + return true; + } + } + _this.__js_helper$_string = _this.__js_helper$_current = null; + return false; + } + }; + A.StringMatch.prototype = { + get$end(_) { + return this.start + this.pattern.length; + }, + $isMatch: 1, + get$start(receiver) { + return this.start; + } + }; + A._StringAllMatchesIterable.prototype = { + get$iterator(_) { + return new A._StringAllMatchesIterator(this._input, this._pattern, this.__js_helper$_index); + }, + get$first(_) { + var t1 = this._pattern, + index = this._input.indexOf(t1, this.__js_helper$_index); + if (index >= 0) + return new A.StringMatch(index, t1); + throw A.wrapException(A.IterableElementError_noElement()); + } + }; + A._StringAllMatchesIterator.prototype = { + moveNext$0() { + var index, end, _this = this, + t1 = _this.__js_helper$_index, + t2 = _this._pattern, + t3 = t2.length, + t4 = _this._input, + t5 = t4.length; + if (t1 + t3 > t5) { + _this.__js_helper$_current = null; + return false; + } + index = t4.indexOf(t2, t1); + if (index < 0) { + _this.__js_helper$_index = t5 + 1; + _this.__js_helper$_current = null; + return false; + } + end = index + t3; + _this.__js_helper$_current = new A.StringMatch(index, t2); + _this.__js_helper$_index = end === _this.__js_helper$_index ? end + 1 : end; + return true; + }, + get$current(_) { + var t1 = this.__js_helper$_current; + t1.toString; + return t1; + } + }; + A._Cell.prototype = { + readLocal$1$0() { + var t1 = this.__late_helper$_value; + if (t1 === this) + A.throwExpression(new A.LateError("Local '' has not been initialized.")); + return t1; + }, + readLocal$0() { + return this.readLocal$1$0(type$.dynamic); + }, + _readLocal$0() { + var t1 = this.__late_helper$_value; + if (t1 === this) + throw A.wrapException(new A.LateError("Local '' has not been initialized.")); + return t1; + } + }; + A.NativeByteBuffer.prototype = { + get$runtimeType(receiver) { + return B.Type_ByteBuffer_rqD; + }, + $isTrustedGetRuntimeType: 1, + $isByteBuffer: 1 + }; + A.NativeTypedData.prototype = { + _invalidPosition$3(receiver, position, $length, $name) { + var t1 = A.RangeError$range(position, 0, $length, $name, null); + throw A.wrapException(t1); + }, + _checkPosition$3(receiver, position, $length, $name) { + if (position >>> 0 !== position || position > $length) + this._invalidPosition$3(receiver, position, $length, $name); + } + }; + A.NativeByteData.prototype = { + get$runtimeType(receiver) { + return B.Type_ByteData_9dB; + }, + $isTrustedGetRuntimeType: 1, + $isByteData: 1 + }; + A.NativeTypedArray.prototype = { + get$length(receiver) { + return receiver.length; + }, + _setRangeFast$4(receiver, start, end, source, skipCount) { + var count, sourceLength, + targetLength = receiver.length; + this._checkPosition$3(receiver, start, targetLength, "start"); + this._checkPosition$3(receiver, end, targetLength, "end"); + if (start > end) + throw A.wrapException(A.RangeError$range(start, 0, end, null, null)); + count = end - start; + if (skipCount < 0) + throw A.wrapException(A.ArgumentError$(skipCount, null)); + sourceLength = source.length; + if (sourceLength - skipCount < count) + throw A.wrapException(A.StateError$("Not enough elements")); + if (skipCount !== 0 || sourceLength !== count) + source = source.subarray(skipCount, skipCount + count); + receiver.set(source, start); + }, + $isJavaScriptIndexingBehavior: 1 + }; + A.NativeTypedArrayOfDouble.prototype = { + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + $indexSet(receiver, index, value) { + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver); + A._checkValidIndex(index, receiver, receiver.length); + receiver[index] = value; + }, + setRange$4(receiver, start, end, iterable, skipCount) { + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver, 5); + if (type$.NativeTypedArrayOfDouble._is(iterable)) { + this._setRangeFast$4(receiver, start, end, iterable, skipCount); + return; + } + this.super$ListBase$setRange(receiver, start, end, iterable, skipCount); + }, + $isEfficientLengthIterable: 1, + $isIterable: 1, + $isList: 1 + }; + A.NativeTypedArrayOfInt.prototype = { + $indexSet(receiver, index, value) { + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver); + A._checkValidIndex(index, receiver, receiver.length); + receiver[index] = value; + }, + setRange$4(receiver, start, end, iterable, skipCount) { + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver, 5); + if (type$.NativeTypedArrayOfInt._is(iterable)) { + this._setRangeFast$4(receiver, start, end, iterable, skipCount); + return; + } + this.super$ListBase$setRange(receiver, start, end, iterable, skipCount); + }, + $isEfficientLengthIterable: 1, + $isIterable: 1, + $isList: 1 + }; + A.NativeFloat32List.prototype = { + get$runtimeType(receiver) { + return B.Type_Float32List_9Kz; + }, + sublist$2(receiver, start, end) { + return new Float32Array(receiver.subarray(start, A._checkValidRange(start, end, receiver.length))); + }, + sublist$1(receiver, start) { + return this.sublist$2(receiver, start, null); + }, + $isTrustedGetRuntimeType: 1, + $isFloat32List: 1 + }; + A.NativeFloat64List.prototype = { + get$runtimeType(receiver) { + return B.Type_Float64List_9Kz; + }, + sublist$2(receiver, start, end) { + return new Float64Array(receiver.subarray(start, A._checkValidRange(start, end, receiver.length))); + }, + sublist$1(receiver, start) { + return this.sublist$2(receiver, start, null); + }, + $isTrustedGetRuntimeType: 1, + $isFloat64List: 1 + }; + A.NativeInt16List.prototype = { + get$runtimeType(receiver) { + return B.Type_Int16List_s5h; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + sublist$2(receiver, start, end) { + return new Int16Array(receiver.subarray(start, A._checkValidRange(start, end, receiver.length))); + }, + sublist$1(receiver, start) { + return this.sublist$2(receiver, start, null); + }, + $isTrustedGetRuntimeType: 1, + $isInt16List: 1 + }; + A.NativeInt32List.prototype = { + get$runtimeType(receiver) { + return B.Type_Int32List_O8Z; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + sublist$2(receiver, start, end) { + return new Int32Array(receiver.subarray(start, A._checkValidRange(start, end, receiver.length))); + }, + sublist$1(receiver, start) { + return this.sublist$2(receiver, start, null); + }, + $isTrustedGetRuntimeType: 1, + $isInt32List: 1 + }; + A.NativeInt8List.prototype = { + get$runtimeType(receiver) { + return B.Type_Int8List_rFV; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + sublist$2(receiver, start, end) { + return new Int8Array(receiver.subarray(start, A._checkValidRange(start, end, receiver.length))); + }, + sublist$1(receiver, start) { + return this.sublist$2(receiver, start, null); + }, + $isTrustedGetRuntimeType: 1, + $isInt8List: 1 + }; + A.NativeUint16List.prototype = { + get$runtimeType(receiver) { + return B.Type_Uint16List_kmP; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + sublist$2(receiver, start, end) { + return new Uint16Array(receiver.subarray(start, A._checkValidRange(start, end, receiver.length))); + }, + sublist$1(receiver, start) { + return this.sublist$2(receiver, start, null); + }, + $isTrustedGetRuntimeType: 1, + $isUint16List: 1 + }; + A.NativeUint32List.prototype = { + get$runtimeType(receiver) { + return B.Type_Uint32List_kmP; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + sublist$2(receiver, start, end) { + return new Uint32Array(receiver.subarray(start, A._checkValidRange(start, end, receiver.length))); + }, + sublist$1(receiver, start) { + return this.sublist$2(receiver, start, null); + }, + $isTrustedGetRuntimeType: 1, + $isUint32List: 1 + }; + A.NativeUint8ClampedList.prototype = { + get$runtimeType(receiver) { + return B.Type_Uint8ClampedList_04U; + }, + get$length(receiver) { + return receiver.length; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + sublist$2(receiver, start, end) { + return new Uint8ClampedArray(receiver.subarray(start, A._checkValidRange(start, end, receiver.length))); + }, + sublist$1(receiver, start) { + return this.sublist$2(receiver, start, null); + }, + $isTrustedGetRuntimeType: 1, + $isUint8ClampedList: 1 + }; + A.NativeUint8List.prototype = { + get$runtimeType(receiver) { + return B.Type_Uint8List_8Eb; + }, + get$length(receiver) { + return receiver.length; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + sublist$2(receiver, start, end) { + return new Uint8Array(receiver.subarray(start, A._checkValidRange(start, end, receiver.length))); + }, + sublist$1(receiver, start) { + return this.sublist$2(receiver, start, null); + }, + $isTrustedGetRuntimeType: 1, + $isNativeUint8List: 1, + $isUint8List: 1 + }; + A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin.prototype = {}; + A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin.prototype = {}; + A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin.prototype = {}; + A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin.prototype = {}; + A.Rti.prototype = { + _eval$1(recipe) { + return A._Universe_evalInEnvironment(init.typeUniverse, this, recipe); + }, + _bind$1(typeOrTuple) { + return A._Universe_bind(init.typeUniverse, this, typeOrTuple); + } + }; + A._FunctionParameters.prototype = {}; + A._Type.prototype = { + toString$0(_) { + return A._rtiToString(this._rti, null); + } + }; + A._Error.prototype = { + toString$0(_) { + return this.__rti$_message; + } + }; + A._TypeError.prototype = { + get$message(_) { + return this.__rti$_message; + }, + $isTypeError: 1 + }; + A._AsyncRun__initializeScheduleImmediate_internalCallback.prototype = { + call$1(__wc0_formal) { + var t1 = this._box_0, + f = t1.storedCallback; + t1.storedCallback = null; + f.call$0(); + }, + $signature: 55 + }; + A._AsyncRun__initializeScheduleImmediate_closure.prototype = { + call$1(callback) { + var t1, t2; + this._box_0.storedCallback = callback; + t1 = this.div; + t2 = this.span; + t1.firstChild ? t1.removeChild(t2) : t1.appendChild(t2); + }, + $signature: 35 + }; + A._AsyncRun__scheduleImmediateJsOverride_internalCallback.prototype = { + call$0() { + this.callback.call$0(); + }, + $signature: 1 + }; + A._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback.prototype = { + call$0() { + this.callback.call$0(); + }, + $signature: 1 + }; + A._TimerImpl.prototype = { + _TimerImpl$2(milliseconds, callback) { + if (self.setTimeout != null) + this._handle = self.setTimeout(A.convertDartClosureToJS(new A._TimerImpl_internalCallback(this, callback), 0), milliseconds); + else + throw A.wrapException(A.UnsupportedError$("`setTimeout()` not found.")); + }, + _TimerImpl$periodic$2(milliseconds, callback) { + if (self.setTimeout != null) + this._handle = self.setInterval(A.convertDartClosureToJS(new A._TimerImpl$periodic_closure(this, milliseconds, Date.now(), callback), 0), milliseconds); + else + throw A.wrapException(A.UnsupportedError$("Periodic timer.")); + }, + cancel$0() { + if (self.setTimeout != null) { + var t1 = this._handle; + if (t1 == null) + return; + if (this._once) + self.clearTimeout(t1); + else + self.clearInterval(t1); + this._handle = null; + } else + throw A.wrapException(A.UnsupportedError$("Canceling a timer.")); + } + }; + A._TimerImpl_internalCallback.prototype = { + call$0() { + var t1 = this.$this; + t1._handle = null; + t1._tick = 1; + this.callback.call$0(); + }, + $signature: 0 + }; + A._TimerImpl$periodic_closure.prototype = { + call$0() { + var duration, _this = this, + t1 = _this.$this, + tick = t1._tick + 1, + t2 = _this.milliseconds; + if (t2 > 0) { + duration = Date.now() - _this.start; + if (duration > (tick + 1) * t2) + tick = B.JSInt_methods.$tdiv(duration, t2); + } + t1._tick = tick; + _this.callback.call$1(t1); + }, + $signature: 1 + }; + A._AsyncAwaitCompleter.prototype = { + complete$1(value) { + var t1, _this = this; + if (value == null) + value = _this.$ti._precomputed1._as(value); + if (!_this.isSync) + _this._future._asyncComplete$1(value); + else { + t1 = _this._future; + if (_this.$ti._eval$1("Future<1>")._is(value)) + t1._chainFuture$1(value); + else + t1._completeWithValue$1(value); + } + }, + completeError$2(e, st) { + var t1 = this._future; + if (this.isSync) + t1._completeError$2(e, st); + else + t1._asyncCompleteError$2(e, st); + } + }; + A._awaitOnObject_closure.prototype = { + call$1(result) { + return this.bodyFunction.call$2(0, result); + }, + $signature: 71 + }; + A._awaitOnObject_closure0.prototype = { + call$2(error, stackTrace) { + this.bodyFunction.call$2(1, new A.ExceptionAndStackTrace(error, stackTrace)); + }, + $signature: 390 + }; + A._wrapJsFunctionForAsync_closure.prototype = { + call$2(errorCode, result) { + this.$protected(errorCode, result); + }, + $signature: 379 + }; + A._SyncStarIterator.prototype = { + get$current(_) { + return this._async$_current; + }, + _resumeBody$2(errorCode, errorValue) { + var body, t1, exception; + errorCode = errorCode; + errorValue = errorValue; + body = this._body; + for (; true;) + try { + t1 = body(this, errorCode, errorValue); + return t1; + } catch (exception) { + errorValue = exception; + errorCode = 1; + } + }, + moveNext$0() { + var nestedIterator, exception, value, suspendedBodies, _this = this, errorValue = null, errorCode = 0; + for (; true;) { + nestedIterator = _this._nestedIterator; + if (nestedIterator != null) + try { + if (nestedIterator.moveNext$0()) { + _this._async$_current = J.get$current$x(nestedIterator); + return true; + } else + _this._nestedIterator = null; + } catch (exception) { + errorValue = exception; + errorCode = 1; + _this._nestedIterator = null; + } + value = _this._resumeBody$2(errorCode, errorValue); + if (1 === value) + return true; + if (0 === value) { + _this._async$_current = null; + suspendedBodies = _this._suspendedBodies; + if (suspendedBodies == null || suspendedBodies.length === 0) { + _this._body = A._SyncStarIterator__terminatedBody; + return false; + } + _this._body = suspendedBodies.pop(); + errorCode = 0; + errorValue = null; + continue; + } + if (2 === value) { + errorCode = 0; + errorValue = null; + continue; + } + if (3 === value) { + errorValue = _this._datum; + _this._datum = null; + suspendedBodies = _this._suspendedBodies; + if (suspendedBodies == null || suspendedBodies.length === 0) { + _this._async$_current = null; + _this._body = A._SyncStarIterator__terminatedBody; + throw errorValue; + return false; + } + _this._body = suspendedBodies.pop(); + errorCode = 1; + continue; + } + throw A.wrapException(A.StateError$("sync*")); + } + return false; + }, + _yieldStar$1(iterable) { + var t1, t2, _this = this; + if (iterable instanceof A._SyncStarIterable) { + t1 = iterable._outerHelper(); + t2 = _this._suspendedBodies; + if (t2 == null) + t2 = _this._suspendedBodies = []; + t2.push(_this._body); + _this._body = t1; + return 2; + } else { + _this._nestedIterator = J.get$iterator$ax(iterable); + return 2; + } + } + }; + A._SyncStarIterable.prototype = { + get$iterator(_) { + return new A._SyncStarIterator(this._outerHelper()); + } + }; + A.AsyncError.prototype = { + toString$0(_) { + return A.S(this.error); + }, + $isError: 1, + get$stackTrace() { + return this.stackTrace; + } + }; + A.Future_wait_handleError.prototype = { + call$2(theError, theStackTrace) { + var _this = this, + t1 = _this._box_0, + t2 = --t1.remaining; + if (t1.values != null) { + t1.values = null; + t1.error = theError; + t1.stackTrace = theStackTrace; + if (t2 === 0 || _this.eagerError) + _this._future._completeError$2(theError, theStackTrace); + } else if (t2 === 0 && !_this.eagerError) { + t2 = t1.error; + t2.toString; + t1 = t1.stackTrace; + t1.toString; + _this._future._completeError$2(t2, t1); + } + }, + $signature: 75 + }; + A.Future_wait_closure.prototype = { + call$1(value) { + var t1, value0, t3, t4, _i, t5, _this = this, + t2 = _this._box_0, + remainingResults = --t2.remaining, + valueList = t2.values; + if (valueList != null) { + J.$indexSet$ax(valueList, _this.pos, value); + if (J.$eq$(remainingResults, 0)) { + t2 = _this.T; + t1 = A._setArrayType([], t2._eval$1("JSArray<0>")); + for (t3 = valueList, t4 = t3.length, _i = 0; _i < t3.length; t3.length === t4 || (0, A.throwConcurrentModificationError)(t3), ++_i) { + value0 = t3[_i]; + t5 = value0; + if (t5 == null) + t5 = t2._as(t5); + J.add$1$ax(t1, t5); + } + _this._future._completeWithValue$1(t1); + } + } else if (J.$eq$(remainingResults, 0) && !_this.eagerError) { + t1 = t2.error; + t1.toString; + t2 = t2.stackTrace; + t2.toString; + _this._future._completeError$2(t1, t2); + } + }, + $signature() { + return this.T._eval$1("Null(0)"); + } + }; + A._Completer.prototype = { + completeError$2(error, stackTrace) { + var _0_0; + if ((this.future._state & 30) !== 0) + throw A.wrapException(A.StateError$("Future already completed")); + _0_0 = A._interceptUserError(error, stackTrace); + this._completeError$2(_0_0.error, _0_0.stackTrace); + }, + completeError$1(error) { + return this.completeError$2(error, null); + } + }; + A._AsyncCompleter.prototype = { + complete$1(value) { + var t1 = this.future; + if ((t1._state & 30) !== 0) + throw A.wrapException(A.StateError$("Future already completed")); + t1._asyncComplete$1(value); + }, + complete$0() { + return this.complete$1(null); + }, + _completeError$2(error, stackTrace) { + this.future._asyncCompleteError$2(error, stackTrace); + } + }; + A._SyncCompleter.prototype = { + complete$1(value) { + var t1 = this.future; + if ((t1._state & 30) !== 0) + throw A.wrapException(A.StateError$("Future already completed")); + t1._complete$1(value); + }, + _completeError$2(error, stackTrace) { + this.future._completeError$2(error, stackTrace); + } + }; + A._FutureListener.prototype = { + matchesErrorTest$1(asyncError) { + if ((this.state & 15) !== 6) + return true; + return this.result._zone.runUnary$2$2(this.callback, asyncError.error, type$.bool, type$.Object); + }, + handleError$1(asyncError) { + var exception, + errorCallback = this.errorCallback, + result = null, + t1 = type$.dynamic, + t2 = type$.Object, + t3 = asyncError.error, + t4 = this.result._zone; + if (type$.dynamic_Function_Object_StackTrace._is(errorCallback)) + result = t4.runBinary$3$3(errorCallback, t3, asyncError.stackTrace, t1, t2, type$.StackTrace); + else + result = t4.runUnary$2$2(errorCallback, t3, t1, t2); + try { + t1 = result; + return t1; + } catch (exception) { + if (type$.TypeError._is(A.unwrapException(exception))) { + if ((this.state & 1) !== 0) + throw A.wrapException(A.ArgumentError$("The error handler of Future.then must return a value of the returned future's type", "onError")); + throw A.wrapException(A.ArgumentError$("The error handler of Future.catchError must return a value of the future's type", "onError")); + } else + throw exception; + } + } + }; + A._Future.prototype = { + then$1$2$onError(_, f, onError, $R) { + var result, t1, + currentZone = $.Zone__current; + if (currentZone === B.C__RootZone) { + if (onError != null && !type$.dynamic_Function_Object_StackTrace._is(onError) && !type$.dynamic_Function_Object._is(onError)) + throw A.wrapException(A.ArgumentError$value(onError, "onError", string$.Error_)); + } else { + f = currentZone.registerUnaryCallback$2$1(f, $R._eval$1("0/"), this.$ti._precomputed1); + if (onError != null) + onError = A._registerErrorHandler(onError, currentZone); + } + result = new A._Future($.Zone__current, $R._eval$1("_Future<0>")); + t1 = onError == null ? 1 : 3; + this._addListener$1(new A._FutureListener(result, t1, f, onError, this.$ti._eval$1("@<1>")._bind$1($R)._eval$1("_FutureListener<1,2>"))); + return result; + }, + then$1$1(_, f, $R) { + return this.then$1$2$onError(0, f, null, $R); + }, + _thenAwait$1$2(f, onError, $E) { + var result = new A._Future($.Zone__current, $E._eval$1("_Future<0>")); + this._addListener$1(new A._FutureListener(result, 19, f, onError, this.$ti._eval$1("@<1>")._bind$1($E)._eval$1("_FutureListener<1,2>"))); + return result; + }, + catchError$1(onError) { + var t1 = this.$ti, + t2 = $.Zone__current, + result = new A._Future(t2, t1); + if (t2 !== B.C__RootZone) + onError = A._registerErrorHandler(onError, t2); + this._addListener$1(new A._FutureListener(result, 2, null, onError, t1._eval$1("_FutureListener<1,1>"))); + return result; + }, + whenComplete$1(action) { + var t1 = this.$ti, + t2 = $.Zone__current, + result = new A._Future(t2, t1); + if (t2 !== B.C__RootZone) + action = t2.registerCallback$1$1(action, type$.dynamic); + this._addListener$1(new A._FutureListener(result, 8, action, null, t1._eval$1("_FutureListener<1,1>"))); + return result; + }, + _setErrorObject$1(error) { + this._state = this._state & 1 | 16; + this._resultOrListeners = error; + }, + _cloneResult$1(source) { + this._state = source._state & 30 | this._state & 1; + this._resultOrListeners = source._resultOrListeners; + }, + _addListener$1(listener) { + var _this = this, + t1 = _this._state; + if (t1 <= 3) { + listener._nextListener = _this._resultOrListeners; + _this._resultOrListeners = listener; + } else { + if ((t1 & 4) !== 0) { + t1 = _this._resultOrListeners; + if ((t1._state & 24) === 0) { + t1._addListener$1(listener); + return; + } + _this._cloneResult$1(t1); + } + _this._zone.scheduleMicrotask$1(new A._Future__addListener_closure(_this, listener)); + } + }, + _prependListeners$1(listeners) { + var t1, existingListeners, next, cursor, next0, _this = this, _box_0 = {}; + _box_0.listeners = listeners; + if (listeners == null) + return; + t1 = _this._state; + if (t1 <= 3) { + existingListeners = _this._resultOrListeners; + _this._resultOrListeners = listeners; + if (existingListeners != null) { + next = listeners._nextListener; + for (cursor = listeners; next != null; cursor = next, next = next0) + next0 = next._nextListener; + cursor._nextListener = existingListeners; + } + } else { + if ((t1 & 4) !== 0) { + t1 = _this._resultOrListeners; + if ((t1._state & 24) === 0) { + t1._prependListeners$1(listeners); + return; + } + _this._cloneResult$1(t1); + } + _box_0.listeners = _this._reverseListeners$1(listeners); + _this._zone.scheduleMicrotask$1(new A._Future__prependListeners_closure(_box_0, _this)); + } + }, + _removeListeners$0() { + var current = this._resultOrListeners; + this._resultOrListeners = null; + return this._reverseListeners$1(current); + }, + _reverseListeners$1(listeners) { + var current, prev, next; + for (current = listeners, prev = null; current != null; prev = current, current = next) { + next = current._nextListener; + current._nextListener = prev; + } + return prev; + }, + _chainForeignFuture$1(source) { + var e, s, exception, _this = this; + _this._state ^= 2; + try { + source.then$1$2$onError(0, new A._Future__chainForeignFuture_closure(_this), new A._Future__chainForeignFuture_closure0(_this), type$.Null); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + A.scheduleMicrotask(new A._Future__chainForeignFuture_closure1(_this, e, s)); + } + }, + _complete$1(value) { + var listeners, _this = this, + t1 = _this.$ti; + if (t1._eval$1("Future<1>")._is(value)) + if (t1._is(value)) + A._Future__chainCoreFuture(value, _this, true); + else + _this._chainForeignFuture$1(value); + else { + listeners = _this._removeListeners$0(); + _this._state = 8; + _this._resultOrListeners = value; + A._Future__propagateToListeners(_this, listeners); + } + }, + _completeWithValue$1(value) { + var _this = this, + listeners = _this._removeListeners$0(); + _this._state = 8; + _this._resultOrListeners = value; + A._Future__propagateToListeners(_this, listeners); + }, + _completeWithResultOf$1(source) { + var t1, t2, listeners, _this = this; + if ((source._state & 16) !== 0) { + t1 = _this._zone; + t2 = source._zone; + t1 = !(t1 === t2 || t1.get$errorZone() === t2.get$errorZone()); + } else + t1 = false; + if (t1) + return; + listeners = _this._removeListeners$0(); + _this._cloneResult$1(source); + A._Future__propagateToListeners(_this, listeners); + }, + _completeError$2(error, stackTrace) { + var listeners = this._removeListeners$0(); + this._setErrorObject$1(new A.AsyncError(error, stackTrace)); + A._Future__propagateToListeners(this, listeners); + }, + _asyncComplete$1(value) { + if (this.$ti._eval$1("Future<1>")._is(value)) { + this._chainFuture$1(value); + return; + } + this._asyncCompleteWithValue$1(value); + }, + _asyncCompleteWithValue$1(value) { + this._state ^= 2; + this._zone.scheduleMicrotask$1(new A._Future__asyncCompleteWithValue_closure(this, value)); + }, + _chainFuture$1(value) { + if (this.$ti._is(value)) { + A._Future__chainCoreFuture(value, this, false); + return; + } + this._chainForeignFuture$1(value); + }, + _asyncCompleteError$2(error, stackTrace) { + this._state ^= 2; + this._zone.scheduleMicrotask$1(new A._Future__asyncCompleteError_closure(this, error, stackTrace)); + }, + $isFuture: 1 + }; + A._Future__addListener_closure.prototype = { + call$0() { + A._Future__propagateToListeners(this.$this, this.listener); + }, + $signature: 0 + }; + A._Future__prependListeners_closure.prototype = { + call$0() { + A._Future__propagateToListeners(this.$this, this._box_0.listeners); + }, + $signature: 0 + }; + A._Future__chainForeignFuture_closure.prototype = { + call$1(value) { + var error, stackTrace, exception, + t1 = this.$this; + t1._state ^= 2; + try { + t1._completeWithValue$1(t1.$ti._precomputed1._as(value)); + } catch (exception) { + error = A.unwrapException(exception); + stackTrace = A.getTraceFromException(exception); + t1._completeError$2(error, stackTrace); + } + }, + $signature: 55 + }; + A._Future__chainForeignFuture_closure0.prototype = { + call$2(error, stackTrace) { + this.$this._completeError$2(error, stackTrace); + }, + $signature: 46 + }; + A._Future__chainForeignFuture_closure1.prototype = { + call$0() { + this.$this._completeError$2(this.e, this.s); + }, + $signature: 0 + }; + A._Future__chainCoreFuture_closure.prototype = { + call$0() { + A._Future__chainCoreFuture(this._box_0.source, this.target, true); + }, + $signature: 0 + }; + A._Future__asyncCompleteWithValue_closure.prototype = { + call$0() { + this.$this._completeWithValue$1(this.value); + }, + $signature: 0 + }; + A._Future__asyncCompleteError_closure.prototype = { + call$0() { + this.$this._completeError$2(this.error, this.stackTrace); + }, + $signature: 0 + }; + A._Future__propagateToListeners_handleWhenCompleteCallback.prototype = { + call$0() { + var e, s, t1, exception, t2, t3, originalSource, joinedResult, _this = this, completeResult = null; + try { + t1 = _this._box_0.listener; + completeResult = t1.result._zone.run$1$1(0, t1.callback, type$.dynamic); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + if (_this.hasError && _this._box_1.source._resultOrListeners.error === e) { + t1 = _this._box_0; + t1.listenerValueOrError = _this._box_1.source._resultOrListeners; + } else { + t1 = e; + t2 = s; + if (t2 == null) + t2 = A.AsyncError_defaultStackTrace(t1); + t3 = _this._box_0; + t3.listenerValueOrError = new A.AsyncError(t1, t2); + t1 = t3; + } + t1.listenerHasError = true; + return; + } + if (completeResult instanceof A._Future && (completeResult._state & 24) !== 0) { + if ((completeResult._state & 16) !== 0) { + t1 = _this._box_0; + t1.listenerValueOrError = completeResult._resultOrListeners; + t1.listenerHasError = true; + } + return; + } + if (completeResult instanceof A._Future) { + originalSource = _this._box_1.source; + joinedResult = new A._Future(originalSource._zone, originalSource.$ti); + J.then$1$2$onError$x(completeResult, new A._Future__propagateToListeners_handleWhenCompleteCallback_closure(joinedResult, originalSource), new A._Future__propagateToListeners_handleWhenCompleteCallback_closure0(joinedResult), type$.void); + t1 = _this._box_0; + t1.listenerValueOrError = joinedResult; + t1.listenerHasError = false; + } + }, + $signature: 0 + }; + A._Future__propagateToListeners_handleWhenCompleteCallback_closure.prototype = { + call$1(__wc0_formal) { + this.joinedResult._completeWithResultOf$1(this.originalSource); + }, + $signature: 55 + }; + A._Future__propagateToListeners_handleWhenCompleteCallback_closure0.prototype = { + call$2(e, s) { + this.joinedResult._completeError$2(e, s); + }, + $signature: 46 + }; + A._Future__propagateToListeners_handleValueCallback.prototype = { + call$0() { + var e, s, t1, t2, t3, exception; + try { + t1 = this._box_0; + t2 = t1.listener; + t3 = t2.$ti; + t1.listenerValueOrError = t2.result._zone.runUnary$2$2(t2.callback, this.sourceResult, t3._eval$1("2/"), t3._precomputed1); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + t1 = e; + t2 = s; + if (t2 == null) + t2 = A.AsyncError_defaultStackTrace(t1); + t3 = this._box_0; + t3.listenerValueOrError = new A.AsyncError(t1, t2); + t3.listenerHasError = true; + } + }, + $signature: 0 + }; + A._Future__propagateToListeners_handleError.prototype = { + call$0() { + var asyncError, e, s, t1, exception, t2, t3, _this = this; + try { + asyncError = _this._box_1.source._resultOrListeners; + t1 = _this._box_0; + if (t1.listener.matchesErrorTest$1(asyncError) && t1.listener.errorCallback != null) { + t1.listenerValueOrError = t1.listener.handleError$1(asyncError); + t1.listenerHasError = false; + } + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + t1 = _this._box_1.source._resultOrListeners; + if (t1.error === e) { + t2 = _this._box_0; + t2.listenerValueOrError = t1; + t1 = t2; + } else { + t1 = e; + t2 = s; + if (t2 == null) + t2 = A.AsyncError_defaultStackTrace(t1); + t3 = _this._box_0; + t3.listenerValueOrError = new A.AsyncError(t1, t2); + t1 = t3; + } + t1.listenerHasError = true; + } + }, + $signature: 0 + }; + A._AsyncCallbackEntry.prototype = {}; + A.Stream.prototype = { + get$isBroadcast() { + return false; + }, + get$length(_) { + var t1 = {}, + future = new A._Future($.Zone__current, type$._Future_int); + t1.count = 0; + this.listen$4$cancelOnError$onDone$onError(0, new A.Stream_length_closure(t1, this), true, new A.Stream_length_closure0(t1, future), future.get$_completeError()); + return future; + } + }; + A.Stream_Stream$fromFuture_closure.prototype = { + call$1(value) { + var t1 = this.controller; + t1._async$_add$1(value); + t1._closeUnchecked$0(); + }, + $signature() { + return this.T._eval$1("Null(0)"); + } + }; + A.Stream_Stream$fromFuture_closure0.prototype = { + call$2(error, stackTrace) { + var t1 = this.controller; + t1._addError$2(error, stackTrace); + t1._closeUnchecked$0(); + }, + $signature: 388 + }; + A.Stream_length_closure.prototype = { + call$1(__wc0_formal) { + ++this._box_0.count; + }, + $signature() { + return A._instanceType(this.$this)._eval$1("~(Stream.T)"); + } + }; + A.Stream_length_closure0.prototype = { + call$0() { + this.future._complete$1(this._box_0.count); + }, + $signature: 0 + }; + A._StreamController.prototype = { + get$stream() { + return new A._ControllerStream(this, A._instanceType(this)._eval$1("_ControllerStream<1>")); + }, + get$_pendingEvents() { + if ((this._state & 8) === 0) + return this._varData; + return this._varData._varData; + }, + _ensurePendingEvents$0() { + var events, state, _this = this; + if ((_this._state & 8) === 0) { + events = _this._varData; + return events == null ? _this._varData = new A._PendingEvents() : events; + } + state = _this._varData; + events = state._varData; + return events == null ? state._varData = new A._PendingEvents() : events; + }, + get$_subscription() { + var varData = this._varData; + return (this._state & 8) !== 0 ? varData._varData : varData; + }, + _badEventState$0() { + if ((this._state & 4) !== 0) + return new A.StateError("Cannot add event after closing"); + return new A.StateError("Cannot add event while adding a stream"); + }, + addStream$2$cancelOnError(source, cancelOnError) { + var t2, t3, t4, _this = this, + t1 = _this._state; + if (t1 >= 4) + throw A.wrapException(_this._badEventState$0()); + if ((t1 & 2) !== 0) { + t1 = new A._Future($.Zone__current, type$._Future_dynamic); + t1._asyncComplete$1(null); + return t1; + } + t1 = _this._varData; + t2 = cancelOnError === true; + t3 = new A._Future($.Zone__current, type$._Future_dynamic); + t4 = t2 ? A._AddStreamState_makeErrorHandler(_this) : _this.get$_addError(); + t4 = source.listen$4$cancelOnError$onDone$onError(0, _this.get$_async$_add(), t2, _this.get$_close(), t4); + t2 = _this._state; + if ((t2 & 1) !== 0 ? (_this.get$_subscription()._state & 4) !== 0 : (t2 & 2) === 0) + t4.pause$0(0); + _this._varData = new A._StreamControllerAddStreamState(t1, t3, t4); + _this._state |= 8; + return t3; + }, + _ensureDoneFuture$0() { + var t1 = this._doneFuture; + if (t1 == null) + t1 = this._doneFuture = (this._state & 2) !== 0 ? $.$get$Future__nullFuture() : new A._Future($.Zone__current, type$._Future_void); + return t1; + }, + add$1(_, value) { + if (this._state >= 4) + throw A.wrapException(this._badEventState$0()); + this._async$_add$1(value); + }, + addError$2(error, stackTrace) { + var _0_0; + if (this._state >= 4) + throw A.wrapException(this._badEventState$0()); + _0_0 = A._interceptUserError(error, stackTrace); + this._addError$2(_0_0.error, _0_0.stackTrace); + }, + addError$1(error) { + return this.addError$2(error, null); + }, + close$0(_) { + var _this = this, + t1 = _this._state; + if ((t1 & 4) !== 0) + return _this._ensureDoneFuture$0(); + if (t1 >= 4) + throw A.wrapException(_this._badEventState$0()); + _this._closeUnchecked$0(); + return _this._ensureDoneFuture$0(); + }, + _closeUnchecked$0() { + var t1 = this._state |= 4; + if ((t1 & 1) !== 0) + this._sendDone$0(); + else if ((t1 & 3) === 0) + this._ensurePendingEvents$0().add$1(0, B.C__DelayedDone); + }, + _async$_add$1(value) { + var t1 = this._state; + if ((t1 & 1) !== 0) + this._sendData$1(value); + else if ((t1 & 3) === 0) + this._ensurePendingEvents$0().add$1(0, new A._DelayedData(value)); + }, + _addError$2(error, stackTrace) { + var t1 = this._state; + if ((t1 & 1) !== 0) + this._sendError$2(error, stackTrace); + else if ((t1 & 3) === 0) + this._ensurePendingEvents$0().add$1(0, new A._DelayedError(error, stackTrace)); + }, + _close$0() { + var addState = this._varData; + this._varData = addState._varData; + this._state &= 4294967287; + addState.addStreamFuture._asyncComplete$1(null); + }, + _subscribe$4(onData, onError, onDone, cancelOnError) { + var subscription, pendingEvents, t1, addState, _this = this; + if ((_this._state & 3) !== 0) + throw A.wrapException(A.StateError$("Stream has already been listened to.")); + subscription = A._ControllerSubscription$(_this, onData, onError, onDone, cancelOnError, A._instanceType(_this)._precomputed1); + pendingEvents = _this.get$_pendingEvents(); + t1 = _this._state |= 1; + if ((t1 & 8) !== 0) { + addState = _this._varData; + addState._varData = subscription; + addState.addSubscription.resume$0(0); + } else + _this._varData = subscription; + subscription._setPendingEvents$1(pendingEvents); + subscription._guardCallback$1(new A._StreamController__subscribe_closure(_this)); + return subscription; + }, + _recordCancel$1(subscription) { + var onCancel, cancelResult, e, s, exception, result0, t1, _this = this, result = null; + if ((_this._state & 8) !== 0) + result = _this._varData.cancel$0(); + _this._varData = null; + _this._state = _this._state & 4294967286 | 2; + onCancel = _this.onCancel; + if (onCancel != null) + if (result == null) + try { + cancelResult = onCancel.call$0(); + if (cancelResult instanceof A._Future) + result = cancelResult; + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + result0 = new A._Future($.Zone__current, type$._Future_void); + result0._asyncCompleteError$2(e, s); + result = result0; + } + else + result = result.whenComplete$1(onCancel); + t1 = new A._StreamController__recordCancel_complete(_this); + if (result != null) + result = result.whenComplete$1(t1); + else + t1.call$0(); + return result; + }, + _recordPause$1(subscription) { + if ((this._state & 8) !== 0) + this._varData.addSubscription.pause$0(0); + A._runGuarded(this.onPause); + }, + _recordResume$1(subscription) { + if ((this._state & 8) !== 0) + this._varData.addSubscription.resume$0(0); + A._runGuarded(this.onResume); + }, + $isEventSink: 1, + set$onPause(val) { + return this.onPause = val; + }, + set$onResume(val) { + return this.onResume = val; + }, + set$onCancel(val) { + return this.onCancel = val; + } + }; + A._StreamController__subscribe_closure.prototype = { + call$0() { + A._runGuarded(this.$this.onListen); + }, + $signature: 0 + }; + A._StreamController__recordCancel_complete.prototype = { + call$0() { + var doneFuture = this.$this._doneFuture; + if (doneFuture != null && (doneFuture._state & 30) === 0) + doneFuture._asyncComplete$1(null); + }, + $signature: 0 + }; + A._SyncStreamControllerDispatch.prototype = { + _sendData$1(data) { + this.get$_subscription()._async$_add$1(data); + }, + _sendError$2(error, stackTrace) { + this.get$_subscription()._addError$2(error, stackTrace); + }, + _sendDone$0() { + this.get$_subscription()._close$0(); + } + }; + A._AsyncStreamControllerDispatch.prototype = { + _sendData$1(data) { + this.get$_subscription()._addPending$1(new A._DelayedData(data)); + }, + _sendError$2(error, stackTrace) { + this.get$_subscription()._addPending$1(new A._DelayedError(error, stackTrace)); + }, + _sendDone$0() { + this.get$_subscription()._addPending$1(B.C__DelayedDone); + } + }; + A._AsyncStreamController.prototype = {}; + A._SyncStreamController.prototype = {}; + A._ControllerStream.prototype = { + get$hashCode(_) { + return (A.Primitives_objectHashCode(this._controller) ^ 892482866) >>> 0; + }, + $eq(_, other) { + if (other == null) + return false; + if (this === other) + return true; + return other instanceof A._ControllerStream && other._controller === this._controller; + } + }; + A._ControllerSubscription.prototype = { + _async$_onCancel$0() { + return this._controller._recordCancel$1(this); + }, + _async$_onPause$0() { + this._controller._recordPause$1(this); + }, + _async$_onResume$0() { + this._controller._recordResume$1(this); + } + }; + A._AddStreamState.prototype = { + cancel$0() { + var cancel = this.addSubscription.cancel$0(); + return cancel.whenComplete$1(new A._AddStreamState_cancel_closure(this)); + } + }; + A._AddStreamState_makeErrorHandler_closure.prototype = { + call$2(e, s) { + var t1 = this.controller; + t1._addError$2(e, s); + t1._close$0(); + }, + $signature: 46 + }; + A._AddStreamState_cancel_closure.prototype = { + call$0() { + this.$this.addStreamFuture._asyncComplete$1(null); + }, + $signature: 1 + }; + A._StreamControllerAddStreamState.prototype = {}; + A._BufferingStreamSubscription.prototype = { + _setPendingEvents$1(pendingEvents) { + var _this = this; + if (pendingEvents == null) + return; + _this._pending = pendingEvents; + if (pendingEvents.lastPendingEvent != null) { + _this._state = (_this._state | 128) >>> 0; + pendingEvents.schedule$1(_this); + } + }, + pause$1(_, resumeSignal) { + var t2, t3, _this = this, + t1 = _this._state; + if ((t1 & 8) !== 0) + return; + t2 = (t1 + 256 | 4) >>> 0; + _this._state = t2; + if (t1 < 256) { + t3 = _this._pending; + if (t3 != null) + if (t3._state === 1) + t3._state = 3; + } + if ((t1 & 4) === 0 && (t2 & 64) === 0) + _this._guardCallback$1(_this.get$_async$_onPause()); + }, + pause$0(_) { + return this.pause$1(0, null); + }, + resume$0(_) { + var _this = this, + t1 = _this._state; + if ((t1 & 8) !== 0) + return; + if (t1 >= 256) { + t1 = _this._state = t1 - 256; + if (t1 < 256) + if ((t1 & 128) !== 0 && _this._pending.lastPendingEvent != null) + _this._pending.schedule$1(_this); + else { + t1 = (t1 & 4294967291) >>> 0; + _this._state = t1; + if ((t1 & 64) === 0) + _this._guardCallback$1(_this.get$_async$_onResume()); + } + } + }, + cancel$0() { + var _this = this, + t1 = (_this._state & 4294967279) >>> 0; + _this._state = t1; + if ((t1 & 8) === 0) + _this._cancel$0(); + t1 = _this._cancelFuture; + return t1 == null ? $.$get$Future__nullFuture() : t1; + }, + _cancel$0() { + var t2, _this = this, + t1 = _this._state = (_this._state | 8) >>> 0; + if ((t1 & 128) !== 0) { + t2 = _this._pending; + if (t2._state === 1) + t2._state = 3; + } + if ((t1 & 64) === 0) + _this._pending = null; + _this._cancelFuture = _this._async$_onCancel$0(); + }, + _async$_add$1(data) { + var t1 = this._state; + if ((t1 & 8) !== 0) + return; + if (t1 < 64) + this._sendData$1(data); + else + this._addPending$1(new A._DelayedData(data)); + }, + _addError$2(error, stackTrace) { + var t1; + if (type$.Error._is(error)) + A.Primitives_trySetStackTrace(error, stackTrace); + t1 = this._state; + if ((t1 & 8) !== 0) + return; + if (t1 < 64) + this._sendError$2(error, stackTrace); + else + this._addPending$1(new A._DelayedError(error, stackTrace)); + }, + _close$0() { + var _this = this, + t1 = _this._state; + if ((t1 & 8) !== 0) + return; + t1 = (t1 | 2) >>> 0; + _this._state = t1; + if (t1 < 64) + _this._sendDone$0(); + else + _this._addPending$1(B.C__DelayedDone); + }, + _async$_onPause$0() { + }, + _async$_onResume$0() { + }, + _async$_onCancel$0() { + return null; + }, + _addPending$1($event) { + var t1, _this = this, + pending = _this._pending; + if (pending == null) + pending = _this._pending = new A._PendingEvents(); + pending.add$1(0, $event); + t1 = _this._state; + if ((t1 & 128) === 0) { + t1 = (t1 | 128) >>> 0; + _this._state = t1; + if (t1 < 256) + pending.schedule$1(_this); + } + }, + _sendData$1(data) { + var _this = this, + t1 = _this._state; + _this._state = (t1 | 64) >>> 0; + _this._zone.runUnaryGuarded$1$2(_this._onData, data, A._instanceType(_this)._eval$1("_BufferingStreamSubscription.T")); + _this._state = (_this._state & 4294967231) >>> 0; + _this._checkState$1((t1 & 4) !== 0); + }, + _sendError$2(error, stackTrace) { + var cancelFuture, _this = this, + t1 = _this._state, + t2 = new A._BufferingStreamSubscription__sendError_sendError(_this, error, stackTrace); + if ((t1 & 1) !== 0) { + _this._state = (t1 | 16) >>> 0; + _this._cancel$0(); + cancelFuture = _this._cancelFuture; + if (cancelFuture != null && cancelFuture !== $.$get$Future__nullFuture()) + cancelFuture.whenComplete$1(t2); + else + t2.call$0(); + } else { + t2.call$0(); + _this._checkState$1((t1 & 4) !== 0); + } + }, + _sendDone$0() { + var cancelFuture, _this = this, + t1 = new A._BufferingStreamSubscription__sendDone_sendDone(_this); + _this._cancel$0(); + _this._state = (_this._state | 16) >>> 0; + cancelFuture = _this._cancelFuture; + if (cancelFuture != null && cancelFuture !== $.$get$Future__nullFuture()) + cancelFuture.whenComplete$1(t1); + else + t1.call$0(); + }, + _guardCallback$1(callback) { + var _this = this, + t1 = _this._state; + _this._state = (t1 | 64) >>> 0; + callback.call$0(); + _this._state = (_this._state & 4294967231) >>> 0; + _this._checkState$1((t1 & 4) !== 0); + }, + _checkState$1(wasInputPaused) { + var t2, isInputPaused, _this = this, + t1 = _this._state; + if ((t1 & 128) !== 0 && _this._pending.lastPendingEvent == null) { + t1 = _this._state = (t1 & 4294967167) >>> 0; + t2 = false; + if ((t1 & 4) !== 0) + if (t1 < 256) { + t2 = _this._pending; + t2 = t2 == null ? null : t2.lastPendingEvent == null; + t2 = t2 !== false; + } + if (t2) { + t1 = (t1 & 4294967291) >>> 0; + _this._state = t1; + } + } + for (; true; wasInputPaused = isInputPaused) { + if ((t1 & 8) !== 0) { + _this._pending = null; + return; + } + isInputPaused = (t1 & 4) !== 0; + if (wasInputPaused === isInputPaused) + break; + _this._state = (t1 ^ 64) >>> 0; + if (isInputPaused) + _this._async$_onPause$0(); + else + _this._async$_onResume$0(); + t1 = (_this._state & 4294967231) >>> 0; + _this._state = t1; + } + if ((t1 & 128) !== 0 && t1 < 256) + _this._pending.schedule$1(_this); + }, + $isStreamSubscription: 1 + }; + A._BufferingStreamSubscription__sendError_sendError.prototype = { + call$0() { + var onError, t3, t4, + t1 = this.$this, + t2 = t1._state; + if ((t2 & 8) !== 0 && (t2 & 16) === 0) + return; + t1._state = (t2 | 64) >>> 0; + onError = t1._onError; + t2 = this.error; + t3 = type$.Object; + t4 = t1._zone; + if (type$.void_Function_Object_StackTrace._is(onError)) + t4.runBinaryGuarded$2$3(onError, t2, this.stackTrace, t3, type$.StackTrace); + else + t4.runUnaryGuarded$1$2(onError, t2, t3); + t1._state = (t1._state & 4294967231) >>> 0; + }, + $signature: 0 + }; + A._BufferingStreamSubscription__sendDone_sendDone.prototype = { + call$0() { + var t1 = this.$this, + t2 = t1._state; + if ((t2 & 16) === 0) + return; + t1._state = (t2 | 74) >>> 0; + t1._zone.runGuarded$1(t1._onDone); + t1._state = (t1._state & 4294967231) >>> 0; + }, + $signature: 0 + }; + A._StreamImpl.prototype = { + listen$4$cancelOnError$onDone$onError(_, onData, cancelOnError, onDone, onError) { + return this._controller._subscribe$4(onData, onError, onDone, cancelOnError === true); + }, + listen$1(_, onData) { + return this.listen$4$cancelOnError$onDone$onError(0, onData, null, null, null); + }, + listen$3$onDone$onError(_, onData, onDone, onError) { + return this.listen$4$cancelOnError$onDone$onError(0, onData, null, onDone, onError); + } + }; + A._DelayedEvent.prototype = { + get$next() { + return this.next; + }, + set$next(val) { + return this.next = val; + } + }; + A._DelayedData.prototype = { + perform$1(dispatch) { + dispatch._sendData$1(this.value); + } + }; + A._DelayedError.prototype = { + perform$1(dispatch) { + dispatch._sendError$2(this.error, this.stackTrace); + } + }; + A._DelayedDone.prototype = { + perform$1(dispatch) { + dispatch._sendDone$0(); + }, + get$next() { + return null; + }, + set$next(__wc0_formal) { + throw A.wrapException(A.StateError$("No events after a done.")); + } + }; + A._PendingEvents.prototype = { + schedule$1(dispatch) { + var _this = this, + t1 = _this._state; + if (t1 === 1) + return; + if (t1 >= 1) { + _this._state = 1; + return; + } + A.scheduleMicrotask(new A._PendingEvents_schedule_closure(_this, dispatch)); + _this._state = 1; + }, + add$1(_, $event) { + var _this = this, + lastEvent = _this.lastPendingEvent; + if (lastEvent == null) + _this.firstPendingEvent = _this.lastPendingEvent = $event; + else { + lastEvent.set$next($event); + _this.lastPendingEvent = $event; + } + } + }; + A._PendingEvents_schedule_closure.prototype = { + call$0() { + var $event, nextEvent, + t1 = this.$this, + oldState = t1._state; + t1._state = 0; + if (oldState === 3) + return; + $event = t1.firstPendingEvent; + nextEvent = $event.get$next(); + t1.firstPendingEvent = nextEvent; + if (nextEvent == null) + t1.lastPendingEvent = null; + $event.perform$1(this.dispatch); + }, + $signature: 0 + }; + A._StreamIterator.prototype = { + get$current(_) { + if (this._async$_hasValue) + return this._stateData; + return null; + }, + moveNext$0() { + var future, _this = this, + subscription = _this._subscription; + if (subscription != null) { + if (_this._async$_hasValue) { + future = new A._Future($.Zone__current, type$._Future_bool); + _this._stateData = future; + _this._async$_hasValue = false; + subscription.resume$0(0); + return future; + } + throw A.wrapException(A.StateError$("Already waiting for next.")); + } + return _this._initializeOrDone$0(); + }, + _initializeOrDone$0() { + var future, subscription, _this = this, + stateData = _this._stateData; + if (stateData != null) { + future = new A._Future($.Zone__current, type$._Future_bool); + _this._stateData = future; + subscription = stateData.listen$4$cancelOnError$onDone$onError(0, _this.get$_onData(), true, _this.get$_onDone(), _this.get$_onError()); + if (_this._stateData != null) + _this._subscription = subscription; + return future; + } + return $.$get$Future__falseFuture(); + }, + cancel$0() { + var _this = this, + subscription = _this._subscription, + stateData = _this._stateData; + _this._stateData = null; + if (subscription != null) { + _this._subscription = null; + if (!_this._async$_hasValue) + stateData._asyncComplete$1(false); + else + _this._async$_hasValue = false; + return subscription.cancel$0(); + } + return $.$get$Future__nullFuture(); + }, + _onData$1(data) { + var moveNextFuture, t1, _this = this; + if (_this._subscription == null) + return; + moveNextFuture = _this._stateData; + _this._stateData = data; + _this._async$_hasValue = true; + moveNextFuture._complete$1(true); + if (_this._async$_hasValue) { + t1 = _this._subscription; + if (t1 != null) + t1.pause$0(0); + } + }, + _onError$2(error, stackTrace) { + var _this = this, + subscription = _this._subscription, + moveNextFuture = _this._stateData; + _this._stateData = _this._subscription = null; + if (subscription != null) + moveNextFuture._completeError$2(error, stackTrace); + else + moveNextFuture._asyncCompleteError$2(error, stackTrace); + }, + _onDone$0() { + var _this = this, + subscription = _this._subscription, + moveNextFuture = _this._stateData; + _this._stateData = _this._subscription = null; + if (subscription != null) + moveNextFuture._completeWithValue$1(false); + else + moveNextFuture._asyncCompleteWithValue$1(false); + } + }; + A._ForwardingStream.prototype = { + get$isBroadcast() { + return this._async$_source.get$isBroadcast(); + }, + listen$4$cancelOnError$onDone$onError(_, onData, cancelOnError, onDone, onError) { + var t1 = this.$ti, + t2 = $.Zone__current, + t3 = cancelOnError === true ? 1 : 0, + t4 = onError != null ? 32 : 0, + t5 = A._BufferingStreamSubscription__registerDataHandler(t2, onData, t1._rest[1]), + t6 = A._BufferingStreamSubscription__registerErrorHandler(t2, onError), + t7 = onDone == null ? A.async___nullDoneHandler$closure() : onDone; + t1 = new A._ForwardingStreamSubscription(this, t5, t6, t2.registerCallback$1$1(t7, type$.void), t2, t3 | t4, t1._eval$1("_ForwardingStreamSubscription<1,2>")); + t1._subscription = this._async$_source.listen$3$onDone$onError(0, t1.get$_handleData(), t1.get$_handleDone(), t1.get$_handleError()); + return t1; + }, + listen$1(_, onData) { + return this.listen$4$cancelOnError$onDone$onError(0, onData, null, null, null); + }, + listen$3$onDone$onError(_, onData, onDone, onError) { + return this.listen$4$cancelOnError$onDone$onError(0, onData, null, onDone, onError); + } + }; + A._ForwardingStreamSubscription.prototype = { + _async$_add$1(data) { + if ((this._state & 2) !== 0) + return; + this.super$_BufferingStreamSubscription$_add(data); + }, + _addError$2(error, stackTrace) { + if ((this._state & 2) !== 0) + return; + this.super$_BufferingStreamSubscription$_addError(error, stackTrace); + }, + _async$_onPause$0() { + var t1 = this._subscription; + if (t1 != null) + t1.pause$0(0); + }, + _async$_onResume$0() { + var t1 = this._subscription; + if (t1 != null) + t1.resume$0(0); + }, + _async$_onCancel$0() { + var subscription = this._subscription; + if (subscription != null) { + this._subscription = null; + return subscription.cancel$0(); + } + return null; + }, + _handleData$1(data) { + this._stream._handleData$2(data, this); + }, + _handleError$2(error, stackTrace) { + this._addError$2(error, stackTrace); + }, + _handleDone$0() { + this._close$0(); + } + }; + A._MapStream.prototype = { + _handleData$2(inputEvent, sink) { + var e, s, exception, error, stackTrace, replacement, outputEvent = null; + try { + outputEvent = this._transform.call$1(inputEvent); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + error = e; + stackTrace = s; + replacement = A._interceptError(error, stackTrace); + if (replacement != null) { + error = replacement.error; + stackTrace = replacement.stackTrace; + } + sink._addError$2(error, stackTrace); + return; + } + sink._async$_add$1(outputEvent); + } + }; + A._ZoneFunction.prototype = {}; + A._ZoneSpecification.prototype = {$isZoneSpecification: 1}; + A._ZoneDelegate.prototype = {$isZoneDelegate: 1}; + A._Zone.prototype = { + _processUncaughtError$3(zone, error, stackTrace) { + var handler, parentDelegate, parentZone, currentZone, e, s, t1, exception, + implementation = this.get$_handleUncaughtError(), + implZone = implementation.zone; + if (implZone === B.C__RootZone) { + A._rootHandleError(error, stackTrace); + return; + } + handler = implementation.$function; + parentDelegate = implZone.get$_parentDelegate(); + t1 = J.get$parent$z(implZone); + t1.toString; + parentZone = t1; + currentZone = $.Zone__current; + try { + $.Zone__current = parentZone; + handler.call$5(implZone, parentDelegate, zone, error, stackTrace); + $.Zone__current = currentZone; + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + $.Zone__current = currentZone; + t1 = error === e ? stackTrace : s; + parentZone._processUncaughtError$3(implZone, e, t1); + } + }, + $isZone: 1 + }; + A._CustomZone.prototype = { + get$_delegate() { + var t1 = this._delegateCache; + return t1 == null ? this._delegateCache = new A._ZoneDelegate(this) : t1; + }, + get$_parentDelegate() { + return this.parent.get$_delegate(); + }, + get$errorZone() { + return this._handleUncaughtError.zone; + }, + runGuarded$1(f) { + var e, s, exception; + try { + this.run$1$1(0, f, type$.void); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + this._processUncaughtError$3(this, e, s); + } + }, + runUnaryGuarded$1$2(f, arg, $T) { + var e, s, exception; + try { + this.runUnary$2$2(f, arg, type$.void, $T); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + this._processUncaughtError$3(this, e, s); + } + }, + runBinaryGuarded$2$3(f, arg1, arg2, T1, T2) { + var e, s, exception; + try { + this.runBinary$3$3(f, arg1, arg2, type$.void, T1, T2); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + this._processUncaughtError$3(this, e, s); + } + }, + bindCallback$1$1(f, $R) { + return new A._CustomZone_bindCallback_closure(this, this.registerCallback$1$1(f, $R), $R); + }, + bindUnaryCallback$2$1(f, $R, $T) { + return new A._CustomZone_bindUnaryCallback_closure(this, this.registerUnaryCallback$2$1(f, $R, $T), $T, $R); + }, + bindCallbackGuarded$1(f) { + return new A._CustomZone_bindCallbackGuarded_closure(this, this.registerCallback$1$1(f, type$.void)); + }, + $index(_, key) { + var value, + t1 = this._async$_map, + result = t1.$index(0, key); + if (result != null || t1.containsKey$1(key)) + return result; + value = this.parent.$index(0, key); + if (value != null) + t1.$indexSet(0, key, value); + return value; + }, + handleUncaughtError$2(error, stackTrace) { + this._processUncaughtError$3(this, error, stackTrace); + }, + fork$2$specification$zoneValues(specification, zoneValues) { + var implementation = this._fork, + t1 = implementation.zone; + return implementation.$function.call$5(t1, t1.get$_parentDelegate(), this, specification, zoneValues); + }, + run$1$1(_, f) { + var implementation = this._run, + t1 = implementation.zone; + return implementation.$function.call$4(t1, t1.get$_parentDelegate(), this, f); + }, + runUnary$2$2(f, arg) { + var implementation = this._runUnary, + t1 = implementation.zone; + return implementation.$function.call$5(t1, t1.get$_parentDelegate(), this, f, arg); + }, + runBinary$3$3(f, arg1, arg2) { + var implementation = this._runBinary, + t1 = implementation.zone; + return implementation.$function.call$6(t1, t1.get$_parentDelegate(), this, f, arg1, arg2); + }, + registerCallback$1$1(callback) { + var implementation = this._registerCallback, + t1 = implementation.zone; + return implementation.$function.call$4(t1, t1.get$_parentDelegate(), this, callback); + }, + registerUnaryCallback$2$1(callback) { + var implementation = this._registerUnaryCallback, + t1 = implementation.zone; + return implementation.$function.call$4(t1, t1.get$_parentDelegate(), this, callback); + }, + registerBinaryCallback$3$1(callback) { + var implementation = this._registerBinaryCallback, + t1 = implementation.zone; + return implementation.$function.call$4(t1, t1.get$_parentDelegate(), this, callback); + }, + errorCallback$2(error, stackTrace) { + var implementation = this._errorCallback, + implementationZone = implementation.zone; + if (implementationZone === B.C__RootZone) + return null; + return implementation.$function.call$5(implementationZone, implementationZone.get$_parentDelegate(), this, error, stackTrace); + }, + scheduleMicrotask$1(f) { + var implementation = this._scheduleMicrotask, + t1 = implementation.zone; + return implementation.$function.call$4(t1, t1.get$_parentDelegate(), this, f); + }, + createTimer$2(duration, f) { + var implementation = this._createTimer, + t1 = implementation.zone; + return implementation.$function.call$5(t1, t1.get$_parentDelegate(), this, duration, f); + }, + print$1(line) { + var implementation = this._print, + t1 = implementation.zone; + return implementation.$function.call$4(t1, t1.get$_parentDelegate(), this, line); + }, + get$_run() { + return this._run; + }, + get$_runUnary() { + return this._runUnary; + }, + get$_runBinary() { + return this._runBinary; + }, + get$_registerCallback() { + return this._registerCallback; + }, + get$_registerUnaryCallback() { + return this._registerUnaryCallback; + }, + get$_registerBinaryCallback() { + return this._registerBinaryCallback; + }, + get$_errorCallback() { + return this._errorCallback; + }, + get$_scheduleMicrotask() { + return this._scheduleMicrotask; + }, + get$_createTimer() { + return this._createTimer; + }, + get$_createPeriodicTimer() { + return this._createPeriodicTimer; + }, + get$_print() { + return this._print; + }, + get$_fork() { + return this._fork; + }, + get$_handleUncaughtError() { + return this._handleUncaughtError; + }, + get$parent(receiver) { + return this.parent; + }, + get$_async$_map() { + return this._async$_map; + } + }; + A._CustomZone_bindCallback_closure.prototype = { + call$0() { + return this.$this.run$1$1(0, this.registered, this.R); + }, + $signature() { + return this.R._eval$1("0()"); + } + }; + A._CustomZone_bindUnaryCallback_closure.prototype = { + call$1(arg) { + var _this = this; + return _this.$this.runUnary$2$2(_this.registered, arg, _this.R, _this.T); + }, + $signature() { + return this.R._eval$1("@<0>")._bind$1(this.T)._eval$1("1(2)"); + } + }; + A._CustomZone_bindCallbackGuarded_closure.prototype = { + call$0() { + return this.$this.runGuarded$1(this.registered); + }, + $signature: 0 + }; + A._rootHandleError_closure.prototype = { + call$0() { + A.Error_throwWithStackTrace(this.error, this.stackTrace); + }, + $signature: 0 + }; + A._RootZone.prototype = { + get$_run() { + return B._ZoneFunction__RootZone__rootRun; + }, + get$_runUnary() { + return B._ZoneFunction__RootZone__rootRunUnary; + }, + get$_runBinary() { + return B._ZoneFunction__RootZone__rootRunBinary; + }, + get$_registerCallback() { + return B._ZoneFunction__RootZone__rootRegisterCallback; + }, + get$_registerUnaryCallback() { + return B._ZoneFunction_Xkh; + }, + get$_registerBinaryCallback() { + return B._ZoneFunction_e9o; + }, + get$_errorCallback() { + return B._ZoneFunction__RootZone__rootErrorCallback; + }, + get$_scheduleMicrotask() { + return B._ZoneFunction__RootZone__rootScheduleMicrotask; + }, + get$_createTimer() { + return B._ZoneFunction__RootZone__rootCreateTimer; + }, + get$_createPeriodicTimer() { + return B._ZoneFunction_PAY; + }, + get$_print() { + return B._ZoneFunction__RootZone__rootPrint; + }, + get$_fork() { + return B._ZoneFunction__RootZone__rootFork; + }, + get$_handleUncaughtError() { + return B._ZoneFunction_KjJ; + }, + get$parent(_) { + return null; + }, + get$_async$_map() { + return $.$get$_RootZone__rootMap(); + }, + get$_delegate() { + var t1 = $._RootZone__rootDelegate; + return t1 == null ? $._RootZone__rootDelegate = new A._ZoneDelegate(this) : t1; + }, + get$_parentDelegate() { + var t1 = $._RootZone__rootDelegate; + return t1 == null ? $._RootZone__rootDelegate = new A._ZoneDelegate(this) : t1; + }, + get$errorZone() { + return this; + }, + runGuarded$1(f) { + var e, s, exception; + try { + if (B.C__RootZone === $.Zone__current) { + f.call$0(); + return; + } + A._rootRun(null, null, this, f); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + A._rootHandleError(e, s); + } + }, + runUnaryGuarded$1$2(f, arg) { + var e, s, exception; + try { + if (B.C__RootZone === $.Zone__current) { + f.call$1(arg); + return; + } + A._rootRunUnary(null, null, this, f, arg); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + A._rootHandleError(e, s); + } + }, + runBinaryGuarded$2$3(f, arg1, arg2) { + var e, s, exception; + try { + if (B.C__RootZone === $.Zone__current) { + f.call$2(arg1, arg2); + return; + } + A._rootRunBinary(null, null, this, f, arg1, arg2); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + A._rootHandleError(e, s); + } + }, + bindCallback$1$1(f, $R) { + return new A._RootZone_bindCallback_closure(this, f, $R); + }, + bindUnaryCallback$2$1(f, $R, $T) { + return new A._RootZone_bindUnaryCallback_closure(this, f, $T, $R); + }, + bindCallbackGuarded$1(f) { + return new A._RootZone_bindCallbackGuarded_closure(this, f); + }, + $index(_, key) { + return null; + }, + handleUncaughtError$2(error, stackTrace) { + A._rootHandleError(error, stackTrace); + }, + fork$2$specification$zoneValues(specification, zoneValues) { + return A._rootFork(null, null, this, specification, zoneValues); + }, + run$1$1(_, f) { + if ($.Zone__current === B.C__RootZone) + return f.call$0(); + return A._rootRun(null, null, this, f); + }, + runUnary$2$2(f, arg) { + if ($.Zone__current === B.C__RootZone) + return f.call$1(arg); + return A._rootRunUnary(null, null, this, f, arg); + }, + runBinary$3$3(f, arg1, arg2) { + if ($.Zone__current === B.C__RootZone) + return f.call$2(arg1, arg2); + return A._rootRunBinary(null, null, this, f, arg1, arg2); + }, + registerCallback$1$1(f) { + return f; + }, + registerUnaryCallback$2$1(f) { + return f; + }, + registerBinaryCallback$3$1(f) { + return f; + }, + errorCallback$2(error, stackTrace) { + return null; + }, + scheduleMicrotask$1(f) { + A._rootScheduleMicrotask(null, null, this, f); + }, + createTimer$2(duration, f) { + return A.Timer__createTimer(duration, f); + }, + print$1(line) { + A.printString(line); + } + }; + A._RootZone_bindCallback_closure.prototype = { + call$0() { + return this.$this.run$1$1(0, this.f, this.R); + }, + $signature() { + return this.R._eval$1("0()"); + } + }; + A._RootZone_bindUnaryCallback_closure.prototype = { + call$1(arg) { + var _this = this; + return _this.$this.runUnary$2$2(_this.f, arg, _this.R, _this.T); + }, + $signature() { + return this.R._eval$1("@<0>")._bind$1(this.T)._eval$1("1(2)"); + } + }; + A._RootZone_bindCallbackGuarded_closure.prototype = { + call$0() { + return this.$this.runGuarded$1(this.f); + }, + $signature: 0 + }; + A._HashMap.prototype = { + get$length(_) { + return this._collection$_length; + }, + get$isEmpty(_) { + return this._collection$_length === 0; + }, + get$isNotEmpty(_) { + return this._collection$_length !== 0; + }, + get$keys(_) { + return new A._HashMapKeyIterable(this, A._instanceType(this)._eval$1("_HashMapKeyIterable<1>")); + }, + get$values(_) { + var t1 = A._instanceType(this); + return A.MappedIterable_MappedIterable(new A._HashMapKeyIterable(this, t1._eval$1("_HashMapKeyIterable<1>")), new A._HashMap_values_closure(this), t1._precomputed1, t1._rest[1]); + }, + containsKey$1(key) { + var strings, nums; + if (typeof key == "string" && key !== "__proto__") { + strings = this._strings; + return strings == null ? false : strings[key] != null; + } else if (typeof key == "number" && (key & 1073741823) === key) { + nums = this._nums; + return nums == null ? false : nums[key] != null; + } else + return this._containsKey$1(key); + }, + _containsKey$1(key) { + var rest = this._collection$_rest; + if (rest == null) + return false; + return this._findBucketIndex$2(this._getBucket$2(rest, key), key) >= 0; + }, + addAll$1(_, other) { + other.forEach$1(0, new A._HashMap_addAll_closure(this)); + }, + $index(_, key) { + var strings, t1, nums; + if (typeof key == "string" && key !== "__proto__") { + strings = this._strings; + t1 = strings == null ? null : A._HashMap__getTableEntry(strings, key); + return t1; + } else if (typeof key == "number" && (key & 1073741823) === key) { + nums = this._nums; + t1 = nums == null ? null : A._HashMap__getTableEntry(nums, key); + return t1; + } else + return this._get$1(key); + }, + _get$1(key) { + var bucket, index, + rest = this._collection$_rest; + if (rest == null) + return null; + bucket = this._getBucket$2(rest, key); + index = this._findBucketIndex$2(bucket, key); + return index < 0 ? null : bucket[index + 1]; + }, + $indexSet(_, key, value) { + var strings, nums, _this = this; + if (typeof key == "string" && key !== "__proto__") { + strings = _this._strings; + _this._addHashTableEntry$3(strings == null ? _this._strings = A._HashMap__newHashTable() : strings, key, value); + } else if (typeof key == "number" && (key & 1073741823) === key) { + nums = _this._nums; + _this._addHashTableEntry$3(nums == null ? _this._nums = A._HashMap__newHashTable() : nums, key, value); + } else + _this._set$2(key, value); + }, + _set$2(key, value) { + var hash, bucket, index, _this = this, + rest = _this._collection$_rest; + if (rest == null) + rest = _this._collection$_rest = A._HashMap__newHashTable(); + hash = _this._computeHashCode$1(key); + bucket = rest[hash]; + if (bucket == null) { + A._HashMap__setTableEntry(rest, hash, [key, value]); + ++_this._collection$_length; + _this._collection$_keys = null; + } else { + index = _this._findBucketIndex$2(bucket, key); + if (index >= 0) + bucket[index + 1] = value; + else { + bucket.push(key, value); + ++_this._collection$_length; + _this._collection$_keys = null; + } + } + }, + remove$1(_, key) { + var t1; + if (key !== "__proto__") + return this._removeHashTableEntry$2(this._strings, key); + else { + t1 = this._remove$1(key); + return t1; + } + }, + _remove$1(key) { + var hash, bucket, index, result, _this = this, + rest = _this._collection$_rest; + if (rest == null) + return null; + hash = _this._computeHashCode$1(key); + bucket = rest[hash]; + index = _this._findBucketIndex$2(bucket, key); + if (index < 0) + return null; + --_this._collection$_length; + _this._collection$_keys = null; + result = bucket.splice(index, 2)[1]; + if (0 === bucket.length) + delete rest[hash]; + return result; + }, + forEach$1(_, action) { + var $length, t1, i, key, t2, _this = this, + keys = _this._computeKeys$0(); + for ($length = keys.length, t1 = A._instanceType(_this)._rest[1], i = 0; i < $length; ++i) { + key = keys[i]; + t2 = _this.$index(0, key); + action.call$2(key, t2 == null ? t1._as(t2) : t2); + if (keys !== _this._collection$_keys) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + } + }, + _computeKeys$0() { + var strings, index, names, entries, i, nums, rest, bucket, $length, i0, _this = this, + result = _this._collection$_keys; + if (result != null) + return result; + result = A.List_List$filled(_this._collection$_length, null, false, type$.dynamic); + strings = _this._strings; + index = 0; + if (strings != null) { + names = Object.getOwnPropertyNames(strings); + entries = names.length; + for (i = 0; i < entries; ++i) { + result[index] = names[i]; + ++index; + } + } + nums = _this._nums; + if (nums != null) { + names = Object.getOwnPropertyNames(nums); + entries = names.length; + for (i = 0; i < entries; ++i) { + result[index] = +names[i]; + ++index; + } + } + rest = _this._collection$_rest; + if (rest != null) { + names = Object.getOwnPropertyNames(rest); + entries = names.length; + for (i = 0; i < entries; ++i) { + bucket = rest[names[i]]; + $length = bucket.length; + for (i0 = 0; i0 < $length; i0 += 2) { + result[index] = bucket[i0]; + ++index; + } + } + } + return _this._collection$_keys = result; + }, + _addHashTableEntry$3(table, key, value) { + if (table[key] == null) { + ++this._collection$_length; + this._collection$_keys = null; + } + A._HashMap__setTableEntry(table, key, value); + }, + _removeHashTableEntry$2(table, key) { + var value; + if (table != null && table[key] != null) { + value = A._HashMap__getTableEntry(table, key); + delete table[key]; + --this._collection$_length; + this._collection$_keys = null; + return value; + } else + return null; + }, + _computeHashCode$1(key) { + return J.get$hashCode$(key) & 1073741823; + }, + _getBucket$2(table, key) { + return table[this._computeHashCode$1(key)]; + }, + _findBucketIndex$2(bucket, key) { + var $length, i; + if (bucket == null) + return -1; + $length = bucket.length; + for (i = 0; i < $length; i += 2) + if (J.$eq$(bucket[i], key)) + return i; + return -1; + } + }; + A._HashMap_values_closure.prototype = { + call$1(each) { + var t1 = this.$this, + t2 = t1.$index(0, each); + return t2 == null ? A._instanceType(t1)._rest[1]._as(t2) : t2; + }, + $signature() { + return A._instanceType(this.$this)._eval$1("2(1)"); + } + }; + A._HashMap_addAll_closure.prototype = { + call$2(key, value) { + this.$this.$indexSet(0, key, value); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("~(1,2)"); + } + }; + A._IdentityHashMap.prototype = { + _computeHashCode$1(key) { + return A.objectHashCode(key) & 1073741823; + }, + _findBucketIndex$2(bucket, key) { + var $length, i, t1; + if (bucket == null) + return -1; + $length = bucket.length; + for (i = 0; i < $length; i += 2) { + t1 = bucket[i]; + if (t1 == null ? key == null : t1 === key) + return i; + } + return -1; + } + }; + A._HashMapKeyIterable.prototype = { + get$length(_) { + return this._map._collection$_length; + }, + get$isEmpty(_) { + return this._map._collection$_length === 0; + }, + get$isNotEmpty(_) { + return this._map._collection$_length !== 0; + }, + get$iterator(_) { + var t1 = this._map; + return new A._HashMapKeyIterator(t1, t1._computeKeys$0(), this.$ti._eval$1("_HashMapKeyIterator<1>")); + }, + contains$1(_, element) { + return this._map.containsKey$1(element); + } + }; + A._HashMapKeyIterator.prototype = { + get$current(_) { + var t1 = this._collection$_current; + return t1 == null ? this.$ti._precomputed1._as(t1) : t1; + }, + moveNext$0() { + var _this = this, + keys = _this._collection$_keys, + offset = _this._offset, + t1 = _this._map; + if (keys !== t1._collection$_keys) + throw A.wrapException(A.ConcurrentModificationError$(t1)); + else if (offset >= keys.length) { + _this._collection$_current = null; + return false; + } else { + _this._collection$_current = keys[offset]; + _this._offset = offset + 1; + return true; + } + } + }; + A._LinkedCustomHashMap.prototype = { + $index(_, key) { + if (!this._validKey.call$1(key)) + return null; + return this.super$JsLinkedHashMap$internalGet(key); + }, + $indexSet(_, key, value) { + this.super$JsLinkedHashMap$internalSet(key, value); + }, + containsKey$1(key) { + if (!this._validKey.call$1(key)) + return false; + return this.super$JsLinkedHashMap$internalContainsKey(key); + }, + remove$1(_, key) { + if (!this._validKey.call$1(key)) + return null; + return this.super$JsLinkedHashMap$internalRemove(key); + }, + internalComputeHashCode$1(key) { + return this._hashCode.call$1(key) & 1073741823; + }, + internalFindBucketIndex$2(bucket, key) { + var $length, t1, i; + if (bucket == null) + return -1; + $length = bucket.length; + for (t1 = this._equals, i = 0; i < $length; ++i) + if (t1.call$2(bucket[i].hashMapCellKey, key)) + return i; + return -1; + } + }; + A._LinkedCustomHashMap_closure.prototype = { + call$1(v) { + return this.K._is(v); + }, + $signature: 9 + }; + A._LinkedHashSet.prototype = { + _newSet$0() { + return new A._LinkedHashSet(A._instanceType(this)._eval$1("_LinkedHashSet<1>")); + }, + _newSimilarSet$1$0($R) { + return new A._LinkedHashSet($R._eval$1("_LinkedHashSet<0>")); + }, + _newSimilarSet$0() { + return this._newSimilarSet$1$0(type$.dynamic); + }, + get$iterator(_) { + var _this = this, + t1 = new A._LinkedHashSetIterator(_this, _this._modifications, A._instanceType(_this)._eval$1("_LinkedHashSetIterator<1>")); + t1._cell = _this._first; + return t1; + }, + get$length(_) { + return this._collection$_length; + }, + get$isEmpty(_) { + return this._collection$_length === 0; + }, + get$isNotEmpty(_) { + return this._collection$_length !== 0; + }, + contains$1(_, object) { + var strings, nums; + if (typeof object == "string" && object !== "__proto__") { + strings = this._strings; + if (strings == null) + return false; + return strings[object] != null; + } else if (typeof object == "number" && (object & 1073741823) === object) { + nums = this._nums; + if (nums == null) + return false; + return nums[object] != null; + } else + return this._contains$1(object); + }, + _contains$1(object) { + var rest = this._collection$_rest; + if (rest == null) + return false; + return this._findBucketIndex$2(rest[this._computeHashCode$1(object)], object) >= 0; + }, + get$first(_) { + var first = this._first; + if (first == null) + throw A.wrapException(A.StateError$("No elements")); + return first._element; + }, + get$last(_) { + var last = this._last; + if (last == null) + throw A.wrapException(A.StateError$("No elements")); + return last._element; + }, + add$1(_, element) { + var strings, nums, _this = this; + if (typeof element == "string" && element !== "__proto__") { + strings = _this._strings; + return _this._addHashTableEntry$2(strings == null ? _this._strings = A._LinkedHashSet__newHashTable() : strings, element); + } else if (typeof element == "number" && (element & 1073741823) === element) { + nums = _this._nums; + return _this._addHashTableEntry$2(nums == null ? _this._nums = A._LinkedHashSet__newHashTable() : nums, element); + } else + return _this._add$1(element); + }, + _add$1(element) { + var hash, bucket, _this = this, + rest = _this._collection$_rest; + if (rest == null) + rest = _this._collection$_rest = A._LinkedHashSet__newHashTable(); + hash = _this._computeHashCode$1(element); + bucket = rest[hash]; + if (bucket == null) + rest[hash] = [_this._newLinkedCell$1(element)]; + else { + if (_this._findBucketIndex$2(bucket, element) >= 0) + return false; + bucket.push(_this._newLinkedCell$1(element)); + } + return true; + }, + remove$1(_, object) { + var _this = this; + if (typeof object == "string" && object !== "__proto__") + return _this._removeHashTableEntry$2(_this._strings, object); + else if (typeof object == "number" && (object & 1073741823) === object) + return _this._removeHashTableEntry$2(_this._nums, object); + else + return _this._remove$1(object); + }, + _remove$1(object) { + var hash, bucket, index, cell, _this = this, + rest = _this._collection$_rest; + if (rest == null) + return false; + hash = _this._computeHashCode$1(object); + bucket = rest[hash]; + index = _this._findBucketIndex$2(bucket, object); + if (index < 0) + return false; + cell = bucket.splice(index, 1)[0]; + if (0 === bucket.length) + delete rest[hash]; + _this._unlinkCell$1(cell); + return true; + }, + _addHashTableEntry$2(table, element) { + if (table[element] != null) + return false; + table[element] = this._newLinkedCell$1(element); + return true; + }, + _removeHashTableEntry$2(table, element) { + var cell; + if (table == null) + return false; + cell = table[element]; + if (cell == null) + return false; + this._unlinkCell$1(cell); + delete table[element]; + return true; + }, + _modified$0() { + this._modifications = this._modifications + 1 & 1073741823; + }, + _newLinkedCell$1(element) { + var t1, _this = this, + cell = new A._LinkedHashSetCell(element); + if (_this._first == null) + _this._first = _this._last = cell; + else { + t1 = _this._last; + t1.toString; + cell._previous = t1; + _this._last = t1._next = cell; + } + ++_this._collection$_length; + _this._modified$0(); + return cell; + }, + _unlinkCell$1(cell) { + var _this = this, + previous = cell._previous, + next = cell._next; + if (previous == null) + _this._first = next; + else + previous._next = next; + if (next == null) + _this._last = previous; + else + next._previous = previous; + --_this._collection$_length; + _this._modified$0(); + }, + _computeHashCode$1(element) { + return J.get$hashCode$(element) & 1073741823; + }, + _findBucketIndex$2(bucket, element) { + var $length, i; + if (bucket == null) + return -1; + $length = bucket.length; + for (i = 0; i < $length; ++i) + if (J.$eq$(bucket[i]._element, element)) + return i; + return -1; + } + }; + A._LinkedIdentityHashSet.prototype = { + _newSet$0() { + return new A._LinkedIdentityHashSet(this.$ti); + }, + _newSimilarSet$1$0($R) { + return new A._LinkedIdentityHashSet($R._eval$1("_LinkedIdentityHashSet<0>")); + }, + _newSimilarSet$0() { + return this._newSimilarSet$1$0(type$.dynamic); + }, + _computeHashCode$1(key) { + return A.objectHashCode(key) & 1073741823; + }, + _findBucketIndex$2(bucket, element) { + var $length, i, t1; + if (bucket == null) + return -1; + $length = bucket.length; + for (i = 0; i < $length; ++i) { + t1 = bucket[i]._element; + if (t1 == null ? element == null : t1 === element) + return i; + } + return -1; + } + }; + A._LinkedHashSetCell.prototype = {}; + A._LinkedHashSetIterator.prototype = { + get$current(_) { + var t1 = this._collection$_current; + return t1 == null ? this.$ti._precomputed1._as(t1) : t1; + }, + moveNext$0() { + var _this = this, + cell = _this._cell, + t1 = _this._set; + if (_this._modifications !== t1._modifications) + throw A.wrapException(A.ConcurrentModificationError$(t1)); + else if (cell == null) { + _this._collection$_current = null; + return false; + } else { + _this._collection$_current = cell._element; + _this._cell = cell._next; + return true; + } + } + }; + A.UnmodifiableListView.prototype = { + cast$1$0(_, $R) { + return new A.UnmodifiableListView(J.cast$1$0$ax(this._collection$_source, $R), $R._eval$1("UnmodifiableListView<0>")); + }, + get$length(_) { + return J.get$length$asx(this._collection$_source); + }, + $index(_, index) { + return J.elementAt$1$ax(this._collection$_source, index); + } + }; + A.HashMap_HashMap$from_closure.prototype = { + call$2(k, v) { + this.result.$indexSet(0, this.K._as(k), this.V._as(v)); + }, + $signature: 162 + }; + A.LinkedHashMap_LinkedHashMap$from_closure.prototype = { + call$2(k, v) { + this.result.$indexSet(0, this.K._as(k), this.V._as(v)); + }, + $signature: 162 + }; + A.ListBase.prototype = { + get$iterator(receiver) { + return new A.ListIterator(receiver, this.get$length(receiver), A.instanceType(receiver)._eval$1("ListIterator")); + }, + elementAt$1(receiver, index) { + return this.$index(receiver, index); + }, + forEach$1(receiver, action) { + var i, + $length = this.get$length(receiver); + for (i = 0; i < $length; ++i) { + action.call$1(this.$index(receiver, i)); + if ($length !== this.get$length(receiver)) + throw A.wrapException(A.ConcurrentModificationError$(receiver)); + } + }, + get$isEmpty(receiver) { + return this.get$length(receiver) === 0; + }, + get$isNotEmpty(receiver) { + return !this.get$isEmpty(receiver); + }, + get$first(receiver) { + if (this.get$length(receiver) === 0) + throw A.wrapException(A.IterableElementError_noElement()); + return this.$index(receiver, 0); + }, + get$last(receiver) { + if (this.get$length(receiver) === 0) + throw A.wrapException(A.IterableElementError_noElement()); + return this.$index(receiver, this.get$length(receiver) - 1); + }, + get$single(receiver) { + if (this.get$length(receiver) === 0) + throw A.wrapException(A.IterableElementError_noElement()); + if (this.get$length(receiver) > 1) + throw A.wrapException(A.IterableElementError_tooMany()); + return this.$index(receiver, 0); + }, + contains$1(receiver, element) { + var i, + $length = this.get$length(receiver); + for (i = 0; i < $length; ++i) { + if (J.$eq$(this.$index(receiver, i), element)) + return true; + if ($length !== this.get$length(receiver)) + throw A.wrapException(A.ConcurrentModificationError$(receiver)); + } + return false; + }, + every$1(receiver, test) { + var i, + $length = this.get$length(receiver); + for (i = 0; i < $length; ++i) { + if (!test.call$1(this.$index(receiver, i))) + return false; + if ($length !== this.get$length(receiver)) + throw A.wrapException(A.ConcurrentModificationError$(receiver)); + } + return true; + }, + any$1(receiver, test) { + var i, + $length = this.get$length(receiver); + for (i = 0; i < $length; ++i) { + if (test.call$1(this.$index(receiver, i))) + return true; + if ($length !== this.get$length(receiver)) + throw A.wrapException(A.ConcurrentModificationError$(receiver)); + } + return false; + }, + lastWhere$2$orElse(receiver, test, orElse) { + var i, element, + $length = this.get$length(receiver); + for (i = $length - 1; i >= 0; --i) { + element = this.$index(receiver, i); + if (test.call$1(element)) + return element; + if ($length !== this.get$length(receiver)) + throw A.wrapException(A.ConcurrentModificationError$(receiver)); + } + if (orElse != null) + return orElse.call$0(); + throw A.wrapException(A.IterableElementError_noElement()); + }, + join$1(receiver, separator) { + var t1; + if (this.get$length(receiver) === 0) + return ""; + t1 = A.StringBuffer__writeAll("", receiver, separator); + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + where$1(receiver, test) { + return new A.WhereIterable(receiver, test, A.instanceType(receiver)._eval$1("WhereIterable")); + }, + map$1$1(receiver, f, $T) { + return new A.MappedListIterable(receiver, f, A.instanceType(receiver)._eval$1("@")._bind$1($T)._eval$1("MappedListIterable<1,2>")); + }, + expand$1$1(receiver, f, $T) { + return new A.ExpandIterable(receiver, f, A.instanceType(receiver)._eval$1("@")._bind$1($T)._eval$1("ExpandIterable<1,2>")); + }, + skip$1(receiver, count) { + return A.SubListIterable$(receiver, count, null, A.instanceType(receiver)._eval$1("ListBase.E")); + }, + take$1(receiver, count) { + return A.SubListIterable$(receiver, 0, A.checkNotNullable(count, "count", type$.int), A.instanceType(receiver)._eval$1("ListBase.E")); + }, + toList$1$growable(receiver, growable) { + var t1, first, result, i, _this = this; + if (_this.get$isEmpty(receiver)) { + t1 = J.JSArray_JSArray$growable(0, A.instanceType(receiver)._eval$1("ListBase.E")); + return t1; + } + first = _this.$index(receiver, 0); + result = A.List_List$filled(_this.get$length(receiver), first, true, A.instanceType(receiver)._eval$1("ListBase.E")); + for (i = 1; i < _this.get$length(receiver); ++i) + result[i] = _this.$index(receiver, i); + return result; + }, + toList$0(receiver) { + return this.toList$1$growable(receiver, true); + }, + toSet$0(receiver) { + var i, + result = A.LinkedHashSet_LinkedHashSet(A.instanceType(receiver)._eval$1("ListBase.E")); + for (i = 0; i < this.get$length(receiver); ++i) + result.add$1(0, this.$index(receiver, i)); + return result; + }, + add$1(receiver, element) { + var t1 = this.get$length(receiver); + this.set$length(receiver, t1 + 1); + this.$indexSet(receiver, t1, element); + }, + addAll$1(receiver, iterable) { + var t1, + i = this.get$length(receiver); + for (t1 = iterable.get$iterator(iterable); t1.moveNext$0();) { + this.add$1(receiver, t1.get$current(t1)); + ++i; + } + }, + _closeGap$2(receiver, start, end) { + var i, _this = this, + $length = _this.get$length(receiver), + size = end - start; + for (i = end; i < $length; ++i) + _this.$indexSet(receiver, i - size, _this.$index(receiver, i)); + _this.set$length(receiver, $length - size); + }, + cast$1$0(receiver, $R) { + return new A.CastList(receiver, A.instanceType(receiver)._eval$1("@")._bind$1($R)._eval$1("CastList<1,2>")); + }, + sort$1(receiver, compare) { + var t1 = compare == null ? A.collection_ListBase__compareAny$closure() : compare; + A.Sort__doSort(receiver, 0, this.get$length(receiver) - 1, t1); + }, + sublist$2(receiver, start, end) { + var listLength = this.get$length(receiver); + A.RangeError_checkValidRange(start, listLength, listLength); + return A.List_List$of(this.getRange$2(receiver, start, listLength), true, A.instanceType(receiver)._eval$1("ListBase.E")); + }, + sublist$1(receiver, start) { + return this.sublist$2(receiver, start, null); + }, + getRange$2(receiver, start, end) { + A.RangeError_checkValidRange(start, end, this.get$length(receiver)); + return A.SubListIterable$(receiver, start, end, A.instanceType(receiver)._eval$1("ListBase.E")); + }, + removeRange$2(receiver, start, end) { + A.RangeError_checkValidRange(start, end, this.get$length(receiver)); + if (end > start) + this._closeGap$2(receiver, start, end); + }, + fillRange$3(receiver, start, end, fill) { + var i; + A.instanceType(receiver)._eval$1("ListBase.E")._as(fill); + A.RangeError_checkValidRange(start, end, this.get$length(receiver)); + for (i = start; i < end; ++i) + this.$indexSet(receiver, i, fill); + }, + setRange$4(receiver, start, end, iterable, skipCount) { + var $length, otherStart, otherList, t1, i; + A.RangeError_checkValidRange(start, end, this.get$length(receiver)); + $length = end - start; + if ($length === 0) + return; + A.RangeError_checkNotNegative(skipCount, "skipCount"); + if (A.instanceType(receiver)._eval$1("List")._is(iterable)) { + otherStart = skipCount; + otherList = iterable; + } else { + otherList = J.skip$1$ax(iterable, skipCount).toList$1$growable(0, false); + otherStart = 0; + } + t1 = J.getInterceptor$asx(otherList); + if (otherStart + $length > t1.get$length(otherList)) + throw A.wrapException(A.IterableElementError_tooFew()); + if (otherStart < start) + for (i = $length - 1; i >= 0; --i) + this.$indexSet(receiver, start + i, t1.$index(otherList, otherStart + i)); + else + for (i = 0; i < $length; ++i) + this.$indexSet(receiver, start + i, t1.$index(otherList, otherStart + i)); + }, + indexOf$1(receiver, element) { + var i; + for (i = 0; i < this.get$length(receiver); ++i) + if (J.$eq$(this.$index(receiver, i), element)) + return i; + return -1; + }, + get$reversed(receiver) { + return new A.ReversedListIterable(receiver, A.instanceType(receiver)._eval$1("ReversedListIterable")); + }, + toString$0(receiver) { + return A.Iterable_iterableToFullString(receiver, "[", "]"); + }, + $isEfficientLengthIterable: 1, + $isIterable: 1, + $isList: 1 + }; + A.MapBase.prototype = { + cast$2$0(_, RK, RV) { + var t1 = A._instanceType(this); + return A.Map_castFrom(this, t1._eval$1("MapBase.K"), t1._eval$1("MapBase.V"), RK, RV); + }, + forEach$1(_, action) { + var t1, t2, key, t3, _this = this; + for (t1 = J.get$iterator$ax(_this.get$keys(_this)), t2 = A._instanceType(_this)._eval$1("MapBase.V"); t1.moveNext$0();) { + key = t1.get$current(t1); + t3 = _this.$index(0, key); + action.call$2(key, t3 == null ? t2._as(t3) : t3); + } + }, + addAll$1(_, other) { + other.forEach$1(0, new A.MapBase_addAll_closure(this)); + }, + get$entries(_) { + var _this = this; + return J.map$1$1$ax(_this.get$keys(_this), new A.MapBase_entries_closure(_this), A._instanceType(_this)._eval$1("MapEntry")); + }, + containsKey$1(key) { + return J.contains$1$asx(this.get$keys(this), key); + }, + get$length(_) { + return J.get$length$asx(this.get$keys(this)); + }, + get$isEmpty(_) { + return J.get$isEmpty$asx(this.get$keys(this)); + }, + get$isNotEmpty(_) { + return J.get$isNotEmpty$asx(this.get$keys(this)); + }, + get$values(_) { + return new A._MapBaseValueIterable(this, A._instanceType(this)._eval$1("_MapBaseValueIterable")); + }, + toString$0(_) { + return A.MapBase_mapToString(this); + }, + $isMap: 1 + }; + A.MapBase_addAll_closure.prototype = { + call$2(key, value) { + this.$this.$indexSet(0, key, value); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("~(MapBase.K,MapBase.V)"); + } + }; + A.MapBase_entries_closure.prototype = { + call$1(key) { + var t1 = this.$this, + t2 = t1.$index(0, key); + if (t2 == null) + t2 = A._instanceType(t1)._eval$1("MapBase.V")._as(t2); + return new A.MapEntry(key, t2, A._instanceType(t1)._eval$1("MapEntry")); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("MapEntry(MapBase.K)"); + } + }; + A.MapBase_mapToString_closure.prototype = { + call$2(k, v) { + var t2, + t1 = this._box_0; + if (!t1.first) + this.result._contents += ", "; + t1.first = false; + t1 = this.result; + t2 = A.S(k); + t2 = t1._contents += t2; + t1._contents = t2 + ": "; + t2 = A.S(v); + t1._contents += t2; + }, + $signature: 170 + }; + A.UnmodifiableMapBase.prototype = {}; + A._MapBaseValueIterable.prototype = { + get$length(_) { + var t1 = this._map; + return t1.get$length(t1); + }, + get$isEmpty(_) { + var t1 = this._map; + return t1.get$isEmpty(t1); + }, + get$isNotEmpty(_) { + var t1 = this._map; + return t1.get$isNotEmpty(t1); + }, + get$first(_) { + var t1 = this._map; + t1 = t1.$index(0, J.get$first$ax(t1.get$keys(t1))); + return t1 == null ? this.$ti._rest[1]._as(t1) : t1; + }, + get$single(_) { + var t1 = this._map; + t1 = t1.$index(0, J.get$single$ax(t1.get$keys(t1))); + return t1 == null ? this.$ti._rest[1]._as(t1) : t1; + }, + get$last(_) { + var t1 = this._map; + t1 = t1.$index(0, J.get$last$ax(t1.get$keys(t1))); + return t1 == null ? this.$ti._rest[1]._as(t1) : t1; + }, + get$iterator(_) { + var t1 = this._map; + return new A._MapBaseValueIterator(J.get$iterator$ax(t1.get$keys(t1)), t1, this.$ti._eval$1("_MapBaseValueIterator<1,2>")); + } + }; + A._MapBaseValueIterator.prototype = { + moveNext$0() { + var _this = this, + t1 = _this._collection$_keys; + if (t1.moveNext$0()) { + _this._collection$_current = _this._map.$index(0, t1.get$current(t1)); + return true; + } + _this._collection$_current = null; + return false; + }, + get$current(_) { + var t1 = this._collection$_current; + return t1 == null ? this.$ti._rest[1]._as(t1) : t1; + } + }; + A._UnmodifiableMapMixin.prototype = { + $indexSet(_, key, value) { + throw A.wrapException(A.UnsupportedError$("Cannot modify unmodifiable map")); + }, + addAll$1(_, other) { + throw A.wrapException(A.UnsupportedError$("Cannot modify unmodifiable map")); + }, + remove$1(_, key) { + throw A.wrapException(A.UnsupportedError$("Cannot modify unmodifiable map")); + } + }; + A.MapView.prototype = { + cast$2$0(_, RK, RV) { + return this._map.cast$2$0(0, RK, RV); + }, + $index(_, key) { + return this._map.$index(0, key); + }, + $indexSet(_, key, value) { + this._map.$indexSet(0, key, value); + }, + addAll$1(_, other) { + this._map.addAll$1(0, other); + }, + containsKey$1(key) { + return this._map.containsKey$1(key); + }, + forEach$1(_, action) { + this._map.forEach$1(0, action); + }, + get$isEmpty(_) { + var t1 = this._map; + return t1.get$isEmpty(t1); + }, + get$isNotEmpty(_) { + var t1 = this._map; + return t1.get$isNotEmpty(t1); + }, + get$length(_) { + var t1 = this._map; + return t1.get$length(t1); + }, + get$keys(_) { + var t1 = this._map; + return t1.get$keys(t1); + }, + remove$1(_, key) { + return this._map.remove$1(0, key); + }, + toString$0(_) { + return this._map.toString$0(0); + }, + get$values(_) { + var t1 = this._map; + return t1.get$values(t1); + }, + get$entries(_) { + var t1 = this._map; + return t1.get$entries(t1); + }, + $isMap: 1 + }; + A.UnmodifiableMapView.prototype = { + cast$2$0(_, RK, RV) { + return new A.UnmodifiableMapView(this._map.cast$2$0(0, RK, RV), RK._eval$1("@<0>")._bind$1(RV)._eval$1("UnmodifiableMapView<1,2>")); + } + }; + A.ListQueue.prototype = { + get$iterator(_) { + var _this = this; + return new A._ListQueueIterator(_this, _this._tail, _this._modificationCount, _this._head, _this.$ti._eval$1("_ListQueueIterator<1>")); + }, + get$isEmpty(_) { + return this._head === this._tail; + }, + get$length(_) { + return (this._tail - this._head & this._table.length - 1) >>> 0; + }, + get$first(_) { + var _this = this, + t1 = _this._head; + if (t1 === _this._tail) + throw A.wrapException(A.IterableElementError_noElement()); + t1 = _this._table[t1]; + return t1 == null ? _this.$ti._precomputed1._as(t1) : t1; + }, + get$last(_) { + var _this = this, + t1 = _this._head, + t2 = _this._tail; + if (t1 === t2) + throw A.wrapException(A.IterableElementError_noElement()); + t1 = _this._table; + t1 = t1[(t2 - 1 & t1.length - 1) >>> 0]; + return t1 == null ? _this.$ti._precomputed1._as(t1) : t1; + }, + get$single(_) { + var t1, _this = this; + if (_this._head === _this._tail) + throw A.wrapException(A.IterableElementError_noElement()); + if (_this.get$length(0) > 1) + throw A.wrapException(A.IterableElementError_tooMany()); + t1 = _this._table[_this._head]; + return t1 == null ? _this.$ti._precomputed1._as(t1) : t1; + }, + elementAt$1(_, index) { + var t1, _this = this; + A.IndexError_check(index, _this.get$length(0), _this, null, null); + t1 = _this._table; + t1 = t1[(_this._head + index & t1.length - 1) >>> 0]; + return t1 == null ? _this.$ti._precomputed1._as(t1) : t1; + }, + toList$1$growable(_, growable) { + var t1, list, t2, t3, i, t4, _this = this, + mask = _this._table.length - 1, + $length = (_this._tail - _this._head & mask) >>> 0; + if ($length === 0) { + t1 = J.JSArray_JSArray$growable(0, _this.$ti._precomputed1); + return t1; + } + t1 = _this.$ti._precomputed1; + list = A.List_List$filled($length, _this.get$first(0), true, t1); + for (t2 = _this._table, t3 = _this._head, i = 0; i < $length; ++i) { + t4 = t2[(t3 + i & mask) >>> 0]; + list[i] = t4 == null ? t1._as(t4) : t4; + } + return list; + }, + toList$0(_) { + return this.toList$1$growable(0, true); + }, + addAll$1(_, elements) { + var addCount, $length, t2, t3, t4, newTable, endSpace, preSpace, _i, _this = this, + t1 = _this.$ti; + if (t1._eval$1("List<1>")._is(elements)) { + addCount = elements.length; + $length = _this.get$length(0); + t2 = $length + addCount; + t3 = _this._table; + t4 = t3.length; + if (t2 >= t4) { + newTable = A.List_List$filled(A.ListQueue__nextPowerOf2(t2 + (t2 >>> 1)), null, false, t1._eval$1("1?")); + _this._tail = _this._collection$_writeToList$1(newTable); + _this._table = newTable; + _this._head = 0; + B.JSArray_methods.setRange$4(newTable, $length, t2, elements, 0); + _this._tail += addCount; + } else { + t1 = _this._tail; + endSpace = t4 - t1; + if (addCount < endSpace) { + B.JSArray_methods.setRange$4(t3, t1, t1 + addCount, elements, 0); + _this._tail += addCount; + } else { + preSpace = addCount - endSpace; + B.JSArray_methods.setRange$4(t3, t1, t1 + endSpace, elements, 0); + B.JSArray_methods.setRange$4(_this._table, 0, preSpace, elements, endSpace); + _this._tail = preSpace; + } + } + ++_this._modificationCount; + } else + for (t1 = elements.length, _i = 0; _i < elements.length; elements.length === t1 || (0, A.throwConcurrentModificationError)(elements), ++_i) + _this._add$1(elements[_i]); + }, + clear$0(_) { + var t2, t3, _this = this, + i = _this._head, + t1 = _this._tail; + if (i !== t1) { + for (t2 = _this._table, t3 = t2.length - 1; i !== t1; i = (i + 1 & t3) >>> 0) + t2[i] = null; + _this._head = _this._tail = 0; + ++_this._modificationCount; + } + }, + toString$0(_) { + return A.Iterable_iterableToFullString(this, "{", "}"); + }, + addFirst$1(value) { + var _this = this, + t1 = _this._head, + t2 = _this._table; + t1 = _this._head = (t1 - 1 & t2.length - 1) >>> 0; + t2[t1] = value; + if (t1 === _this._tail) + _this._grow$0(); + ++_this._modificationCount; + }, + removeFirst$0() { + var t2, result, _this = this, + t1 = _this._head; + if (t1 === _this._tail) + throw A.wrapException(A.IterableElementError_noElement()); + ++_this._modificationCount; + t2 = _this._table; + result = t2[t1]; + if (result == null) + result = _this.$ti._precomputed1._as(result); + t2[t1] = null; + _this._head = (t1 + 1 & t2.length - 1) >>> 0; + return result; + }, + _add$1(element) { + var _this = this, + t1 = _this._table, + t2 = _this._tail; + t1[t2] = element; + t1 = (t2 + 1 & t1.length - 1) >>> 0; + _this._tail = t1; + if (_this._head === t1) + _this._grow$0(); + ++_this._modificationCount; + }, + _grow$0() { + var _this = this, + newTable = A.List_List$filled(_this._table.length * 2, null, false, _this.$ti._eval$1("1?")), + t1 = _this._table, + t2 = _this._head, + split = t1.length - t2; + B.JSArray_methods.setRange$4(newTable, 0, split, t1, t2); + B.JSArray_methods.setRange$4(newTable, split, split + _this._head, _this._table, 0); + _this._head = 0; + _this._tail = _this._table.length; + _this._table = newTable; + }, + _collection$_writeToList$1(target) { + var $length, firstPartSize, _this = this, + t1 = _this._head, + t2 = _this._tail, + t3 = _this._table; + if (t1 <= t2) { + $length = t2 - t1; + B.JSArray_methods.setRange$4(target, 0, $length, t3, t1); + return $length; + } else { + firstPartSize = t3.length - t1; + B.JSArray_methods.setRange$4(target, 0, firstPartSize, t3, t1); + B.JSArray_methods.setRange$4(target, firstPartSize, firstPartSize + _this._tail, _this._table, 0); + return _this._tail + firstPartSize; + } + }, + $isQueue: 1 + }; + A._ListQueueIterator.prototype = { + get$current(_) { + var t1 = this._collection$_current; + return t1 == null ? this.$ti._precomputed1._as(t1) : t1; + }, + moveNext$0() { + var t2, _this = this, + t1 = _this._queue; + if (_this._modificationCount !== t1._modificationCount) + A.throwExpression(A.ConcurrentModificationError$(t1)); + t2 = _this._collection$_position; + if (t2 === _this._collection$_end) { + _this._collection$_current = null; + return false; + } + t1 = t1._table; + _this._collection$_current = t1[t2]; + _this._collection$_position = (t2 + 1 & t1.length - 1) >>> 0; + return true; + } + }; + A.SetBase.prototype = { + get$isEmpty(_) { + return this.get$length(this) === 0; + }, + get$isNotEmpty(_) { + return this.get$length(this) !== 0; + }, + addAll$1(_, elements) { + var t1; + for (t1 = J.get$iterator$ax(elements); t1.moveNext$0();) + this.add$1(0, t1.get$current(t1)); + }, + removeAll$1(elements) { + var t1; + for (t1 = J.get$iterator$ax(elements); t1.moveNext$0();) + this.remove$1(0, t1.get$current(t1)); + }, + difference$1(other) { + var t1, t2, element, + result = this.toSet$0(0); + for (t1 = this.get$iterator(this), t2 = other._source; t1.moveNext$0();) { + element = t1.get$current(t1); + if (t2.contains$1(0, element)) + result.remove$1(0, element); + } + return result; + }, + toList$1$growable(_, growable) { + return A.List_List$of(this, true, A._instanceType(this)._precomputed1); + }, + toList$0(_) { + return this.toList$1$growable(0, true); + }, + map$1$1(_, f, $T) { + return new A.EfficientLengthMappedIterable(this, f, A._instanceType(this)._eval$1("@<1>")._bind$1($T)._eval$1("EfficientLengthMappedIterable<1,2>")); + }, + get$single(_) { + var it, _this = this; + if (_this.get$length(_this) > 1) + throw A.wrapException(A.IterableElementError_tooMany()); + it = _this.get$iterator(_this); + if (!it.moveNext$0()) + throw A.wrapException(A.IterableElementError_noElement()); + return it.get$current(it); + }, + toString$0(_) { + return A.Iterable_iterableToFullString(this, "{", "}"); + }, + where$1(_, f) { + return new A.WhereIterable(this, f, A._instanceType(this)._eval$1("WhereIterable<1>")); + }, + forEach$1(_, f) { + var t1; + for (t1 = this.get$iterator(this); t1.moveNext$0();) + f.call$1(t1.get$current(t1)); + }, + every$1(_, f) { + var t1; + for (t1 = this.get$iterator(this); t1.moveNext$0();) + if (!f.call$1(t1.get$current(t1))) + return false; + return true; + }, + any$1(_, test) { + var t1; + for (t1 = this.get$iterator(this); t1.moveNext$0();) + if (test.call$1(t1.get$current(t1))) + return true; + return false; + }, + take$1(_, n) { + return A.TakeIterable_TakeIterable(this, n, A._instanceType(this)._precomputed1); + }, + skip$1(_, n) { + return A.SkipIterable_SkipIterable(this, n, A._instanceType(this)._precomputed1); + }, + get$first(_) { + var it = this.get$iterator(this); + if (!it.moveNext$0()) + throw A.wrapException(A.IterableElementError_noElement()); + return it.get$current(it); + }, + get$last(_) { + var result, + it = this.get$iterator(this); + if (!it.moveNext$0()) + throw A.wrapException(A.IterableElementError_noElement()); + do + result = it.get$current(it); + while (it.moveNext$0()); + return result; + }, + elementAt$1(_, index) { + var iterator, skipCount; + A.RangeError_checkNotNegative(index, "index"); + iterator = this.get$iterator(this); + for (skipCount = index; iterator.moveNext$0();) { + if (skipCount === 0) + return iterator.get$current(iterator); + --skipCount; + } + throw A.wrapException(A.IndexError$withLength(index, index - skipCount, this, null, "index")); + }, + $isEfficientLengthIterable: 1, + $isIterable: 1, + $isSet: 1 + }; + A._SetBase.prototype = { + difference$1(other) { + var t1, t2, t3, element, _this = this, + result = _this._newSet$0(); + for (t1 = A._LinkedHashSetIterator$(_this, _this._modifications, A._instanceType(_this)._precomputed1), t2 = other._source, t3 = t1.$ti._precomputed1; t1.moveNext$0();) { + element = t1._collection$_current; + if (element == null) + element = t3._as(element); + if (!t2.contains$1(0, element)) + result.add$1(0, element); + } + return result; + }, + intersection$1(other) { + var t1, t2, t3, element, _this = this, + result = _this._newSet$0(); + for (t1 = A._LinkedHashSetIterator$(_this, _this._modifications, A._instanceType(_this)._precomputed1), t2 = other._baseMap, t3 = t1.$ti._precomputed1; t1.moveNext$0();) { + element = t1._collection$_current; + if (element == null) + element = t3._as(element); + if (t2.containsKey$1(element)) + result.add$1(0, element); + } + return result; + }, + toSet$0(_) { + var t1 = this._newSet$0(); + t1.addAll$1(0, this); + return t1; + } + }; + A._UnmodifiableSetMixin.prototype = { + add$1(_, value) { + return A._UnmodifiableSetMixin__throwUnmodifiable(); + }, + addAll$1(_, elements) { + return A._UnmodifiableSetMixin__throwUnmodifiable(); + }, + remove$1(_, value) { + return A._UnmodifiableSetMixin__throwUnmodifiable(); + } + }; + A.UnmodifiableSetView.prototype = { + contains$1(_, element) { + return this._collection$_source.contains$1(0, element); + }, + get$length(_) { + return this._collection$_source._collection$_length; + }, + get$iterator(_) { + var t1 = this._collection$_source; + return A._LinkedHashSetIterator$(t1, t1._modifications, A._instanceType(t1)._precomputed1); + }, + toSet$0(_) { + return this._collection$_source.toSet$0(0); + } + }; + A._UnmodifiableMapView_MapView__UnmodifiableMapMixin.prototype = {}; + A._UnmodifiableSetView_SetBase__UnmodifiableSetMixin.prototype = {}; + A._JsonMap.prototype = { + $index(_, key) { + var result, + t1 = this._processed; + if (t1 == null) + return this._data.$index(0, key); + else if (typeof key != "string") + return null; + else { + result = t1[key]; + return typeof result == "undefined" ? this._process$1(key) : result; + } + }, + get$length(_) { + return this._processed == null ? this._data.__js_helper$_length : this._convert$_computeKeys$0().length; + }, + get$isEmpty(_) { + return this.get$length(0) === 0; + }, + get$isNotEmpty(_) { + return this.get$length(0) > 0; + }, + get$keys(_) { + var t1; + if (this._processed == null) { + t1 = this._data; + return new A.LinkedHashMapKeysIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapKeysIterable<1>")); + } + return new A._JsonMapKeyIterable(this); + }, + get$values(_) { + var t1, _this = this; + if (_this._processed == null) { + t1 = _this._data; + return new A.LinkedHashMapValuesIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapValuesIterable<2>")); + } + return A.MappedIterable_MappedIterable(_this._convert$_computeKeys$0(), new A._JsonMap_values_closure(_this), type$.String, type$.dynamic); + }, + $indexSet(_, key, value) { + var processed, original, _this = this; + if (_this._processed == null) + _this._data.$indexSet(0, key, value); + else if (_this.containsKey$1(key)) { + processed = _this._processed; + processed[key] = value; + original = _this._original; + if (original == null ? processed != null : original !== processed) + original[key] = null; + } else + _this._upgrade$0().$indexSet(0, key, value); + }, + addAll$1(_, other) { + other.forEach$1(0, new A._JsonMap_addAll_closure(this)); + }, + containsKey$1(key) { + if (this._processed == null) + return this._data.containsKey$1(key); + if (typeof key != "string") + return false; + return Object.prototype.hasOwnProperty.call(this._original, key); + }, + remove$1(_, key) { + if (this._processed != null && !this.containsKey$1(key)) + return null; + return this._upgrade$0().remove$1(0, key); + }, + forEach$1(_, f) { + var keys, i, key, value, _this = this; + if (_this._processed == null) + return _this._data.forEach$1(0, f); + keys = _this._convert$_computeKeys$0(); + for (i = 0; i < keys.length; ++i) { + key = keys[i]; + value = _this._processed[key]; + if (typeof value == "undefined") { + value = A._convertJsonToDartLazy(_this._original[key]); + _this._processed[key] = value; + } + f.call$2(key, value); + if (keys !== _this._data) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + } + }, + _convert$_computeKeys$0() { + var keys = this._data; + if (keys == null) + keys = this._data = A._setArrayType(Object.keys(this._original), type$.JSArray_String); + return keys; + }, + _upgrade$0() { + var result, keys, i, t1, key, _this = this; + if (_this._processed == null) + return _this._data; + result = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.dynamic); + keys = _this._convert$_computeKeys$0(); + for (i = 0; t1 = keys.length, i < t1; ++i) { + key = keys[i]; + result.$indexSet(0, key, _this.$index(0, key)); + } + if (t1 === 0) + keys.push(""); + else + B.JSArray_methods.clear$0(keys); + _this._original = _this._processed = null; + return _this._data = result; + }, + _process$1(key) { + var result; + if (!Object.prototype.hasOwnProperty.call(this._original, key)) + return null; + result = A._convertJsonToDartLazy(this._original[key]); + return this._processed[key] = result; + } + }; + A._JsonMap_values_closure.prototype = { + call$1(each) { + return this.$this.$index(0, each); + }, + $signature: 199 + }; + A._JsonMap_addAll_closure.prototype = { + call$2(key, value) { + this.$this.$indexSet(0, key, value); + }, + $signature: 139 + }; + A._JsonMapKeyIterable.prototype = { + get$length(_) { + return this._convert$_parent.get$length(0); + }, + elementAt$1(_, index) { + var t1 = this._convert$_parent; + return t1._processed == null ? t1.get$keys(0).elementAt$1(0, index) : t1._convert$_computeKeys$0()[index]; + }, + get$iterator(_) { + var t1 = this._convert$_parent; + if (t1._processed == null) { + t1 = t1.get$keys(0); + t1 = t1.get$iterator(t1); + } else { + t1 = t1._convert$_computeKeys$0(); + t1 = new J.ArrayIterator(t1, t1.length, A._arrayInstanceType(t1)._eval$1("ArrayIterator<1>")); + } + return t1; + }, + contains$1(_, key) { + return this._convert$_parent.containsKey$1(key); + } + }; + A._Utf8Decoder__decoder_closure.prototype = { + call$0() { + var t1, exception; + try { + t1 = new TextDecoder("utf-8", {fatal: true}); + return t1; + } catch (exception) { + } + return null; + }, + $signature: 59 + }; + A._Utf8Decoder__decoderNonfatal_closure.prototype = { + call$0() { + var t1, exception; + try { + t1 = new TextDecoder("utf-8", {fatal: false}); + return t1; + } catch (exception) { + } + return null; + }, + $signature: 59 + }; + A.AsciiCodec.prototype = { + encode$1(source) { + return B.AsciiEncoder_127.convert$1(source); + } + }; + A._UnicodeSubsetEncoder.prototype = { + convert$1(string) { + var t1, i, codeUnit, + end = A.RangeError_checkValidRange(0, null, string.length), + result = new Uint8Array(end); + for (t1 = ~this._subsetMask, i = 0; i < end; ++i) { + codeUnit = string.charCodeAt(i); + if ((codeUnit & t1) !== 0) + throw A.wrapException(A.ArgumentError$value(string, "string", "Contains invalid characters.")); + result[i] = codeUnit; + } + return result; + } + }; + A.AsciiEncoder.prototype = {}; + A.Base64Codec.prototype = { + normalize$3(source, start, end) { + var inverseAlphabet, i, sliceStart, buffer, firstPadding, firstPaddingSourceIndex, paddingCount, i0, char, i1, digit1, digit2, char0, value, t1, t2, endLength, $length, + _s31_ = "Invalid base64 encoding length "; + end = A.RangeError_checkValidRange(start, end, source.length); + inverseAlphabet = $.$get$_Base64Decoder__inverseAlphabet(); + for (i = start, sliceStart = i, buffer = null, firstPadding = -1, firstPaddingSourceIndex = -1, paddingCount = 0; i < end; i = i0) { + i0 = i + 1; + char = source.charCodeAt(i); + if (char === 37) { + i1 = i0 + 2; + if (i1 <= end) { + digit1 = A.hexDigitValue(source.charCodeAt(i0)); + digit2 = A.hexDigitValue(source.charCodeAt(i0 + 1)); + char0 = digit1 * 16 + digit2 - (digit2 & 256); + if (char0 === 37) + char0 = -1; + i0 = i1; + } else + char0 = -1; + } else + char0 = char; + if (0 <= char0 && char0 <= 127) { + value = inverseAlphabet[char0]; + if (value >= 0) { + char0 = string$.ABCDEF.charCodeAt(value); + if (char0 === char) + continue; + char = char0; + } else { + if (value === -1) { + if (firstPadding < 0) { + t1 = buffer == null ? null : buffer._contents.length; + if (t1 == null) + t1 = 0; + firstPadding = t1 + (i - sliceStart); + firstPaddingSourceIndex = i; + } + ++paddingCount; + if (char === 61) + continue; + } + char = char0; + } + if (value !== -2) { + if (buffer == null) { + buffer = new A.StringBuffer(""); + t1 = buffer; + } else + t1 = buffer; + t1._contents += B.JSString_methods.substring$2(source, sliceStart, i); + t2 = A.Primitives_stringFromCharCode(char); + t1._contents += t2; + sliceStart = i0; + continue; + } + } + throw A.wrapException(A.FormatException$("Invalid base64 data", source, i)); + } + if (buffer != null) { + t1 = B.JSString_methods.substring$2(source, sliceStart, end); + t1 = buffer._contents += t1; + t2 = t1.length; + if (firstPadding >= 0) + A.Base64Codec__checkPadding(source, firstPaddingSourceIndex, end, firstPadding, paddingCount, t2); + else { + endLength = B.JSInt_methods.$mod(t2 - 1, 4) + 1; + if (endLength === 1) + throw A.wrapException(A.FormatException$(_s31_, source, end)); + for (; endLength < 4;) { + t1 += "="; + buffer._contents = t1; + ++endLength; + } + } + t1 = buffer._contents; + return B.JSString_methods.replaceRange$3(source, start, end, t1.charCodeAt(0) == 0 ? t1 : t1); + } + $length = end - start; + if (firstPadding >= 0) + A.Base64Codec__checkPadding(source, firstPaddingSourceIndex, end, firstPadding, paddingCount, $length); + else { + endLength = B.JSInt_methods.$mod($length, 4); + if (endLength === 1) + throw A.wrapException(A.FormatException$(_s31_, source, end)); + if (endLength > 1) + source = B.JSString_methods.replaceRange$3(source, end, end, endLength === 2 ? "==" : "="); + } + return source; + } + }; + A.Base64Encoder.prototype = { + startChunkedConversion$1(sink) { + return new A._Utf8Base64EncoderSink(new A._Utf8StringSinkAdapter(new A._Utf8Decoder(false), sink, sink._stringSink), new A._Base64Encoder(string$.ABCDEF)); + } + }; + A._Base64Encoder.prototype = { + createBuffer$1(bufferLength) { + return new Uint8Array(bufferLength); + }, + encode$4(bytes, start, end, isLast) { + var output, _this = this, + byteCount = (_this._convert$_state & 3) + (end - start), + fullChunks = B.JSInt_methods._tdivFast$1(byteCount, 3), + bufferLength = fullChunks * 4; + if (isLast && byteCount - fullChunks * 3 > 0) + bufferLength += 4; + output = _this.createBuffer$1(bufferLength); + _this._convert$_state = A._Base64Encoder_encodeChunk(_this._alphabet, bytes, start, end, isLast, output, 0, _this._convert$_state); + if (bufferLength > 0) + return output; + return null; + } + }; + A._Base64EncoderSink.prototype = {}; + A._Utf8Base64EncoderSink.prototype = { + _convert$_add$4(source, start, end, isLast) { + var buffer = this._encoder.encode$4(source, start, end, isLast); + if (buffer != null) + this._sink.addSlice$4(buffer, 0, buffer.length, isLast); + } + }; + A.ByteConversionSink.prototype = {}; + A.Codec.prototype = {}; + A.Converter.prototype = {}; + A.Encoding.prototype = {}; + A.JsonUnsupportedObjectError.prototype = { + toString$0(_) { + var safeString = A.Error_safeToString(this.unsupportedObject); + return (this.cause != null ? "Converting object to an encodable object failed:" : "Converting object did not return an encodable object:") + " " + safeString; + } + }; + A.JsonCyclicError.prototype = { + toString$0(_) { + return "Cyclic error in JSON stringify"; + } + }; + A.JsonCodec.prototype = { + decode$1(source) { + var t1 = A._parseJson(source, this.get$decoder()._reviver); + return t1; + }, + encode$2$toEncodable(value, toEncodable) { + var t1 = A._JsonStringStringifier_stringify(value, this.get$encoder()._toEncodable, null); + return t1; + }, + get$encoder() { + return B.JsonEncoder_null; + }, + get$decoder() { + return B.JsonDecoder_null; + } + }; + A.JsonEncoder.prototype = {}; + A.JsonDecoder.prototype = {}; + A._JsonStringifier.prototype = { + writeStringContent$1(s) { + var offset, i, charCode, t1, t2, _this = this, + $length = s.length; + for (offset = 0, i = 0; i < $length; ++i) { + charCode = s.charCodeAt(i); + if (charCode > 92) { + if (charCode >= 55296) { + t1 = charCode & 64512; + if (t1 === 55296) { + t2 = i + 1; + t2 = !(t2 < $length && (s.charCodeAt(t2) & 64512) === 56320); + } else + t2 = false; + if (!t2) + if (t1 === 56320) { + t1 = i - 1; + t1 = !(t1 >= 0 && (s.charCodeAt(t1) & 64512) === 55296); + } else + t1 = false; + else + t1 = true; + if (t1) { + if (i > offset) + _this.writeStringSlice$3(s, offset, i); + offset = i + 1; + _this.writeCharCode$1(92); + _this.writeCharCode$1(117); + _this.writeCharCode$1(100); + t1 = charCode >>> 8 & 15; + _this.writeCharCode$1(t1 < 10 ? 48 + t1 : 87 + t1); + t1 = charCode >>> 4 & 15; + _this.writeCharCode$1(t1 < 10 ? 48 + t1 : 87 + t1); + t1 = charCode & 15; + _this.writeCharCode$1(t1 < 10 ? 48 + t1 : 87 + t1); + } + } + continue; + } + if (charCode < 32) { + if (i > offset) + _this.writeStringSlice$3(s, offset, i); + offset = i + 1; + _this.writeCharCode$1(92); + switch (charCode) { + case 8: + _this.writeCharCode$1(98); + break; + case 9: + _this.writeCharCode$1(116); + break; + case 10: + _this.writeCharCode$1(110); + break; + case 12: + _this.writeCharCode$1(102); + break; + case 13: + _this.writeCharCode$1(114); + break; + default: + _this.writeCharCode$1(117); + _this.writeCharCode$1(48); + _this.writeCharCode$1(48); + t1 = charCode >>> 4 & 15; + _this.writeCharCode$1(t1 < 10 ? 48 + t1 : 87 + t1); + t1 = charCode & 15; + _this.writeCharCode$1(t1 < 10 ? 48 + t1 : 87 + t1); + break; + } + } else if (charCode === 34 || charCode === 92) { + if (i > offset) + _this.writeStringSlice$3(s, offset, i); + offset = i + 1; + _this.writeCharCode$1(92); + _this.writeCharCode$1(charCode); + } + } + if (offset === 0) + _this.writeString$1(s); + else if (offset < $length) + _this.writeStringSlice$3(s, offset, $length); + }, + _checkCycle$1(object) { + var t1, t2, i, t3; + for (t1 = this._seen, t2 = t1.length, i = 0; i < t2; ++i) { + t3 = t1[i]; + if (object == null ? t3 == null : object === t3) + throw A.wrapException(new A.JsonCyclicError(object, null)); + } + t1.push(object); + }, + writeObject$1(object) { + var customJson, e, t1, exception, _this = this; + if (_this.writeJsonValue$1(object)) + return; + _this._checkCycle$1(object); + try { + customJson = _this._toEncodable.call$1(object); + if (!_this.writeJsonValue$1(customJson)) { + t1 = A.JsonUnsupportedObjectError$(object, null, _this.get$_partialResult()); + throw A.wrapException(t1); + } + _this._seen.pop(); + } catch (exception) { + e = A.unwrapException(exception); + t1 = A.JsonUnsupportedObjectError$(object, e, _this.get$_partialResult()); + throw A.wrapException(t1); + } + }, + writeJsonValue$1(object) { + var success, _this = this; + if (typeof object == "number") { + if (!isFinite(object)) + return false; + _this.writeNumber$1(object); + return true; + } else if (object === true) { + _this.writeString$1("true"); + return true; + } else if (object === false) { + _this.writeString$1("false"); + return true; + } else if (object == null) { + _this.writeString$1("null"); + return true; + } else if (typeof object == "string") { + _this.writeString$1('"'); + _this.writeStringContent$1(object); + _this.writeString$1('"'); + return true; + } else if (type$.List_dynamic._is(object)) { + _this._checkCycle$1(object); + _this.writeList$1(object); + _this._seen.pop(); + return true; + } else if (type$.Map_dynamic_dynamic._is(object)) { + _this._checkCycle$1(object); + success = _this.writeMap$1(object); + _this._seen.pop(); + return success; + } else + return false; + }, + writeList$1(list) { + var t1, i, _this = this; + _this.writeString$1("["); + t1 = J.getInterceptor$asx(list); + if (t1.get$isNotEmpty(list)) { + _this.writeObject$1(t1.$index(list, 0)); + for (i = 1; i < t1.get$length(list); ++i) { + _this.writeString$1(","); + _this.writeObject$1(t1.$index(list, i)); + } + } + _this.writeString$1("]"); + }, + writeMap$1(map) { + var t1, keyValueList, i, separator, _this = this, _box_0 = {}; + if (map.get$isEmpty(map)) { + _this.writeString$1("{}"); + return true; + } + t1 = map.get$length(map) * 2; + keyValueList = A.List_List$filled(t1, null, false, type$.nullable_Object); + i = _box_0.i = 0; + _box_0.allStringKeys = true; + map.forEach$1(0, new A._JsonStringifier_writeMap_closure(_box_0, keyValueList)); + if (!_box_0.allStringKeys) + return false; + _this.writeString$1("{"); + for (separator = '"'; i < t1; i += 2, separator = ',"') { + _this.writeString$1(separator); + _this.writeStringContent$1(A._asString(keyValueList[i])); + _this.writeString$1('":'); + _this.writeObject$1(keyValueList[i + 1]); + } + _this.writeString$1("}"); + return true; + } + }; + A._JsonStringifier_writeMap_closure.prototype = { + call$2(key, value) { + var t1, t2, t3, i; + if (typeof key != "string") + this._box_0.allStringKeys = false; + t1 = this.keyValueList; + t2 = this._box_0; + t3 = t2.i; + i = t2.i = t3 + 1; + t1[t3] = key; + t2.i = i + 1; + t1[i] = value; + }, + $signature: 170 + }; + A._JsonStringStringifier.prototype = { + get$_partialResult() { + var t1 = this._sink._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + writeNumber$1(number) { + var t1 = this._sink, + t2 = B.JSNumber_methods.toString$0(number); + t1._contents += t2; + }, + writeString$1(string) { + this._sink._contents += string; + }, + writeStringSlice$3(string, start, end) { + this._sink._contents += B.JSString_methods.substring$2(string, start, end); + }, + writeCharCode$1(charCode) { + var t1 = this._sink, + t2 = A.Primitives_stringFromCharCode(charCode); + t1._contents += t2; + } + }; + A.StringConversionSink.prototype = {}; + A._StringSinkConversionSink.prototype = { + close$0(_) { + } + }; + A._StringCallbackSink.prototype = { + close$0(_) { + var t1 = this._stringSink, + t2 = t1._contents; + t1._contents = ""; + this._convert$_callback.call$1(t2.charCodeAt(0) == 0 ? t2 : t2); + }, + asUtf8Sink$1(allowMalformed) { + return new A._Utf8StringSinkAdapter(new A._Utf8Decoder(allowMalformed), this, this._stringSink); + } + }; + A._Utf8StringSinkAdapter.prototype = { + close$0(_) { + this._decoder.flush$1(this._stringSink); + this._sink.close$0(0); + }, + add$1(_, chunk) { + this.addSlice$4(chunk, 0, J.get$length$asx(chunk), false); + }, + addSlice$4(codeUnits, startIndex, endIndex, isLast) { + var t1 = this._stringSink, + t2 = this._decoder._convertGeneral$4(codeUnits, startIndex, endIndex, false); + t1._contents += t2; + if (isLast) + this.close$0(0); + } + }; + A.Utf8Codec.prototype = { + encode$1(string) { + return B.C_Utf8Encoder.convert$1(string); + } + }; + A.Utf8Encoder.prototype = { + convert$1(string) { + var t1, encoder, + end = A.RangeError_checkValidRange(0, null, string.length); + if (end === 0) + return new Uint8Array(0); + t1 = new Uint8Array(end * 3); + encoder = new A._Utf8Encoder(t1); + if (encoder._fillBuffer$3(string, 0, end) !== end) + encoder._writeReplacementCharacter$0(); + return B.NativeUint8List_methods.sublist$2(t1, 0, encoder._bufferIndex); + } + }; + A._Utf8Encoder.prototype = { + _writeReplacementCharacter$0() { + var _this = this, + t1 = _this._buffer, + t2 = _this._bufferIndex, + t3 = _this._bufferIndex = t2 + 1; + t1.$flags & 2 && A.throwUnsupportedOperation(t1); + t1[t2] = 239; + t2 = _this._bufferIndex = t3 + 1; + t1[t3] = 191; + _this._bufferIndex = t2 + 1; + t1[t2] = 189; + }, + _writeSurrogate$2(leadingSurrogate, nextCodeUnit) { + var rune, t1, t2, t3, _this = this; + if ((nextCodeUnit & 64512) === 56320) { + rune = 65536 + ((leadingSurrogate & 1023) << 10) | nextCodeUnit & 1023; + t1 = _this._buffer; + t2 = _this._bufferIndex; + t3 = _this._bufferIndex = t2 + 1; + t1.$flags & 2 && A.throwUnsupportedOperation(t1); + t1[t2] = rune >>> 18 | 240; + t2 = _this._bufferIndex = t3 + 1; + t1[t3] = rune >>> 12 & 63 | 128; + t3 = _this._bufferIndex = t2 + 1; + t1[t2] = rune >>> 6 & 63 | 128; + _this._bufferIndex = t3 + 1; + t1[t3] = rune & 63 | 128; + return true; + } else { + _this._writeReplacementCharacter$0(); + return false; + } + }, + _fillBuffer$3(str, start, end) { + var t1, t2, t3, stringIndex, codeUnit, t4, stringIndex0, t5, _this = this; + if (start !== end && (str.charCodeAt(end - 1) & 64512) === 55296) + --end; + for (t1 = _this._buffer, t2 = t1.$flags | 0, t3 = t1.length, stringIndex = start; stringIndex < end; ++stringIndex) { + codeUnit = str.charCodeAt(stringIndex); + if (codeUnit <= 127) { + t4 = _this._bufferIndex; + if (t4 >= t3) + break; + _this._bufferIndex = t4 + 1; + t2 & 2 && A.throwUnsupportedOperation(t1); + t1[t4] = codeUnit; + } else { + t4 = codeUnit & 64512; + if (t4 === 55296) { + if (_this._bufferIndex + 4 > t3) + break; + stringIndex0 = stringIndex + 1; + if (_this._writeSurrogate$2(codeUnit, str.charCodeAt(stringIndex0))) + stringIndex = stringIndex0; + } else if (t4 === 56320) { + if (_this._bufferIndex + 3 > t3) + break; + _this._writeReplacementCharacter$0(); + } else if (codeUnit <= 2047) { + t4 = _this._bufferIndex; + t5 = t4 + 1; + if (t5 >= t3) + break; + _this._bufferIndex = t5; + t2 & 2 && A.throwUnsupportedOperation(t1); + t1[t4] = codeUnit >>> 6 | 192; + _this._bufferIndex = t5 + 1; + t1[t5] = codeUnit & 63 | 128; + } else { + t4 = _this._bufferIndex; + if (t4 + 2 >= t3) + break; + t5 = _this._bufferIndex = t4 + 1; + t2 & 2 && A.throwUnsupportedOperation(t1); + t1[t4] = codeUnit >>> 12 | 224; + t4 = _this._bufferIndex = t5 + 1; + t1[t5] = codeUnit >>> 6 & 63 | 128; + _this._bufferIndex = t4 + 1; + t1[t4] = codeUnit & 63 | 128; + } + } + } + return stringIndex; + } + }; + A.Utf8Decoder.prototype = { + convert$1(codeUnits) { + return new A._Utf8Decoder(this._allowMalformed)._convertGeneral$4(codeUnits, 0, null, true); + } + }; + A._Utf8Decoder.prototype = { + _convertGeneral$4(codeUnits, start, maybeEnd, single) { + var casted, bytes, errorOffset, t1, result, message, _this = this, + end = A.RangeError_checkValidRange(start, maybeEnd, J.get$length$asx(codeUnits)); + if (start === end) + return ""; + if (codeUnits instanceof Uint8Array) { + casted = codeUnits; + bytes = casted; + errorOffset = 0; + } else { + bytes = A._Utf8Decoder__makeNativeUint8List(codeUnits, start, end); + end -= start; + errorOffset = start; + start = 0; + } + if (single && end - start >= 15) { + t1 = _this.allowMalformed; + result = A._Utf8Decoder__convertInterceptedUint8List(t1, bytes, start, end); + if (result != null) { + if (!t1) + return result; + if (result.indexOf("\ufffd") < 0) + return result; + } + } + result = _this._decodeRecursive$4(bytes, start, end, single); + t1 = _this._convert$_state; + if ((t1 & 1) !== 0) { + message = A._Utf8Decoder_errorDescription(t1); + _this._convert$_state = 0; + throw A.wrapException(A.FormatException$(message, codeUnits, errorOffset + _this._charOrIndex)); + } + return result; + }, + _decodeRecursive$4(bytes, start, end, single) { + var mid, s1, _this = this; + if (end - start > 1000) { + mid = B.JSInt_methods._tdivFast$1(start + end, 2); + s1 = _this._decodeRecursive$4(bytes, start, mid, false); + if ((_this._convert$_state & 1) !== 0) + return s1; + return s1 + _this._decodeRecursive$4(bytes, mid, end, single); + } + return _this.decodeGeneral$4(bytes, start, end, single); + }, + flush$1(sink) { + var t1, + state = this._convert$_state; + this._convert$_state = 0; + if (state <= 32) + return; + if (this.allowMalformed) { + t1 = A.Primitives_stringFromCharCode(65533); + sink._contents += t1; + } else + throw A.wrapException(A.FormatException$(A._Utf8Decoder_errorDescription(77), null, null)); + }, + decodeGeneral$4(bytes, start, end, single) { + var t1, type, t2, i0, markEnd, i1, m, _this = this, _65533 = 65533, + state = _this._convert$_state, + char = _this._charOrIndex, + buffer = new A.StringBuffer(""), + i = start + 1, + byte = bytes[start]; + $label0$0: + for (t1 = _this.allowMalformed; true;) { + for (; true; i = i0) { + type = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHIHHHJEEBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBKCCCCCCCCCCCCDCLONNNMEEEEEEEEEEE".charCodeAt(byte) & 31; + char = state <= 32 ? byte & 61694 >>> type : (byte & 63 | char << 6) >>> 0; + state = " \x000:XECCCCCN:lDb \x000:XECCCCCNvlDb \x000:XECCCCCN:lDb AAAAA\x00\x00\x00\x00\x00AAAAA00000AAAAA:::::AAAAAGG000AAAAA00KKKAAAAAG::::AAAAA:IIIIAAAAA000\x800AAAAA\x00\x00\x00\x00 AAAAA".charCodeAt(state + type); + if (state === 0) { + t2 = A.Primitives_stringFromCharCode(char); + buffer._contents += t2; + if (i === end) + break $label0$0; + break; + } else if ((state & 1) !== 0) { + if (t1) + switch (state) { + case 69: + case 67: + t2 = A.Primitives_stringFromCharCode(_65533); + buffer._contents += t2; + break; + case 65: + t2 = A.Primitives_stringFromCharCode(_65533); + buffer._contents += t2; + --i; + break; + default: + t2 = A.Primitives_stringFromCharCode(_65533); + t2 = buffer._contents += t2; + buffer._contents = t2 + A.Primitives_stringFromCharCode(_65533); + break; + } + else { + _this._convert$_state = state; + _this._charOrIndex = i - 1; + return ""; + } + state = 0; + } + if (i === end) + break $label0$0; + i0 = i + 1; + byte = bytes[i]; + } + i0 = i + 1; + byte = bytes[i]; + if (byte < 128) { + while (true) { + if (!(i0 < end)) { + markEnd = end; + break; + } + i1 = i0 + 1; + byte = bytes[i0]; + if (byte >= 128) { + markEnd = i1 - 1; + i0 = i1; + break; + } + i0 = i1; + } + if (markEnd - i < 20) + for (m = i; m < markEnd; ++m) { + t2 = A.Primitives_stringFromCharCode(bytes[m]); + buffer._contents += t2; + } + else { + t2 = A.String_String$fromCharCodes(bytes, i, markEnd); + buffer._contents += t2; + } + if (markEnd === end) + break $label0$0; + i = i0; + } else + i = i0; + } + if (single && state > 32) + if (t1) { + t1 = A.Primitives_stringFromCharCode(_65533); + buffer._contents += t1; + } else { + _this._convert$_state = 77; + _this._charOrIndex = end; + return ""; + } + _this._convert$_state = state; + _this._charOrIndex = char; + t1 = buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + }; + A.NoSuchMethodError_toString_closure.prototype = { + call$2(key, value) { + var t1 = this.sb, + t2 = this._box_0, + t3 = t1._contents += t2.comma; + t3 += key.__internal$_name; + t1._contents = t3; + t1._contents = t3 + ": "; + t3 = A.Error_safeToString(value); + t1._contents += t3; + t2.comma = ", "; + }, + $signature: 467 + }; + A.DateTime.prototype = { + $eq(_, other) { + var t1; + if (other == null) + return false; + t1 = false; + if (other instanceof A.DateTime) + if (this._value === other._value) + t1 = this._microsecond === other._microsecond; + return t1; + }, + get$hashCode(_) { + return A.Object_hash(this._value, this._microsecond, B.C_SentinelValue, B.C_SentinelValue); + }, + isAfter$1(other) { + var t1 = this._value, + t2 = other._value; + if (t1 <= t2) + t1 = t1 === t2 && this._microsecond > other._microsecond; + else + t1 = true; + return t1; + }, + compareTo$1(_, other) { + var r = B.JSInt_methods.compareTo$1(this._value, other._value); + if (r !== 0) + return r; + return B.JSInt_methods.compareTo$1(this._microsecond, other._microsecond); + }, + toString$0(_) { + var _this = this, + y = A.DateTime__fourDigits(A.Primitives_getYear(_this)), + m = A.DateTime__twoDigits(A.Primitives_getMonth(_this)), + d = A.DateTime__twoDigits(A.Primitives_getDay(_this)), + h = A.DateTime__twoDigits(A.Primitives_getHours(_this)), + min = A.DateTime__twoDigits(A.Primitives_getMinutes(_this)), + sec = A.DateTime__twoDigits(A.Primitives_getSeconds(_this)), + ms = A.DateTime__threeDigits(A.Primitives_getMilliseconds(_this)), + t1 = _this._microsecond, + us = t1 === 0 ? "" : A.DateTime__threeDigits(t1); + return y + "-" + m + "-" + d + " " + h + ":" + min + ":" + sec + "." + ms + us; + }, + $isComparable: 1 + }; + A.Duration.prototype = { + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.Duration && this._duration === other._duration; + }, + get$hashCode(_) { + return B.JSInt_methods.get$hashCode(this._duration); + }, + compareTo$1(_, other) { + return B.JSInt_methods.compareTo$1(this._duration, other._duration); + }, + toString$0(_) { + var sign, minutes, minutesPadding, seconds, secondsPadding, + microseconds = this._duration, + hours = B.JSInt_methods._tdivFast$1(microseconds, 3600000000), + microseconds0 = microseconds % 3600000000; + if (microseconds < 0) { + hours = 0 - hours; + microseconds = 0 - microseconds0; + sign = "-"; + } else { + microseconds = microseconds0; + sign = ""; + } + minutes = B.JSInt_methods._tdivFast$1(microseconds, 60000000); + microseconds %= 60000000; + minutesPadding = minutes < 10 ? "0" : ""; + seconds = B.JSInt_methods._tdivFast$1(microseconds, 1000000); + secondsPadding = seconds < 10 ? "0" : ""; + return sign + hours + ":" + minutesPadding + minutes + ":" + secondsPadding + seconds + "." + B.JSString_methods.padLeft$2(B.JSInt_methods.toString$0(microseconds % 1000000), 6, "0"); + }, + $isComparable: 1 + }; + A._Enum.prototype = { + toString$0(_) { + return this._enumToString$0(); + } + }; + A.Error.prototype = { + get$stackTrace() { + return A.Primitives_extractStackTrace(this); + } + }; + A.AssertionError.prototype = { + toString$0(_) { + var t1 = this.message; + if (t1 != null) + return "Assertion failed: " + A.Error_safeToString(t1); + return "Assertion failed"; + }, + get$message(receiver) { + return this.message; + } + }; + A.TypeError.prototype = {}; + A.ArgumentError.prototype = { + get$_errorName() { + return "Invalid argument" + (!this._hasValue ? "(s)" : ""); + }, + get$_errorExplanation() { + return ""; + }, + toString$0(_) { + var _this = this, + $name = _this.name, + nameString = $name == null ? "" : " (" + $name + ")", + message = _this.message, + messageString = message == null ? "" : ": " + A.S(message), + prefix = _this.get$_errorName() + nameString + messageString; + if (!_this._hasValue) + return prefix; + return prefix + _this.get$_errorExplanation() + ": " + A.Error_safeToString(_this.get$invalidValue()); + }, + get$invalidValue() { + return this.invalidValue; + }, + get$message(receiver) { + return this.message; + } + }; + A.RangeError.prototype = { + get$invalidValue() { + return this.invalidValue; + }, + get$_errorName() { + return "RangeError"; + }, + get$_errorExplanation() { + var explanation, + start = this.start, + end = this.end; + if (start == null) + explanation = end != null ? ": Not less than or equal to " + A.S(end) : ""; + else if (end == null) + explanation = ": Not greater than or equal to " + A.S(start); + else if (end > start) + explanation = ": Not in inclusive range " + A.S(start) + ".." + A.S(end); + else + explanation = end < start ? ": Valid value range is empty" : ": Only valid value is " + A.S(start); + return explanation; + } + }; + A.IndexError.prototype = { + get$invalidValue() { + return this.invalidValue; + }, + get$_errorName() { + return "RangeError"; + }, + get$_errorExplanation() { + if (this.invalidValue < 0) + return ": index must not be negative"; + var t1 = this.length; + if (t1 === 0) + return ": no indices are valid"; + return ": index should be less than " + t1; + }, + $isRangeError: 1, + get$length(receiver) { + return this.length; + } + }; + A.NoSuchMethodError.prototype = { + toString$0(_) { + var $arguments, t1, _i, t2, t3, argument, receiverText, actualParameters, _this = this, _box_0 = {}, + sb = new A.StringBuffer(""); + _box_0.comma = ""; + $arguments = _this._core$_arguments; + for (t1 = $arguments.length, _i = 0, t2 = "", t3 = ""; _i < t1; ++_i, t3 = ", ") { + argument = $arguments[_i]; + sb._contents = t2 + t3; + t2 = A.Error_safeToString(argument); + t2 = sb._contents += t2; + _box_0.comma = ", "; + } + _this._namedArguments.forEach$1(0, new A.NoSuchMethodError_toString_closure(_box_0, sb)); + receiverText = A.Error_safeToString(_this._core$_receiver); + actualParameters = sb.toString$0(0); + return "NoSuchMethodError: method not found: '" + _this._memberName.__internal$_name + "'\nReceiver: " + receiverText + "\nArguments: [" + actualParameters + "]"; + } + }; + A.UnsupportedError.prototype = { + toString$0(_) { + return "Unsupported operation: " + this.message; + }, + get$message(receiver) { + return this.message; + } + }; + A.UnimplementedError.prototype = { + toString$0(_) { + return "UnimplementedError: " + this.message; + }, + get$message(receiver) { + return this.message; + } + }; + A.StateError.prototype = { + toString$0(_) { + return "Bad state: " + this.message; + }, + get$message(receiver) { + return this.message; + } + }; + A.ConcurrentModificationError.prototype = { + toString$0(_) { + var t1 = this.modifiedObject; + if (t1 == null) + return "Concurrent modification during iteration."; + return "Concurrent modification during iteration: " + A.Error_safeToString(t1) + "."; + } + }; + A.OutOfMemoryError.prototype = { + toString$0(_) { + return "Out of Memory"; + }, + get$stackTrace() { + return null; + }, + $isError: 1 + }; + A.StackOverflowError.prototype = { + toString$0(_) { + return "Stack Overflow"; + }, + get$stackTrace() { + return null; + }, + $isError: 1 + }; + A._Exception.prototype = { + toString$0(_) { + return "Exception: " + this.message; + }, + $isException: 1, + get$message(receiver) { + return this.message; + } + }; + A.FormatException.prototype = { + toString$0(_) { + var t1, lineNum, lineStart, previousCharWasCR, i, char, lineEnd, prefix, postfix, end, start, + message = this.message, + report = "" !== message ? "FormatException: " + message : "FormatException", + offset = this.offset, + source = this.source; + if (typeof source == "string") { + if (offset != null) + t1 = offset < 0 || offset > source.length; + else + t1 = false; + if (t1) + offset = null; + if (offset == null) { + if (source.length > 78) + source = B.JSString_methods.substring$2(source, 0, 75) + "..."; + return report + "\n" + source; + } + for (lineNum = 1, lineStart = 0, previousCharWasCR = false, i = 0; i < offset; ++i) { + char = source.charCodeAt(i); + if (char === 10) { + if (lineStart !== i || !previousCharWasCR) + ++lineNum; + lineStart = i + 1; + previousCharWasCR = false; + } else if (char === 13) { + ++lineNum; + lineStart = i + 1; + previousCharWasCR = true; + } + } + report = lineNum > 1 ? report + (" (at line " + lineNum + ", character " + (offset - lineStart + 1) + ")\n") : report + (" (at character " + (offset + 1) + ")\n"); + lineEnd = source.length; + for (i = offset; i < lineEnd; ++i) { + char = source.charCodeAt(i); + if (char === 10 || char === 13) { + lineEnd = i; + break; + } + } + prefix = ""; + if (lineEnd - lineStart > 78) { + postfix = "..."; + if (offset - lineStart < 75) { + end = lineStart + 75; + start = lineStart; + } else { + if (lineEnd - offset < 75) { + start = lineEnd - 75; + end = lineEnd; + postfix = ""; + } else { + start = offset - 36; + end = offset + 36; + } + prefix = "..."; + } + } else { + end = lineEnd; + start = lineStart; + postfix = ""; + } + return report + prefix + B.JSString_methods.substring$2(source, start, end) + postfix + "\n" + B.JSString_methods.$mul(" ", offset - start + prefix.length) + "^\n"; + } else + return offset != null ? report + (" (at offset " + A.S(offset) + ")") : report; + }, + $isException: 1, + get$message(receiver) { + return this.message; + } + }; + A.Iterable.prototype = { + cast$1$0(_, $R) { + return A.CastIterable_CastIterable(this, A._instanceType(this)._eval$1("Iterable.E"), $R); + }, + followedBy$1(_, other) { + var _this = this, + t1 = A._instanceType(_this); + if (t1._eval$1("EfficientLengthIterable")._is(_this)) + return A.FollowedByIterable_FollowedByIterable$firstEfficient(_this, other, t1._eval$1("Iterable.E")); + return new A.FollowedByIterable(_this, other, t1._eval$1("FollowedByIterable")); + }, + map$1$1(_, toElement, $T) { + return A.MappedIterable_MappedIterable(this, toElement, A._instanceType(this)._eval$1("Iterable.E"), $T); + }, + where$1(_, test) { + return new A.WhereIterable(this, test, A._instanceType(this)._eval$1("WhereIterable")); + }, + expand$1$1(_, toElements, $T) { + return new A.ExpandIterable(this, toElements, A._instanceType(this)._eval$1("@")._bind$1($T)._eval$1("ExpandIterable<1,2>")); + }, + contains$1(_, element) { + var t1; + for (t1 = this.get$iterator(this); t1.moveNext$0();) + if (J.$eq$(t1.get$current(t1), element)) + return true; + return false; + }, + forEach$1(_, action) { + var t1; + for (t1 = this.get$iterator(this); t1.moveNext$0();) + action.call$1(t1.get$current(t1)); + }, + fold$1$2(_, initialValue, combine) { + var t1, value; + for (t1 = this.get$iterator(this), value = initialValue; t1.moveNext$0();) + value = combine.call$2(value, t1.get$current(t1)); + return value; + }, + fold$2(_, initialValue, combine) { + return this.fold$1$2(0, initialValue, combine, type$.dynamic); + }, + every$1(_, test) { + var t1; + for (t1 = this.get$iterator(this); t1.moveNext$0();) + if (!test.call$1(t1.get$current(t1))) + return false; + return true; + }, + join$1(_, separator) { + var first, t1, + iterator = this.get$iterator(this); + if (!iterator.moveNext$0()) + return ""; + first = J.toString$0$(iterator.get$current(iterator)); + if (!iterator.moveNext$0()) + return first; + if (separator.length === 0) { + t1 = first; + do + t1 += A.S(J.toString$0$(iterator.get$current(iterator))); + while (iterator.moveNext$0()); + } else { + t1 = first; + do + t1 = t1 + separator + A.S(J.toString$0$(iterator.get$current(iterator))); + while (iterator.moveNext$0()); + } + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + any$1(_, test) { + var t1; + for (t1 = this.get$iterator(this); t1.moveNext$0();) + if (test.call$1(t1.get$current(t1))) + return true; + return false; + }, + toList$1$growable(_, growable) { + return A.List_List$of(this, growable, A._instanceType(this)._eval$1("Iterable.E")); + }, + toList$0(_) { + return this.toList$1$growable(0, true); + }, + toSet$0(_) { + return A.LinkedHashSet_LinkedHashSet$of(this, A._instanceType(this)._eval$1("Iterable.E")); + }, + get$length(_) { + var count, + it = this.get$iterator(this); + for (count = 0; it.moveNext$0();) + ++count; + return count; + }, + get$isEmpty(_) { + return !this.get$iterator(this).moveNext$0(); + }, + get$isNotEmpty(_) { + return !this.get$isEmpty(this); + }, + take$1(_, count) { + return A.TakeIterable_TakeIterable(this, count, A._instanceType(this)._eval$1("Iterable.E")); + }, + skip$1(_, count) { + return A.SkipIterable_SkipIterable(this, count, A._instanceType(this)._eval$1("Iterable.E")); + }, + skipWhile$1(_, test) { + return new A.SkipWhileIterable(this, test, A._instanceType(this)._eval$1("SkipWhileIterable")); + }, + get$first(_) { + var it = this.get$iterator(this); + if (!it.moveNext$0()) + throw A.wrapException(A.IterableElementError_noElement()); + return it.get$current(it); + }, + get$last(_) { + var result, + it = this.get$iterator(this); + if (!it.moveNext$0()) + throw A.wrapException(A.IterableElementError_noElement()); + do + result = it.get$current(it); + while (it.moveNext$0()); + return result; + }, + get$single(_) { + var result, + it = this.get$iterator(this); + if (!it.moveNext$0()) + throw A.wrapException(A.IterableElementError_noElement()); + result = it.get$current(it); + if (it.moveNext$0()) + throw A.wrapException(A.IterableElementError_tooMany()); + return result; + }, + elementAt$1(_, index) { + var iterator, skipCount; + A.RangeError_checkNotNegative(index, "index"); + iterator = this.get$iterator(this); + for (skipCount = index; iterator.moveNext$0();) { + if (skipCount === 0) + return iterator.get$current(iterator); + --skipCount; + } + throw A.wrapException(A.IndexError$withLength(index, index - skipCount, this, null, "index")); + }, + toString$0(_) { + return A.Iterable_iterableToShortString(this, "(", ")"); + } + }; + A._GeneratorIterable.prototype = { + elementAt$1(_, index) { + A.IndexError_check(index, this.length, this, null, null); + return this._generator.call$1(index); + }, + get$length(receiver) { + return this.length; + } + }; + A.MapEntry.prototype = { + toString$0(_) { + return "MapEntry(" + A.S(this.key) + ": " + A.S(this.value) + ")"; + } + }; + A.Null.prototype = { + get$hashCode(_) { + return A.Object.prototype.get$hashCode.call(this, 0); + }, + toString$0(_) { + return "null"; + } + }; + A.Object.prototype = {$isObject: 1, + $eq(_, other) { + return this === other; + }, + get$hashCode(_) { + return A.Primitives_objectHashCode(this); + }, + toString$0(_) { + return "Instance of '" + A.Primitives_objectTypeName(this) + "'"; + }, + noSuchMethod$1(_, invocation) { + throw A.wrapException(A.NoSuchMethodError_NoSuchMethodError$withInvocation(this, invocation)); + }, + get$runtimeType(_) { + return A.getRuntimeTypeOfDartObject(this); + }, + toString() { + return this.toString$0(this); + } + }; + A._StringStackTrace.prototype = { + toString$0(_) { + return this._stackTrace; + }, + $isStackTrace: 1 + }; + A.Runes.prototype = { + get$iterator(_) { + return new A.RuneIterator(this.string); + }, + get$last(_) { + var code, previousCode, + t1 = this.string, + t2 = t1.length; + if (t2 === 0) + throw A.wrapException(A.StateError$("No elements.")); + code = t1.charCodeAt(t2 - 1); + if ((code & 64512) === 56320 && t2 > 1) { + previousCode = t1.charCodeAt(t2 - 2); + if ((previousCode & 64512) === 55296) + return A._combineSurrogatePair(previousCode, code); + } + return code; + } + }; + A.RuneIterator.prototype = { + get$current(_) { + return this._currentCodePoint; + }, + moveNext$0() { + var codeUnit, nextPosition, nextCodeUnit, _this = this, + t1 = _this._position = _this._nextPosition, + t2 = _this.string, + t3 = t2.length; + if (t1 === t3) { + _this._currentCodePoint = -1; + return false; + } + codeUnit = t2.charCodeAt(t1); + nextPosition = t1 + 1; + if ((codeUnit & 64512) === 55296 && nextPosition < t3) { + nextCodeUnit = t2.charCodeAt(nextPosition); + if ((nextCodeUnit & 64512) === 56320) { + _this._nextPosition = nextPosition + 1; + _this._currentCodePoint = A._combineSurrogatePair(codeUnit, nextCodeUnit); + return true; + } + } + _this._nextPosition = nextPosition; + _this._currentCodePoint = codeUnit; + return true; + } + }; + A.StringBuffer.prototype = { + get$length(_) { + return this._contents.length; + }, + write$1(_, obj) { + var t1 = A.S(obj); + this._contents += t1; + }, + writeCharCode$1(charCode) { + var t1 = A.Primitives_stringFromCharCode(charCode); + this._contents += t1; + }, + toString$0(_) { + var t1 = this._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + }; + A.Uri__parseIPv4Address_error.prototype = { + call$2(msg, position) { + throw A.wrapException(A.FormatException$("Illegal IPv4 address, " + msg, this.host, position)); + }, + $signature: 531 + }; + A.Uri_parseIPv6Address_error.prototype = { + call$2(msg, position) { + throw A.wrapException(A.FormatException$("Illegal IPv6 address, " + msg, this.host, position)); + }, + $signature: 533 + }; + A.Uri_parseIPv6Address_parseHex.prototype = { + call$2(start, end) { + var value; + if (end - start > 4) + this.error.call$2("an IPv6 part can only contain a maximum of 4 hex digits", start); + value = A.int_parse(B.JSString_methods.substring$2(this.host, start, end), 16); + if (value < 0 || value > 65535) + this.error.call$2("each part must be in the range of `0x0..0xFFFF`", start); + return value; + }, + $signature: 582 + }; + A._Uri.prototype = { + get$_text() { + var t1, t2, t3, t4, _this = this, + value = _this.___Uri__text_FI; + if (value === $) { + t1 = _this.scheme; + t2 = t1.length !== 0 ? "" + t1 + ":" : ""; + t3 = _this._host; + t4 = t3 == null; + if (!t4 || t1 === "file") { + t1 = t2 + "//"; + t2 = _this._userInfo; + if (t2.length !== 0) + t1 = t1 + t2 + "@"; + if (!t4) + t1 += t3; + t2 = _this._port; + if (t2 != null) + t1 = t1 + ":" + A.S(t2); + } else + t1 = t2; + t1 += _this.path; + t2 = _this._query; + if (t2 != null) + t1 = t1 + "?" + t2; + t2 = _this._fragment; + if (t2 != null) + t1 = t1 + "#" + t2; + value !== $ && A.throwUnnamedLateFieldADI(); + value = _this.___Uri__text_FI = t1.charCodeAt(0) == 0 ? t1 : t1; + } + return value; + }, + get$pathSegments() { + var pathToSplit, result, _this = this, + value = _this.___Uri_pathSegments_FI; + if (value === $) { + pathToSplit = _this.path; + if (pathToSplit.length !== 0 && pathToSplit.charCodeAt(0) === 47) + pathToSplit = B.JSString_methods.substring$1(pathToSplit, 1); + result = pathToSplit.length === 0 ? B.List_empty : A.List_List$unmodifiable(new A.MappedListIterable(A._setArrayType(pathToSplit.split("/"), type$.JSArray_String), A.core_Uri_decodeComponent$closure(), type$.MappedListIterable_String_dynamic), type$.String); + _this.___Uri_pathSegments_FI !== $ && A.throwUnnamedLateFieldADI(); + value = _this.___Uri_pathSegments_FI = result; + } + return value; + }, + get$hashCode(_) { + var result, _this = this, + value = _this.___Uri_hashCode_FI; + if (value === $) { + result = B.JSString_methods.get$hashCode(_this.get$_text()); + _this.___Uri_hashCode_FI !== $ && A.throwUnnamedLateFieldADI(); + _this.___Uri_hashCode_FI = result; + value = result; + } + return value; + }, + get$userInfo() { + return this._userInfo; + }, + get$host() { + var host = this._host; + if (host == null) + return ""; + if (B.JSString_methods.startsWith$1(host, "[")) + return B.JSString_methods.substring$2(host, 1, host.length - 1); + return host; + }, + get$port(_) { + var t1 = this._port; + return t1 == null ? A._Uri__defaultPort(this.scheme) : t1; + }, + get$query() { + var t1 = this._query; + return t1 == null ? "" : t1; + }, + get$fragment() { + var t1 = this._fragment; + return t1 == null ? "" : t1; + }, + isScheme$1(scheme) { + var thisScheme = this.scheme; + if (scheme.length !== thisScheme.length) + return false; + return A._caseInsensitiveCompareStart(scheme, thisScheme, 0) >= 0; + }, + replace$1$scheme(scheme) { + var isFile, userInfo, port, host, currentPath, t1, path, _this = this; + scheme = A._Uri__makeScheme(scheme, 0, scheme.length); + isFile = scheme === "file"; + userInfo = _this._userInfo; + port = _this._port; + if (scheme !== _this.scheme) + port = A._Uri__makePort(port, scheme); + host = _this._host; + if (!(host != null)) + host = userInfo.length !== 0 || port != null || isFile ? "" : null; + currentPath = _this.path; + if (!isFile) + t1 = host != null && currentPath.length !== 0; + else + t1 = true; + if (t1 && !B.JSString_methods.startsWith$1(currentPath, "/")) + currentPath = "/" + currentPath; + path = currentPath; + return A._Uri$_internal(scheme, userInfo, host, port, path, _this._query, _this._fragment); + }, + _mergePaths$2(base, reference) { + var backCount, refStart, baseEnd, newEnd, delta, t1, t2; + for (backCount = 0, refStart = 0; B.JSString_methods.startsWith$2(reference, "../", refStart);) { + refStart += 3; + ++backCount; + } + baseEnd = B.JSString_methods.lastIndexOf$1(base, "/"); + while (true) { + if (!(baseEnd > 0 && backCount > 0)) + break; + newEnd = B.JSString_methods.lastIndexOf$2(base, "/", baseEnd - 1); + if (newEnd < 0) + break; + delta = baseEnd - newEnd; + t1 = delta !== 2; + t2 = false; + if (!t1 || delta === 3) + if (base.charCodeAt(newEnd + 1) === 46) + t1 = !t1 || base.charCodeAt(newEnd + 2) === 46; + else + t1 = t2; + else + t1 = t2; + if (t1) + break; + --backCount; + baseEnd = newEnd; + } + return B.JSString_methods.replaceRange$3(base, baseEnd + 1, null, B.JSString_methods.substring$1(reference, refStart - 3 * backCount)); + }, + resolve$1(_, reference) { + return this.resolveUri$1(A.Uri_parse(reference)); + }, + resolveUri$1(reference) { + var targetScheme, targetUserInfo, targetHost, targetPort, targetPath, targetQuery, split, packageNameEnd, packageName, mergedPath, t1, fragment, _this = this, _null = null; + if (reference.get$scheme().length !== 0) { + if (type$._PlatformUri._is(reference)) + return reference; + targetScheme = reference.get$scheme(); + if (reference.get$hasAuthority()) { + targetUserInfo = reference.get$userInfo(); + targetHost = reference.get$host(); + targetPort = reference.get$hasPort() ? reference.get$port(reference) : _null; + } else { + targetPort = _null; + targetHost = targetPort; + targetUserInfo = ""; + } + targetPath = A._Uri__removeDotSegments(reference.get$path(reference)); + targetQuery = reference.get$hasQuery() ? reference.get$query() : _null; + split = 0; + } else { + targetScheme = _this.scheme; + if (reference.get$hasAuthority()) { + if (type$._PlatformUri._is(reference)) + return reference.replace$1$scheme(targetScheme); + targetUserInfo = reference.get$userInfo(); + targetHost = reference.get$host(); + targetPort = A._Uri__makePort(reference.get$hasPort() ? reference.get$port(reference) : _null, targetScheme); + targetPath = A._Uri__removeDotSegments(reference.get$path(reference)); + targetQuery = reference.get$hasQuery() ? reference.get$query() : _null; + split = 1; + } else { + targetUserInfo = _this._userInfo; + targetHost = _this._host; + targetPort = _this._port; + targetPath = _this.path; + if (reference.get$hasEmptyPath()) + if (reference.get$hasQuery()) { + targetQuery = reference.get$query(); + split = 3; + } else { + targetQuery = _this._query; + split = 4; + } + else { + packageNameEnd = A._Uri__packageNameEnd(_this, targetPath); + if (packageNameEnd > 0) { + packageName = B.JSString_methods.substring$2(targetPath, 0, packageNameEnd); + targetPath = reference.get$hasAbsolutePath() ? packageName + A._Uri__removeDotSegments(reference.get$path(reference)) : packageName + A._Uri__removeDotSegments(_this._mergePaths$2(B.JSString_methods.substring$1(targetPath, packageName.length), reference.get$path(reference))); + } else if (reference.get$hasAbsolutePath()) + targetPath = A._Uri__removeDotSegments(reference.get$path(reference)); + else if (targetPath.length === 0) + if (targetHost == null) + targetPath = targetScheme.length === 0 ? reference.get$path(reference) : A._Uri__removeDotSegments(reference.get$path(reference)); + else + targetPath = A._Uri__removeDotSegments("/" + reference.get$path(reference)); + else { + mergedPath = _this._mergePaths$2(targetPath, reference.get$path(reference)); + t1 = targetScheme.length === 0; + if (!t1 || targetHost != null || B.JSString_methods.startsWith$1(targetPath, "/")) + targetPath = A._Uri__removeDotSegments(mergedPath); + else + targetPath = A._Uri__normalizeRelativePath(mergedPath, !t1 || targetHost != null); + } + targetQuery = reference.get$hasQuery() ? reference.get$query() : _null; + split = 2; + } + } + } + fragment = reference.get$hasFragment() ? reference.get$fragment() : _null; + if (!type$._PlatformUri._is(reference)) { + if (split === 0) + targetScheme = A._Uri__makeScheme(targetScheme, 0, targetScheme.length); + if (split <= 1) { + targetUserInfo = A._Uri__makeUserInfo(targetUserInfo, 0, targetUserInfo.length); + if (targetPort != null) + targetPort = A._Uri__makePort(targetPort, targetScheme); + if (targetHost != null && targetHost.length !== 0) + targetHost = A._Uri__makeHost(targetHost, 0, targetHost.length, false); + } + t1 = split <= 3; + if (t1) + targetPath = A._Uri__makePath(targetPath, 0, targetPath.length, _null, targetScheme, targetHost != null); + if (t1 && targetQuery != null) + targetQuery = A._Uri__makeQuery(targetQuery, 0, targetQuery.length, _null); + if (fragment != null) + fragment = A._Uri__makeFragment(fragment, 0, fragment.length); + } + return A._Uri$_internal(targetScheme, targetUserInfo, targetHost, targetPort, targetPath, targetQuery, fragment); + }, + get$hasAuthority() { + return this._host != null; + }, + get$hasPort() { + return this._port != null; + }, + get$hasQuery() { + return this._query != null; + }, + get$hasFragment() { + return this._fragment != null; + }, + get$hasEmptyPath() { + return this.path.length === 0; + }, + get$hasAbsolutePath() { + return B.JSString_methods.startsWith$1(this.path, "/"); + }, + toFilePath$0() { + var pathSegments, _this = this, + t1 = _this.scheme; + if (t1 !== "" && t1 !== "file") + throw A.wrapException(A.UnsupportedError$("Cannot extract a file path from a " + t1 + " URI")); + t1 = _this._query; + if ((t1 == null ? "" : t1) !== "") + throw A.wrapException(A.UnsupportedError$(string$.Cannotfq)); + t1 = _this._fragment; + if ((t1 == null ? "" : t1) !== "") + throw A.wrapException(A.UnsupportedError$(string$.Cannotff)); + t1 = $.$get$_Uri__isWindowsCached(); + if (t1) + t1 = A._Uri__toWindowsFilePath(_this); + else { + if (_this._host != null && _this.get$host() !== "") + A.throwExpression(A.UnsupportedError$(string$.Cannotn)); + pathSegments = _this.get$pathSegments(); + A._Uri__checkNonWindowsPathReservedCharacters(pathSegments, false); + t1 = A.StringBuffer__writeAll(B.JSString_methods.startsWith$1(_this.path, "/") ? "" + "/" : "", pathSegments, "/"); + t1 = t1.charCodeAt(0) == 0 ? t1 : t1; + } + return t1; + }, + toString$0(_) { + return this.get$_text(); + }, + $eq(_, other) { + var t1, t2, t3, _this = this; + if (other == null) + return false; + if (_this === other) + return true; + t1 = false; + if (type$.Uri._is(other)) + if (_this.scheme === other.get$scheme()) + if (_this._host != null === other.get$hasAuthority()) + if (_this._userInfo === other.get$userInfo()) + if (_this.get$host() === other.get$host()) + if (_this.get$port(0) === other.get$port(other)) + if (_this.path === other.get$path(other)) { + t2 = _this._query; + t3 = t2 == null; + if (!t3 === other.get$hasQuery()) { + if (t3) + t2 = ""; + if (t2 === other.get$query()) { + t2 = _this._fragment; + t3 = t2 == null; + if (!t3 === other.get$hasFragment()) { + t1 = t3 ? "" : t2; + t1 = t1 === other.get$fragment(); + } + } + } + } + return t1; + }, + $isUri: 1, + $is_PlatformUri: 1, + get$scheme() { + return this.scheme; + }, + get$path(receiver) { + return this.path; + } + }; + A._Uri__makePath_closure.prototype = { + call$1(s) { + return A._Uri__uriEncode(64, s, B.C_Utf8Codec, false); + }, + $signature: 6 + }; + A.UriData.prototype = { + get$uri() { + var t2, queryIndex, end, query, _this = this, _null = null, + t1 = _this._uriCache; + if (t1 == null) { + t1 = _this._text; + t2 = _this._separatorIndices[0] + 1; + queryIndex = B.JSString_methods.indexOf$2(t1, "?", t2); + end = t1.length; + if (queryIndex >= 0) { + query = A._Uri__normalizeOrSubstring(t1, queryIndex + 1, end, 256, false, false); + end = queryIndex; + } else + query = _null; + t1 = _this._uriCache = new A._DataUri("data", "", _null, _null, A._Uri__normalizeOrSubstring(t1, t2, end, 128, false, false), query, _null); + } + return t1; + }, + toString$0(_) { + var t1 = this._text; + return this._separatorIndices[0] === -1 ? "data:" + t1 : t1; + } + }; + A._SimpleUri.prototype = { + get$hasAuthority() { + return this._hostStart > 0; + }, + get$hasPort() { + return this._hostStart > 0 && this._portStart + 1 < this._pathStart; + }, + get$hasQuery() { + return this._queryStart < this._fragmentStart; + }, + get$hasFragment() { + return this._fragmentStart < this._uri.length; + }, + get$hasAbsolutePath() { + return B.JSString_methods.startsWith$2(this._uri, "/", this._pathStart); + }, + get$hasEmptyPath() { + return this._pathStart === this._queryStart; + }, + get$scheme() { + var t1 = this._schemeCache; + return t1 == null ? this._schemeCache = this._computeScheme$0() : t1; + }, + _computeScheme$0() { + var t2, _this = this, + t1 = _this._schemeEnd; + if (t1 <= 0) + return ""; + t2 = t1 === 4; + if (t2 && B.JSString_methods.startsWith$1(_this._uri, "http")) + return "http"; + if (t1 === 5 && B.JSString_methods.startsWith$1(_this._uri, "https")) + return "https"; + if (t2 && B.JSString_methods.startsWith$1(_this._uri, "file")) + return "file"; + if (t1 === 7 && B.JSString_methods.startsWith$1(_this._uri, "package")) + return "package"; + return B.JSString_methods.substring$2(_this._uri, 0, t1); + }, + get$userInfo() { + var t1 = this._hostStart, + t2 = this._schemeEnd + 3; + return t1 > t2 ? B.JSString_methods.substring$2(this._uri, t2, t1 - 1) : ""; + }, + get$host() { + var t1 = this._hostStart; + return t1 > 0 ? B.JSString_methods.substring$2(this._uri, t1, this._portStart) : ""; + }, + get$port(_) { + var t1, _this = this; + if (_this.get$hasPort()) + return A.int_parse(B.JSString_methods.substring$2(_this._uri, _this._portStart + 1, _this._pathStart), null); + t1 = _this._schemeEnd; + if (t1 === 4 && B.JSString_methods.startsWith$1(_this._uri, "http")) + return 80; + if (t1 === 5 && B.JSString_methods.startsWith$1(_this._uri, "https")) + return 443; + return 0; + }, + get$path(_) { + return B.JSString_methods.substring$2(this._uri, this._pathStart, this._queryStart); + }, + get$query() { + var t1 = this._queryStart, + t2 = this._fragmentStart; + return t1 < t2 ? B.JSString_methods.substring$2(this._uri, t1 + 1, t2) : ""; + }, + get$fragment() { + var t1 = this._fragmentStart, + t2 = this._uri; + return t1 < t2.length ? B.JSString_methods.substring$1(t2, t1 + 1) : ""; + }, + get$pathSegments() { + var parts, i, + start = this._pathStart, + end = this._queryStart, + t1 = this._uri; + if (B.JSString_methods.startsWith$2(t1, "/", start)) + ++start; + if (start === end) + return B.List_empty; + parts = A._setArrayType([], type$.JSArray_String); + for (i = start; i < end; ++i) + if (t1.charCodeAt(i) === 47) { + parts.push(B.JSString_methods.substring$2(t1, start, i)); + start = i + 1; + } + parts.push(B.JSString_methods.substring$2(t1, start, end)); + return A.List_List$unmodifiable(parts, type$.String); + }, + _isPort$1(port) { + var portDigitStart = this._portStart + 1; + return portDigitStart + port.length === this._pathStart && B.JSString_methods.startsWith$2(this._uri, port, portDigitStart); + }, + removeFragment$0() { + var _this = this, + t1 = _this._fragmentStart, + t2 = _this._uri; + if (t1 >= t2.length) + return _this; + return new A._SimpleUri(B.JSString_methods.substring$2(t2, 0, t1), _this._schemeEnd, _this._hostStart, _this._portStart, _this._pathStart, _this._queryStart, t1, _this._schemeCache); + }, + replace$1$scheme(scheme) { + var schemeChanged, isFile, t1, userInfo, port, host, t2, path, t3, query, fragment, _this = this, _null = null; + scheme = A._Uri__makeScheme(scheme, 0, scheme.length); + schemeChanged = !(_this._schemeEnd === scheme.length && B.JSString_methods.startsWith$1(_this._uri, scheme)); + isFile = scheme === "file"; + t1 = _this._hostStart; + userInfo = t1 > 0 ? B.JSString_methods.substring$2(_this._uri, _this._schemeEnd + 3, t1) : ""; + port = _this.get$hasPort() ? _this.get$port(0) : _null; + if (schemeChanged) + port = A._Uri__makePort(port, scheme); + t1 = _this._hostStart; + if (t1 > 0) + host = B.JSString_methods.substring$2(_this._uri, t1, _this._portStart); + else + host = userInfo.length !== 0 || port != null || isFile ? "" : _null; + t1 = _this._uri; + t2 = _this._queryStart; + path = B.JSString_methods.substring$2(t1, _this._pathStart, t2); + if (!isFile) + t3 = host != null && path.length !== 0; + else + t3 = true; + if (t3 && !B.JSString_methods.startsWith$1(path, "/")) + path = "/" + path; + t3 = _this._fragmentStart; + query = t2 < t3 ? B.JSString_methods.substring$2(t1, t2 + 1, t3) : _null; + t2 = _this._fragmentStart; + fragment = t2 < t1.length ? B.JSString_methods.substring$1(t1, t2 + 1) : _null; + return A._Uri$_internal(scheme, userInfo, host, port, path, query, fragment); + }, + resolve$1(_, reference) { + return this.resolveUri$1(A.Uri_parse(reference)); + }, + resolveUri$1(reference) { + if (reference instanceof A._SimpleUri) + return this._simpleMerge$2(this, reference); + return this._toNonSimple$0().resolveUri$1(reference); + }, + _simpleMerge$2(base, ref) { + var t2, t3, t4, isSimple, delta, refStart, basePathStart, packageNameEnd, basePathStart0, baseStart, baseEnd, baseUri, baseStart0, backCount, refStart0, insert, + t1 = ref._schemeEnd; + if (t1 > 0) + return ref; + t2 = ref._hostStart; + if (t2 > 0) { + t3 = base._schemeEnd; + if (t3 <= 0) + return ref; + t4 = t3 === 4; + if (t4 && B.JSString_methods.startsWith$1(base._uri, "file")) + isSimple = ref._pathStart !== ref._queryStart; + else if (t4 && B.JSString_methods.startsWith$1(base._uri, "http")) + isSimple = !ref._isPort$1("80"); + else + isSimple = !(t3 === 5 && B.JSString_methods.startsWith$1(base._uri, "https")) || !ref._isPort$1("443"); + if (isSimple) { + delta = t3 + 1; + return new A._SimpleUri(B.JSString_methods.substring$2(base._uri, 0, delta) + B.JSString_methods.substring$1(ref._uri, t1 + 1), t3, t2 + delta, ref._portStart + delta, ref._pathStart + delta, ref._queryStart + delta, ref._fragmentStart + delta, base._schemeCache); + } else + return this._toNonSimple$0().resolveUri$1(ref); + } + refStart = ref._pathStart; + t1 = ref._queryStart; + if (refStart === t1) { + t2 = ref._fragmentStart; + if (t1 < t2) { + t3 = base._queryStart; + delta = t3 - t1; + return new A._SimpleUri(B.JSString_methods.substring$2(base._uri, 0, t3) + B.JSString_methods.substring$1(ref._uri, t1), base._schemeEnd, base._hostStart, base._portStart, base._pathStart, t1 + delta, t2 + delta, base._schemeCache); + } + t1 = ref._uri; + if (t2 < t1.length) { + t3 = base._fragmentStart; + return new A._SimpleUri(B.JSString_methods.substring$2(base._uri, 0, t3) + B.JSString_methods.substring$1(t1, t2), base._schemeEnd, base._hostStart, base._portStart, base._pathStart, base._queryStart, t2 + (t3 - t2), base._schemeCache); + } + return base.removeFragment$0(); + } + t2 = ref._uri; + if (B.JSString_methods.startsWith$2(t2, "/", refStart)) { + basePathStart = base._pathStart; + packageNameEnd = A._SimpleUri__packageNameEnd(this); + basePathStart0 = packageNameEnd > 0 ? packageNameEnd : basePathStart; + delta = basePathStart0 - refStart; + return new A._SimpleUri(B.JSString_methods.substring$2(base._uri, 0, basePathStart0) + B.JSString_methods.substring$1(t2, refStart), base._schemeEnd, base._hostStart, base._portStart, basePathStart, t1 + delta, ref._fragmentStart + delta, base._schemeCache); + } + baseStart = base._pathStart; + baseEnd = base._queryStart; + if (baseStart === baseEnd && base._hostStart > 0) { + for (; B.JSString_methods.startsWith$2(t2, "../", refStart);) + refStart += 3; + delta = baseStart - refStart + 1; + return new A._SimpleUri(B.JSString_methods.substring$2(base._uri, 0, baseStart) + "/" + B.JSString_methods.substring$1(t2, refStart), base._schemeEnd, base._hostStart, base._portStart, baseStart, t1 + delta, ref._fragmentStart + delta, base._schemeCache); + } + baseUri = base._uri; + packageNameEnd = A._SimpleUri__packageNameEnd(this); + if (packageNameEnd >= 0) + baseStart0 = packageNameEnd; + else + for (baseStart0 = baseStart; B.JSString_methods.startsWith$2(baseUri, "../", baseStart0);) + baseStart0 += 3; + backCount = 0; + while (true) { + refStart0 = refStart + 3; + if (!(refStart0 <= t1 && B.JSString_methods.startsWith$2(t2, "../", refStart))) + break; + ++backCount; + refStart = refStart0; + } + for (insert = ""; baseEnd > baseStart0;) { + --baseEnd; + if (baseUri.charCodeAt(baseEnd) === 47) { + if (backCount === 0) { + insert = "/"; + break; + } + --backCount; + insert = "/"; + } + } + if (baseEnd === baseStart0 && base._schemeEnd <= 0 && !B.JSString_methods.startsWith$2(baseUri, "/", baseStart)) { + refStart -= backCount * 3; + insert = ""; + } + delta = baseEnd - refStart + insert.length; + return new A._SimpleUri(B.JSString_methods.substring$2(baseUri, 0, baseEnd) + insert + B.JSString_methods.substring$1(t2, refStart), base._schemeEnd, base._hostStart, base._portStart, baseStart, t1 + delta, ref._fragmentStart + delta, base._schemeCache); + }, + toFilePath$0() { + var t2, t3, _this = this, + t1 = _this._schemeEnd; + if (t1 >= 0) { + t2 = !(t1 === 4 && B.JSString_methods.startsWith$1(_this._uri, "file")); + t1 = t2; + } else + t1 = false; + if (t1) + throw A.wrapException(A.UnsupportedError$("Cannot extract a file path from a " + _this.get$scheme() + " URI")); + t1 = _this._queryStart; + t2 = _this._uri; + if (t1 < t2.length) { + if (t1 < _this._fragmentStart) + throw A.wrapException(A.UnsupportedError$(string$.Cannotfq)); + throw A.wrapException(A.UnsupportedError$(string$.Cannotff)); + } + t3 = $.$get$_Uri__isWindowsCached(); + if (t3) + t1 = A._Uri__toWindowsFilePath(_this); + else { + if (_this._hostStart < _this._portStart) + A.throwExpression(A.UnsupportedError$(string$.Cannotn)); + t1 = B.JSString_methods.substring$2(t2, _this._pathStart, t1); + } + return t1; + }, + get$hashCode(_) { + var t1 = this._hashCodeCache; + return t1 == null ? this._hashCodeCache = B.JSString_methods.get$hashCode(this._uri) : t1; + }, + $eq(_, other) { + if (other == null) + return false; + if (this === other) + return true; + return type$.Uri._is(other) && this._uri === other.toString$0(0); + }, + _toNonSimple$0() { + var _this = this, _null = null, + t1 = _this.get$scheme(), + t2 = _this.get$userInfo(), + t3 = _this._hostStart > 0 ? _this.get$host() : _null, + t4 = _this.get$hasPort() ? _this.get$port(0) : _null, + t5 = _this._uri, + t6 = _this._queryStart, + t7 = B.JSString_methods.substring$2(t5, _this._pathStart, t6), + t8 = _this._fragmentStart; + t6 = t6 < t8 ? _this.get$query() : _null; + return A._Uri$_internal(t1, t2, t3, t4, t7, t6, t8 < t5.length ? _this.get$fragment() : _null); + }, + toString$0(_) { + return this._uri; + }, + $isUri: 1, + $is_PlatformUri: 1 + }; + A._DataUri.prototype = {}; + A.Expando.prototype = { + $indexSet(_, object, value) { + if (object instanceof A._Record) + A.Expando__badExpandoKey(object); + this._jsWeakMap.set(object, value); + }, + toString$0(_) { + return "Expando:null"; + } + }; + A.jsify__convert.prototype = { + call$1(o) { + var t1, convertedMap, key, convertedList; + if (A._noJsifyRequired(o)) + return o; + t1 = this._convertedObjects; + if (t1.containsKey$1(o)) + return t1.$index(0, o); + if (type$.Map_of_nullable_Object_and_nullable_Object._is(o)) { + convertedMap = {}; + t1.$indexSet(0, o, convertedMap); + for (t1 = J.get$iterator$ax(o.get$keys(o)); t1.moveNext$0();) { + key = t1.get$current(t1); + convertedMap[key] = this.call$1(o.$index(0, key)); + } + return convertedMap; + } else if (type$.Iterable_nullable_Object._is(o)) { + convertedList = []; + t1.$indexSet(0, o, convertedList); + B.JSArray_methods.addAll$1(convertedList, J.map$1$1$ax(o, this, type$.dynamic)); + return convertedList; + } else + return o; + }, + $signature: 335 + }; + A.promiseToFuture_closure.prototype = { + call$1(r) { + return this.completer.complete$1(r); + }, + $signature: 71 + }; + A.promiseToFuture_closure0.prototype = { + call$1(e) { + if (e == null) + return this.completer.completeError$1(new A.NullRejectionException(e === undefined)); + return this.completer.completeError$1(e); + }, + $signature: 71 + }; + A.NullRejectionException.prototype = { + toString$0(_) { + return "Promise was rejected with a value of `" + (this.isUndefined ? "undefined" : "null") + "`."; + }, + $isException: 1 + }; + A._JSRandom.prototype = { + nextInt$1(max) { + if (max <= 0 || max > 4294967296) + throw A.wrapException(A.RangeError$("max must be in range 0 < max \u2264 2^32, was " + max)); + return Math.random() * max >>> 0; + }, + nextDouble$0() { + return Math.random(); + } + }; + A.ArgParser.prototype = { + addFlag$6$abbr$defaultsTo$help$hide$negatable($name, abbr, defaultsTo, help, hide, negatable) { + var _null = null; + this._addOption$13$aliases$hide$hideNegatedUsage$negatable($name, abbr, help, _null, _null, _null, defaultsTo, _null, B.OptionType_tI9, B.List_empty, hide, false, negatable); + }, + addFlag$2$hide($name, hide) { + return this.addFlag$6$abbr$defaultsTo$help$hide$negatable($name, null, false, null, hide, true); + }, + addFlag$2$help($name, help) { + return this.addFlag$6$abbr$defaultsTo$help$hide$negatable($name, null, false, help, false, true); + }, + addFlag$3$defaultsTo$help($name, defaultsTo, help) { + return this.addFlag$6$abbr$defaultsTo$help$hide$negatable($name, null, defaultsTo, help, false, true); + }, + addFlag$3$help$negatable($name, help, negatable) { + return this.addFlag$6$abbr$defaultsTo$help$hide$negatable($name, null, false, help, false, negatable); + }, + addFlag$3$abbr$help($name, abbr, help) { + return this.addFlag$6$abbr$defaultsTo$help$hide$negatable($name, abbr, false, help, false, true); + }, + addFlag$4$abbr$help$negatable($name, abbr, help, negatable) { + return this.addFlag$6$abbr$defaultsTo$help$hide$negatable($name, abbr, false, help, false, negatable); + }, + addOption$7$abbr$allowed$defaultsTo$help$hide$valueHelp($name, abbr, allowed, defaultsTo, help, hide, valueHelp) { + this._addOption$12$aliases$hide$mandatory($name, abbr, help, valueHelp, allowed, null, defaultsTo, null, B.OptionType_zZK, B.List_empty, hide, false); + }, + addOption$2$hide($name, hide) { + var _null = null; + return this.addOption$7$abbr$allowed$defaultsTo$help$hide$valueHelp($name, _null, _null, _null, _null, hide, _null); + }, + addOption$6$abbr$allowed$defaultsTo$help$valueHelp($name, abbr, allowed, defaultsTo, help, valueHelp) { + return this.addOption$7$abbr$allowed$defaultsTo$help$hide$valueHelp($name, abbr, allowed, defaultsTo, help, false, valueHelp); + }, + addOption$4$allowed$defaultsTo$help($name, allowed, defaultsTo, help) { + return this.addOption$7$abbr$allowed$defaultsTo$help$hide$valueHelp($name, null, allowed, defaultsTo, help, false, null); + }, + addMultiOption$7$abbr$allowed$allowedHelp$help$splitCommas$valueHelp($name, abbr, allowed, allowedHelp, help, splitCommas, valueHelp) { + var t1 = A._setArrayType([], type$.JSArray_String); + this._addOption$12$aliases$hide$splitCommas($name, abbr, help, valueHelp, allowed, allowedHelp, t1, null, B.OptionType_1Ol, B.List_empty, false, splitCommas); + }, + addMultiOption$5$abbr$help$splitCommas$valueHelp($name, abbr, help, splitCommas, valueHelp) { + return this.addMultiOption$7$abbr$allowed$allowedHelp$help$splitCommas$valueHelp($name, abbr, null, null, help, splitCommas, valueHelp); + }, + addMultiOption$6$abbr$allowed$allowedHelp$help$valueHelp($name, abbr, allowed, allowedHelp, help, valueHelp) { + return this.addMultiOption$7$abbr$allowed$allowedHelp$help$splitCommas$valueHelp($name, abbr, allowed, allowedHelp, help, true, valueHelp); + }, + addMultiOption$2$help($name, help) { + var _null = null; + return this.addMultiOption$7$abbr$allowed$allowedHelp$help$splitCommas$valueHelp($name, _null, _null, _null, help, true, _null); + }, + _addOption$15$aliases$hide$hideNegatedUsage$mandatory$negatable$splitCommas($name, abbr, help, valueHelp, allowed, allowedHelp, defaultsTo, callback, type, aliases, hide, hideNegatedUsage, mandatory, negatable, splitCommas) { + var existing, t2, t3, option, _i, _this = this, _null = null, + t1 = A._setArrayType([$name], type$.JSArray_String); + B.JSArray_methods.addAll$1(t1, aliases); + if (B.JSArray_methods.any$1(t1, new A.ArgParser__addOption_closure(_this))) + throw A.wrapException(A.ArgumentError$('Duplicate option or alias "' + $name + '".', _null)); + t1 = abbr != null; + if (t1) { + existing = _this.findByAbbreviation$1(abbr); + if (existing != null) + throw A.wrapException(A.ArgumentError$('Abbreviation "' + abbr + '" is already used by "' + existing.name + '".', _null)); + } + t2 = allowed == null ? _null : A.List_List$unmodifiable(allowed, type$.String); + if (allowedHelp == null) + t3 = _null; + else { + t3 = type$.String; + t3 = A.ConstantMap_ConstantMap$from(allowedHelp, t3, t3); + } + option = new A.Option($name, abbr, help, valueHelp, t2, t3, defaultsTo, negatable, false, callback, type, splitCommas == null ? type === B.OptionType_1Ol : splitCommas, false, hide); + if ($name.length === 0) + A.throwExpression(A.ArgumentError$("Name cannot be empty.", _null)); + else if (B.JSString_methods.startsWith$1($name, "-")) + A.throwExpression(A.ArgumentError$("Name " + $name + ' cannot start with "-".', _null)); + t2 = $.$get$Option__invalidChars()._nativeRegExp; + if (t2.test($name)) + A.throwExpression(A.ArgumentError$('Name "' + $name + '" contains invalid characters.', _null)); + if (t1) { + if (abbr.length !== 1) + A.throwExpression(A.ArgumentError$("Abbreviation must be null or have length 1.", _null)); + else if (abbr === "-") + A.throwExpression(A.ArgumentError$('Abbreviation cannot be "-".', _null)); + if (t2.test(abbr)) + A.throwExpression(A.ArgumentError$("Abbreviation is an invalid character.", _null)); + } + _this._arg_parser$_options.$indexSet(0, $name, option); + _this._optionsAndSeparators.push(option); + for (t1 = _this._aliases, _i = 0; false; ++_i) + t1.$indexSet(0, aliases[_i], $name); + }, + _addOption$12$aliases$hide$splitCommas($name, abbr, help, valueHelp, allowed, allowedHelp, defaultsTo, callback, type, aliases, hide, splitCommas) { + return this._addOption$15$aliases$hide$hideNegatedUsage$mandatory$negatable$splitCommas($name, abbr, help, valueHelp, allowed, allowedHelp, defaultsTo, callback, type, aliases, hide, false, false, false, splitCommas); + }, + _addOption$12$aliases$hide$mandatory($name, abbr, help, valueHelp, allowed, allowedHelp, defaultsTo, callback, type, aliases, hide, mandatory) { + return this._addOption$15$aliases$hide$hideNegatedUsage$mandatory$negatable$splitCommas($name, abbr, help, valueHelp, allowed, allowedHelp, defaultsTo, callback, type, aliases, hide, false, mandatory, false, null); + }, + _addOption$13$aliases$hide$hideNegatedUsage$negatable($name, abbr, help, valueHelp, allowed, allowedHelp, defaultsTo, callback, type, aliases, hide, hideNegatedUsage, negatable) { + return this._addOption$15$aliases$hide$hideNegatedUsage$mandatory$negatable$splitCommas($name, abbr, help, valueHelp, allowed, allowedHelp, defaultsTo, callback, type, aliases, hide, hideNegatedUsage, false, negatable, null); + }, + findByAbbreviation$1(abbr) { + var t1, t2; + for (t1 = this.options._map, t1 = t1.get$values(t1), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t2 = t1.get$current(t1); + if (t2.abbr === abbr) + return t2; + } + return null; + }, + findByNameOrAlias$1($name) { + var t1 = this._aliases.$index(0, $name); + if (t1 == null) + t1 = $name; + return this.options._map.$index(0, t1); + } + }; + A.ArgParser__addOption_closure.prototype = { + call$1($name) { + return this.$this.findByNameOrAlias$1($name) != null; + }, + $signature: 5 + }; + A.ArgParserException.prototype = {}; + A.ArgResults.prototype = { + $index(_, $name) { + var t1 = this._parser.options._map; + if (!t1.containsKey$1($name)) + throw A.wrapException(A.ArgumentError$('Could not find an option named "--' + $name + '".', null)); + t1 = t1.$index(0, $name); + t1.toString; + return t1.valueOrDefault$1(this._parsed.$index(0, $name)); + }, + wasParsed$1($name) { + if (!this._parser.options._map.containsKey$1($name)) + throw A.wrapException(A.ArgumentError$('Could not find an option named "--' + $name + '".', null)); + return this._parsed.containsKey$1($name); + } + }; + A.Option.prototype = { + valueOrDefault$1(value) { + var t1; + if (value != null) + return value; + if (this.type === B.OptionType_1Ol) { + t1 = this.defaultsTo; + return t1 == null ? A._setArrayType([], type$.JSArray_String) : t1; + } + return this.defaultsTo; + } + }; + A.OptionType.prototype = {}; + A.Parser0.prototype = { + parse$0(_) { + var commandResults, commandName, commandParser, error, t1, t3, t4, t5, t6, t7, t8, command, exception, _this = this, + t2 = _this._args; + t2.toList$0(0); + commandResults = null; + for (t3 = _this._parser$_rest, t4 = _this._grammar, t5 = t4.commands, t6 = t2.$ti._precomputed1; !t2.get$isEmpty(0);) { + t7 = t2._head; + if (t7 === t2._tail) + A.throwExpression(A.IterableElementError_noElement()); + t7 = t2._table[t7]; + t8 = t7 == null; + if ((t8 ? t6._as(t7) : t7) === "--") { + t2.removeFirst$0(); + break; + } + if (t8) + t7 = t6._as(t7); + command = t5._map.$index(0, t7); + if (command != null) { + t5 = t3.length; + t7 = t2._head; + if (t7 === t2._tail) + A.throwExpression(A.IterableElementError_noElement()); + t7 = t2._table[t7]; + t6 = t7 == null ? t6._as(t7) : t7; + if (t5 !== 0) + A.throwExpression(A.ArgParserException$("Cannot specify arguments before a command.", null, t6, null, null)); + commandName = t2.removeFirst$0(); + t5 = type$.JSArray_String; + t6 = A._setArrayType([], t5); + B.JSArray_methods.addAll$1(t6, t3); + commandParser = new A.Parser0(commandName, _this, command, t2, t6, A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.dynamic)); + try { + commandResults = J.parse$0$z(commandParser); + } catch (exception) { + t2 = A.unwrapException(exception); + if (t2 instanceof A.ArgParserException) { + error = t2; + t2 = error.message; + t1 = A._setArrayType([commandName], t5); + J.addAll$1$ax(t1, error.commands); + throw A.wrapException(A.ArgParserException$(t2, t1, error.argumentName, error.source, error.offset)); + } else + throw exception; + } + B.JSArray_methods.clear$0(t3); + break; + } + if (_this._parseSoloOption$0()) + continue; + if (_this._parseAbbreviation$1(_this)) + continue; + if (_this._parseLongOption$0()) + continue; + t3.push(t2.removeFirst$0()); + } + t4.options._map.forEach$1(0, new A.Parser_parse_closure(_this)); + B.JSArray_methods.addAll$1(t3, t2); + t2.clear$0(0); + return new A.ArgResults(t4, _this._results, _this._commandName, new A.UnmodifiableListView(t3, type$.UnmodifiableListView_String)); + }, + _readNextArgAsValue$2(option, arg) { + var _this = this, + t1 = _this._args; + _this._validate$3(!t1.get$isEmpty(0), 'Missing argument for "' + arg + '".', arg); + _this._setOption$4(_this._results, option, t1.get$first(0), arg); + t1.removeFirst$0(); + }, + _parseSoloOption$0() { + var opt, + t1 = this._args; + if (t1.get$first(0).length !== 2) + return false; + if (!B.JSString_methods.startsWith$1(t1.get$first(0), "-")) + return false; + opt = t1.get$first(0)[1]; + if (!A._isLetterOrDigit(opt.charCodeAt(0))) + return false; + this._handleSoloOption$1(opt); + return true; + }, + _handleSoloOption$1(opt) { + var t1, _this = this, + option = _this._grammar.findByAbbreviation$1(opt); + if (option == null) { + t1 = _this._parser$_parent; + _this._validate$3(t1 != null, 'Could not find an option or flag "-' + opt + '".', "-" + opt); + t1._handleSoloOption$1(opt); + return true; + } + _this._args.removeFirst$0(); + if (option.type === B.OptionType_tI9) + _this._results.$indexSet(0, option.name, true); + else + _this._readNextArgAsValue$2(option, "-" + opt); + return true; + }, + _parseAbbreviation$1(innermostCommand) { + var t2, index, t3, t4, t5, lettersAndDigits, rest, + t1 = this._args; + if (t1.get$first(0).length < 2) + return false; + if (!B.JSString_methods.startsWith$1(t1.get$first(0), "-")) + return false; + t2 = t1.$ti._precomputed1; + index = 1; + while (true) { + t3 = t1._head; + if (t3 === t1._tail) + A.throwExpression(A.IterableElementError_noElement()); + t3 = t1._table[t3]; + t4 = t3 == null; + if (index < (t4 ? t2._as(t3) : t3).length) { + t5 = true; + t3 = (t4 ? t2._as(t3) : t3).charCodeAt(index); + if (!(t3 >= 65 && t3 <= 90)) + if (!(t3 >= 97 && t3 <= 122)) + t3 = t3 >= 48 && t3 <= 57; + else + t3 = t5; + else + t3 = t5; + } else + t3 = false; + if (!t3) + break; + ++index; + } + if (index === 1) + return false; + lettersAndDigits = B.JSString_methods.substring$2(t1.get$first(0), 1, index); + rest = B.JSString_methods.substring$1(t1.get$first(0), index); + if (B.JSString_methods.contains$1(rest, "\n") || B.JSString_methods.contains$1(rest, "\r")) + return false; + this._handleAbbreviation$3(lettersAndDigits, rest, innermostCommand); + return true; + }, + _handleAbbreviation$3(lettersAndDigits, rest, innermostCommand) { + var t1, i, i0, _this = this, + c = B.JSString_methods.substring$2(lettersAndDigits, 0, 1), + first = _this._grammar.findByAbbreviation$1(c); + if (first == null) { + t1 = _this._parser$_parent; + _this._validate$3(t1 != null, string$.Could_ + c + '".', "-" + c); + t1._handleAbbreviation$3(lettersAndDigits, rest, innermostCommand); + return true; + } else { + t1 = "-" + c; + if (first.type !== B.OptionType_tI9) + _this._setOption$4(_this._results, first, B.JSString_methods.substring$1(lettersAndDigits, 1) + rest, t1); + else { + _this._validate$3(rest === "", 'Option "-' + c + '" is a flag and cannot handle value "' + B.JSString_methods.substring$1(lettersAndDigits, 1) + rest + '".', t1); + for (t1 = lettersAndDigits.length, i = 0; i < t1; i = i0) { + i0 = i + 1; + innermostCommand._parseShortFlag$1(B.JSString_methods.substring$2(lettersAndDigits, i, i0)); + } + } + } + _this._args.removeFirst$0(); + return true; + }, + _parseShortFlag$1(c) { + var t1, _this = this, + option = _this._grammar.findByAbbreviation$1(c); + if (option == null) { + t1 = _this._parser$_parent; + _this._validate$3(t1 != null, string$.Could_ + c + '".', "-" + c); + t1._parseShortFlag$1(c); + return; + } + _this._validate$3(option.type === B.OptionType_tI9, 'Option "-' + c + '" must be a flag to be in a collapsed "-".', "-" + c); + _this._results.$indexSet(0, option.name, true); + }, + _parseLongOption$0() { + var index, t2, $name, t3, i, t4, t5, value, + t1 = this._args; + if (!B.JSString_methods.startsWith$1(t1.get$first(0), "--")) + return false; + index = B.JSString_methods.indexOf$1(t1.get$first(0), "="); + t2 = index === -1; + $name = t2 ? B.JSString_methods.substring$1(t1.get$first(0), 2) : B.JSString_methods.substring$2(t1.get$first(0), 2, index); + for (t3 = $name.length, i = 0; i !== t3; ++i) { + t4 = $name.charCodeAt(i); + t5 = true; + if (!(t4 >= 65 && t4 <= 90)) + if (!(t4 >= 97 && t4 <= 122)) + t5 = t4 >= 48 && t4 <= 57; + if (!(t5 || t4 === 45 || t4 === 95)) + return false; + } + value = t2 ? null : B.JSString_methods.substring$1(t1.get$first(0), index + 1); + if (value != null) + t1 = B.JSString_methods.contains$1(value, "\n") || B.JSString_methods.contains$1(value, "\r"); + else + t1 = false; + if (t1) + return false; + this._handleLongOption$2($name, value); + return true; + }, + _handleLongOption$2($name, value) { + var _this = this, + _s34_ = 'Could not find an option named "--', + t1 = _this._grammar, + option = t1.findByNameOrAlias$1($name); + if (option != null) { + _this._args.removeFirst$0(); + if (option.type === B.OptionType_tI9) { + _this._validate$3(value == null, 'Flag option "--' + $name + '" should not be given a value.', "--" + $name); + _this._results.$indexSet(0, option.name, true); + } else { + t1 = "--" + $name; + if (value != null) + _this._setOption$4(_this._results, option, value, t1); + else + _this._readNextArgAsValue$2(option, t1); + } + } else if (B.JSString_methods.startsWith$1($name, "no-")) { + option = t1.findByNameOrAlias$1(B.JSString_methods.substring$1($name, 3)); + if (option == null) { + t1 = _this._parser$_parent; + _this._validate$3(t1 != null, _s34_ + $name + '".', "--" + $name); + t1._handleLongOption$2($name, value); + return true; + } + _this._args.removeFirst$0(); + t1 = "--" + $name; + _this._validate$3(option.type === B.OptionType_tI9, 'Cannot negate non-flag option "--' + $name + '".', t1); + _this._validate$3(option.negatable, 'Cannot negate option "--' + $name + '".', t1); + _this._results.$indexSet(0, option.name, false); + } else { + t1 = _this._parser$_parent; + _this._validate$3(t1 != null, _s34_ + $name + '".', "--" + $name); + t1._handleLongOption$2($name, value); + return true; + } + return true; + }, + _validate$3(condition, message, args) { + if (!condition) + throw A.wrapException(A.ArgParserException$(message, null, args, null, null)); + }, + _setOption$4(results, option, value, arg) { + var list, t1, t2, t3, _i, element; + if (option.type !== B.OptionType_1Ol) { + this._validateAllowed$3(option, value, arg); + results.$indexSet(0, option.name, value); + return; + } + list = type$.List_dynamic._as(results.putIfAbsent$2(option.name, new A.Parser__setOption_closure())); + if (option.splitCommas) + for (t1 = value.split(","), t2 = t1.length, t3 = J.getInterceptor$ax(list), _i = 0; _i < t2; ++_i) { + element = t1[_i]; + this._validateAllowed$3(option, element, arg); + t3.add$1(list, element); + } + else { + this._validateAllowed$3(option, value, arg); + J.add$1$ax(list, value); + } + }, + _validateAllowed$3(option, value, arg) { + var t1 = option.allowed; + if (t1 == null) + return; + this._validate$3(B.JSArray_methods.contains$1(t1, value), '"' + value + '" is not an allowed value for option "' + arg + '".', arg); + } + }; + A.Parser_parse_closure.prototype = { + call$2($name, option) { + var parsedOption = this.$this._results.$index(0, $name), + callback = option.callback; + if (callback == null) + return; + callback.call$1(option.valueOrDefault$1(parsedOption)); + }, + $signature: 386 + }; + A.Parser__setOption_closure.prototype = { + call$0() { + return A._setArrayType([], type$.JSArray_String); + }, + $signature: 138 + }; + A._Usage.prototype = { + get$_columnWidths() { + var result, _this = this, + value = _this.___Usage__columnWidths_FI; + if (value === $) { + result = _this._calculateColumnWidths$0(); + _this.___Usage__columnWidths_FI !== $ && A.throwUnnamedLateFieldADI(); + _this.___Usage__columnWidths_FI = result; + value = result; + } + return value; + }, + generate$0() { + var t1, t2, t3, t4, _i, optionOrSeparator, t5, _this = this; + for (t1 = _this._usage$_optionsAndSeparators, t2 = t1.length, t3 = type$.Option, t4 = _this._usage$_buffer, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + optionOrSeparator = t1[_i]; + if (typeof optionOrSeparator == "string") { + t5 = t4._contents; + t4._contents = (t5.length !== 0 ? t4._contents = t5 + "\n\n" : t5) + optionOrSeparator; + _this._newlinesNeeded = 1; + continue; + } + t3._as(optionOrSeparator); + if (optionOrSeparator.hide) + continue; + _this._writeOption$1(optionOrSeparator); + } + t1 = t4._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _writeOption$1(option) { + var _0_0, _1_0, t2, t3, t4, $name, $content, _this = this, + t1 = option.abbr; + _this._write$2(0, t1 == null ? "" : "-" + t1 + ", "); + t1 = _this._longOption$1(option); + _this._write$2(1, t1); + _0_0 = option.help; + if (_0_0 != null) + _this._write$2(2, _0_0); + _1_0 = option.allowedHelp; + if (_1_0 != null) { + _this._newline$0(); + for (t1 = _1_0.get$entries(_1_0), t1 = t1.get$iterator(t1), t2 = option.defaultsTo, t3 = type$.List_dynamic._is(t2); t1.moveNext$0();) { + t4 = t1.get$current(t1); + $name = t4.key; + $content = t4.value; + t4 = (t3 ? B.JSArray_methods.contains$1(t2, $name) : t2 === $name) ? " (default)" : ""; + _this._write$2(1, " [" + $name + "]" + t4); + _this._write$2(2, $content); + } + _this._newline$0(); + } else if (option.allowed != null) + _this._write$2(2, _this._buildAllowedList$1(option)); + else { + t1 = option.type; + if (t1 === B.OptionType_tI9) { + if (option.defaultsTo === true) + _this._write$2(2, "(defaults to on)"); + } else if (t1 === B.OptionType_1Ol) { + t1 = option.defaultsTo; + if (t1 != null && type$.Iterable_dynamic._as(t1).length !== 0) { + type$.List_dynamic._as(t1); + _this._write$2(2, "(defaults to " + new A.MappedListIterable(t1, new A._Usage__writeOption_closure(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,String>")).join$1(0, ", ") + ")"); + } + } else { + t1 = option.defaultsTo; + if (t1 != null) + _this._write$2(2, '(defaults to "' + A.S(t1) + '")'); + } + } + }, + _longOption$1(option) { + var t1 = option.name, + result = option.negatable ? "--[no-]" + t1 : "--" + t1; + t1 = option.valueHelp; + return t1 != null ? result + ("=<" + t1 + ">") : result; + }, + _calculateColumnWidths$0() { + var t1, t2, t3, abbr, title, _i, option, t4, t5, t6, t7, t8; + for (t1 = this._usage$_optionsAndSeparators, t2 = t1.length, t3 = type$.List_dynamic, abbr = 0, title = 0, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + option = t1[_i]; + if (!(option instanceof A.Option)) + continue; + if (option.hide) + continue; + t4 = option.abbr; + abbr = Math.max(abbr, (t4 == null ? "" : "-" + t4 + ", ").length); + t4 = this._longOption$1(option); + title = Math.max(title, t4.length); + t4 = option.allowedHelp; + if (t4 != null) + for (t4 = J.get$iterator$ax(t4.get$keys(t4)), t5 = option.defaultsTo, t6 = t3._is(t5); t4.moveNext$0();) { + t7 = t4.get$current(t4); + t8 = (t6 ? B.JSArray_methods.contains$1(t5, t7) : t5 === t7) ? " (default)" : ""; + title = Math.max(title, (" [" + t7 + "]" + t8).length); + } + } + return A._setArrayType([abbr, title + 4], type$.JSArray_int); + }, + _newline$0() { + ++this._newlinesNeeded; + this._currentColumn = 0; + }, + _write$2(column, text) { + var t1, _i, + lines = A._setArrayType(text.split("\n"), type$.JSArray_String); + this.get$_columnWidths(); + while (true) { + if (!(lines.length !== 0 && J.trim$0$s(B.JSArray_methods.get$first(lines)) === "")) + break; + B.JSArray_methods.removeAt$1(lines, 0); + } + while (true) { + if (!(lines.length !== 0 && J.trim$0$s(B.JSArray_methods.get$last(lines)) === "")) + break; + lines.pop(); + } + for (t1 = lines.length, _i = 0; _i < lines.length; lines.length === t1 || (0, A.throwConcurrentModificationError)(lines), ++_i) + this._writeLine$2(column, lines[_i]); + }, + _writeLine$2(column, text) { + var t1, t2, _this = this; + for (t1 = _this._usage$_buffer; t2 = _this._newlinesNeeded, t2 > 0;) { + t1._contents += "\n"; + _this._newlinesNeeded = t2 - 1; + } + for (; t2 = _this._currentColumn, t2 !== column;) { + if (t2 < 2) { + t2 = B.JSString_methods.$mul(" ", _this.get$_columnWidths()[_this._currentColumn]); + t1._contents += t2; + } else + t1._contents += "\n"; + _this._currentColumn = (_this._currentColumn + 1) % 3; + } + _this.get$_columnWidths(); + if (column < 2) { + t2 = B.JSString_methods.padRight$1(text, _this.get$_columnWidths()[column]); + t1._contents += t2; + } else + t1._contents += text; + _this._currentColumn = (_this._currentColumn + 1) % 3; + if (column === 2) + ++_this._newlinesNeeded; + }, + _buildAllowedList$1(option) { + var t2, t3, first, _i, allowed, + t1 = option.defaultsTo, + isDefault = type$.List_dynamic._is(t1) ? B.JSArray_methods.get$contains(t1) : new A._Usage__buildAllowedList_closure(option); + t1 = "" + "["; + for (t2 = option.allowed, t3 = t2.length, first = true, _i = 0; _i < t3; ++_i, first = false) { + allowed = t2[_i]; + t1 = (!first ? t1 + ", " : t1) + allowed; + if (isDefault.call$1(allowed)) + t1 += " (default)"; + } + t1 += "]"; + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + }; + A._Usage__writeOption_closure.prototype = { + call$1(value) { + return '"' + A.S(value) + '"'; + }, + $signature: 134 + }; + A._Usage__buildAllowedList_closure.prototype = { + call$1(value) { + return value === this.option.defaultsTo; + }, + $signature: 5 + }; + A.FutureGroup.prototype = { + add$1(_, task) { + var t1, index, _this = this; + if (_this._future_group$_closed) + throw A.wrapException(A.StateError$("The FutureGroup is closed.")); + t1 = _this._future_group$_values; + index = t1.length; + t1.push(null); + ++_this._future_group$_pending; + task.then$1$1(0, new A.FutureGroup_add_closure(_this, index), type$.Null).catchError$1(new A.FutureGroup_add_closure0(_this)); + }, + close$0(_) { + var t1, t2, _this = this; + _this._future_group$_closed = true; + if (_this._future_group$_pending !== 0) + return; + t1 = _this._future_group$_completer; + if ((t1.future._state & 30) !== 0) + return; + t2 = _this.$ti._eval$1("WhereTypeIterable<1>"); + t1.complete$1(A.List_List$of(new A.WhereTypeIterable(_this._future_group$_values, t2), true, t2._eval$1("Iterable.E"))); + } + }; + A.FutureGroup_add_closure.prototype = { + call$1(value) { + var t3, t4, + t1 = this.$this, + t2 = t1._future_group$_completer; + if ((t2.future._state & 30) !== 0) + return null; + t3 = --t1._future_group$_pending; + t4 = t1._future_group$_values; + t4[this.index] = value; + if (t3 !== 0) + return null; + if (!t1._future_group$_closed) + return null; + t1 = t1.$ti._eval$1("WhereTypeIterable<1>"); + t2.complete$1(A.List_List$of(new A.WhereTypeIterable(t4, t1), true, t1._eval$1("Iterable.E"))); + }, + $signature() { + return this.$this.$ti._eval$1("Null(1)"); + } + }; + A.FutureGroup_add_closure0.prototype = { + call$2(error, stackTrace) { + var t1 = this.$this._future_group$_completer; + if ((t1.future._state & 30) !== 0) + return null; + t1.completeError$2(error, stackTrace); + }, + $signature: 46 + }; + A.ErrorResult.prototype = { + complete$1(completer) { + completer.completeError$2(this.error, this.stackTrace); + }, + get$hashCode(_) { + return (J.get$hashCode$(this.error) ^ A.Primitives_objectHashCode(this.stackTrace) ^ 492929599) >>> 0; + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.ErrorResult && J.$eq$(this.error, other.error) && this.stackTrace === other.stackTrace; + }, + $isResult: 1 + }; + A.ValueResult.prototype = { + complete$1(completer) { + completer.complete$1(this.value); + }, + get$hashCode(_) { + return (J.get$hashCode$(this.value) ^ 842997089) >>> 0; + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.ValueResult && J.$eq$(this.value, other.value); + }, + $isResult: 1 + }; + A.StreamCompleter.prototype = { + setSourceStream$1(sourceStream) { + var t1 = this._stream_completer$_stream; + if (t1._sourceStream != null) + throw A.wrapException(A.StateError$("Source stream already set")); + t1._sourceStream = sourceStream; + if (t1._stream_completer$_controller != null) + t1._linkStreamToController$0(); + }, + setError$2(error, stackTrace) { + var t1 = this.$ti._precomputed1; + this.setSourceStream$1(A.Stream_Stream$fromFuture(A.Future_Future$error(error, stackTrace, t1), t1)); + }, + setError$1(error) { + return this.setError$2(error, null); + } + }; + A._CompleterStream.prototype = { + listen$4$cancelOnError$onDone$onError(_, onData, cancelOnError, onDone, onError) { + var sourceStream, t1, _this = this, _null = null; + if (_this._stream_completer$_controller == null) { + sourceStream = _this._sourceStream; + if (sourceStream != null && !sourceStream.get$isBroadcast()) + return sourceStream.listen$4$cancelOnError$onDone$onError(0, onData, cancelOnError, onDone, onError); + if (_this._stream_completer$_controller == null) + _this._stream_completer$_controller = A.StreamController_StreamController(_null, _null, _null, _null, true, _this.$ti._precomputed1); + if (_this._sourceStream != null) + _this._linkStreamToController$0(); + } + t1 = _this._stream_completer$_controller; + t1.toString; + return new A._ControllerStream(t1, A._instanceType(t1)._eval$1("_ControllerStream<1>")).listen$4$cancelOnError$onDone$onError(0, onData, cancelOnError, onDone, onError); + }, + listen$1(_, onData) { + return this.listen$4$cancelOnError$onDone$onError(0, onData, null, null, null); + }, + listen$3$onDone$onError(_, onData, onDone, onError) { + return this.listen$4$cancelOnError$onDone$onError(0, onData, null, onDone, onError); + }, + _linkStreamToController$0() { + var t2, + t1 = this._stream_completer$_controller; + t1.toString; + t2 = this._sourceStream; + t2.toString; + t1.addStream$2$cancelOnError(t2, false).whenComplete$1(t1.get$close(t1)); + } + }; + A.StreamGroup.prototype = { + add$1(_, stream) { + var t1, _this = this; + if (_this._closed) + throw A.wrapException(A.StateError$("Can't add a Stream to a closed StreamGroup.")); + t1 = _this._stream_group$_state; + if (t1 === B._StreamGroupState_dormant) + _this._subscriptions.putIfAbsent$2(stream, new A.StreamGroup_add_closure()); + else if (t1 === B._StreamGroupState_canceled) + return stream.listen$1(0, null).cancel$0(); + else + _this._subscriptions.putIfAbsent$2(stream, new A.StreamGroup_add_closure0(_this, stream)); + return null; + }, + remove$1(_, stream) { + var t1 = this._subscriptions, + subscription = t1.remove$1(0, stream), + future = subscription == null ? null : subscription.cancel$0(); + if (t1.__js_helper$_length === 0) + if (this._closed) { + t1 = this.__StreamGroup__controller_A; + t1 === $ && A.throwUnnamedLateFieldNI(); + A.scheduleMicrotask(t1.get$close(t1)); + } + return future; + }, + _onListen$0() { + var stream, t1, t2, t3, _i, entry, exception, _this = this; + _this._stream_group$_state = B._StreamGroupState_listening; + for (t1 = _this._subscriptions, t2 = A.List_List$of(new A.LinkedHashMapEntriesIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapEntriesIterable<1,2>")), true, _this.$ti._eval$1("MapEntry,StreamSubscription<1>?>")), t3 = t2.length, _i = 0; _i < t3; ++_i) { + entry = t2[_i]; + if (entry.value != null) + continue; + stream = entry.key; + try { + t1.$indexSet(0, stream, _this._listenToStream$1(stream)); + } catch (exception) { + t1 = _this._onCancel$0(); + if (t1 != null) + t1.catchError$1(new A.StreamGroup__onListen_closure()); + throw exception; + } + } + }, + _onPause$0() { + this._stream_group$_state = B._StreamGroupState_paused; + for (var t1 = this._subscriptions, t1 = new A.LinkedHashMapValueIterator(t1, t1.__js_helper$_modifications, t1.__js_helper$_first); t1.moveNext$0();) + t1.__js_helper$_current.pause$0(0); + }, + _onResume$0() { + this._stream_group$_state = B._StreamGroupState_listening; + for (var t1 = this._subscriptions, t1 = new A.LinkedHashMapValueIterator(t1, t1.__js_helper$_modifications, t1.__js_helper$_first); t1.moveNext$0();) + t1.__js_helper$_current.resume$0(0); + }, + _onCancel$0() { + var t1, t2, t3, futures; + this._stream_group$_state = B._StreamGroupState_canceled; + t1 = this._subscriptions; + t2 = A._instanceType(t1)._eval$1("LinkedHashMapEntriesIterable<1,2>"); + t3 = type$.NonNullsIterable_Future_void; + futures = A.List_List$of(new A.NonNullsIterable(A.MappedIterable_MappedIterable(new A.LinkedHashMapEntriesIterable(t1, t2), new A.StreamGroup__onCancel_closure(this), t2._eval$1("Iterable.E"), type$.nullable_Future_void), t3), true, t3._eval$1("Iterable.E")); + t1.clear$0(0); + return futures.length === 0 ? null : A.Future_wait(futures, false, type$.void); + }, + _listenToStream$1(stream) { + var subscription, + t1 = this.__StreamGroup__controller_A; + t1 === $ && A.throwUnnamedLateFieldNI(); + subscription = stream.listen$3$onDone$onError(0, t1.get$add(t1), new A.StreamGroup__listenToStream_closure(this, stream), t1.get$addError()); + if (this._stream_group$_state === B._StreamGroupState_paused) + subscription.pause$0(0); + return subscription; + } + }; + A.StreamGroup_add_closure.prototype = { + call$0() { + return null; + }, + $signature: 1 + }; + A.StreamGroup_add_closure0.prototype = { + call$0() { + return this.$this._listenToStream$1(this.stream); + }, + $signature() { + return this.$this.$ti._eval$1("StreamSubscription<1>()"); + } + }; + A.StreamGroup__onListen_closure.prototype = { + call$1(_) { + }, + $signature: 55 + }; + A.StreamGroup__onCancel_closure.prototype = { + call$1(entry) { + var t1, exception, + subscription = entry.value; + try { + if (subscription != null) { + t1 = subscription.cancel$0(); + return t1; + } + t1 = J.listen$1$z(entry.key, null).cancel$0(); + return t1; + } catch (exception) { + return null; + } + }, + $signature() { + return this.$this.$ti._eval$1("Future<~>?(MapEntry,StreamSubscription<1>?>)"); + } + }; + A.StreamGroup__listenToStream_closure.prototype = { + call$0() { + return this.$this.remove$1(0, this.stream); + }, + $signature: 0 + }; + A._StreamGroupState.prototype = { + toString$0(_) { + return this.name; + } + }; + A.StreamQueue.prototype = { + _updateRequests$0() { + var t1, t2, t3, t4, _this = this; + for (t1 = _this._requestQueue, t2 = _this._eventQueue, t3 = t1.$ti._precomputed1; !t1.get$isEmpty(0);) { + t4 = t1._head; + if (t4 === t1._tail) + A.throwExpression(A.IterableElementError_noElement()); + t4 = t1._table[t4]; + if (t4 == null) + t4 = t3._as(t4); + if (t4.update$2(t2, _this._isDone)) + t1.removeFirst$0(); + else + return; + } + if (!_this._isDone) + _this._stream_queue$_subscription.pause$0(0); + }, + _ensureListening$0() { + var t1, _this = this; + if (_this._isDone) + return; + t1 = _this._stream_queue$_subscription; + if (t1 == null) + _this._stream_queue$_subscription = _this._stream_queue$_source.listen$3$onDone$onError(0, new A.StreamQueue__ensureListening_closure(_this), new A.StreamQueue__ensureListening_closure0(_this), new A.StreamQueue__ensureListening_closure1(_this)); + else + t1.resume$0(0); + }, + _addResult$1(result) { + ++this._eventsReceived; + this._eventQueue._queue_list$_add$1(result); + this._updateRequests$0(); + }, + _addRequest$1(request) { + var _this = this, + t1 = _this._requestQueue; + if (t1._head === t1._tail) { + if (request.update$2(_this._eventQueue, _this._isDone)) + return; + _this._ensureListening$0(); + } + t1._add$1(request); + } + }; + A.StreamQueue__ensureListening_closure.prototype = { + call$1(data) { + var t1 = this.$this; + t1._addResult$1(new A.ValueResult(data, t1.$ti._eval$1("ValueResult<1>"))); + }, + $signature() { + return this.$this.$ti._eval$1("~(1)"); + } + }; + A.StreamQueue__ensureListening_closure1.prototype = { + call$2(error, stackTrace) { + this.$this._addResult$1(new A.ErrorResult(error, stackTrace)); + }, + $signature: 46 + }; + A.StreamQueue__ensureListening_closure0.prototype = { + call$0() { + var t1 = this.$this; + t1._stream_queue$_subscription = null; + t1._isDone = true; + t1._updateRequests$0(); + }, + $signature: 0 + }; + A._NextRequest.prototype = { + update$2(events, isDone) { + if (!events.get$isEmpty(events)) { + events.removeFirst$0().complete$1(this._completer); + return true; + } + if (isDone) { + this._completer.completeError$2(new A.StateError("No elements"), A.StackTrace_current()); + return true; + } + return false; + }, + $is_EventRequest: 1 + }; + A._isStrictMode_closure.prototype = { + call$0() { + var exception; + try { + "".name = null; + return false; + } catch (exception) { + return true; + } + }, + $signature: 19 + }; + A.Repl.prototype = {}; + A.alwaysValid_closure.prototype = { + call$1(text) { + return true; + }, + $signature: 5 + }; + A.ReplAdapter.prototype = { + runAsync$0() { + var rl, runController, _this = this, t1 = {}, + t2 = J.get$isTTY$x(self.process.stdin), + output = (t2 == null ? false : t2) ? self.process.stdout : null; + t2 = _this.repl.prompt; + rl = J.createInterface$1$x($.$get$readline(), {input: self.process.stdin, output: output, prompt: t2}); + _this.rl = rl; + t1.statement = ""; + t1.prompt = t2; + runController = A._Cell$(); + runController.__late_helper$_value = A.StreamController_StreamController(_this.get$exit(_this), new A.ReplAdapter_runAsync_closure(t1, _this, rl, runController), null, null, false, type$.String); + return runController._readLocal$0().get$stream(); + }, + exit$0(_) { + var t1 = this.rl; + if (t1 != null) + J.close$0$x(t1); + this.rl = null; + } + }; + A.ReplAdapter_runAsync_closure.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$handler = 1, $async$errorStack = [], $async$self = this, lineController, lineQueue, line, error, stackTrace, t1, t2, t3, t4, $prompt, prompt0, t5, t6, t7, t8, line0, toZone, statement, exception, $async$exception; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$handler = 3; + lineController = A.StreamController_StreamController(null, null, null, null, false, type$.String); + t1 = lineController; + t2 = A.QueueList$(null, type$.Result_String); + t3 = A.ListQueue$(type$._EventRequest_dynamic); + lineQueue = new A.StreamQueue(new A._ControllerStream(t1, A._instanceType(t1)._eval$1("_ControllerStream<1>")), t2, t3, type$.StreamQueue_String); + t1 = $async$self.rl; + t2 = J.getInterceptor$x(t1); + t2.on$2(t1, "line", A.allowInterop(new A.ReplAdapter_runAsync__closure(lineController))); + t3 = $async$self._box_0, t4 = $async$self.$this.repl, $prompt = t4.continuation, prompt0 = t4.prompt, t5 = $async$self.runController; + case 6: + // for condition + // trivial condition + t6 = J.get$isTTY$x(self.process.stdin); + if (t6 == null ? false : t6) + J.write$1$x(self.process.stdout, t3.prompt); + t6 = lineQueue; + t6.toString; + t7 = t6.$ti; + t8 = new A._Future($.Zone__current, t7._eval$1("_Future<1>")); + t6._addRequest$1(new A._NextRequest(new A._AsyncCompleter(t8, t7._eval$1("_AsyncCompleter<1>")), t7._eval$1("_NextRequest<1>"))); + $async$goto = 8; + return A._asyncAwait(t8, $async$call$0); + case 8: + // returning from await. + line = $async$result; + t6 = J.get$isTTY$x(self.process.stdin); + if (!(t6 == null ? false : t6)) { + line0 = t3.prompt + A.S(line); + toZone = $.printToZone; + if (toZone == null) + A.printString(line0); + else + toZone.call$1(line0); + } + statement = B.JSString_methods.$add(t3.statement, line); + t3.statement = statement; + if (t4.validator.call$1(statement)) { + t6 = t5.__late_helper$_value; + if (t6 === t5) + A.throwExpression(A.LateError$localNI("")); + J.add$1$ax(t6, t3.statement); + t3.statement = ""; + t3.prompt = prompt0; + t2.setPrompt$1(t1, prompt0); + } else { + t3.statement += "\n"; + t3.prompt = $prompt; + t2.setPrompt$1(t1, $prompt); + } + // goto for condition + $async$goto = 6; + break; + case 7: + // after for + $async$handler = 1; + // goto after finally + $async$goto = 5; + break; + case 3: + // catch + $async$handler = 2; + $async$exception = $async$errorStack.pop(); + error = A.unwrapException($async$exception); + stackTrace = A.getTraceFromException($async$exception); + t1 = $async$self.runController; + t1._readLocal$0().addError$2(error, stackTrace); + t2 = $async$self.$this.exit$0(0); + t2 = A._Future$value(t2, type$.void); + $async$goto = 9; + return A._asyncAwait(t2, $async$call$0); + case 9: + // returning from await. + J.close$0$x(t1._readLocal$0()); + // goto after finally + $async$goto = 5; + break; + case 2: + // uncaught + // goto rethrow + $async$goto = 1; + break; + case 5: + // after finally + // implicit return + return A._asyncReturn(null, $async$completer); + case 1: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 32 + }; + A.ReplAdapter_runAsync__closure.prototype = { + call$1(value) { + return this.lineController.add$1(0, A._asString(value)); + }, + $signature: 71 + }; + A.Stdin.prototype = {}; + A.Stdout.prototype = {}; + A.ReadlineModule.prototype = {}; + A.ReadlineOptions.prototype = {}; + A.ReadlineInterface.prototype = {}; + A.EmptyUnmodifiableSet.prototype = { + get$iterator(_) { + return B.C_EmptyIterator; + }, + get$length(_) { + return 0; + }, + contains$1(_, element) { + return false; + }, + toSet$0(_) { + return A.LinkedHashSet_LinkedHashSet$_empty(this.$ti._precomputed1); + }, + $isEfficientLengthIterable: 1, + $isSet: 1 + }; + A._EmptyUnmodifiableSet_IterableBase_UnmodifiableSetMixin.prototype = {}; + A.DefaultEquality.prototype = {}; + A.IterableEquality.prototype = { + equals$2(_, elements1, elements2) { + var it1, it2, hasNext; + if (elements1 === elements2) + return true; + it1 = J.get$iterator$ax(elements1); + it2 = J.get$iterator$ax(elements2); + for (; true;) { + hasNext = it1.moveNext$0(); + if (hasNext !== it2.moveNext$0()) + return false; + if (!hasNext) + return true; + if (!J.$eq$(it1.get$current(it1), it2.get$current(it2))) + return false; + } + }, + hash$1(elements) { + var t1, hash, _i; + for (t1 = elements.length, hash = 0, _i = 0; _i < elements.length; elements.length === t1 || (0, A.throwConcurrentModificationError)(elements), ++_i) { + hash = hash + J.get$hashCode$(elements[_i]) & 2147483647; + hash = hash + (hash << 10 >>> 0) & 2147483647; + hash ^= hash >>> 6; + } + hash = hash + (hash << 3 >>> 0) & 2147483647; + hash ^= hash >>> 11; + return hash + (hash << 15 >>> 0) & 2147483647; + } + }; + A.ListEquality.prototype = { + equals$2(_, list1, list2) { + var t1, $length, t2, i; + if (list1 == null ? list2 == null : list1 === list2) + return true; + if (list1 == null || list2 == null) + return false; + t1 = J.getInterceptor$asx(list1); + $length = t1.get$length(list1); + t2 = J.getInterceptor$asx(list2); + if ($length !== t2.get$length(list2)) + return false; + for (i = 0; i < $length; ++i) + if (!J.$eq$(t1.$index(list1, i), t2.$index(list2, i))) + return false; + return true; + }, + hash$1(list) { + var hash, i; + for (hash = 0, i = 0; i < list.length; ++i) { + hash = hash + J.get$hashCode$(list[i]) & 2147483647; + hash = hash + (hash << 10 >>> 0) & 2147483647; + hash ^= hash >>> 6; + } + hash = hash + (hash << 3 >>> 0) & 2147483647; + hash ^= hash >>> 11; + return hash + (hash << 15 >>> 0) & 2147483647; + } + }; + A._MapEntry.prototype = { + get$hashCode(_) { + return 3 * J.get$hashCode$(this.key) + 7 * J.get$hashCode$(this.value) & 2147483647; + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A._MapEntry && J.$eq$(this.key, other.key) && J.$eq$(this.value, other.value); + } + }; + A.MapEquality.prototype = { + equals$2(_, map1, map2) { + var equalElementCounts, t1, key, entry, count; + if (map1 === map2) + return true; + if (map1.get$length(map1) !== map2.get$length(map2)) + return false; + equalElementCounts = A.HashMap_HashMap(type$._MapEntry, type$.int); + for (t1 = J.get$iterator$ax(map1.get$keys(map1)); t1.moveNext$0();) { + key = t1.get$current(t1); + entry = new A._MapEntry(this, key, map1.$index(0, key)); + count = equalElementCounts.$index(0, entry); + equalElementCounts.$indexSet(0, entry, (count == null ? 0 : count) + 1); + } + for (t1 = J.get$iterator$ax(map2.get$keys(map2)); t1.moveNext$0();) { + key = t1.get$current(t1); + entry = new A._MapEntry(this, key, map2.$index(0, key)); + count = equalElementCounts.$index(0, entry); + if (count == null || count === 0) + return false; + equalElementCounts.$indexSet(0, entry, count - 1); + } + return true; + }, + hash$1(map) { + var t1, t2, hash, key, keyHash, t3; + for (t1 = J.get$iterator$ax(map.get$keys(map)), t2 = this.$ti._rest[1], hash = 0; t1.moveNext$0();) { + key = t1.get$current(t1); + keyHash = J.get$hashCode$(key); + t3 = map.$index(0, key); + hash = hash + 3 * keyHash + 7 * J.get$hashCode$(t3 == null ? t2._as(t3) : t3) & 2147483647; + } + hash = hash + (hash << 3 >>> 0) & 2147483647; + hash ^= hash >>> 11; + return hash + (hash << 15 >>> 0) & 2147483647; + } + }; + A.QueueList.prototype = { + add$1(_, element) { + this._queue_list$_add$1(element); + }, + addAll$1(_, iterable) { + var addCount, $length, t1, endSpace, t2, preSpace, _this = this; + if (type$.List_dynamic._is(iterable)) { + addCount = J.get$length$asx(iterable); + $length = _this.get$length(0); + t1 = $length + addCount; + if (t1 >= J.get$length$asx(_this._queue_list$_table)) { + _this._preGrow$1(t1); + J.setRange$4$ax(_this._queue_list$_table, $length, t1, iterable, 0); + _this.set$_queue_list$_tail(_this.get$_queue_list$_tail() + addCount); + } else { + endSpace = J.get$length$asx(_this._queue_list$_table) - _this.get$_queue_list$_tail(); + t1 = _this._queue_list$_table; + t2 = J.getInterceptor$ax(t1); + if (addCount < endSpace) { + t2.setRange$4(t1, _this.get$_queue_list$_tail(), _this.get$_queue_list$_tail() + addCount, iterable, 0); + _this.set$_queue_list$_tail(_this.get$_queue_list$_tail() + addCount); + } else { + preSpace = addCount - endSpace; + t2.setRange$4(t1, _this.get$_queue_list$_tail(), _this.get$_queue_list$_tail() + endSpace, iterable, 0); + J.setRange$4$ax(_this._queue_list$_table, 0, preSpace, iterable, endSpace); + _this.set$_queue_list$_tail(preSpace); + } + } + } else + for (t1 = J.get$iterator$ax(iterable); t1.moveNext$0();) + _this._queue_list$_add$1(t1.get$current(t1)); + }, + cast$1$0(_, $T) { + return new A._CastQueueList(this, J.cast$1$0$ax(this._queue_list$_table, $T), -1, -1, A._instanceType(this)._eval$1("@")._bind$1($T)._eval$1("_CastQueueList<1,2>")); + }, + toString$0(_) { + return A.Iterable_iterableToFullString(this, "{", "}"); + }, + addFirst$1(element) { + var _this = this; + _this.set$_queue_list$_head((_this.get$_queue_list$_head() - 1 & J.get$length$asx(_this._queue_list$_table) - 1) >>> 0); + J.$indexSet$ax(_this._queue_list$_table, _this.get$_queue_list$_head(), element); + if (_this.get$_queue_list$_head() === _this.get$_queue_list$_tail()) + _this._queue_list$_grow$0(); + }, + removeFirst$0() { + var result, _this = this; + if (_this.get$_queue_list$_head() === _this.get$_queue_list$_tail()) + throw A.wrapException(A.StateError$("No element")); + result = J.$index$asx(_this._queue_list$_table, _this.get$_queue_list$_head()); + if (result == null) + result = A._instanceType(_this)._eval$1("QueueList.E")._as(result); + J.$indexSet$ax(_this._queue_list$_table, _this.get$_queue_list$_head(), null); + _this.set$_queue_list$_head((_this.get$_queue_list$_head() + 1 & J.get$length$asx(_this._queue_list$_table) - 1) >>> 0); + return result; + }, + removeLast$0(_) { + var result, _this = this; + if (_this.get$_queue_list$_head() === _this.get$_queue_list$_tail()) + throw A.wrapException(A.StateError$("No element")); + _this.set$_queue_list$_tail((_this.get$_queue_list$_tail() - 1 & J.get$length$asx(_this._queue_list$_table) - 1) >>> 0); + result = J.$index$asx(_this._queue_list$_table, _this.get$_queue_list$_tail()); + if (result == null) + result = A._instanceType(_this)._eval$1("QueueList.E")._as(result); + J.$indexSet$ax(_this._queue_list$_table, _this.get$_queue_list$_tail(), null); + return result; + }, + get$length(_) { + return (this.get$_queue_list$_tail() - this.get$_queue_list$_head() & J.get$length$asx(this._queue_list$_table) - 1) >>> 0; + }, + set$length(_, value) { + var delta, newTail, t1, t2, _this = this; + if (value < 0) + throw A.wrapException(A.RangeError$("Length " + value + " may not be negative.")); + if (value > _this.get$length(0) && !A._instanceType(_this)._eval$1("QueueList.E")._is(null)) + throw A.wrapException(A.UnsupportedError$("The length can only be increased when the element type is nullable, but the current element type is `" + A.createRuntimeType(A._instanceType(_this)._eval$1("QueueList.E")).toString$0(0) + "`.")); + delta = value - _this.get$length(0); + if (delta >= 0) { + if (J.get$length$asx(_this._queue_list$_table) <= value) + _this._preGrow$1(value); + _this.set$_queue_list$_tail((_this.get$_queue_list$_tail() + delta & J.get$length$asx(_this._queue_list$_table) - 1) >>> 0); + return; + } + newTail = _this.get$_queue_list$_tail() + delta; + t1 = _this._queue_list$_table; + if (newTail >= 0) + J.fillRange$3$ax(t1, newTail, _this.get$_queue_list$_tail(), null); + else { + newTail += J.get$length$asx(t1); + J.fillRange$3$ax(_this._queue_list$_table, 0, _this.get$_queue_list$_tail(), null); + t1 = _this._queue_list$_table; + t2 = J.getInterceptor$asx(t1); + t2.fillRange$3(t1, newTail, t2.get$length(t1), null); + } + _this.set$_queue_list$_tail(newTail); + }, + $index(_, index) { + var t1, _this = this; + if (index < 0 || index >= _this.get$length(0)) + throw A.wrapException(A.RangeError$("Index " + index + " must be in the range [0.." + _this.get$length(0) + ").")); + t1 = J.$index$asx(_this._queue_list$_table, (_this.get$_queue_list$_head() + index & J.get$length$asx(_this._queue_list$_table) - 1) >>> 0); + return t1 == null ? A._instanceType(_this)._eval$1("QueueList.E")._as(t1) : t1; + }, + $indexSet(_, index, value) { + var _this = this; + if (index < 0 || index >= _this.get$length(0)) + throw A.wrapException(A.RangeError$("Index " + index + " must be in the range [0.." + _this.get$length(0) + ").")); + J.$indexSet$ax(_this._queue_list$_table, (_this.get$_queue_list$_head() + index & J.get$length$asx(_this._queue_list$_table) - 1) >>> 0, value); + }, + _queue_list$_add$1(element) { + var _this = this; + J.$indexSet$ax(_this._queue_list$_table, _this.get$_queue_list$_tail(), element); + _this.set$_queue_list$_tail((_this.get$_queue_list$_tail() + 1 & J.get$length$asx(_this._queue_list$_table) - 1) >>> 0); + if (_this.get$_queue_list$_head() === _this.get$_queue_list$_tail()) + _this._queue_list$_grow$0(); + }, + _queue_list$_grow$0() { + var _this = this, + newTable = A.List_List$filled(J.get$length$asx(_this._queue_list$_table) * 2, null, false, A._instanceType(_this)._eval$1("QueueList.E?")), + split = J.get$length$asx(_this._queue_list$_table) - _this.get$_queue_list$_head(); + B.JSArray_methods.setRange$4(newTable, 0, split, _this._queue_list$_table, _this.get$_queue_list$_head()); + B.JSArray_methods.setRange$4(newTable, split, split + _this.get$_queue_list$_head(), _this._queue_list$_table, 0); + _this.set$_queue_list$_head(0); + _this.set$_queue_list$_tail(J.get$length$asx(_this._queue_list$_table)); + _this._queue_list$_table = newTable; + }, + _writeToList$1(target) { + var $length, firstPartSize, _this = this; + if (_this.get$_queue_list$_head() <= _this.get$_queue_list$_tail()) { + $length = _this.get$_queue_list$_tail() - _this.get$_queue_list$_head(); + B.JSArray_methods.setRange$4(target, 0, $length, _this._queue_list$_table, _this.get$_queue_list$_head()); + return $length; + } else { + firstPartSize = J.get$length$asx(_this._queue_list$_table) - _this.get$_queue_list$_head(); + B.JSArray_methods.setRange$4(target, 0, firstPartSize, _this._queue_list$_table, _this.get$_queue_list$_head()); + B.JSArray_methods.setRange$4(target, firstPartSize, firstPartSize + _this.get$_queue_list$_tail(), _this._queue_list$_table, 0); + return _this.get$_queue_list$_tail() + firstPartSize; + } + }, + _preGrow$1(newElementCount) { + var _this = this, + newTable = A.List_List$filled(A.QueueList__nextPowerOf2(newElementCount + B.JSInt_methods._shrOtherPositive$1(newElementCount, 1)), null, false, A._instanceType(_this)._eval$1("QueueList.E?")); + _this.set$_queue_list$_tail(_this._writeToList$1(newTable)); + _this._queue_list$_table = newTable; + _this.set$_queue_list$_head(0); + }, + $isEfficientLengthIterable: 1, + $isQueue: 1, + $isIterable: 1, + $isList: 1, + get$_queue_list$_head() { + return this._queue_list$_head; + }, + get$_queue_list$_tail() { + return this._queue_list$_tail; + }, + set$_queue_list$_head(val) { + return this._queue_list$_head = val; + }, + set$_queue_list$_tail(val) { + return this._queue_list$_tail = val; + } + }; + A._CastQueueList.prototype = { + get$_queue_list$_head() { + return this._queue_list$_delegate.get$_queue_list$_head(); + }, + set$_queue_list$_head(value) { + this._queue_list$_delegate.set$_queue_list$_head(value); + }, + get$_queue_list$_tail() { + return this._queue_list$_delegate.get$_queue_list$_tail(); + }, + set$_queue_list$_tail(value) { + this._queue_list$_delegate.set$_queue_list$_tail(value); + } + }; + A._QueueList_Object_ListMixin.prototype = {}; + A.UnionSet.prototype = { + get$length(_) { + var t1 = this.get$_union_set$_iterable().get$length(0); + return t1; + }, + get$iterator(_) { + var t1 = this.get$_union_set$_iterable(); + return t1.get$iterator(t1); + }, + get$_union_set$_iterable() { + var t1 = this._sets, + t2 = this.$ti._precomputed1, + t3 = A._instanceType(t1)._eval$1("@<1>")._bind$1(t2)._eval$1("ExpandIterable<1,2>"); + t2 = A.LinkedHashSet_LinkedHashSet$_empty(t2); + return new A.WhereIterable(new A.ExpandIterable(t1, new A.UnionSet__iterable_closure(this), t3), t2.get$add(t2), t3._eval$1("WhereIterable")); + }, + contains$1(_, element) { + return this._sets.any$1(0, new A.UnionSet_contains_closure(this, element)); + }, + toSet$0(_) { + var t2, t3, t4, + t1 = A.LinkedHashSet_LinkedHashSet$_empty(this.$ti._precomputed1); + for (t2 = this._sets, t2 = A._LinkedHashSetIterator$(t2, t2._modifications, A._instanceType(t2)._precomputed1), t3 = t2.$ti._precomputed1; t2.moveNext$0();) { + t4 = t2._collection$_current; + t1.addAll$1(0, t4 == null ? t3._as(t4) : t4); + } + return t1; + } + }; + A.UnionSet__iterable_closure.prototype = { + call$1(set) { + return set; + }, + $signature() { + return this.$this.$ti._eval$1("Set<1>(Set<1>)"); + } + }; + A.UnionSet_contains_closure.prototype = { + call$1(set) { + return set.contains$1(0, this.element); + }, + $signature() { + return this.$this.$ti._eval$1("bool(Set<1>)"); + } + }; + A._UnionSet_SetBase_UnmodifiableSetMixin.prototype = {}; + A.UnmodifiableSetView0.prototype = {}; + A.UnmodifiableSetMixin.prototype = { + add$1(_, value) { + return A.UnmodifiableSetMixin__throw(); + }, + addAll$1(_, elements) { + return A.UnmodifiableSetMixin__throw(); + }, + remove$1(_, value) { + return A.UnmodifiableSetMixin__throw(); + } + }; + A._UnmodifiableSetView_DelegatingSet_UnmodifiableSetMixin.prototype = {}; + A._DelegatingIterableBase.prototype = { + any$1(_, test) { + return J.any$1$ax(this.get$_base(), test); + }, + contains$1(_, element) { + return J.contains$1$asx(this.get$_base(), element); + }, + elementAt$1(_, index) { + return J.elementAt$1$ax(this.get$_base(), index); + }, + every$1(_, test) { + return J.every$1$ax(this.get$_base(), test); + }, + get$first(_) { + return J.get$first$ax(this.get$_base()); + }, + get$isEmpty(_) { + return J.get$isEmpty$asx(this.get$_base()); + }, + get$isNotEmpty(_) { + return J.get$isNotEmpty$asx(this.get$_base()); + }, + get$iterator(_) { + return J.get$iterator$ax(this.get$_base()); + }, + get$last(_) { + return J.get$last$ax(this.get$_base()); + }, + get$length(_) { + return J.get$length$asx(this.get$_base()); + }, + map$1$1(_, f, $T) { + return J.map$1$1$ax(this.get$_base(), f, $T); + }, + get$single(_) { + return J.get$single$ax(this.get$_base()); + }, + skip$1(_, n) { + return J.skip$1$ax(this.get$_base(), n); + }, + take$1(_, n) { + return J.take$1$ax(this.get$_base(), n); + }, + toList$1$growable(_, growable) { + return J.toList$1$growable$ax(this.get$_base(), true); + }, + toList$0(_) { + return this.toList$1$growable(0, true); + }, + toSet$0(_) { + return J.toSet$0$ax(this.get$_base()); + }, + where$1(_, test) { + return J.where$1$ax(this.get$_base(), test); + }, + toString$0(_) { + return J.toString$0$(this.get$_base()); + }, + $isIterable: 1 + }; + A.DelegatingSet.prototype = { + add$1(_, value) { + return this._base.add$1(0, value); + }, + addAll$1(_, elements) { + this._base.addAll$1(0, elements); + }, + toSet$0(_) { + return new A.DelegatingSet(this._base.toSet$0(0), A._instanceType(this)._eval$1("DelegatingSet<1>")); + }, + $isEfficientLengthIterable: 1, + $isSet: 1, + get$_base() { + return this._base; + } + }; + A.MapKeySet.prototype = { + get$_base() { + var t1 = this._baseMap; + return t1.get$keys(t1); + }, + contains$1(_, element) { + return this._baseMap.containsKey$1(element); + }, + get$isEmpty(_) { + var t1 = this._baseMap; + return t1.get$isEmpty(t1); + }, + get$isNotEmpty(_) { + var t1 = this._baseMap; + return t1.get$isNotEmpty(t1); + }, + get$length(_) { + var t1 = this._baseMap; + return t1.get$length(t1); + }, + toString$0(_) { + return A.Iterable_iterableToFullString(this, "{", "}"); + }, + difference$1(other) { + return J.where$1$ax(this.get$_base(), new A.MapKeySet_difference_closure(this, other)).toSet$0(0); + }, + $isEfficientLengthIterable: 1, + $isSet: 1 + }; + A.MapKeySet_difference_closure.prototype = { + call$1(element) { + return !this.other._source.contains$1(0, element); + }, + $signature() { + return this.$this.$ti._eval$1("bool(1)"); + } + }; + A._MapKeySet__DelegatingIterableBase_UnmodifiableSetMixin.prototype = {}; + A.BufferModule.prototype = {}; + A.BufferConstants.prototype = {}; + A.Buffer.prototype = {}; + A.ConsoleModule.prototype = {}; + A.Console.prototype = {}; + A.EventEmitter.prototype = {}; + A.FS.prototype = {}; + A.FSConstants.prototype = {}; + A.Realpath.prototype = {}; + A.RealpathSync.prototype = {}; + A.FSWatcher.prototype = {}; + A.ReadStream.prototype = {}; + A.ReadStreamOptions.prototype = {}; + A.WriteStream.prototype = {}; + A.WriteStreamOptions.prototype = {}; + A.FileOptions.prototype = {}; + A.StatOptions.prototype = {}; + A.MkdirOptions.prototype = {}; + A.RmdirOptions.prototype = {}; + A.WatchOptions.prototype = {}; + A.WatchFileOptions.prototype = {}; + A.Stats.prototype = {}; + A.Promise.prototype = {}; + A.Date.prototype = {}; + A.JsError.prototype = {}; + A.Atomics.prototype = {}; + A.Modules.prototype = {}; + A.Module.prototype = {}; + A.Net.prototype = {}; + A.Socket.prototype = {}; + A.NetAddress.prototype = {}; + A.NetServer.prototype = {}; + A.NodeJsError.prototype = {}; + A.JsAssertionError.prototype = {}; + A.JsRangeError.prototype = {}; + A.JsReferenceError.prototype = {}; + A.JsSyntaxError.prototype = {}; + A.JsTypeError.prototype = {}; + A.JsSystemError.prototype = {}; + A.Process.prototype = {}; + A.CPUUsage.prototype = {}; + A.Release.prototype = {}; + A.StreamModule.prototype = {}; + A.Readable.prototype = {}; + A.Writable.prototype = {}; + A.Duplex.prototype = {}; + A.Transform.prototype = {}; + A.WritableOptions.prototype = {}; + A.ReadableOptions.prototype = {}; + A.Immediate.prototype = {}; + A.Timeout.prototype = {}; + A.TTY.prototype = {}; + A.TTYReadStream.prototype = {}; + A.TTYWriteStream.prototype = {}; + A.Util.prototype = {}; + A.promiseToFuture_closure1.prototype = { + call$1(value) { + this.completer.complete$1(value); + }, + $signature: 55 + }; + A.promiseToFuture_closure2.prototype = { + call$1(error) { + this.completer.completeError$1(error); + }, + $signature: 55 + }; + A.futureToPromise_closure.prototype = { + call$2(resolve, reject) { + this.future.then$1$2$onError(0, new A.futureToPromise__closure(resolve, this.T), reject, type$.dynamic); + }, + $signature: 391 + }; + A.futureToPromise__closure.prototype = { + call$1(result) { + return this.resolve.call$1(result); + }, + $signature() { + return this.T._eval$1("@(0)"); + } + }; + A.Context.prototype = { + absolute$15(part1, part2, part3, part4, part5, part6, part7, part8, part9, part10, part11, part12, part13, part14, part15) { + var t1; + A._validateArgList("absolute", A._setArrayType([part1, part2, part3, part4, part5, part6, part7, part8, part9, part10, part11, part12, part13, part14, part15], type$.JSArray_nullable_String)); + if (part2 == null) { + t1 = this.style; + t1 = t1.rootLength$1(part1) > 0 && !t1.isRootRelative$1(part1); + } else + t1 = false; + if (t1) + return part1; + t1 = this._context$_current; + return this.join$16(0, t1 == null ? A.current() : t1, part1, part2, part3, part4, part5, part6, part7, part8, part9, part10, part11, part12, part13, part14, part15); + }, + absolute$1(part1) { + var _null = null; + return this.absolute$15(part1, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null); + }, + dirname$1(path) { + var t1, t2, + parsed = A.ParsedPath_ParsedPath$parse(path, this.style); + parsed.removeTrailingSeparators$0(); + t1 = parsed.parts; + t2 = t1.length; + if (t2 === 0) { + t1 = parsed.root; + return t1 == null ? "." : t1; + } + if (t2 === 1) { + t1 = parsed.root; + return t1 == null ? "." : t1; + } + B.JSArray_methods.removeLast$0(t1); + parsed.separators.pop(); + parsed.removeTrailingSeparators$0(); + return parsed.toString$0(0); + }, + join$16(_, part1, part2, part3, part4, part5, part6, part7, part8, part9, part10, part11, part12, part13, part14, part15, part16) { + var parts = A._setArrayType([part1, part2, part3, part4, part5, part6, part7, part8, part9, part10, part11, part12, part13, part14, part15, part16], type$.JSArray_nullable_String); + A._validateArgList("join", parts); + return this.joinAll$1(new A.WhereTypeIterable(parts, type$.WhereTypeIterable_String)); + }, + join$2(_, part1, part2) { + var _null = null; + return this.join$16(0, part1, part2, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null); + }, + joinAll$1(parts) { + var t1, t2, t3, needsSeparator, isAbsoluteAndNotRootRelative, t4, t5, parsed, path; + for (t1 = J.where$1$ax(parts, new A.Context_joinAll_closure()), t2 = J.get$iterator$ax(t1.__internal$_iterable), t1 = new A.WhereIterator(t2, t1._f), t3 = this.style, needsSeparator = false, isAbsoluteAndNotRootRelative = false, t4 = ""; t1.moveNext$0();) { + t5 = t2.get$current(t2); + if (t3.isRootRelative$1(t5) && isAbsoluteAndNotRootRelative) { + parsed = A.ParsedPath_ParsedPath$parse(t5, t3); + path = t4.charCodeAt(0) == 0 ? t4 : t4; + t4 = B.JSString_methods.substring$2(path, 0, t3.rootLength$2$withDrive(path, true)); + parsed.root = t4; + if (t3.needsSeparator$1(t4)) + parsed.separators[0] = t3.get$separator(t3); + t4 = "" + parsed.toString$0(0); + } else if (t3.rootLength$1(t5) > 0) { + isAbsoluteAndNotRootRelative = !t3.isRootRelative$1(t5); + t4 = "" + t5; + } else { + if (!(t5.length !== 0 && t3.containsSeparator$1(t5[0]))) + if (needsSeparator) + t4 += t3.get$separator(t3); + t4 += t5; + } + needsSeparator = t3.needsSeparator$1(t5); + } + return t4.charCodeAt(0) == 0 ? t4 : t4; + }, + split$1(_, path) { + var parsed = A.ParsedPath_ParsedPath$parse(path, this.style), + t1 = parsed.parts, + t2 = A._arrayInstanceType(t1)._eval$1("WhereIterable<1>"); + t2 = A.List_List$of(new A.WhereIterable(t1, new A.Context_split_closure(), t2), true, t2._eval$1("Iterable.E")); + parsed.parts = t2; + t1 = parsed.root; + if (t1 != null) + B.JSArray_methods.insert$2(t2, 0, t1); + return parsed.parts; + }, + canonicalize$1(_, path) { + var t1, parsed; + path = this.absolute$1(path); + t1 = this.style; + if (t1 !== $.$get$Style_windows() && !this._needsNormalization$1(path)) + return path; + parsed = A.ParsedPath_ParsedPath$parse(path, t1); + parsed.normalize$1$canonicalize(true); + return parsed.toString$0(0); + }, + normalize$1(path) { + var parsed; + if (!this._needsNormalization$1(path)) + return path; + parsed = A.ParsedPath_ParsedPath$parse(path, this.style); + parsed.normalize$0(); + return parsed.toString$0(0); + }, + _needsNormalization$1(path) { + var i, start, previous, t2, t3, previousPrevious, codeUnit, t4, + t1 = this.style, + root = t1.rootLength$1(path); + if (root !== 0) { + if (t1 === $.$get$Style_windows()) + for (i = 0; i < root; ++i) + if (path.charCodeAt(i) === 47) + return true; + start = root; + previous = 47; + } else { + start = 0; + previous = null; + } + for (t2 = new A.CodeUnits(path)._string, t3 = t2.length, i = start, previousPrevious = null; i < t3; ++i, previousPrevious = previous, previous = codeUnit) { + codeUnit = t2.charCodeAt(i); + if (t1.isSeparator$1(codeUnit)) { + if (t1 === $.$get$Style_windows() && codeUnit === 47) + return true; + if (previous != null && t1.isSeparator$1(previous)) + return true; + if (previous === 46) + t4 = previousPrevious == null || previousPrevious === 46 || t1.isSeparator$1(previousPrevious); + else + t4 = false; + if (t4) + return true; + } + } + if (previous == null) + return true; + if (t1.isSeparator$1(previous)) + return true; + if (previous === 46) + t1 = previousPrevious == null || t1.isSeparator$1(previousPrevious) || previousPrevious === 46; + else + t1 = false; + if (t1) + return true; + return false; + }, + relative$2$from(path, from) { + var fromParsed, pathParsed, t2, t3, _this = this, + _s26_ = 'Unable to find a path to "', + t1 = from == null; + if (t1 && _this.style.rootLength$1(path) <= 0) + return _this.normalize$1(path); + if (t1) { + t1 = _this._context$_current; + from = t1 == null ? A.current() : t1; + } else + from = _this.absolute$1(from); + t1 = _this.style; + if (t1.rootLength$1(from) <= 0 && t1.rootLength$1(path) > 0) + return _this.normalize$1(path); + if (t1.rootLength$1(path) <= 0 || t1.isRootRelative$1(path)) + path = _this.absolute$1(path); + if (t1.rootLength$1(path) <= 0 && t1.rootLength$1(from) > 0) + throw A.wrapException(A.PathException$(_s26_ + path + '" from "' + from + '".')); + fromParsed = A.ParsedPath_ParsedPath$parse(from, t1); + fromParsed.normalize$0(); + pathParsed = A.ParsedPath_ParsedPath$parse(path, t1); + pathParsed.normalize$0(); + t2 = fromParsed.parts; + if (t2.length !== 0 && t2[0] === ".") + return pathParsed.toString$0(0); + t2 = fromParsed.root; + t3 = pathParsed.root; + if (t2 != t3) + t2 = t2 == null || t3 == null || !t1.pathsEqual$2(t2, t3); + else + t2 = false; + if (t2) + return pathParsed.toString$0(0); + while (true) { + t2 = fromParsed.parts; + if (t2.length !== 0) { + t3 = pathParsed.parts; + t2 = t3.length !== 0 && t1.pathsEqual$2(t2[0], t3[0]); + } else + t2 = false; + if (!t2) + break; + B.JSArray_methods.removeAt$1(fromParsed.parts, 0); + B.JSArray_methods.removeAt$1(fromParsed.separators, 1); + B.JSArray_methods.removeAt$1(pathParsed.parts, 0); + B.JSArray_methods.removeAt$1(pathParsed.separators, 1); + } + t2 = fromParsed.parts; + t3 = t2.length; + if (t3 !== 0 && t2[0] === "..") + throw A.wrapException(A.PathException$(_s26_ + path + '" from "' + from + '".')); + t2 = type$.String; + B.JSArray_methods.insertAll$2(pathParsed.parts, 0, A.List_List$filled(t3, "..", false, t2)); + t3 = pathParsed.separators; + t3[0] = ""; + B.JSArray_methods.insertAll$2(t3, 1, A.List_List$filled(fromParsed.parts.length, t1.get$separator(t1), false, t2)); + t1 = pathParsed.parts; + t2 = t1.length; + if (t2 === 0) + return "."; + if (t2 > 1 && J.$eq$(B.JSArray_methods.get$last(t1), ".")) { + B.JSArray_methods.removeLast$0(pathParsed.parts); + t1 = pathParsed.separators; + t1.pop(); + t1.pop(); + t1.push(""); + } + pathParsed.root = ""; + pathParsed.removeTrailingSeparators$0(); + return pathParsed.toString$0(0); + }, + relative$1(path) { + return this.relative$2$from(path, null); + }, + _isWithinOrEquals$2($parent, child) { + var relative, t1, parentIsAbsolute, childIsAbsolute, childIsRootRelative, parentIsRootRelative, result, exception, _this = this; + $parent = $parent; + child = child; + t1 = _this.style; + parentIsAbsolute = t1.rootLength$1($parent) > 0; + childIsAbsolute = t1.rootLength$1(child) > 0; + if (parentIsAbsolute && !childIsAbsolute) { + child = _this.absolute$1(child); + if (t1.isRootRelative$1($parent)) + $parent = _this.absolute$1($parent); + } else if (childIsAbsolute && !parentIsAbsolute) { + $parent = _this.absolute$1($parent); + if (t1.isRootRelative$1(child)) + child = _this.absolute$1(child); + } else if (childIsAbsolute && parentIsAbsolute) { + childIsRootRelative = t1.isRootRelative$1(child); + parentIsRootRelative = t1.isRootRelative$1($parent); + if (childIsRootRelative && !parentIsRootRelative) + child = _this.absolute$1(child); + else if (parentIsRootRelative && !childIsRootRelative) + $parent = _this.absolute$1($parent); + } + result = _this._isWithinOrEqualsFast$2($parent, child); + if (result !== B._PathRelation_inconclusive) + return result; + relative = null; + try { + relative = _this.relative$2$from(child, $parent); + } catch (exception) { + if (A.unwrapException(exception) instanceof A.PathException) + return B._PathRelation_different; + else + throw exception; + } + if (t1.rootLength$1(relative) > 0) + return B._PathRelation_different; + if (J.$eq$(relative, ".")) + return B._PathRelation_equal; + if (J.$eq$(relative, "..")) + return B._PathRelation_different; + return J.get$length$asx(relative) >= 3 && J.startsWith$1$s(relative, "..") && t1.isSeparator$1(J.codeUnitAt$1$s(relative, 2)) ? B._PathRelation_different : B._PathRelation_within; + }, + _isWithinOrEqualsFast$2($parent, child) { + var t1, parentRootLength, childRootLength, i, t2, t3, childIndex, parentIndex, lastCodeUnit, lastParentSeparator, parentCodeUnit, childCodeUnit, parentIndex0, direction, _this = this; + if ($parent === ".") + $parent = ""; + t1 = _this.style; + parentRootLength = t1.rootLength$1($parent); + childRootLength = t1.rootLength$1(child); + if (parentRootLength !== childRootLength) + return B._PathRelation_different; + for (i = 0; i < parentRootLength; ++i) + if (!t1.codeUnitsEqual$2($parent.charCodeAt(i), child.charCodeAt(i))) + return B._PathRelation_different; + t2 = child.length; + t3 = $parent.length; + childIndex = childRootLength; + parentIndex = parentRootLength; + lastCodeUnit = 47; + lastParentSeparator = null; + while (true) { + if (!(parentIndex < t3 && childIndex < t2)) + break; + c$0: { + parentCodeUnit = $parent.charCodeAt(parentIndex); + childCodeUnit = child.charCodeAt(childIndex); + if (t1.codeUnitsEqual$2(parentCodeUnit, childCodeUnit)) { + if (t1.isSeparator$1(parentCodeUnit)) + lastParentSeparator = parentIndex; + ++parentIndex; + ++childIndex; + lastCodeUnit = parentCodeUnit; + break c$0; + } + if (t1.isSeparator$1(parentCodeUnit) && t1.isSeparator$1(lastCodeUnit)) { + parentIndex0 = parentIndex + 1; + lastParentSeparator = parentIndex; + parentIndex = parentIndex0; + break c$0; + } else if (t1.isSeparator$1(childCodeUnit) && t1.isSeparator$1(lastCodeUnit)) { + ++childIndex; + break c$0; + } + if (parentCodeUnit === 46 && t1.isSeparator$1(lastCodeUnit)) { + ++parentIndex; + if (parentIndex === t3) + break; + parentCodeUnit = $parent.charCodeAt(parentIndex); + if (t1.isSeparator$1(parentCodeUnit)) { + parentIndex0 = parentIndex + 1; + lastParentSeparator = parentIndex; + parentIndex = parentIndex0; + break c$0; + } + if (parentCodeUnit === 46) { + ++parentIndex; + if (parentIndex === t3 || t1.isSeparator$1($parent.charCodeAt(parentIndex))) + return B._PathRelation_inconclusive; + } + } + if (childCodeUnit === 46 && t1.isSeparator$1(lastCodeUnit)) { + ++childIndex; + if (childIndex === t2) + break; + childCodeUnit = child.charCodeAt(childIndex); + if (t1.isSeparator$1(childCodeUnit)) { + ++childIndex; + break c$0; + } + if (childCodeUnit === 46) { + ++childIndex; + if (childIndex === t2 || t1.isSeparator$1(child.charCodeAt(childIndex))) + return B._PathRelation_inconclusive; + } + } + if (_this._pathDirection$2(child, childIndex) !== B._PathDirection_Wme) + return B._PathRelation_inconclusive; + if (_this._pathDirection$2($parent, parentIndex) !== B._PathDirection_Wme) + return B._PathRelation_inconclusive; + return B._PathRelation_different; + } + } + if (childIndex === t2) { + if (parentIndex === t3 || t1.isSeparator$1($parent.charCodeAt(parentIndex))) + lastParentSeparator = parentIndex; + else if (lastParentSeparator == null) + lastParentSeparator = Math.max(0, parentRootLength - 1); + direction = _this._pathDirection$2($parent, lastParentSeparator); + if (direction === B._PathDirection_dMN) + return B._PathRelation_equal; + return direction === B._PathDirection_vgO ? B._PathRelation_inconclusive : B._PathRelation_different; + } + direction = _this._pathDirection$2(child, childIndex); + if (direction === B._PathDirection_dMN) + return B._PathRelation_equal; + if (direction === B._PathDirection_vgO) + return B._PathRelation_inconclusive; + return t1.isSeparator$1(child.charCodeAt(childIndex)) || t1.isSeparator$1(lastCodeUnit) ? B._PathRelation_within : B._PathRelation_different; + }, + _pathDirection$2(path, index) { + var t1, t2, i, depth, reachedRoot, i0, t3; + for (t1 = path.length, t2 = this.style, i = index, depth = 0, reachedRoot = false; i < t1;) { + while (true) { + if (!(i < t1 && t2.isSeparator$1(path.charCodeAt(i)))) + break; + ++i; + } + if (i === t1) + break; + i0 = i; + while (true) { + if (!(i0 < t1 && !t2.isSeparator$1(path.charCodeAt(i0)))) + break; + ++i0; + } + t3 = i0 - i; + if (!(t3 === 1 && path.charCodeAt(i) === 46)) + if (t3 === 2 && path.charCodeAt(i) === 46 && path.charCodeAt(i + 1) === 46) { + --depth; + if (depth < 0) + break; + if (depth === 0) + reachedRoot = true; + } else + ++depth; + if (i0 === t1) + break; + i = i0 + 1; + } + if (depth < 0) + return B._PathDirection_vgO; + if (depth === 0) + return B._PathDirection_dMN; + if (reachedRoot) + return B._PathDirection_6kc; + return B._PathDirection_Wme; + }, + hash$1(path) { + var result, parsed, t1, _this = this; + path = _this.absolute$1(path); + result = _this._hashFast$1(path); + if (result != null) + return result; + parsed = A.ParsedPath_ParsedPath$parse(path, _this.style); + parsed.normalize$0(); + t1 = _this._hashFast$1(parsed.toString$0(0)); + t1.toString; + return t1; + }, + _hashFast$1(path) { + var t1, t2, hash, beginning, wasSeparator, i, codeUnit, t3, next; + for (t1 = path.length, t2 = this.style, hash = 4603, beginning = true, wasSeparator = true, i = 0; i < t1; ++i) { + codeUnit = t2.canonicalizeCodeUnit$1(path.charCodeAt(i)); + if (t2.isSeparator$1(codeUnit)) { + wasSeparator = true; + continue; + } + if (codeUnit === 46 && wasSeparator) { + t3 = i + 1; + if (t3 === t1) + break; + next = path.charCodeAt(t3); + if (t2.isSeparator$1(next)) + continue; + t3 = false; + if (!beginning) + if (next === 46) { + t3 = i + 2; + t3 = t3 === t1 || t2.isSeparator$1(path.charCodeAt(t3)); + } + if (t3) + return null; + } + hash = ((hash & 67108863) * 33 ^ codeUnit) >>> 0; + beginning = false; + wasSeparator = false; + } + return hash; + }, + withoutExtension$1(path) { + var t1, i, + parsed = A.ParsedPath_ParsedPath$parse(path, this.style); + for (t1 = parsed.parts, i = t1.length - 1; i >= 0; --i) + if (t1[i].length !== 0) { + t1[i] = parsed._splitExtension$0()[0]; + break; + } + return parsed.toString$0(0); + }, + toUri$1(path) { + var t2, + t1 = this.style; + if (t1.rootLength$1(path) <= 0) + return t1.relativePathToUri$1(path); + else { + t2 = this._context$_current; + return t1.absolutePathToUri$1(this.join$2(0, t2 == null ? A.current() : t2, path)); + } + }, + prettyUri$1(uri) { + var path, rel, _this = this, + typedUri = A._parseUri(uri); + if (typedUri.get$scheme() === "file" && _this.style === $.$get$Style_url()) + return typedUri.toString$0(0); + else if (typedUri.get$scheme() !== "file" && typedUri.get$scheme() !== "" && _this.style !== $.$get$Style_url()) + return typedUri.toString$0(0); + path = _this.normalize$1(_this.style.pathFromUri$1(A._parseUri(typedUri))); + rel = _this.relative$1(path); + return _this.split$1(0, rel).length > _this.split$1(0, path).length ? path : rel; + } + }; + A.Context_joinAll_closure.prototype = { + call$1(part) { + return part !== ""; + }, + $signature: 5 + }; + A.Context_split_closure.prototype = { + call$1(part) { + return part.length !== 0; + }, + $signature: 5 + }; + A._validateArgList_closure.prototype = { + call$1(arg) { + return arg == null ? "null" : '"' + arg + '"'; + }, + $signature: 392 + }; + A._PathDirection.prototype = { + toString$0(_) { + return this.name; + } + }; + A._PathRelation.prototype = { + toString$0(_) { + return this.name; + } + }; + A.InternalStyle.prototype = { + getRoot$1(path) { + var $length = this.rootLength$1(path); + if ($length > 0) + return B.JSString_methods.substring$2(path, 0, $length); + return this.isRootRelative$1(path) ? path[0] : null; + }, + relativePathToUri$1(path) { + var segments, _null = null, + t1 = path.length; + if (t1 === 0) + return A._Uri__Uri(_null, _null, _null, _null); + segments = A.Context_Context(this).split$1(0, path); + if (this.isSeparator$1(path.charCodeAt(t1 - 1))) + B.JSArray_methods.add$1(segments, ""); + return A._Uri__Uri(_null, _null, segments, _null); + }, + codeUnitsEqual$2(codeUnit1, codeUnit2) { + return codeUnit1 === codeUnit2; + }, + pathsEqual$2(path1, path2) { + return path1 === path2; + }, + canonicalizeCodeUnit$1(codeUnit) { + return codeUnit; + }, + canonicalizePart$1(part) { + return part; + } + }; + A.ParsedPath.prototype = { + get$basename() { + var _this = this, + t1 = type$.String, + copy = new A.ParsedPath(_this.style, _this.root, _this.isRootRelative, A.List_List$from(_this.parts, true, t1), A.List_List$from(_this.separators, true, t1)); + copy.removeTrailingSeparators$0(); + t1 = copy.parts; + if (t1.length === 0) { + t1 = _this.root; + return t1 == null ? "" : t1; + } + return B.JSArray_methods.get$last(t1); + }, + get$hasTrailingSeparator() { + var t1 = this.parts; + if (t1.length !== 0) + t1 = J.$eq$(B.JSArray_methods.get$last(t1), "") || !J.$eq$(B.JSArray_methods.get$last(this.separators), ""); + else + t1 = false; + return t1; + }, + removeTrailingSeparators$0() { + var t1, t2, _this = this; + while (true) { + t1 = _this.parts; + if (!(t1.length !== 0 && J.$eq$(B.JSArray_methods.get$last(t1), ""))) + break; + B.JSArray_methods.removeLast$0(_this.parts); + _this.separators.pop(); + } + t1 = _this.separators; + t2 = t1.length; + if (t2 !== 0) + t1[t2 - 1] = ""; + }, + normalize$1$canonicalize(canonicalize) { + var t1, t2, t3, leadingDoubles, _i, part, _this = this, + newParts = A._setArrayType([], type$.JSArray_String); + for (t1 = _this.parts, t2 = t1.length, t3 = _this.style, leadingDoubles = 0, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + part = t1[_i]; + if (!(part === "." || part === "")) + if (part === "..") + if (newParts.length !== 0) + newParts.pop(); + else + ++leadingDoubles; + else + newParts.push(canonicalize ? t3.canonicalizePart$1(part) : part); + } + if (_this.root == null) + B.JSArray_methods.insertAll$2(newParts, 0, A.List_List$filled(leadingDoubles, "..", false, type$.String)); + if (newParts.length === 0 && _this.root == null) + newParts.push("."); + _this.parts = newParts; + _this.separators = A.List_List$filled(newParts.length + 1, t3.get$separator(t3), true, type$.String); + t1 = _this.root; + if (t1 == null || newParts.length === 0 || !t3.needsSeparator$1(t1)) + _this.separators[0] = ""; + t1 = _this.root; + if (t1 != null && t3 === $.$get$Style_windows()) { + if (canonicalize) + t1 = _this.root = t1.toLowerCase(); + t1.toString; + _this.root = A.stringReplaceAllUnchecked(t1, "/", "\\"); + } + _this.removeTrailingSeparators$0(); + }, + normalize$0() { + return this.normalize$1$canonicalize(false); + }, + toString$0(_) { + var t2, t3, t4, i, + t1 = this.root; + t1 = t1 != null ? "" + t1 : ""; + for (t2 = this.parts, t3 = t2.length, t4 = this.separators, i = 0; i < t3; ++i) + t1 = t1 + t4[i] + t2[i]; + t1 += A.S(B.JSArray_methods.get$last(t4)); + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _kthLastIndexOf$3(path, character, k) { + var index, count, leftMostIndexedCharacter; + for (index = path.length - 1, count = 0, leftMostIndexedCharacter = 0; index >= 0; --index) + if (path[index] === character) { + ++count; + if (count === k) + return index; + leftMostIndexedCharacter = index; + } + return leftMostIndexedCharacter; + }, + _splitExtension$1(level) { + var t1, file, lastDot; + if (level <= 0) + throw A.wrapException(A.RangeError$value(level, "level", "level's value must be greater than 0")); + t1 = this.parts; + t1 = new A.CastList(t1, A._arrayInstanceType(t1)._eval$1("CastList<1,String?>")); + file = t1.lastWhere$2$orElse(t1, new A.ParsedPath__splitExtension_closure(), new A.ParsedPath__splitExtension_closure0()); + if (file == null) + return A._setArrayType(["", ""], type$.JSArray_String); + if (file === "..") + return A._setArrayType(["..", ""], type$.JSArray_String); + lastDot = this._kthLastIndexOf$3(file, ".", level); + if (lastDot <= 0) + return A._setArrayType([file, ""], type$.JSArray_String); + return A._setArrayType([B.JSString_methods.substring$2(file, 0, lastDot), B.JSString_methods.substring$1(file, lastDot)], type$.JSArray_String); + }, + _splitExtension$0() { + return this._splitExtension$1(1); + } + }; + A.ParsedPath__splitExtension_closure.prototype = { + call$1(p) { + return p !== ""; + }, + $signature: 271 + }; + A.ParsedPath__splitExtension_closure0.prototype = { + call$0() { + return null; + }, + $signature: 1 + }; + A.PathException.prototype = { + toString$0(_) { + return "PathException: " + this.message; + }, + $isException: 1, + get$message(receiver) { + return this.message; + } + }; + A.PathMap.prototype = {}; + A.PathMap__create_closure.prototype = { + call$2(path1, path2) { + if (path1 == null) + return path2 == null; + if (path2 == null) + return false; + return this._box_0.context._isWithinOrEquals$2(path1, path2) === B._PathRelation_equal; + }, + $signature: 450 + }; + A.PathMap__create_closure0.prototype = { + call$1(path) { + return path == null ? 0 : this._box_0.context.hash$1(path); + }, + $signature: 470 + }; + A.PathMap__create_closure1.prototype = { + call$1(path) { + return typeof path == "string" || path == null; + }, + $signature: 482 + }; + A.Style.prototype = { + toString$0(_) { + return this.get$name(this); + } + }; + A.PosixStyle.prototype = { + containsSeparator$1(path) { + return B.JSString_methods.contains$1(path, "/"); + }, + isSeparator$1(codeUnit) { + return codeUnit === 47; + }, + needsSeparator$1(path) { + var t1 = path.length; + return t1 !== 0 && path.charCodeAt(t1 - 1) !== 47; + }, + rootLength$2$withDrive(path, withDrive) { + if (path.length !== 0 && path.charCodeAt(0) === 47) + return 1; + return 0; + }, + rootLength$1(path) { + return this.rootLength$2$withDrive(path, false); + }, + isRootRelative$1(path) { + return false; + }, + pathFromUri$1(uri) { + var t1; + if (uri.get$scheme() === "" || uri.get$scheme() === "file") { + t1 = uri.get$path(uri); + return A._Uri__uriDecode(t1, 0, t1.length, B.C_Utf8Codec, false); + } + throw A.wrapException(A.ArgumentError$("Uri " + uri.toString$0(0) + " must have scheme 'file:'.", null)); + }, + absolutePathToUri$1(path) { + var parsed = A.ParsedPath_ParsedPath$parse(path, this), + t1 = parsed.parts; + if (t1.length === 0) + B.JSArray_methods.addAll$1(t1, A._setArrayType(["", ""], type$.JSArray_String)); + else if (parsed.get$hasTrailingSeparator()) + B.JSArray_methods.add$1(parsed.parts, ""); + return A._Uri__Uri(null, null, parsed.parts, "file"); + }, + get$name() { + return "posix"; + }, + get$separator() { + return "/"; + } + }; + A.UrlStyle.prototype = { + containsSeparator$1(path) { + return B.JSString_methods.contains$1(path, "/"); + }, + isSeparator$1(codeUnit) { + return codeUnit === 47; + }, + needsSeparator$1(path) { + var t1 = path.length; + if (t1 === 0) + return false; + if (path.charCodeAt(t1 - 1) !== 47) + return true; + return B.JSString_methods.endsWith$1(path, "://") && this.rootLength$1(path) === t1; + }, + rootLength$2$withDrive(path, withDrive) { + var i, codeUnit, index, + t1 = path.length; + if (t1 === 0) + return 0; + if (path.charCodeAt(0) === 47) + return 1; + for (i = 0; i < t1; ++i) { + codeUnit = path.charCodeAt(i); + if (codeUnit === 47) + return 0; + if (codeUnit === 58) { + if (i === 0) + return 0; + index = B.JSString_methods.indexOf$2(path, "/", B.JSString_methods.startsWith$2(path, "//", i + 1) ? i + 3 : i); + if (index <= 0) + return t1; + if (!withDrive || t1 < index + 3) + return index; + if (!B.JSString_methods.startsWith$1(path, "file://")) + return index; + t1 = A.driveLetterEnd(path, index + 1); + return t1 == null ? index : t1; + } + } + return 0; + }, + rootLength$1(path) { + return this.rootLength$2$withDrive(path, false); + }, + isRootRelative$1(path) { + return path.length !== 0 && path.charCodeAt(0) === 47; + }, + pathFromUri$1(uri) { + return uri.toString$0(0); + }, + relativePathToUri$1(path) { + return A.Uri_parse(path); + }, + absolutePathToUri$1(path) { + return A.Uri_parse(path); + }, + get$name() { + return "url"; + }, + get$separator() { + return "/"; + } + }; + A.WindowsStyle.prototype = { + containsSeparator$1(path) { + return B.JSString_methods.contains$1(path, "/"); + }, + isSeparator$1(codeUnit) { + return codeUnit === 47 || codeUnit === 92; + }, + needsSeparator$1(path) { + var t1 = path.length; + if (t1 === 0) + return false; + t1 = path.charCodeAt(t1 - 1); + return !(t1 === 47 || t1 === 92); + }, + rootLength$2$withDrive(path, withDrive) { + var index, + t1 = path.length; + if (t1 === 0) + return 0; + if (path.charCodeAt(0) === 47) + return 1; + if (path.charCodeAt(0) === 92) { + if (t1 < 2 || path.charCodeAt(1) !== 92) + return 1; + index = B.JSString_methods.indexOf$2(path, "\\", 2); + if (index > 0) { + index = B.JSString_methods.indexOf$2(path, "\\", index + 1); + if (index > 0) + return index; + } + return t1; + } + if (t1 < 3) + return 0; + if (!A.isAlphabetic(path.charCodeAt(0))) + return 0; + if (path.charCodeAt(1) !== 58) + return 0; + t1 = path.charCodeAt(2); + if (!(t1 === 47 || t1 === 92)) + return 0; + return 3; + }, + rootLength$1(path) { + return this.rootLength$2$withDrive(path, false); + }, + isRootRelative$1(path) { + return this.rootLength$1(path) === 1; + }, + pathFromUri$1(uri) { + var path, t1; + if (uri.get$scheme() !== "" && uri.get$scheme() !== "file") + throw A.wrapException(A.ArgumentError$("Uri " + uri.toString$0(0) + " must have scheme 'file:'.", null)); + path = uri.get$path(uri); + if (uri.get$host() === "") { + if (path.length >= 3 && B.JSString_methods.startsWith$1(path, "/") && A.driveLetterEnd(path, 1) != null) + path = B.JSString_methods.replaceFirst$2(path, "/", ""); + } else + path = "\\\\" + uri.get$host() + path; + t1 = A.stringReplaceAllUnchecked(path, "/", "\\"); + return A._Uri__uriDecode(t1, 0, t1.length, B.C_Utf8Codec, false); + }, + absolutePathToUri$1(path) { + var rootParts, t2, + parsed = A.ParsedPath_ParsedPath$parse(path, this), + t1 = parsed.root; + t1.toString; + if (B.JSString_methods.startsWith$1(t1, "\\\\")) { + rootParts = new A.WhereIterable(A._setArrayType(t1.split("\\"), type$.JSArray_String), new A.WindowsStyle_absolutePathToUri_closure(), type$.WhereIterable_String); + B.JSArray_methods.insert$2(parsed.parts, 0, rootParts.get$last(0)); + if (parsed.get$hasTrailingSeparator()) + B.JSArray_methods.add$1(parsed.parts, ""); + return A._Uri__Uri(rootParts.get$first(0), null, parsed.parts, "file"); + } else { + if (parsed.parts.length === 0 || parsed.get$hasTrailingSeparator()) + B.JSArray_methods.add$1(parsed.parts, ""); + t1 = parsed.parts; + t2 = parsed.root; + t2.toString; + t2 = A.stringReplaceAllUnchecked(t2, "/", ""); + B.JSArray_methods.insert$2(t1, 0, A.stringReplaceAllUnchecked(t2, "\\", "")); + return A._Uri__Uri(null, null, parsed.parts, "file"); + } + }, + codeUnitsEqual$2(codeUnit1, codeUnit2) { + var upperCase1; + if (codeUnit1 === codeUnit2) + return true; + if (codeUnit1 === 47) + return codeUnit2 === 92; + if (codeUnit1 === 92) + return codeUnit2 === 47; + if ((codeUnit1 ^ codeUnit2) !== 32) + return false; + upperCase1 = codeUnit1 | 32; + return upperCase1 >= 97 && upperCase1 <= 122; + }, + pathsEqual$2(path1, path2) { + var t1, i; + if (path1 === path2) + return true; + t1 = path1.length; + if (t1 !== path2.length) + return false; + for (i = 0; i < t1; ++i) + if (!this.codeUnitsEqual$2(path1.charCodeAt(i), path2.charCodeAt(i))) + return false; + return true; + }, + canonicalizeCodeUnit$1(codeUnit) { + if (codeUnit === 47) + return 92; + if (codeUnit < 65) + return codeUnit; + if (codeUnit > 90) + return codeUnit; + return codeUnit | 32; + }, + canonicalizePart$1(part) { + return part.toLowerCase(); + }, + get$name() { + return "windows"; + }, + get$separator() { + return "\\"; + } + }; + A.WindowsStyle_absolutePathToUri_closure.prototype = { + call$1(part) { + return part !== ""; + }, + $signature: 5 + }; + A.Version.prototype = { + get$min() { + return this; + }, + get$max() { + return this; + }, + get$includeMin() { + return true; + }, + get$includeMax() { + return true; + }, + $eq(_, other) { + var _this = this; + if (other == null) + return false; + return other instanceof A.Version && _this.major === other.major && _this.minor === other.minor && _this.patch === other.patch && B.C_IterableEquality.equals$2(0, _this.preRelease, other.preRelease) && B.C_IterableEquality.equals$2(0, _this.build, other.build); + }, + get$hashCode(_) { + var _this = this; + return (_this.major ^ _this.minor ^ _this.patch ^ B.C_IterableEquality.hash$1(_this.preRelease) ^ B.C_IterableEquality.hash$1(_this.build)) >>> 0; + }, + compareTo$1(_, other) { + var t1, t2, t3, comparison, _this = this; + if (other instanceof A.Version) { + t1 = _this.major; + t2 = other.major; + if (t1 !== t2) + return B.JSInt_methods.compareTo$1(t1, t2); + t1 = _this.minor; + t2 = other.minor; + if (t1 !== t2) + return B.JSInt_methods.compareTo$1(t1, t2); + t1 = _this.patch; + t2 = other.patch; + if (t1 !== t2) + return B.JSInt_methods.compareTo$1(t1, t2); + t1 = _this.preRelease; + t2 = t1.length === 0; + if (t2 && other.preRelease.length !== 0) + return 1; + t3 = other.preRelease; + if (t3.length === 0 && !t2) + return -1; + comparison = _this._compareLists$2(t1, t3); + if (comparison !== 0) + return comparison; + t1 = _this.build; + t2 = t1.length === 0; + if (t2 && other.build.length !== 0) + return -1; + t3 = other.build; + if (t3.length === 0 && !t2) + return 1; + return _this._compareLists$2(t1, t3); + } else + return -other.compareTo$1(0, _this); + }, + toString$0(_) { + return this._version$_text; + }, + _compareLists$2(a, b) { + var i, t1, t2, aPart, bPart; + for (i = 0; t1 = a.length, t2 = b.length, i < Math.max(t1, t2); ++i) { + aPart = i < t1 ? a[i] : null; + bPart = i < t2 ? b[i] : null; + if (J.$eq$(aPart, bPart)) + continue; + if (aPart == null) + return -1; + if (bPart == null) + return 1; + if (typeof aPart == "number") + if (typeof bPart == "number") + return B.JSNumber_methods.compareTo$1(aPart, bPart); + else + return -1; + else if (typeof bPart == "number") + return 1; + else { + A._asString(aPart); + A._asString(bPart); + if (aPart === bPart) + t1 = 0; + else + t1 = aPart < bPart ? -1 : 1; + return t1; + } + } + return 0; + }, + $isComparable: 1, + $isVersionRange: 1 + }; + A.Version__splitParts_closure.prototype = { + call$1(part) { + var t1 = A.Primitives_parseInt(part, null); + return t1 == null ? part : t1; + }, + $signature: 596 + }; + A.VersionRange.prototype = { + $eq(_, other) { + var t1; + if (other == null) + return false; + if (!type$.VersionRange._is(other)) + return false; + t1 = false; + if (this.min == other.get$min()) + if (J.$eq$(this.max, other.get$max())) { + t1 = !other.get$includeMin(); + if (t1) + other.get$includeMax(); + } + return t1; + }, + get$hashCode(_) { + var t1 = B.JSNull_methods.get$hashCode(this.min), + t2 = J.get$hashCode$(this.max); + return (t1 ^ t2 * 3 ^ 1090795 ^ 3633126) >>> 0; + }, + allows$1(other) { + var t1 = this.max; + if (t1 != null) + if (other.compareTo$1(0, t1) > 0) + return false; + return true; + }, + compareTo$1(_, other) { + if (other.get$min() == null) + return this._compareMax$1(other); + return -1; + }, + _compareMax$1(other) { + var t2, result, + t1 = this.max; + if (t1 == null) { + if (other.get$max() == null) + return 0; + return 1; + } else if (other.get$max() == null) + return -1; + t2 = other.get$max(); + t2.toString; + result = t1.compareTo$1(0, t2); + if (result !== 0) + return result; + other.get$includeMax(); + return 0; + }, + toString$0(_) { + var t2, + max = this.max, + t1 = max == null; + if (!t1) + t2 = "" + "<=" + max.toString$0(0); + else + t2 = ""; + t1 = t1 ? t2 + "any" : t2; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + $isComparable: 1, + get$min() { + return this.min; + }, + get$max() { + return this.max; + }, + get$includeMin() { + return this.includeMin; + }, + get$includeMax() { + return this.includeMax; + } + }; + A.CssMediaQuery.prototype = { + merge$1(other) { + var t1, ourModifier, t2, t3, ourType, t4, theirModifier, t5, t6, theirType, t7, t8, negativeConditions, conditions, type, modifier, fewerConditions, fewerConditions0, moreConditions, _this = this, _null = null, _s3_ = "all"; + if (!_this.conjunction || !other.conjunction) + return B._SingletonCssMediaQueryMergeResult_1; + t1 = _this.modifier; + ourModifier = t1 == null ? _null : t1.toLowerCase(); + t2 = _this.type; + t3 = t2 == null; + ourType = t3 ? _null : t2.toLowerCase(); + t4 = other.modifier; + theirModifier = t4 == null ? _null : t4.toLowerCase(); + t5 = other.type; + t6 = t5 == null; + theirType = t6 ? _null : t5.toLowerCase(); + t7 = ourType == null; + if (t7 && theirType == null) { + t1 = A.List_List$of(_this.conditions, true, type$.String); + B.JSArray_methods.addAll$1(t1, other.conditions); + return new A.MediaQuerySuccessfulMergeResult(A.CssMediaQuery$condition(t1, true)); + } + t8 = ourModifier === "not"; + if (t8 !== (theirModifier === "not")) { + if (ourType == theirType) { + negativeConditions = t8 ? _this.conditions : other.conditions; + if (B.JSArray_methods.every$1(negativeConditions, B.JSArray_methods.get$contains(t8 ? other.conditions : _this.conditions))) + return B._SingletonCssMediaQueryMergeResult_0; + else + return B._SingletonCssMediaQueryMergeResult_1; + } else if (t3 || A.equalsIgnoreCase(t2, _s3_) || t6 || A.equalsIgnoreCase(t5, _s3_)) + return B._SingletonCssMediaQueryMergeResult_1; + if (t8) { + conditions = other.conditions; + type = theirType; + modifier = theirModifier; + } else { + conditions = _this.conditions; + type = ourType; + modifier = ourModifier; + } + } else if (t8) { + if (ourType != theirType) + return B._SingletonCssMediaQueryMergeResult_1; + fewerConditions = _this.conditions; + fewerConditions0 = other.conditions; + t3 = fewerConditions.length > fewerConditions0.length; + moreConditions = t3 ? fewerConditions : fewerConditions0; + if (t3) + fewerConditions = fewerConditions0; + if (!B.JSArray_methods.every$1(fewerConditions, B.JSArray_methods.get$contains(moreConditions))) + return B._SingletonCssMediaQueryMergeResult_1; + conditions = moreConditions; + type = ourType; + modifier = ourModifier; + } else if (t3 || A.equalsIgnoreCase(t2, _s3_)) { + type = (t6 || A.equalsIgnoreCase(t5, _s3_)) && t7 ? _null : theirType; + t3 = A.List_List$of(_this.conditions, true, type$.String); + B.JSArray_methods.addAll$1(t3, other.conditions); + conditions = t3; + modifier = theirModifier; + } else { + if (t6 || A.equalsIgnoreCase(t5, _s3_)) { + t3 = A.List_List$of(_this.conditions, true, type$.String); + B.JSArray_methods.addAll$1(t3, other.conditions); + conditions = t3; + modifier = ourModifier; + } else { + if (ourType != theirType) + return B._SingletonCssMediaQueryMergeResult_0; + else { + modifier = ourModifier == null ? theirModifier : ourModifier; + t3 = A.List_List$of(_this.conditions, true, type$.String); + B.JSArray_methods.addAll$1(t3, other.conditions); + } + conditions = t3; + } + type = ourType; + } + t2 = type == ourType ? t2 : t5; + return new A.MediaQuerySuccessfulMergeResult(A.CssMediaQuery$type(t2, conditions, modifier == ourModifier ? t1 : t4)); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.CssMediaQuery && other.modifier == this.modifier && other.type == this.type && B.C_ListEquality.equals$2(0, other.conditions, this.conditions); + }, + get$hashCode(_) { + return J.get$hashCode$(this.modifier) ^ J.get$hashCode$(this.type) ^ B.C_ListEquality0.hash$1(this.conditions); + }, + toString$0(_) { + var t2, _this = this, + t1 = _this.modifier; + t1 = t1 != null ? "" + (t1 + " ") : ""; + t2 = _this.type; + if (t2 != null) { + t1 += t2; + if (_this.conditions.length !== 0) + t1 += " and "; + } + t2 = _this.conjunction ? " and " : " or "; + t2 = t1 + B.JSArray_methods.join$1(_this.conditions, t2); + return t2.charCodeAt(0) == 0 ? t2 : t2; + } + }; + A._SingletonCssMediaQueryMergeResult.prototype = { + _enumToString$0() { + return "_SingletonCssMediaQueryMergeResult." + this._name; + } + }; + A.MediaQuerySuccessfulMergeResult.prototype = { + toString$0(_) { + return this.query.toString$0(0); + } + }; + A.ModifiableCssAtRule.prototype = { + accept$1$1(visitor) { + return visitor.visitCssAtRule$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + equalsIgnoringChildren$1(other) { + var t1, t2; + if (other instanceof A.ModifiableCssAtRule) { + t1 = this.name; + t2 = other.name; + t1 = t1.$ti._is(t2) && J.$eq$(t2.value, t1.value) && J.$eq$(this.value, other.value) && this.isChildless === other.isChildless; + } else + t1 = false; + return t1; + }, + copyWithoutChildren$0() { + var _this = this; + return A.ModifiableCssAtRule$(_this.name, _this.span, _this.isChildless, _this.value); + }, + addChild$1(child) { + this.super$ModifiableCssParentNode$addChild(child); + }, + get$isChildless() { + return this.isChildless; + }, + get$span(receiver) { + return this.span; + } + }; + A.ModifiableCssComment.prototype = { + accept$1$1(visitor) { + return visitor.visitCssComment$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + $isCssComment: 1, + get$span(receiver) { + return this.span; + } + }; + A.ModifiableCssDeclaration.prototype = { + accept$1$1(visitor) { + return visitor.visitCssDeclaration$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return this.name.toString$0(0) + ": " + this.value.toString$0(0) + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A.ModifiableCssImport.prototype = { + accept$1$1(visitor) { + return visitor.visitCssImport$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + get$span(receiver) { + return this.span; + } + }; + A.ModifiableCssKeyframeBlock.prototype = { + accept$1$1(visitor) { + return visitor.visitCssKeyframeBlock$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + equalsIgnoringChildren$1(other) { + return other instanceof A.ModifiableCssKeyframeBlock && B.C_ListEquality.equals$2(0, this.selector.value, other.selector.value); + }, + copyWithoutChildren$0() { + return A.ModifiableCssKeyframeBlock$(this.selector, this.span); + }, + get$span(receiver) { + return this.span; + } + }; + A.ModifiableCssMediaRule.prototype = { + accept$1$1(visitor) { + return visitor.visitCssMediaRule$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + equalsIgnoringChildren$1(other) { + return other instanceof A.ModifiableCssMediaRule && B.C_ListEquality.equals$2(0, this.queries, other.queries); + }, + copyWithoutChildren$0() { + return A.ModifiableCssMediaRule$(this.queries, this.span); + }, + get$span(receiver) { + return this.span; + } + }; + A.ModifiableCssNode.prototype = { + get$parent(_) { + return this._parent; + }, + get$hasFollowingSibling() { + var t2, + t1 = this._parent; + if (t1 == null) + t1 = null; + else { + t1 = t1.children; + t2 = this._indexInParent; + t2.toString; + t1 = A.SubListIterable$(t1, t2 + 1, null, t1.$ti._eval$1("ListBase.E")).any$1(0, new A.ModifiableCssNode_hasFollowingSibling_closure()); + } + return t1 === true; + }, + get$isGroupEnd() { + return this.isGroupEnd; + } + }; + A.ModifiableCssNode_hasFollowingSibling_closure.prototype = { + call$1(sibling) { + return !sibling.accept$1(B._IsInvisibleVisitor_true_false); + }, + $signature: 325 + }; + A.ModifiableCssParentNode.prototype = { + get$isChildless() { + return false; + }, + addChild$1(child) { + var t1; + child._parent = this; + t1 = this._children; + child._indexInParent = t1.length; + t1.push(child); + }, + clearChildren$0() { + var t1, t2, _i, child; + for (t1 = this._children, t2 = t1.length, _i = 0; _i < t2; ++_i) { + child = t1[_i]; + child._indexInParent = child._parent = null; + } + B.JSArray_methods.clear$0(t1); + }, + $isCssParentNode: 1, + get$children(receiver) { + return this.children; + } + }; + A.ModifiableCssStyleRule.prototype = { + accept$1$1(visitor) { + return visitor.visitCssStyleRule$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + equalsIgnoringChildren$1(other) { + var t1; + if (other instanceof A.ModifiableCssStyleRule) + t1 = B.C_ListEquality.equals$2(0, other._style_rule$_selector._box$_inner.value.components, this._style_rule$_selector._box$_inner.value.components); + else + t1 = false; + return t1; + }, + copyWithoutChildren$0() { + return A.ModifiableCssStyleRule$(this._style_rule$_selector, this.span, false, this.originalSelector); + }, + $isCssStyleRule: 1, + get$span(receiver) { + return this.span; + } + }; + A.ModifiableCssStylesheet.prototype = { + accept$1$1(visitor) { + return visitor.visitCssStylesheet$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + equalsIgnoringChildren$1(other) { + return other instanceof A.ModifiableCssStylesheet; + }, + copyWithoutChildren$0() { + return A.ModifiableCssStylesheet$(this.span); + }, + $isCssStylesheet: 1, + get$span(receiver) { + return this.span; + } + }; + A.ModifiableCssSupportsRule.prototype = { + accept$1$1(visitor) { + return visitor.visitCssSupportsRule$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + equalsIgnoringChildren$1(other) { + var t1, t2; + if (other instanceof A.ModifiableCssSupportsRule) { + t1 = this.condition; + t2 = other.condition; + t1 = t1.$ti._is(t2) && J.$eq$(t2.value, t1.value); + } else + t1 = false; + return t1; + }, + copyWithoutChildren$0() { + return A.ModifiableCssSupportsRule$(this.condition, this.span); + }, + get$span(receiver) { + return this.span; + } + }; + A.CssNode.prototype = { + toString$0(_) { + var _null = null; + return A.serialize(this, true, _null, true, _null, _null, false, _null, true)._0; + }, + $isAstNode: 1 + }; + A.CssParentNode.prototype = {}; + A._IsInvisibleVisitor.prototype = { + visitCssAtRule$1(rule) { + return false; + }, + visitCssComment$1(comment) { + return this.includeComments && comment.text.charCodeAt(2) !== 33; + }, + visitCssStyleRule$1(rule) { + var t1 = rule._style_rule$_selector._box$_inner; + return (this.includeBogus ? t1.value.accept$1(B._IsInvisibleVisitor_true) : t1.value.accept$1(B._IsInvisibleVisitor_false)) || this.super$EveryCssVisitor$visitCssStyleRule(rule); + } + }; + A.__IsInvisibleVisitor_Object_EveryCssVisitor.prototype = {}; + A.CssStylesheet.prototype = { + get$parent(_) { + return null; + }, + get$isGroupEnd() { + return false; + }, + get$isChildless() { + return false; + }, + accept$1$1(visitor) { + return visitor.visitCssStylesheet$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + get$children(receiver) { + return this.children; + }, + get$span(receiver) { + return this.span; + } + }; + A.CssValue.prototype = { + $eq(_, other) { + if (other == null) + return false; + return this.$ti._is(other) && J.$eq$(other.value, this.value); + }, + get$hashCode(_) { + return J.get$hashCode$(this.value); + }, + toString$0(_) { + return J.toString$0$(this.value); + }, + $isAstNode: 1, + get$span(receiver) { + return this.span; + } + }; + A._FakeAstNode.prototype = { + get$span(_) { + return this._callback.call$0(); + }, + $isAstNode: 1 + }; + A.ArgumentList.prototype = { + get$isEmpty(_) { + var t1; + if (this.positional.length === 0) { + t1 = this.named; + t1 = t1.get$isEmpty(t1) && this.rest == null; + } else + t1 = false; + return t1; + }, + toString$0(_) { + var t2, t3, _i, _1_0, _2_0, _this = this, + t1 = A._setArrayType([], type$.JSArray_String); + for (t2 = _this.positional, t3 = t2.length, _i = 0; _i < t3; ++_i) + t1.push(_this._parenthesizeArgument$1(t2[_i])); + for (t2 = A.MapExtensions_get_pairs(_this.named, type$.String, type$.Expression), t2 = t2.get$iterator(t2); t2.moveNext$0();) { + t3 = t2.get$current(t2); + t1.push("$" + t3._0 + ": " + _this._parenthesizeArgument$1(t3._1)); + } + _1_0 = _this.rest; + if (_1_0 != null) + t1.push(_this._parenthesizeArgument$1(_1_0) + "..."); + _2_0 = _this.keywordRest; + if (_2_0 != null) + t1.push(_this._parenthesizeArgument$1(_2_0) + "..."); + return "(" + B.JSArray_methods.join$1(t1, ", ") + ")"; + }, + _parenthesizeArgument$1(argument) { + var t1; + $label0$0: { + if (argument instanceof A.ListExpression && B.ListSeparator_qVN === argument.separator && !argument.hasBrackets && argument.contents.length >= 2) { + t1 = "(" + argument.toString$0(0) + ")"; + break $label0$0; + } + t1 = argument.toString$0(0); + break $label0$0; + } + return t1; + }, + $isAstNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.AtRootQuery.prototype = { + excludes$1(node) { + var t1, _this = this; + if (_this._all) + return !_this.include; + $label0$0: { + if (node instanceof A.ModifiableCssStyleRule) { + t1 = _this._at_root_query$_rule !== _this.include; + break $label0$0; + } + if (node instanceof A.ModifiableCssMediaRule) { + t1 = _this.excludesName$1("media"); + break $label0$0; + } + if (node instanceof A.ModifiableCssSupportsRule) { + t1 = _this.excludesName$1("supports"); + break $label0$0; + } + if (node instanceof A.ModifiableCssAtRule) { + t1 = _this.excludesName$1(node.name.value.toLowerCase()); + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + excludesName$1($name) { + var t1 = this._all || this.names.contains$1(0, $name); + return t1 !== this.include; + } + }; + A.ConfiguredVariable.prototype = { + toString$0(_) { + var t1 = this.expression.toString$0(0), + t2 = this.isGuarded ? " !default" : ""; + return "$" + this.name + ": " + t1 + t2; + }, + $isAstNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.Expression.prototype = {$isAstNode: 1}; + A.BinaryOperationExpression.prototype = { + get$span(_) { + var right, + left = this.left; + for (; left instanceof A.BinaryOperationExpression;) + left = left.left; + right = this.right; + for (; right instanceof A.BinaryOperationExpression;) + right = right.right; + return left.get$span(left).expand$1(0, right.get$span(right)); + }, + get$operatorSpan() { + var t3, t4, + t1 = this.left, + t2 = t1.get$span(t1); + t2 = t2.get$file(t2); + t3 = this.right; + t4 = t3.get$span(t3); + if (t2 === t4.get$file(t4)) { + t2 = t1.get$span(t1); + t2 = t2.get$end(t2); + t4 = t3.get$span(t3); + t4 = t2.offset < t4.get$start(t4).offset; + t2 = t4; + } else + t2 = false; + if (t2) { + t2 = t1.get$span(t1); + t2 = t2.get$file(t2); + t1 = t1.get$span(t1); + t1 = t1.get$end(t1); + t3 = t3.get$span(t3); + t3 = A.SpanExtensions_trimRight(A.SpanExtensions_trimLeft(t2.span$2(0, t1.offset, t3.get$start(t3).offset))); + t1 = t3; + } else + t1 = this.get$span(0); + return t1; + }, + accept$1$1(visitor) { + return visitor.visitBinaryOperationExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1, t2, right, t3, operator, _this = this, + _0_0 = _this.left; + $label0$0: { + if (_0_0 instanceof A.BinaryOperationExpression) { + t1 = _0_0.operator.precedence < _this.operator.precedence; + break $label0$0; + } + if (_0_0 instanceof A.ListExpression && !_0_0.hasBrackets && _0_0.contents.length >= 2) { + t1 = true; + break $label0$0; + } + t1 = false; + break $label0$0; + } + t2 = t1 ? "" + A.Primitives_stringFromCharCode(40) : ""; + t2 += _0_0.toString$0(0); + t1 = t1 ? t2 + A.Primitives_stringFromCharCode(41) : t2; + t2 = _this.operator; + t1 = t1 + A.Primitives_stringFromCharCode(32) + t2.operator + A.Primitives_stringFromCharCode(32); + right = _this.right; + $label1$1: { + t3 = false; + if (right instanceof A.BinaryOperationExpression) { + operator = right.operator; + if (operator.precedence <= t2.precedence) { + t3 = !(operator === t2 && operator.isAssociative); + t2 = t3; + } else + t2 = t3; + break $label1$1; + } + if (right instanceof A.ListExpression && !right.hasBrackets && right.contents.length >= 2) { + t2 = true; + break $label1$1; + } + t2 = t3; + break $label1$1; + } + if (t2) + t1 += A.Primitives_stringFromCharCode(40); + t1 += right.toString$0(0); + if (t2) + t1 += A.Primitives_stringFromCharCode(41); + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + }; + A.BinaryOperator.prototype = { + _enumToString$0() { + return "BinaryOperator." + this._name; + }, + toString$0(_) { + return this.name; + } + }; + A.BooleanExpression.prototype = { + accept$1$1(visitor) { + return visitor.visitBooleanExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return String(this.value); + }, + get$span(receiver) { + return this.span; + } + }; + A.ColorExpression.prototype = { + accept$1$1(visitor) { + return visitor.visitColorExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return A.serializeValue(this.value, true, true); + }, + get$span(receiver) { + return this.span; + } + }; + A.FunctionExpression.prototype = { + get$nameSpan() { + if (this.namespace == null) + return A.SpanExtensions_initialIdentifier(this.span); + return A.SpanExtensions_initialIdentifier(A.FileSpanExtension_subspan(A.SpanExtensions_withoutInitialIdentifier(this.span), 1, null)); + }, + accept$1$1(visitor) { + return visitor.visitFunctionExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.namespace; + t1 = t1 != null ? "" + (t1 + ".") : ""; + t1 += this.originalName + this.$arguments.toString$0(0); + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + get$span(receiver) { + return this.span; + } + }; + A.IfExpression.prototype = { + accept$1$1(visitor) { + return visitor.visitIfExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "if" + this.$arguments.toString$0(0); + }, + get$span(receiver) { + return this.span; + } + }; + A.InterpolatedFunctionExpression.prototype = { + accept$1$1(visitor) { + return visitor.visitInterpolatedFunctionExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return this.name.toString$0(0) + this.$arguments.toString$0(0); + }, + get$span(receiver) { + return this.span; + } + }; + A.ListExpression.prototype = { + accept$1$1(visitor) { + return visitor.visitListExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t2, t3, t4, t5, _this = this, + t1 = _this.hasBrackets; + if (t1) + t2 = "" + A.Primitives_stringFromCharCode(91); + else { + t2 = _this.contents.length; + if (t2 !== 0) + t2 = t2 === 1 && _this.separator === B.ListSeparator_qVN; + else + t2 = true; + t2 = t2 ? "" + A.Primitives_stringFromCharCode(40) : ""; + } + t3 = _this.contents; + t4 = _this.separator === B.ListSeparator_qVN; + t5 = t4 ? ", " : " "; + t5 = t2 + new A.MappedListIterable(t3, new A.ListExpression_toString_closure(_this), A._arrayInstanceType(t3)._eval$1("MappedListIterable<1,String>")).join$1(0, t5); + if (t1) + t1 = t5 + A.Primitives_stringFromCharCode(93); + else { + t1 = t3.length; + if (t1 === 0) + t1 = t5 + A.Primitives_stringFromCharCode(41); + else + t1 = t1 === 1 && t4 ? t5 + ",)" : t5; + } + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _list0$_elementNeedsParens$1(expression) { + var childSeparator, t1, _0_13; + $label0$0: { + if (expression instanceof A.ListExpression && expression.contents.length >= 2 && !expression.hasBrackets) { + childSeparator = expression.separator; + t1 = this.separator === B.ListSeparator_qVN ? childSeparator === B.ListSeparator_qVN : childSeparator !== B.ListSeparator_undecided_null_undecided; + break $label0$0; + } + if (expression instanceof A.UnaryOperationExpression) { + _0_13 = expression.operator; + if (B.UnaryOperator_Rbl !== _0_13) + t1 = B.UnaryOperator_UCP === _0_13; + else + t1 = true; + } else + t1 = false; + if (t1) { + t1 = this.separator === B.ListSeparator_qSL; + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + get$span(receiver) { + return this.span; + } + }; + A.ListExpression_toString_closure.prototype = { + call$1(element) { + return this.$this._list0$_elementNeedsParens$1(element) ? "(" + element.toString$0(0) + ")" : element.toString$0(0); + }, + $signature: 133 + }; + A.MapExpression.prototype = { + accept$1$1(visitor) { + return visitor.visitMapExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t2, t3, _i, t4, + t1 = A._setArrayType([], type$.JSArray_String); + for (t2 = this.pairs, t3 = t2.length, _i = 0; _i < t3; ++_i) { + t4 = t2[_i]; + t1.push(t4._0.toString$0(0) + ": " + t4._1.toString$0(0)); + } + return "(" + B.JSArray_methods.join$1(t1, ", ") + ")"; + }, + get$span(receiver) { + return this.span; + } + }; + A.NullExpression.prototype = { + accept$1$1(visitor) { + return visitor.visitNullExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "null"; + }, + get$span(receiver) { + return this.span; + } + }; + A.NumberExpression.prototype = { + accept$1$1(visitor) { + return visitor.visitNumberExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return A.serializeValue(A.SassNumber_SassNumber(this.value, this.unit), true, true); + }, + get$span(receiver) { + return this.span; + } + }; + A.ParenthesizedExpression.prototype = { + accept$1$1(visitor) { + return visitor.visitParenthesizedExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "(" + this.expression.toString$0(0) + ")"; + }, + get$span(receiver) { + return this.span; + } + }; + A.SelectorExpression.prototype = { + accept$1$1(visitor) { + return visitor.visitSelectorExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "&"; + }, + get$span(receiver) { + return this.span; + } + }; + A.StringExpression.prototype = { + get$span(_) { + return this.text.span; + }, + accept$1$1(visitor) { + return visitor.visitStringExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + asInterpolation$1$static($static) { + var t1, t2, quote, t3, t4, t5, buffer, t6, i, value, t7; + if (!this.hasQuotes) + return this.text; + t1 = this.text; + t2 = t1.contents; + quote = A.StringExpression__bestQuote(new A.WhereTypeIterable(t2, type$.WhereTypeIterable_String)); + t3 = new A.StringBuffer(""); + t4 = A._setArrayType([], type$.JSArray_Object); + t5 = A._setArrayType([], type$.JSArray_nullable_FileSpan); + buffer = new A.InterpolationBuffer(t3, t4, t5); + t6 = A.Primitives_stringFromCharCode(quote); + t3._contents += t6; + for (t6 = t2.length, i = 0; i < t6; ++i) { + value = t2[i]; + if (value instanceof A.Expression) { + t7 = t1.spanForElement$1(i); + buffer._flushText$0(); + t4.push(value); + t5.push(t7); + continue; + } + if (typeof value == "string") + A.StringExpression__quoteInnerText(value, quote, buffer, $static); + } + t2 = A.Primitives_stringFromCharCode(quote); + t3._contents += t2; + return buffer.interpolation$1(t1.span); + }, + asInterpolation$0() { + return this.asInterpolation$1$static(false); + }, + toString$0(_) { + return this.asInterpolation$0().toString$0(0); + } + }; + A.SupportsExpression.prototype = { + get$span(_) { + var t1 = this.condition; + return t1.get$span(t1); + }, + accept$1$1(visitor) { + return visitor.visitSupportsExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return this.condition.toString$0(0); + } + }; + A.UnaryOperationExpression.prototype = { + accept$1$1(visitor) { + return visitor.visitUnaryOperationExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var operand, + t1 = this.operator, + t2 = t1.operator; + t1 = t1 === B.UnaryOperator_not_not_not ? t2 + A.Primitives_stringFromCharCode(32) : t2; + operand = this.operand; + $label0$0: { + t2 = true; + if (!(operand instanceof A.BinaryOperationExpression)) + if (!(operand instanceof A.UnaryOperationExpression)) + t2 = operand instanceof A.ListExpression && !operand.hasBrackets && operand.contents.length >= 2; + if (t2) + break $label0$0; + break $label0$0; + } + if (t2) + t1 += "40"; + t1 += operand.toString$0(0); + if (t2) + t1 += "41"; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + get$span(receiver) { + return this.span; + } + }; + A.UnaryOperator.prototype = { + _enumToString$0() { + return "UnaryOperator." + this._name; + }, + toString$0(_) { + return this.name; + } + }; + A.ValueExpression.prototype = { + accept$1$1(visitor) { + return visitor.visitValueExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return this.value.toString$0(0); + }, + get$span(receiver) { + return this.span; + } + }; + A.VariableExpression.prototype = { + accept$1$1(visitor) { + return visitor.visitVariableExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return this.span.get$text(); + }, + get$span(receiver) { + return this.span; + } + }; + A.DynamicImport.prototype = { + toString$0(_) { + return A.StringExpression_quoteText(this.urlString); + }, + $isAstNode: 1, + $isImport: 1, + get$span(receiver) { + return this.span; + } + }; + A.StaticImport.prototype = { + toString$0(_) { + var t1 = this.url.toString$0(0), + t2 = this.modifiers; + return t1 + (t2 == null ? "" : " " + t2.toString$0(0)); + }, + $isAstNode: 1, + $isImport: 1, + get$span(receiver) { + return this.span; + } + }; + A.Interpolation.prototype = { + get$asPlain() { + var _0_1, t1, _0_6_isSet, _0_6, _0_60, first, + _0_0 = this.contents; + $label0$0: { + _0_1 = _0_0.length; + if (_0_1 <= 0) { + t1 = ""; + break $label0$0; + } + _0_6_isSet = _0_1 === 1; + if (_0_6_isSet) { + _0_6 = _0_0[0]; + _0_60 = _0_6; + t1 = typeof _0_6 == "string"; + _0_6 = _0_60; + } else { + _0_6 = null; + t1 = false; + } + if (t1) { + first = A._asString(_0_6_isSet ? _0_6 : _0_0[0]); + t1 = first; + break $label0$0; + } + t1 = null; + break $label0$0; + } + return t1; + }, + get$initialPlain() { + var _0_4_isSet, _0_4, _0_40, t1, first, + _0_0 = this.contents; + $label0$0: { + _0_4_isSet = _0_0.length >= 1; + if (_0_4_isSet) { + _0_4 = _0_0[0]; + _0_40 = _0_4; + t1 = typeof _0_4 == "string"; + _0_4 = _0_40; + } else { + _0_4 = null; + t1 = false; + } + if (t1) { + first = A._asString(_0_4_isSet ? _0_4 : _0_0[0]); + t1 = first; + break $label0$0; + } + t1 = ""; + break $label0$0; + } + return t1; + }, + spanForElement$1(index) { + var t1, t2, t3, t4, _this = this; + $label0$0: { + if (typeof _this.contents[index] == "string") { + t1 = _this.span; + t2 = t1.file; + if (index === 0) + t3 = A.FileLocation$_(t2, t1._file$_start); + else { + t3 = _this.spans[index - 1]; + t3 = t3.get$end(t3); + } + t4 = _this.spans; + if (index === t4.length) + t1 = A.FileLocation$_(t2, t1._end); + else { + t1 = t4[index + 1]; + t1 = t1.get$start(t1); + } + t1 = t2.span$2(0, t3.offset, t1.offset); + break $label0$0; + } + t1 = _this.spans[index]; + t1.toString; + break $label0$0; + } + return t1; + }, + Interpolation$3(contents, spans, span) { + var t1, t2, t3, t4, i, t5, isString, _s5_ = "spans", + _s8_ = "contents"; + if (spans.length !== J.get$length$asx(contents)) + throw A.wrapException(A.ArgumentError$value(this.spans, _s5_, "Must be the same length as contents.")); + for (t1 = this.contents, t2 = t1.length, t3 = spans.length, t4 = this.spans, i = 0; i < t2; ++i) { + t5 = t1[i]; + isString = typeof t5 == "string"; + if (!isString && !(t5 instanceof A.Expression)) + throw A.wrapException(A.ArgumentError$value(t1, _s8_, "May only contain Strings or Expressions.")); + else if (isString) { + if (i !== 0 && typeof t1[i - 1] == "string") + throw A.wrapException(A.ArgumentError$value(t1, _s8_, "May not contain adjacent Strings.")); + else if (i < t3 && t4[i] != null) + throw A.wrapException(A.ArgumentError$value(t4, _s5_, string$.May_no + i + ").")); + } else if (i >= t3 || t4[i] == null) + throw A.wrapException(A.ArgumentError$value(t4, _s5_, string$.Must_n + i + ").")); + } + }, + toString$0(_) { + var t1 = this.contents; + return new A.MappedListIterable(t1, new A.Interpolation_toString_closure(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,String>")).join$0(0); + }, + $isAstNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.Interpolation_toString_closure.prototype = { + call$1(value) { + return typeof value == "string" ? value : "#{" + A.S(value) + "}"; + }, + $signature: 132 + }; + A.Parameter.prototype = { + toString$0(_) { + var t1 = this.defaultValue, + t2 = this.name; + return t1 == null ? t2 : t2 + ": " + t1.toString$0(0); + }, + $isAstNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.ParameterList.prototype = { + get$spanWithName() { + var t3, t4, + t1 = this.span, + t2 = t1.file, + text = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t2._decodedChars, 0, null), 0, null), + i = A.FileLocation$_(t2, t1._file$_start).offset - 1; + while (true) { + if (i > 0) { + t3 = text.charCodeAt(i); + t3 = t3 === 32 || t3 === 9 || t3 === 10 || t3 === 13 || t3 === 12; + } else + t3 = false; + if (!t3) + break; + --i; + } + t3 = text.charCodeAt(i); + if (!(t3 === 95 || A.CharacterExtension_get_isAlphabetic(t3) || t3 >= 128)) + t3 = t3 >= 48 && t3 <= 57 || t3 === 45; + else + t3 = true; + if (!t3) + return t1; + --i; + while (true) { + if (i >= 0) { + t3 = text.charCodeAt(i); + if (t3 !== 95) { + if (!(t3 >= 97 && t3 <= 122)) + t4 = t3 >= 65 && t3 <= 90; + else + t4 = true; + t4 = t4 || t3 >= 128; + } else + t4 = true; + if (!t4) + t3 = t3 >= 48 && t3 <= 57 || t3 === 45; + else + t3 = true; + } else + t3 = false; + if (!t3) + break; + --i; + } + t3 = i + 1; + t4 = text.charCodeAt(t3); + if (!(t4 === 95 || A.CharacterExtension_get_isAlphabetic(t4) || t4 >= 128)) + return t1; + return A.SpanExtensions_trimRight(A.SpanExtensions_trimLeft(t2.span$2(0, t3, A.FileLocation$_(t2, t1._end).offset))); + }, + verify$2(positional, names) { + var t1, t2, t3, namedUsed, i, parameter, t4, unknownNames, _this = this, + _s10_ = "invocation"; + for (t1 = _this.parameters, t2 = t1.length, t3 = names._baseMap, namedUsed = 0, i = 0; i < t2; ++i) { + parameter = t1[i]; + if (i < positional) { + t4 = parameter.name; + if (t3.containsKey$1(t4)) + throw A.wrapException(A.SassScriptException$("Argument " + _this._originalParameterName$1(t4) + string$.x20was_p, null)); + } else { + t4 = parameter.name; + if (t3.containsKey$1(t4)) + ++namedUsed; + else if (parameter.defaultValue == null) + throw A.wrapException(A.MultiSpanSassScriptException$("Missing argument " + _this._originalParameterName$1(t4) + ".", _s10_, A.LinkedHashMap_LinkedHashMap$_literal([_this.get$spanWithName(), "declaration"], type$.FileSpan, type$.String))); + } + } + if (_this.restParameter != null) + return; + if (positional > t2) { + t1 = names.get$isEmpty(0) ? "" : "positional "; + throw A.wrapException(A.MultiSpanSassScriptException$("Only " + t2 + " " + t1 + A.pluralize("argument", t2, null) + " allowed, but " + positional + " " + A.pluralize("was", positional, "were") + " passed.", _s10_, A.LinkedHashMap_LinkedHashMap$_literal([_this.get$spanWithName(), "declaration"], type$.FileSpan, type$.String))); + } + if (namedUsed < t3.get$length(t3)) { + t2 = type$.String; + unknownNames = A.LinkedHashSet_LinkedHashSet$of(names, t2); + unknownNames.removeAll$1(new A.MappedListIterable(t1, new A.ParameterList_verify_closure(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Object?>"))); + throw A.wrapException(A.MultiSpanSassScriptException$("No " + A.pluralize("parameter", unknownNames._collection$_length, null) + " named " + A.toSentence(unknownNames.map$1$1(0, new A.ParameterList_verify_closure0(), type$.Object), "or") + ".", _s10_, A.LinkedHashMap_LinkedHashMap$_literal([_this.get$spanWithName(), "declaration"], type$.FileSpan, t2))); + } + }, + _originalParameterName$1($name) { + var t1, text, t2, _i, parameter, t3, end; + if ($name === this.restParameter) { + t1 = this.span; + text = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1.file._decodedChars, t1._file$_start, t1._end), 0, null); + return B.JSString_methods.substring$2(B.JSString_methods.substring$1(text, B.JSString_methods.lastIndexOf$1(text, "$")), 0, B.JSString_methods.indexOf$1(text, ".")); + } + for (t1 = this.parameters, t2 = t1.length, _i = 0; _i < t2; ++_i) { + parameter = t1[_i]; + if (parameter.name === $name) { + t1 = parameter.span; + if (parameter.defaultValue == null) { + t2 = t1._file$_start; + t3 = t1.file._decodedChars; + t3 = A.String_String$fromCharCodes(new Uint32Array(t3.subarray(t2, A._checkValidRange(t2, t1._end, t3.length))), 0, null); + t1 = t3; + } else { + text = t1.get$text(); + t1 = B.JSString_methods.substring$2(text, 0, B.JSString_methods.indexOf$1(text, ":")); + end = A._lastNonWhitespace(t1, false); + t1 = end == null ? "" : B.JSString_methods.substring$2(t1, 0, end + 1); + } + return t1; + } + } + throw A.wrapException(A.ArgumentError$(string$.This_d + $name + '".', null)); + }, + matches$2(positional, names) { + var t1, t2, t3, namedUsed, i, parameter; + for (t1 = this.parameters, t2 = t1.length, t3 = names._baseMap, namedUsed = 0, i = 0; i < t2; ++i) { + parameter = t1[i]; + if (i < positional) { + if (t3.containsKey$1(parameter.name)) + return false; + } else if (t3.containsKey$1(parameter.name)) + ++namedUsed; + else if (parameter.defaultValue == null) + return false; + } + if (this.restParameter != null) + return true; + if (positional > t2) + return false; + if (namedUsed < t3.get$length(t3)) + return false; + return true; + }, + toString$0(_) { + var t2, t3, _i, + t1 = A._setArrayType([], type$.JSArray_String); + for (t2 = this.parameters, t3 = t2.length, _i = 0; _i < t3; ++_i) + t1.push("$" + t2[_i].toString$0(0)); + t2 = this.restParameter; + if (t2 != null) + t1.push("$" + t2 + "..."); + return B.JSArray_methods.join$1(t1, ", "); + }, + $isAstNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.ParameterList_verify_closure.prototype = { + call$1(parameter) { + return parameter.name; + }, + $signature: 342 + }; + A.ParameterList_verify_closure0.prototype = { + call$1($name) { + return "$" + $name; + }, + $signature: 6 + }; + A.Statement.prototype = {$isAstNode: 1}; + A.AtRootRule.prototype = { + accept$1$1(visitor) { + return visitor.visitAtRootRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var buffer = new A.StringBuffer("@at-root "), + t1 = this.query; + if (t1 != null) + buffer._contents = "@at-root " + (t1.toString$0(0) + " "); + t1 = this.children; + return buffer.toString$0(0) + " {" + (t1 && B.JSArray_methods).join$1(t1, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.AtRule.prototype = { + accept$1$1(visitor) { + return visitor.visitAtRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var children, + t1 = "@" + this.name.toString$0(0), + buffer = new A.StringBuffer(t1), + t2 = this.value; + if (t2 != null) + buffer._contents = t1 + (" " + t2.toString$0(0)); + children = this.children; + return children == null ? buffer.toString$0(0) + ";" : buffer.toString$0(0) + " {" + B.JSArray_methods.join$1(children, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.CallableDeclaration.prototype = { + get$span(receiver) { + return this.span; + } + }; + A.ContentBlock.prototype = { + accept$1$1(visitor) { + return visitor.visitContentBlock$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t2, + t1 = this.parameters; + t1 = t1.parameters.length === 0 && t1.restParameter == null ? "" : " using (" + t1.toString$0(0) + ")"; + t2 = this.children; + return t1 + (" {" + (t2 && B.JSArray_methods).join$1(t2, " ") + "}"); + } + }; + A.ContentRule.prototype = { + accept$1$1(visitor) { + return visitor.visitContentRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.$arguments; + return t1.get$isEmpty(0) ? "@content;" : "@content(" + t1.toString$0(0) + ");"; + }, + get$span(receiver) { + return this.span; + } + }; + A.DebugRule.prototype = { + accept$1$1(visitor) { + return visitor.visitDebugRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "@debug " + this.expression.toString$0(0) + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A.Declaration.prototype = { + accept$1$1(visitor) { + return visitor.visitDeclaration$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t3, _0_0, + buffer = new A.StringBuffer(""), + t1 = this.name, + t2 = "" + t1.toString$0(0); + buffer._contents = t2; + t2 = buffer._contents = t2 + A.Primitives_stringFromCharCode(58); + t3 = this.value; + if (t3 != null) { + t1 = !B.JSString_methods.startsWith$1(t1.get$initialPlain(), "--") ? buffer._contents = t2 + A.Primitives_stringFromCharCode(32) : t2; + buffer._contents = t1 + t3.toString$0(0); + } + _0_0 = this.children; + if (_0_0 != null) + return buffer.toString$0(0) + " {" + B.JSArray_methods.join$1(_0_0, " ") + "}"; + else + return buffer.toString$0(0) + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A.EachRule.prototype = { + accept$1$1(visitor) { + return visitor.visitEachRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.variables, + t2 = this.children; + return "@each " + new A.MappedListIterable(t1, new A.EachRule_toString_closure(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,String>")).join$1(0, ", ") + " in " + this.list.toString$0(0) + " {" + (t2 && B.JSArray_methods).join$1(t2, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.EachRule_toString_closure.prototype = { + call$1(variable) { + return "$" + variable; + }, + $signature: 6 + }; + A.ErrorRule.prototype = { + accept$1$1(visitor) { + return visitor.visitErrorRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "@error " + this.expression.toString$0(0) + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A.ExtendRule.prototype = { + accept$1$1(visitor) { + return visitor.visitExtendRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.selector.toString$0(0), + t2 = this.isOptional ? " !optional" : ""; + return "@extend " + t1 + t2 + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A.ForRule.prototype = { + accept$1$1(visitor) { + return visitor.visitForRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var _this = this, + t1 = _this.from.toString$0(0), + t2 = _this.isExclusive ? "to" : "through", + t3 = _this.children; + return "@for $" + _this.variable + " from " + t1 + " " + t2 + " " + _this.to.toString$0(0) + " {" + (t3 && B.JSArray_methods).join$1(t3, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.ForwardRule.prototype = { + accept$1$1(visitor) { + return visitor.visitForwardRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t2, prefix, _this = this, + t1 = "@forward " + A.StringExpression_quoteText(_this.url.toString$0(0)), + shownMixinsAndFunctions = _this.shownMixinsAndFunctions, + hiddenMixinsAndFunctions = _this.hiddenMixinsAndFunctions; + if (shownMixinsAndFunctions != null) { + t2 = _this.shownVariables; + t2.toString; + t2 = t1 + " show " + _this._forward_rule$_memberList$2(shownMixinsAndFunctions, t2); + t1 = t2; + } else if (hiddenMixinsAndFunctions != null && hiddenMixinsAndFunctions._base.get$isNotEmpty(0)) { + t2 = _this.hiddenVariables; + t2.toString; + t2 = t1 + " hide " + _this._forward_rule$_memberList$2(hiddenMixinsAndFunctions, t2); + t1 = t2; + } + prefix = _this.prefix; + if (prefix != null) + t1 += " as " + prefix + "*"; + t2 = _this.configuration; + t1 = (t2.length !== 0 ? t1 + (" with (" + B.JSArray_methods.join$1(t2, ", ") + ")") : t1) + ";"; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _forward_rule$_memberList$2(mixinsAndFunctions, variables) { + var t2, + t1 = A.List_List$of(mixinsAndFunctions, true, type$.String); + for (t2 = variables._base.get$iterator(0); t2.moveNext$0();) + t1.push("$" + t2.get$current(0)); + return B.JSArray_methods.join$1(t1, ", "); + }, + get$span(receiver) { + return this.span; + } + }; + A.FunctionRule.prototype = { + accept$1$1(visitor) { + return visitor.visitFunctionRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.children; + return "@function " + this.name + "(" + this.parameters.toString$0(0) + ") {" + (t1 && B.JSArray_methods).join$1(t1, " ") + "}"; + } + }; + A.IfRule.prototype = { + accept$1$1(visitor) { + return visitor.visitIfRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var result = A.ListExtensions_mapIndexed(this.clauses, new A.IfRule_toString_closure(), type$.IfClause, type$.String).join$1(0, " "), + lastClause = this.lastClause; + return lastClause != null ? result + (" " + lastClause.toString$0(0)) : result; + }, + get$span(receiver) { + return this.span; + } + }; + A.IfRule_toString_closure.prototype = { + call$2(index, clause) { + var t1 = index === 0 ? "if" : "else if"; + return "@" + t1 + " " + clause.expression.toString$0(0) + " {" + B.JSArray_methods.join$1(clause.children, " ") + "}"; + }, + $signature: 395 + }; + A.IfRuleClause.prototype = {}; + A.IfRuleClause$__closure.prototype = { + call$1(child) { + var t1; + $label0$0: { + if (child instanceof A.VariableDeclaration || child instanceof A.FunctionRule || child instanceof A.MixinRule) { + t1 = true; + break $label0$0; + } + if (child instanceof A.ImportRule) { + t1 = B.JSArray_methods.any$1(child.imports, new A.IfRuleClause$___closure()); + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + $signature: 150 + }; + A.IfRuleClause$___closure.prototype = { + call$1($import) { + return $import instanceof A.DynamicImport; + }, + $signature: 151 + }; + A.IfClause.prototype = { + toString$0(_) { + return "@if " + this.expression.toString$0(0) + " {" + B.JSArray_methods.join$1(this.children, " ") + "}"; + } + }; + A.ElseClause.prototype = { + toString$0(_) { + return "@else {" + B.JSArray_methods.join$1(this.children, " ") + "}"; + } + }; + A.ImportRule.prototype = { + accept$1$1(visitor) { + return visitor.visitImportRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "@import " + B.JSArray_methods.join$1(this.imports, ", ") + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A.IncludeRule.prototype = { + get$spanWithoutContent() { + var t2, t3, + t1 = this.span; + if (!(this.content == null)) { + t2 = t1.file; + t3 = this.$arguments.span; + t3 = A.SpanExtensions_trimRight(A.SpanExtensions_trimLeft(t2.span$2(0, A.FileLocation$_(t2, t1._file$_start).offset, t3.get$end(t3).offset))); + t1 = t3; + } + return t1; + }, + get$nameSpan() { + var startSpan, scanner, _null = null, + t1 = this.span, + t2 = t1._file$_start, + t3 = t1._end, + t4 = t1.file._decodedChars; + if (B.JSString_methods.startsWith$1(A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t4, t2, t3), 0, _null), "+")) + startSpan = A.SpanExtensions_trimLeft(A.FileSpanExtension_subspan(t1, 1, _null)); + else { + scanner = A.StringScanner$(A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t4, t2, t3), 0, _null), _null, _null); + scanner.expectChar$1(64); + A._scanIdentifier(scanner); + startSpan = A.SpanExtensions_trimLeft(A.FileSpanExtension_subspan(t1, scanner._string_scanner$_position, _null)); + } + return A.SpanExtensions_initialIdentifier(this.namespace != null ? A.FileSpanExtension_subspan(A.SpanExtensions_withoutInitialIdentifier(startSpan), 1, _null) : startSpan); + }, + accept$1$1(visitor) { + return visitor.visitIncludeRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t2, _this = this, + t1 = _this.namespace; + t1 = t1 != null ? "@include " + (t1 + ".") : "@include "; + t1 += _this.name; + t2 = _this.$arguments; + if (!t2.get$isEmpty(0)) + t1 += "(" + t2.toString$0(0) + ")"; + t2 = _this.content; + t1 += t2 == null ? ";" : " " + t2.toString$0(0); + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + get$span(receiver) { + return this.span; + } + }; + A.LoudComment.prototype = { + get$span(_) { + return this.text.span; + }, + accept$1$1(visitor) { + return visitor.visitLoudComment$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return this.text.toString$0(0); + } + }; + A.MediaRule.prototype = { + accept$1$1(visitor) { + return visitor.visitMediaRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.children; + return "@media " + this.query.toString$0(0) + " {" + (t1 && B.JSArray_methods).join$1(t1, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.MixinRule.prototype = { + get$hasContent() { + var result, _this = this, + value = _this.__MixinRule_hasContent_FI; + if (value === $) { + result = J.$eq$(B.C__HasContentVisitor.visitChildren$1(_this.children), true); + _this.__MixinRule_hasContent_FI !== $ && A.throwUnnamedLateFieldADI(); + _this.__MixinRule_hasContent_FI = result; + value = result; + } + return value; + }, + accept$1$1(visitor) { + return visitor.visitMixinRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = "@mixin " + this.name, + t2 = this.parameters; + if (!(t2.parameters.length === 0 && t2.restParameter == null)) + t1 += "(" + t2.toString$0(0) + ")"; + t2 = this.children; + t2 = t1 + (" {" + (t2 && B.JSArray_methods).join$1(t2, " ") + "}"); + return t2.charCodeAt(0) == 0 ? t2 : t2; + } + }; + A._HasContentVisitor.prototype = { + visitContentRule$1(_, _0) { + return true; + } + }; + A.__HasContentVisitor_Object_StatementSearchVisitor.prototype = {}; + A.ParentStatement.prototype = {}; + A.ParentStatement_closure.prototype = { + call$1(child) { + var t1; + $label0$0: { + if (child instanceof A.VariableDeclaration || child instanceof A.FunctionRule || child instanceof A.MixinRule) { + t1 = true; + break $label0$0; + } + if (child instanceof A.ImportRule) { + t1 = B.JSArray_methods.any$1(child.imports, new A.ParentStatement__closure()); + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + $signature: 150 + }; + A.ParentStatement__closure.prototype = { + call$1($import) { + return $import instanceof A.DynamicImport; + }, + $signature: 151 + }; + A.ReturnRule.prototype = { + accept$1$1(visitor) { + return visitor.visitReturnRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "@return " + this.expression.toString$0(0) + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A.SilentComment.prototype = { + accept$1$1(visitor) { + return visitor.visitSilentComment$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return this.text; + }, + get$span(receiver) { + return this.span; + } + }; + A.StyleRule.prototype = { + accept$1$1(visitor) { + return visitor.visitStyleRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.children; + return this.selector.toString$0(0) + " {" + (t1 && B.JSArray_methods).join$1(t1, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.Stylesheet.prototype = { + Stylesheet$internal$5$globalVariables$plainCss(children, span, parseTimeWarnings, globalVariables, plainCss) { + var t1, t2, t3, t4, _i, child; + for (t1 = this.children, t2 = t1.length, t3 = this._forwards, t4 = this._uses, _i = 0; _i < t2; ++_i) { + child = t1[_i]; + if (child instanceof A.UseRule) { + t4.push(child); + continue; + } + if (child instanceof A.ForwardRule) { + t3.push(child); + continue; + } + if (child instanceof A.SilentComment || child instanceof A.LoudComment || child instanceof A.VariableDeclaration) + continue; + break; + } + }, + accept$1$1(visitor) { + return visitor.visitStylesheet$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.children; + return (t1 && B.JSArray_methods).join$1(t1, " "); + }, + get$span(receiver) { + return this.span; + } + }; + A.SupportsRule.prototype = { + accept$1$1(visitor) { + return visitor.visitSupportsRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.children; + return "@supports " + this.condition.toString$0(0) + " {" + (t1 && B.JSArray_methods).join$1(t1, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.UseRule.prototype = { + UseRule$4$configuration(url, namespace, span, configuration) { + var t1, t2, _i, variable; + for (t1 = this.configuration, t2 = t1.length, _i = 0; _i < t2; ++_i) { + variable = t1[_i]; + if (variable.isGuarded) + throw A.wrapException(A.ArgumentError$value(variable, "configured variable", "can't be guarded in a @use rule.")); + } + }, + accept$1$1(visitor) { + return visitor.visitUseRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.url, + t2 = "@use " + A.StringExpression_quoteText(t1.toString$0(0)), + basename = t1.get$pathSegments().length === 0 ? "" : B.JSArray_methods.get$last(t1.get$pathSegments()), + dot = B.JSString_methods.indexOf$1(basename, "."); + t1 = this.namespace; + if (t1 !== B.JSString_methods.substring$2(basename, 0, dot === -1 ? basename.length : dot)) + t1 = t2 + (" as " + (t1 == null ? "*" : t1)); + else + t1 = t2; + t2 = this.configuration; + t1 = (t2.length !== 0 ? t1 + (" with (" + B.JSArray_methods.join$1(t2, ", ") + ")") : t1) + ";"; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + get$span(receiver) { + return this.span; + } + }; + A.VariableDeclaration.prototype = { + accept$1$1(visitor) { + return visitor.visitVariableDeclaration$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.namespace; + t1 = t1 != null ? "" + (t1 + ".") : ""; + t1 += "$" + this.name + ": " + this.expression.toString$0(0) + ";"; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + get$span(receiver) { + return this.span; + } + }; + A.WarnRule.prototype = { + accept$1$1(visitor) { + return visitor.visitWarnRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "@warn " + this.expression.toString$0(0) + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A.WhileRule.prototype = { + accept$1$1(visitor) { + return visitor.visitWhileRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.children; + return "@while " + this.condition.toString$0(0) + " {" + (t1 && B.JSArray_methods).join$1(t1, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.SupportsAnything.prototype = { + withSpan$1(span) { + return new A.SupportsAnything(this.contents, span); + }, + toString$0(_) { + return "(" + this.contents.toString$0(0) + ")"; + }, + $isAstNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.SupportsDeclaration.prototype = { + get$isCustomProperty() { + var t1, + _0_0 = this.name; + $label0$0: { + if (_0_0 instanceof A.StringExpression && !_0_0.hasQuotes) { + t1 = B.JSString_methods.startsWith$1(_0_0.text.get$initialPlain(), "--"); + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + withSpan$1(span) { + return new A.SupportsDeclaration(this.name, this.value, span); + }, + toString$0(_) { + return "(" + this.name.toString$0(0) + ": " + this.value.toString$0(0) + ")"; + }, + $isAstNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.SupportsFunction.prototype = { + withSpan$1(span) { + return new A.SupportsFunction(this.name, this.$arguments, span); + }, + toString$0(_) { + return this.name.toString$0(0) + "(" + this.$arguments.toString$0(0) + ")"; + }, + $isAstNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.SupportsInterpolation.prototype = { + withSpan$1(span) { + return new A.SupportsInterpolation(this.expression, span); + }, + toString$0(_) { + return "#{" + this.expression.toString$0(0) + "}"; + }, + $isAstNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.SupportsNegation.prototype = { + withSpan$1(span) { + return new A.SupportsNegation(this.condition, span); + }, + toString$0(_) { + var t1 = this.condition; + if (t1 instanceof A.SupportsNegation || t1 instanceof A.SupportsOperation) + return "not (" + t1.toString$0(0) + ")"; + else + return "not " + t1.toString$0(0); + }, + $isAstNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.SupportsOperation.prototype = { + withSpan$1(span) { + return A.SupportsOperation$(this.left, this.right, this.operator, span); + }, + toString$0(_) { + var _this = this; + return _this._parenthesize$1(_this.left) + " " + _this.operator + " " + _this._parenthesize$1(_this.right); + }, + _parenthesize$1(condition) { + var t1; + if (!(condition instanceof A.SupportsNegation)) + t1 = condition instanceof A.SupportsOperation && condition.operator === this.operator; + else + t1 = true; + return t1 ? "(" + condition.toString$0(0) + ")" : condition.toString$0(0); + }, + $isAstNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.Selector.prototype = { + assertNotBogus$1$name($name) { + if (!this.accept$1(B._IsBogusVisitor_true)) + return; + A.warnForDeprecation("$" + $name + ": " + (this.toString$0(0) + string$.x20is_nov), B.Deprecation_9hF); + }, + toString$0(_) { + var _null = null, + visitor = A._SerializeVisitor$(_null, true, _null, _null, true, false, _null, true); + this.accept$1(visitor); + return visitor._serialize$_buffer.toString$0(0); + }, + $isAstNode: 1, + get$span(receiver) { + return this.span; + } + }; + A._IsInvisibleVisitor0.prototype = { + visitSelectorList$1(list) { + return B.JSArray_methods.every$1(list.components, this.get$visitComplexSelector()); + }, + visitComplexSelector$1(complex) { + var t1; + if (!this.super$AnySelectorVisitor$visitComplexSelector(complex)) + t1 = this.includeBogus && complex.accept$1(B._IsBogusVisitor_false); + else + t1 = true; + return t1; + }, + visitPlaceholderSelector$1(placeholder) { + return true; + }, + visitPseudoSelector$1(pseudo) { + var t1, + _0_0 = pseudo.selector; + if (_0_0 != null) { + if (pseudo.name === "not") + t1 = this.includeBogus && _0_0.accept$1(B._IsBogusVisitor_true); + else + t1 = this.visitSelectorList$1(_0_0); + return t1; + } else + return false; + } + }; + A._IsBogusVisitor.prototype = { + visitComplexSelector$1(complex) { + var t2, + t1 = complex.components; + if (t1.length === 0) + return complex.leadingCombinators.length !== 0; + else { + t2 = this.includeLeadingCombinator ? 0 : 1; + return complex.leadingCombinators.length > t2 || B.JSArray_methods.get$last(t1).combinators.length !== 0 || B.JSArray_methods.any$1(t1, new A._IsBogusVisitor_visitComplexSelector_closure(this)); + } + }, + visitPseudoSelector$1(pseudo) { + var selector = pseudo.selector; + if (selector == null) + return false; + return pseudo.name === "has" ? selector.accept$1(B._IsBogusVisitor_false) : selector.accept$1(B._IsBogusVisitor_true); + } + }; + A._IsBogusVisitor_visitComplexSelector_closure.prototype = { + call$1(component) { + return component.combinators.length > 1 || this.$this.visitCompoundSelector$1(component.selector); + }, + $signature: 53 + }; + A._IsUselessVisitor.prototype = { + visitComplexSelector$1(complex) { + return complex.leadingCombinators.length > 1 || B.JSArray_methods.any$1(complex.components, new A._IsUselessVisitor_visitComplexSelector_closure(this)); + }, + visitPseudoSelector$1(pseudo) { + return pseudo.accept$1(B._IsBogusVisitor_true); + } + }; + A._IsUselessVisitor_visitComplexSelector_closure.prototype = { + call$1(component) { + return component.combinators.length > 1 || this.$this.visitCompoundSelector$1(component.selector); + }, + $signature: 53 + }; + A.__IsBogusVisitor_Object_AnySelectorVisitor.prototype = {}; + A.__IsInvisibleVisitor_Object_AnySelectorVisitor.prototype = {}; + A.__IsUselessVisitor_Object_AnySelectorVisitor.prototype = {}; + A.AttributeSelector.prototype = { + accept$1$1(visitor) { + return visitor.visitAttributeSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + $eq(_, other) { + var _this = this; + if (other == null) + return false; + return other instanceof A.AttributeSelector && other.name.$eq(0, _this.name) && other.op == _this.op && other.value == _this.value && other.modifier == _this.modifier; + }, + get$hashCode(_) { + var _this = this, + t1 = _this.name; + return (B.JSString_methods.get$hashCode(t1.name) ^ J.get$hashCode$(t1.namespace) ^ J.get$hashCode$(_this.op) ^ J.get$hashCode$(_this.value) ^ J.get$hashCode$(_this.modifier)) >>> 0; + } + }; + A.AttributeOperator.prototype = { + _enumToString$0() { + return "AttributeOperator." + this._name; + }, + toString$0(_) { + return this._attribute$_text; + } + }; + A.ClassSelector.prototype = { + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.ClassSelector && other.name === this.name; + }, + accept$1$1(visitor) { + return visitor.visitClassSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + addSuffix$1(suffix) { + return new A.ClassSelector(this.name + suffix, this.span); + }, + get$hashCode(_) { + return B.JSString_methods.get$hashCode(this.name); + } + }; + A.Combinator.prototype = { + _enumToString$0() { + return "Combinator." + this._name; + }, + toString$0(_) { + return this._combinator$_text; + } + }; + A.ComplexSelector.prototype = { + get$specificity() { + var result, _this = this, + value = _this.__ComplexSelector_specificity_FI; + if (value === $) { + result = B.JSArray_methods.fold$2(_this.components, 0, new A.ComplexSelector_specificity_closure()); + _this.__ComplexSelector_specificity_FI !== $ && A.throwUnnamedLateFieldADI(); + _this.__ComplexSelector_specificity_FI = result; + value = result; + } + return value; + }, + get$singleCompound() { + var _0_0, t1, _0_4, selector; + if (this.leadingCombinators.length !== 0) + return null; + _0_0 = this.components; + $label0$0: { + t1 = false; + if (_0_0.length === 1) { + _0_4 = _0_0[0]; + selector = _0_4.selector; + t1 = _0_4.combinators.length <= 0; + } else + selector = null; + if (t1) { + t1 = selector; + break $label0$0; + } + t1 = null; + break $label0$0; + } + return t1; + }, + accept$1$1(visitor) { + return visitor.visitComplexSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + isSuperselector$1(other) { + return this.leadingCombinators.length === 0 && other.leadingCombinators.length === 0 && A.complexIsSuperselector(this.components, other.components); + }, + withAdditionalCombinators$1(combinators) { + var _0_0, _0_1, t1, initial, last, _this = this; + if (combinators.length === 0) + return _this; + _0_0 = _this.components; + $label0$0: { + _0_1 = _0_0.length; + if (_0_1 >= 1) { + t1 = _0_1 - 1; + initial = B.JSArray_methods.sublist$2(_0_0, 0, t1); + last = _0_0[t1]; + t1 = A.List_List$of(initial, true, type$.ComplexSelectorComponent); + t1.push(last.withAdditionalCombinators$1(combinators)); + t1 = A.ComplexSelector$(_this.leadingCombinators, t1, _this.span, _this.lineBreak); + break $label0$0; + } + if (_0_1 <= 0) { + t1 = A.List_List$of(_this.leadingCombinators, true, type$.CssValue_Combinator); + B.JSArray_methods.addAll$1(t1, combinators); + t1 = A.ComplexSelector$(t1, B.List_empty2, _this.span, _this.lineBreak); + break $label0$0; + } + t1 = null; + } + return t1; + }, + concatenate$3$forceLineBreak(child, span, forceLineBreak) { + var t2, _0_1, initial, last, _this = this, + t1 = child.leadingCombinators, + _0_0 = _this.components; + if (t1.length === 0) { + t1 = A.List_List$of(_0_0, true, type$.ComplexSelectorComponent); + B.JSArray_methods.addAll$1(t1, child.components); + t2 = _this.lineBreak || child.lineBreak || forceLineBreak; + return A.ComplexSelector$(_this.leadingCombinators, t1, span, t2); + } else { + _0_1 = _0_0.length; + if (_0_1 >= 1) { + t2 = _0_1 - 1; + initial = B.JSArray_methods.sublist$2(_0_0, 0, t2); + last = _0_0[t2]; + t2 = A.List_List$of(initial, true, type$.ComplexSelectorComponent); + t2.push(last.withAdditionalCombinators$1(t1)); + B.JSArray_methods.addAll$1(t2, child.components); + t1 = _this.lineBreak || child.lineBreak || forceLineBreak; + return A.ComplexSelector$(_this.leadingCombinators, t2, span, t1); + } else { + t2 = A.List_List$of(_this.leadingCombinators, true, type$.CssValue_Combinator); + B.JSArray_methods.addAll$1(t2, t1); + t1 = _this.lineBreak || child.lineBreak || forceLineBreak; + return A.ComplexSelector$(t2, child.components, span, t1); + } + } + }, + concatenate$2(child, span) { + return this.concatenate$3$forceLineBreak(child, span, false); + }, + get$hashCode(_) { + return B.C_ListEquality0.hash$1(this.leadingCombinators) ^ B.C_ListEquality0.hash$1(this.components); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.ComplexSelector && B.C_ListEquality.equals$2(0, this.leadingCombinators, other.leadingCombinators) && B.C_ListEquality.equals$2(0, this.components, other.components); + } + }; + A.ComplexSelector_specificity_closure.prototype = { + call$2(sum, component) { + return sum + component.selector.get$specificity(); + }, + $signature: 359 + }; + A.ComplexSelectorComponent.prototype = { + withAdditionalCombinators$1(combinators) { + var t1, t2, _this = this; + if (combinators.length === 0) + t1 = _this; + else { + t1 = type$.CssValue_Combinator; + t2 = A.List_List$of(_this.combinators, true, t1); + B.JSArray_methods.addAll$1(t2, combinators); + t1 = new A.ComplexSelectorComponent(_this.selector, A.List_List$unmodifiable(t2, t1), _this.span); + } + return t1; + }, + get$hashCode(_) { + return B.C_ListEquality0.hash$1(this.selector.components) ^ B.C_ListEquality0.hash$1(this.combinators); + }, + $eq(_, other) { + var t1; + if (other == null) + return false; + if (other instanceof A.ComplexSelectorComponent) { + t1 = B.C_ListEquality.equals$2(0, this.selector.components, other.selector.components); + t1 = t1 && B.C_ListEquality.equals$2(0, this.combinators, other.combinators); + } else + t1 = false; + return t1; + }, + toString$0(_) { + var t1 = this.combinators; + return A.serializeSelector(this.selector, true) + new A.MappedListIterable(t1, new A.ComplexSelectorComponent_toString_closure(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,String>")).join$1(0, ""); + } + }; + A.ComplexSelectorComponent_toString_closure.prototype = { + call$1(combinator) { + return " " + combinator.toString$0(0); + }, + $signature: 440 + }; + A.CompoundSelector.prototype = { + get$specificity() { + var result, _this = this, + value = _this.__CompoundSelector_specificity_FI; + if (value === $) { + result = B.JSArray_methods.fold$2(_this.components, 0, new A.CompoundSelector_specificity_closure()); + _this.__CompoundSelector_specificity_FI !== $ && A.throwUnnamedLateFieldADI(); + _this.__CompoundSelector_specificity_FI = result; + value = result; + } + return value; + }, + get$hasComplicatedSuperselectorSemantics() { + var result, _this = this, + value = _this.__CompoundSelector_hasComplicatedSuperselectorSemantics_FI; + if (value === $) { + result = B.JSArray_methods.any$1(_this.components, new A.CompoundSelector_hasComplicatedSuperselectorSemantics_closure()); + _this.__CompoundSelector_hasComplicatedSuperselectorSemantics_FI !== $ && A.throwUnnamedLateFieldADI(); + _this.__CompoundSelector_hasComplicatedSuperselectorSemantics_FI = result; + value = result; + } + return value; + }, + accept$1$1(visitor) { + return visitor.visitCompoundSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + get$hashCode(_) { + return B.C_ListEquality0.hash$1(this.components); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.CompoundSelector && B.C_ListEquality.equals$2(0, this.components, other.components); + } + }; + A.CompoundSelector_specificity_closure.prototype = { + call$2(sum, component) { + return sum + component.get$specificity(); + }, + $signature: 444 + }; + A.CompoundSelector_hasComplicatedSuperselectorSemantics_closure.prototype = { + call$1(component) { + return component.get$hasComplicatedSuperselectorSemantics(); + }, + $signature: 13 + }; + A.IDSelector.prototype = { + get$specificity() { + return A._asInt(Math.pow(A.SimpleSelector.prototype.get$specificity.call(this), 2)); + }, + accept$1$1(visitor) { + return visitor.visitIDSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + addSuffix$1(suffix) { + return new A.IDSelector(this.name + suffix, this.span); + }, + unify$1(compound) { + if (B.JSArray_methods.any$1(compound, new A.IDSelector_unify_closure(this))) + return null; + return this.super$SimpleSelector$unify(compound); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.IDSelector && other.name === this.name; + }, + get$hashCode(_) { + return B.JSString_methods.get$hashCode(this.name); + } + }; + A.IDSelector_unify_closure.prototype = { + call$1(simple) { + var t1; + if (simple instanceof A.IDSelector) + t1 = this.$this.name !== simple.name; + else + t1 = false; + return t1; + }, + $signature: 13 + }; + A.SelectorList.prototype = { + get$asSassList() { + var t1 = this.components; + return A.SassList$(new A.MappedListIterable(t1, new A.SelectorList_asSassList_closure(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Value>")), B.ListSeparator_qVN, false); + }, + accept$1$1(visitor) { + return visitor.visitSelectorList$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + unify$1(other) { + var t3, t4, t5, t6, _i, complex1, t7, _i0, t8, + t1 = type$.JSArray_ComplexSelector, + t2 = A._setArrayType([], t1); + for (t3 = this.components, t4 = t3.length, t5 = other.components, t6 = t5.length, _i = 0; _i < t4; ++_i) { + complex1 = t3[_i]; + for (t7 = complex1.span, _i0 = 0; _i0 < t6; ++_i0) { + t8 = A.unifyComplex(A._setArrayType([complex1, t5[_i0]], t1), t7); + if (t8 != null) + B.JSArray_methods.addAll$1(t2, t8); + } + } + return t2.length === 0 ? null : A.SelectorList$(t2, this.span); + }, + nestWithin$3$implicitParent$preserveParentSelectors($parent, implicitParent, preserveParentSelectors) { + var parentSelector, t1, _this = this; + if ($parent == null) { + if (preserveParentSelectors) + return _this; + parentSelector = B.C__ParentSelectorVisitor.visitSelectorList$1(_this); + if (parentSelector == null) + return _this; + throw A.wrapException(A.SassException$(string$.Top_les, parentSelector.span, null)); + } + t1 = _this.components; + return A.SelectorList$(A.flattenVertically(new A.MappedListIterable(t1, new A.SelectorList_nestWithin_closure(_this, preserveParentSelectors, implicitParent, $parent), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Iterable>")), type$.ComplexSelector), _this.span); + }, + nestWithin$1($parent) { + return this.nestWithin$3$implicitParent$preserveParentSelectors($parent, true, false); + }, + nestWithin$2$implicitParent($parent, implicitParent) { + return this.nestWithin$3$implicitParent$preserveParentSelectors($parent, implicitParent, false); + }, + _nestWithinCompound$2(component, $parent) { + var resolvedSimples, parentSelector, error, stackTrace, t2, resolvedSimples0, exception, + t1 = component.selector, + simples = t1.components, + containsSelectorPseudo = J.any$1$ax(simples, new A.SelectorList__nestWithinCompound_closure()); + if (!containsSelectorPseudo && !(J.get$first$ax(simples) instanceof A.ParentSelector)) + return null; + if (containsSelectorPseudo) { + t2 = simples; + resolvedSimples0 = new A.MappedListIterable(t2, new A.SelectorList__nestWithinCompound_closure0($parent), A._arrayInstanceType(t2)._eval$1("MappedListIterable<1,SimpleSelector>")); + } else + resolvedSimples0 = simples; + resolvedSimples = resolvedSimples0; + parentSelector = J.get$first$ax(simples); + try { + if (!(parentSelector instanceof A.ParentSelector)) { + t2 = component.span; + t2 = A._setArrayType([A.ComplexSelector$(B.List_empty0, A._setArrayType([new A.ComplexSelectorComponent(A.CompoundSelector$(resolvedSimples, t1.span), A.List_List$unmodifiable(component.combinators, type$.CssValue_Combinator), t2)], type$.JSArray_ComplexSelectorComponent), t2, false)], type$.JSArray_ComplexSelector); + return t2; + } else if (J.get$length$asx(simples) === 1 && parentSelector.suffix == null) { + t1 = $parent.withAdditionalCombinators$1(component.combinators); + return t1.components; + } + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException) { + error = t1; + stackTrace = A.getTraceFromException(exception); + A.throwWithTrace(error.withAdditionalSpan$2(parentSelector.span, "parent selector"), error, stackTrace); + } else + throw exception; + } + t1 = $parent.components; + return new A.MappedListIterable(t1, new A.SelectorList__nestWithinCompound_closure1(parentSelector, resolvedSimples, component), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,ComplexSelector>")); + }, + isSuperselector$1(other) { + return A.listIsSuperselector(this.components, other.components); + }, + withAdditionalCombinators$1(combinators) { + var t1; + if (combinators.length === 0) + t1 = this; + else { + t1 = this.components; + t1 = A.SelectorList$(new A.MappedListIterable(t1, new A.SelectorList_withAdditionalCombinators_closure(combinators), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,ComplexSelector>")), this.span); + } + return t1; + }, + get$hashCode(_) { + return B.C_ListEquality0.hash$1(this.components); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.SelectorList && B.C_ListEquality.equals$2(0, this.components, other.components); + } + }; + A.SelectorList_asSassList_closure.prototype = { + call$1(complex) { + var t3, t4, _i, component, visitor, t5, t6, t7, _i0, _null = null, + t1 = type$.JSArray_Value, + t2 = A._setArrayType([], t1); + for (t3 = complex.leadingCombinators, t4 = t3.length, _i = 0; _i < t4; ++_i) + t2.push(new A.SassString(J.toString$0$(t3[_i].value), false)); + for (t3 = complex.components, t4 = t3.length, _i = 0; _i < t4; ++_i) { + component = t3[_i]; + visitor = A._SerializeVisitor$(_null, true, _null, _null, true, false, _null, true); + component.selector.accept$1(visitor); + t5 = A._setArrayType([new A.SassString(visitor._serialize$_buffer.toString$0(0), false)], t1); + for (t6 = component.combinators, t7 = t6.length, _i0 = 0; _i0 < t7; ++_i0) + t5.push(new A.SassString(J.toString$0$(t6[_i0].value), false)); + B.JSArray_methods.addAll$1(t2, t5); + } + return A.SassList$(t2, B.ListSeparator_qSL, false); + }, + $signature: 332 + }; + A.SelectorList_nestWithin_closure.prototype = { + call$1(complex) { + var t1, newComplexes, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, _i, component, resolved, i, t12, t13, t14, _i0, newComplex, t15, t16, _this = this; + if (_this.preserveParentSelectors || complex.accept$1(B.C__ParentSelectorVisitor) == null) { + if (!_this.implicitParent) + return A._setArrayType([complex], type$.JSArray_ComplexSelector); + t1 = _this.parent.components; + return new A.MappedListIterable(t1, new A.SelectorList_nestWithin__closure(complex), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,ComplexSelector>")); + } + t1 = type$.JSArray_ComplexSelector; + newComplexes = A._setArrayType([], t1); + for (t2 = complex.components, t3 = t2.length, t4 = _this.$this, t5 = _this.parent, t6 = type$.ComplexSelector, t7 = complex.leadingCombinators, t8 = t7.length === 0, t9 = complex.span, t10 = type$.ComplexSelectorComponent, t11 = type$.JSArray_ComplexSelectorComponent, _i = 0; _i < t3; ++_i) { + component = t2[_i]; + resolved = t4._nestWithinCompound$2(component, t5); + if (resolved == null) + if (newComplexes.length === 0) + newComplexes.push(A.ComplexSelector$(t7, A._setArrayType([component], t11), t9, false)); + else + for (i = 0; i < newComplexes.length; ++i) { + t12 = newComplexes[i]; + t13 = A.List_List$of(t12.components, true, t10); + t13.push(component); + newComplexes[i] = A.ComplexSelector$(t12.leadingCombinators, t13, t9, t12.lineBreak); + } + else if (newComplexes.length === 0) + B.JSArray_methods.addAll$1(newComplexes, t8 ? resolved : J.map$1$1$ax(resolved, new A.SelectorList_nestWithin__closure0(complex), t6)); + else { + t12 = A._setArrayType([], t1); + for (t13 = newComplexes.length, t14 = J.getInterceptor$ax(resolved), _i0 = 0; _i0 < newComplexes.length; newComplexes.length === t13 || (0, A.throwConcurrentModificationError)(newComplexes), ++_i0) { + newComplex = newComplexes[_i0]; + for (t15 = t14.get$iterator(resolved), t16 = newComplex.span; t15.moveNext$0();) + t12.push(newComplex.concatenate$2(t15.get$current(t15), t16)); + } + newComplexes = t12; + } + } + return newComplexes; + }, + $signature: 344 + }; + A.SelectorList_nestWithin__closure.prototype = { + call$1(parentComplex) { + var t1 = this.complex; + return parentComplex.concatenate$2(t1, t1.span); + }, + $signature: 60 + }; + A.SelectorList_nestWithin__closure0.prototype = { + call$1(resolvedComplex) { + var t1 = resolvedComplex.leadingCombinators, + t2 = this.complex, + t3 = t2.leadingCombinators; + if (t1.length === 0) + t1 = t3; + else { + t3 = A.List_List$of(t3, true, type$.CssValue_Combinator); + B.JSArray_methods.addAll$1(t3, t1); + t1 = t3; + } + return A.ComplexSelector$(t1, resolvedComplex.components, t2.span, resolvedComplex.lineBreak); + }, + $signature: 60 + }; + A.SelectorList__nestWithinCompound_closure.prototype = { + call$1(simple) { + var selector; + if (!(simple instanceof A.PseudoSelector)) + return false; + selector = simple.selector; + return selector != null && selector.accept$1(B.C__ParentSelectorVisitor) != null; + }, + $signature: 13 + }; + A.SelectorList__nestWithinCompound_closure0.prototype = { + call$1(simple) { + var selector, t1, _0_2; + $label0$0: { + selector = null; + t1 = false; + if (simple instanceof A.PseudoSelector) { + _0_2 = simple.selector; + if (_0_2 != null) { + selector = _0_2 == null ? type$.SelectorList._as(_0_2) : _0_2; + t1 = selector.accept$1(B.C__ParentSelectorVisitor) != null; + } + } + if (t1) { + t1 = simple.withSelector$1(selector.nestWithin$2$implicitParent(this.parent, false)); + break $label0$0; + } + t1 = simple; + break $label0$0; + } + return t1; + }, + $signature: 368 + }; + A.SelectorList__nestWithinCompound_closure1.prototype = { + call$1(complex) { + var lastComponent, suffix, lastSimples, t1, t2, last, t3, error, stackTrace, t4, t5, t6, t7, exception, _this = this; + try { + t4 = complex.components; + lastComponent = B.JSArray_methods.get$last(t4); + if (lastComponent.combinators.length !== 0) { + t1 = A.MultiSpanSassException$('Selector "' + complex.toString$0(0) + string$.x22x20can_, A.SpanExtensions_trimRight(lastComponent.span), "outer selector", A.LinkedHashMap_LinkedHashMap$_literal([_this.parentSelector.span, "parent selector"], type$.FileSpan, type$.String), null); + throw A.wrapException(t1); + } + suffix = _this.parentSelector.suffix; + lastSimples = lastComponent.selector.components; + t5 = type$.SimpleSelector; + t6 = _this.resolvedSimples; + t7 = J.getInterceptor$ax(t6); + if (suffix == null) { + t1 = A.List_List$of(lastSimples, true, t5); + J.addAll$1$ax(t1, t7.skip$1(t6, 1)); + t1 = t1; + } else { + t2 = A.List_List$of(A.IterableExtension_get_exceptLast(lastSimples), true, t5); + J.add$1$ax(t2, J.get$last$ax(lastSimples).addSuffix$1(suffix)); + J.addAll$1$ax(t2, t7.skip$1(t6, 1)); + t1 = t2; + } + t2 = _this.component; + last = A.CompoundSelector$(t1, t2.selector.span); + t3 = A.List_List$of(A.IterableExtension_get_exceptLast(t4), true, type$.ComplexSelectorComponent); + t4 = t2.span; + J.add$1$ax(t3, new A.ComplexSelectorComponent(last, A.List_List$unmodifiable(t2.combinators, type$.CssValue_Combinator), t4)); + t4 = A.ComplexSelector$(complex.leadingCombinators, t3, t4, complex.lineBreak); + return t4; + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException) { + error = t1; + stackTrace = A.getTraceFromException(exception); + A.throwWithTrace(error.withAdditionalSpan$2(_this.parentSelector.span, "parent selector"), error, stackTrace); + } else + throw exception; + } + }, + $signature: 60 + }; + A.SelectorList_withAdditionalCombinators_closure.prototype = { + call$1(complex) { + return complex.withAdditionalCombinators$1(this.combinators); + }, + $signature: 60 + }; + A._ParentSelectorVisitor.prototype = { + visitParentSelector$1(selector) { + return selector; + } + }; + A.__ParentSelectorVisitor_Object_SelectorSearchVisitor.prototype = {}; + A.ParentSelector.prototype = { + accept$1$1(visitor) { + return visitor.visitParentSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + unify$1(compound) { + return A.throwExpression(A.UnsupportedError$("& doesn't support unification.")); + } + }; + A.PlaceholderSelector.prototype = { + accept$1$1(visitor) { + return visitor.visitPlaceholderSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + addSuffix$1(suffix) { + return new A.PlaceholderSelector(this.name + suffix, this.span); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.PlaceholderSelector && other.name === this.name; + }, + get$hashCode(_) { + return B.JSString_methods.get$hashCode(this.name); + } + }; + A.PseudoSelector.prototype = { + get$isHostContext() { + return this.isClass && this.name === "host-context" && this.selector != null; + }, + get$hasComplicatedSuperselectorSemantics() { + return !this.isClass || this.selector != null; + }, + get$specificity() { + var result, _this = this, + value = _this.__PseudoSelector_specificity_FI; + if (value === $) { + result = new A.PseudoSelector_specificity_closure(_this).call$0(); + _this.__PseudoSelector_specificity_FI !== $ && A.throwUnnamedLateFieldADI(); + _this.__PseudoSelector_specificity_FI = result; + value = result; + } + return value; + }, + withSelector$1(selector) { + var _this = this; + return A.PseudoSelector$(_this.name, _this.span, _this.argument, !_this.isClass, selector); + }, + addSuffix$1(suffix) { + var _this = this; + if (_this.argument != null || _this.selector != null) + _this.super$SimpleSelector$addSuffix(suffix); + return A.PseudoSelector$(_this.name + suffix, _this.span, null, !_this.isClass, null); + }, + unify$1(compound) { + var other, result, t2, addedThis, _i, simple, _this = this, + t1 = _this.name; + if (t1 === "host" || t1 === "host-context") { + if (!B.JSArray_methods.every$1(compound, new A.PseudoSelector_unify_closure())) + return null; + } else { + t1 = false; + if (compound.length === 1) { + other = compound[0]; + if (!(other instanceof A.UniversalSelector)) { + if (other instanceof A.PseudoSelector) + t1 = other.isClass && other.name === "host" || other.get$isHostContext(); + } else + t1 = true; + } else + other = null; + if (t1) + return other.unify$1(A._setArrayType([_this], type$.JSArray_SimpleSelector)); + } + if (B.JSArray_methods.contains$1(compound, _this)) + return compound; + result = A._setArrayType([], type$.JSArray_SimpleSelector); + for (t1 = compound.length, t2 = !_this.isClass, addedThis = false, _i = 0; _i < compound.length; compound.length === t1 || (0, A.throwConcurrentModificationError)(compound), ++_i) { + simple = compound[_i]; + if (simple instanceof A.PseudoSelector && !simple.isClass) { + if (t2) + return null; + result.push(_this); + addedThis = true; + } + result.push(simple); + } + if (!addedThis) + result.push(_this); + return result; + }, + isSuperselector$1(other) { + var selector, t1, t2, _this = this; + if (_this.super$SimpleSelector$isSuperselector(other)) + return true; + selector = _this.selector; + if (selector == null) + return _this.$eq(0, other); + if (other instanceof A.PseudoSelector && !_this.isClass && !other.isClass && _this.normalizedName === "slotted" && other.name === _this.name) { + t1 = A.NullableExtension_andThen(other.selector, selector.get$isSuperselector()); + return t1 == null ? false : t1; + } + t1 = type$.JSArray_SimpleSelector; + t2 = _this.span; + return A.compoundIsSuperselector(A.CompoundSelector$(A._setArrayType([_this], t1), t2), A.CompoundSelector$(A._setArrayType([other], t1), t2), null); + }, + accept$1$1(visitor) { + return visitor.visitPseudoSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + $eq(_, other) { + var _this = this; + if (other == null) + return false; + return other instanceof A.PseudoSelector && other.name === _this.name && other.isClass === _this.isClass && other.argument == _this.argument && J.$eq$(other.selector, _this.selector); + }, + get$hashCode(_) { + var _this = this, + t1 = B.JSString_methods.get$hashCode(_this.name), + t2 = !_this.isClass ? 519018 : 218159; + return t1 ^ t2 ^ J.get$hashCode$(_this.argument) ^ J.get$hashCode$(_this.selector); + } + }; + A.PseudoSelector_specificity_closure.prototype = { + call$0() { + var selector, t2, + t1 = this.$this; + if (!t1.isClass) + return 1; + selector = t1.selector; + if (selector == null) + return A.SimpleSelector.prototype.get$specificity.call(t1); + switch (t1.normalizedName) { + case "where": + return 0; + case "is": + case "not": + case "has": + case "matches": + t1 = selector.components; + return A.IterableIntegerExtension_get_max(new A.MappedListIterable(t1, new A.PseudoSelector_specificity__closure(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,int>"))); + case "nth-child": + case "nth-last-child": + t1 = A.SimpleSelector.prototype.get$specificity.call(t1); + t2 = selector.components; + return t1 + A.IterableIntegerExtension_get_max(new A.MappedListIterable(t2, new A.PseudoSelector_specificity__closure0(), A._arrayInstanceType(t2)._eval$1("MappedListIterable<1,int>"))); + default: + return A.SimpleSelector.prototype.get$specificity.call(t1); + } + }, + $signature: 10 + }; + A.PseudoSelector_specificity__closure.prototype = { + call$1(component) { + return component.get$specificity(); + }, + $signature: 171 + }; + A.PseudoSelector_specificity__closure0.prototype = { + call$1(component) { + return component.get$specificity(); + }, + $signature: 171 + }; + A.PseudoSelector_unify_closure.prototype = { + call$1(simple) { + var t1; + if (simple instanceof A.PseudoSelector) + t1 = simple.isClass && simple.name === "host" || simple.selector != null; + else + t1 = false; + return t1; + }, + $signature: 13 + }; + A.QualifiedName.prototype = { + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.QualifiedName && other.name === this.name && other.namespace == this.namespace; + }, + get$hashCode(_) { + return B.JSString_methods.get$hashCode(this.name) ^ J.get$hashCode$(this.namespace); + }, + toString$0(_) { + var t1 = this.namespace, + t2 = this.name; + return t1 == null ? t2 : t1 + "|" + t2; + } + }; + A.SimpleSelector.prototype = { + get$specificity() { + return 1000; + }, + get$hasComplicatedSuperselectorSemantics() { + return false; + }, + addSuffix$1(suffix) { + return A.throwExpression(A.MultiSpanSassException$('Selector "' + this.toString$0(0) + "\" can't have a suffix", this.span, "outer selector", A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String), null)); + }, + unify$1(compound) { + var other, result, addedThis, _i, simple, _this = this, + t1 = false; + if (compound.length === 1) { + other = compound[0]; + if (!(other instanceof A.UniversalSelector)) { + if (other instanceof A.PseudoSelector) + t1 = other.isClass && other.name === "host" || other.get$isHostContext(); + } else + t1 = true; + } else + other = null; + if (t1) + return other.unify$1(A._setArrayType([_this], type$.JSArray_SimpleSelector)); + if (B.JSArray_methods.contains$1(compound, _this)) + return compound; + result = A._setArrayType([], type$.JSArray_SimpleSelector); + for (t1 = compound.length, addedThis = false, _i = 0; _i < compound.length; compound.length === t1 || (0, A.throwConcurrentModificationError)(compound), ++_i) { + simple = compound[_i]; + if (!addedThis && simple instanceof A.PseudoSelector) { + result.push(_this); + addedThis = true; + } + result.push(simple); + } + if (!addedThis) + result.push(_this); + return result; + }, + isSuperselector$1(other) { + var list; + if (this.$eq(0, other)) + return true; + if (other instanceof A.PseudoSelector && other.isClass) { + list = other.selector; + if (list != null && $._subselectorPseudos.contains$1(0, other.normalizedName)) + return B.JSArray_methods.every$1(list.components, new A.SimpleSelector_isSuperselector_closure(this)); + } + return false; + } + }; + A.SimpleSelector_isSuperselector_closure.prototype = { + call$1(complex) { + var t1 = complex.components; + return t1.length !== 0 && B.JSArray_methods.any$1(B.JSArray_methods.get$last(t1).selector.components, new A.SimpleSelector_isSuperselector__closure(this.$this)); + }, + $signature: 20 + }; + A.SimpleSelector_isSuperselector__closure.prototype = { + call$1(simple) { + return this.$this.isSuperselector$1(simple); + }, + $signature: 13 + }; + A.TypeSelector.prototype = { + get$specificity() { + return 1; + }, + accept$1$1(visitor) { + return visitor.visitTypeSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + addSuffix$1(suffix) { + var t1 = this.name; + return new A.TypeSelector(new A.QualifiedName(t1.name + suffix, t1.namespace), this.span); + }, + unify$1(compound) { + var unified, t1, + _0_0 = A.IterableExtensions_get_firstOrNull(compound); + if (_0_0 instanceof A.UniversalSelector || _0_0 instanceof A.TypeSelector) { + unified = A.unifyUniversalAndElement(this, B.JSArray_methods.get$first(compound)); + if (unified == null) + return null; + t1 = A._setArrayType([unified], type$.JSArray_SimpleSelector); + B.JSArray_methods.addAll$1(t1, A.SubListIterable$(compound, 1, null, A._arrayInstanceType(compound)._precomputed1)); + return t1; + } else { + t1 = A._setArrayType([this], type$.JSArray_SimpleSelector); + B.JSArray_methods.addAll$1(t1, compound); + return t1; + } + }, + isSuperselector$1(other) { + var t1, t2, t3; + if (!this.super$SimpleSelector$isSuperselector(other)) { + t1 = false; + if (other instanceof A.TypeSelector) { + t2 = this.name; + t3 = other.name; + if (t2.name === t3.name) { + t1 = t2.namespace; + t1 = t1 === "*" || t1 == t3.namespace; + } + } + } else + t1 = true; + return t1; + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.TypeSelector && other.name.$eq(0, this.name); + }, + get$hashCode(_) { + var t1 = this.name; + return B.JSString_methods.get$hashCode(t1.name) ^ J.get$hashCode$(t1.namespace); + } + }; + A.UniversalSelector.prototype = { + get$specificity() { + return 0; + }, + accept$1$1(visitor) { + return visitor.visitUniversalSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + unify$1(compound) { + var _0_4, t1, rest, unified, t2, _this = this, _null = null, + _0_1 = compound.length, + _0_4_isSet = _0_1 >= 1; + if (_0_4_isSet) { + _0_4 = compound[0]; + if (!(_0_4 instanceof A.UniversalSelector)) + t1 = _0_4 instanceof A.TypeSelector; + else + t1 = true; + rest = t1 ? B.JSArray_methods.sublist$1(compound, 1) : _null; + } else { + rest = _null; + _0_4 = rest; + t1 = false; + } + if (t1) { + unified = A.unifyUniversalAndElement(_this, B.JSArray_methods.get$first(compound)); + if (unified == null) + return _null; + t1 = A._setArrayType([unified], type$.JSArray_SimpleSelector); + B.JSArray_methods.addAll$1(t1, rest); + return t1; + } + t1 = false; + if (_0_1 === 1) { + if (_0_4_isSet) + t2 = _0_4; + else { + _0_4 = compound[0]; + t2 = _0_4; + _0_4_isSet = true; + } + if (t2 instanceof A.PseudoSelector) { + t2 = _0_4_isSet ? _0_4 : compound[0]; + type$.PseudoSelector._as(t2); + t1 = t2.isClass && t2.name === "host" || t2.get$isHostContext(); + } + } + if (t1) + return _null; + if (_0_1 <= 0) + return A._setArrayType([_this], type$.JSArray_SimpleSelector); + t1 = _this.namespace; + if (t1 == null || t1 === "*") + t1 = compound; + else { + t1 = A._setArrayType([_this], type$.JSArray_SimpleSelector); + B.JSArray_methods.addAll$1(t1, compound); + } + return t1; + }, + isSuperselector$1(other) { + var t1 = this.namespace; + if (t1 === "*") + return true; + if (other instanceof A.TypeSelector) + return t1 == other.name.namespace; + if (other instanceof A.UniversalSelector) + return t1 == other.namespace; + return t1 == null || this.super$SimpleSelector$isSuperselector(other); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.UniversalSelector && other.namespace == this.namespace; + }, + get$hashCode(_) { + return J.get$hashCode$(this.namespace); + } + }; + A._compileStylesheet_closure0.prototype = { + call$1(url) { + var t1; + if (url === "") { + t1 = this.stylesheet.span; + t1 = A.Uri_Uri$dataFromString(A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1.get$file(t1)._decodedChars, 0, null), 0, null), B.C_Utf8Codec, null).get$_text(); + } else + t1 = this.importCache.sourceMapUrl$1(0, A.Uri_parse(url)).toString$0(0); + return t1; + }, + $signature: 6 + }; + A.AsyncEnvironment.prototype = { + closure$0() { + var t4, t5, t6, _this = this, + t1 = _this._async_environment$_forwardedModules, + t2 = _this._async_environment$_nestedForwardedModules, + t3 = _this._async_environment$_variables; + t3 = A._setArrayType(t3.slice(0), A._arrayInstanceType(t3)); + t4 = _this._async_environment$_variableNodes; + t4 = A._setArrayType(t4.slice(0), A._arrayInstanceType(t4)); + t5 = _this._async_environment$_functions; + t5 = A._setArrayType(t5.slice(0), A._arrayInstanceType(t5)); + t6 = _this._async_environment$_mixins; + t6 = A._setArrayType(t6.slice(0), A._arrayInstanceType(t6)); + return A.AsyncEnvironment$_(_this._async_environment$_modules, _this._async_environment$_namespaceNodes, _this._async_environment$_globalModules, _this._async_environment$_importedModules, t1, t2, _this._async_environment$_allModules, t3, t4, t5, t6, _this._async_environment$_content); + }, + forwardModule$2(module, rule) { + var view, t1, t2, _this = this, + forwardedModules = _this._async_environment$_forwardedModules; + if (forwardedModules == null) + forwardedModules = _this._async_environment$_forwardedModules = A.LinkedHashMap_LinkedHashMap$_empty(type$.Module_AsyncCallable, type$.AstNode); + view = A.ForwardedModuleView_ifNecessary(module, rule, type$.AsyncCallable); + for (t1 = new A.LinkedHashMapKeyIterator(forwardedModules, forwardedModules.__js_helper$_modifications, forwardedModules.__js_helper$_first); t1.moveNext$0();) { + t2 = t1.__js_helper$_current; + _this._async_environment$_assertNoConflicts$5(view.get$variables(), t2.get$variables(), view, t2, "variable"); + _this._async_environment$_assertNoConflicts$5(view.get$functions(view), t2.get$functions(t2), view, t2, "function"); + _this._async_environment$_assertNoConflicts$5(view.get$mixins(), t2.get$mixins(), view, t2, "mixin"); + } + _this._async_environment$_allModules.push(module); + forwardedModules.$indexSet(0, view, rule); + }, + _async_environment$_assertNoConflicts$5(newMembers, oldMembers, newModule, oldModule, type) { + var larger, smaller, t1, t2, t3, t4, $name, small, large, span; + if (newMembers.get$length(newMembers) < oldMembers.get$length(oldMembers)) { + larger = oldMembers; + smaller = newMembers; + } else { + larger = newMembers; + smaller = oldMembers; + } + for (t1 = type$.String, t2 = A.MapExtensions_get_pairs(smaller, t1, type$.Object), t2 = t2.get$iterator(t2), t3 = type === "variable"; t2.moveNext$0();) { + t4 = t2.get$current(t2); + $name = t4._0; + small = t4._1; + large = larger.$index(0, $name); + if (large == null) + continue; + if (t3 ? newModule.variableIdentity$1($name) === oldModule.variableIdentity$1($name) : J.$eq$(large, small)) + continue; + if (t3) + $name = "$" + $name; + t2 = this._async_environment$_forwardedModules; + if (t2 == null) + span = null; + else { + t2 = t2.$index(0, oldModule); + span = t2 == null ? null : t2.get$span(t2); + } + t2 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, t1); + if (span != null) + t2.$indexSet(0, span, "original @forward"); + throw A.wrapException(A.MultiSpanSassScriptException$("Two forwarded modules both define a " + type + " named " + $name + ".", "new @forward", t2)); + } + }, + importForwards$1(module) { + var forwardedModules, t1, t2, t3, t4, node, t5, t6, t7, t8, t9, t10, _i, t11, shadowed, t12, t13, _length, _list, _this = this, + forwarded = module._async_environment$_environment._async_environment$_forwardedModules; + if (forwarded == null) + return; + forwardedModules = _this._async_environment$_forwardedModules; + if (forwardedModules != null) { + t1 = type$.Module_AsyncCallable; + t2 = type$.AstNode; + t3 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t1 = A.MapExtensions_get_pairs(forwarded, t1, t2), t1 = t1.get$iterator(t1), t2 = _this._async_environment$_globalModules; t1.moveNext$0();) { + t4 = t1.get$current(t1); + module = t4._0; + node = t4._1; + if (!forwardedModules.containsKey$1(module) || !t2.containsKey$1(module)) + t3.$indexSet(0, module, node); + } + forwarded = t3; + } else + forwardedModules = _this._async_environment$_forwardedModules = A.LinkedHashMap_LinkedHashMap$_empty(type$.Module_AsyncCallable, type$.AstNode); + t1 = type$.String; + t2 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + for (t3 = new A.LinkedHashMapKeyIterator(forwarded, forwarded.__js_helper$_modifications, forwarded.__js_helper$_first); t3.moveNext$0();) + for (t4 = t3.__js_helper$_current.get$variables(), t4 = J.get$iterator$ax(t4.get$keys(t4)); t4.moveNext$0();) + t2.add$1(0, t4.get$current(t4)); + t3 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + for (t4 = new A.LinkedHashMapKeyIterator(forwarded, forwarded.__js_helper$_modifications, forwarded.__js_helper$_first); t4.moveNext$0();) { + t5 = t4.__js_helper$_current; + for (t5 = t5.get$functions(t5), t5 = J.get$iterator$ax(t5.get$keys(t5)); t5.moveNext$0();) + t3.add$1(0, t5.get$current(t5)); + } + t1 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + for (t4 = new A.LinkedHashMapKeyIterator(forwarded, forwarded.__js_helper$_modifications, forwarded.__js_helper$_first); t4.moveNext$0();) + for (t5 = t4.__js_helper$_current.get$mixins(), t5 = J.get$iterator$ax(t5.get$keys(t5)); t5.moveNext$0();) + t1.add$1(0, t5.get$current(t5)); + t4 = _this._async_environment$_variables; + t5 = t4.length; + if (t5 === 1) { + for (t5 = _this._async_environment$_importedModules, t6 = type$.Module_AsyncCallable, t7 = type$.AstNode, t8 = A.MapExtensions_get_pairs(t5, t6, t7).toList$0(0), t9 = t8.length, t10 = type$.AsyncCallable, _i = 0; _i < t8.length; t8.length === t9 || (0, A.throwConcurrentModificationError)(t8), ++_i) { + t11 = t8[_i]; + module = t11._0; + shadowed = A.ShadowedModuleView_ifNecessary(module, t3, t1, t2, t10); + if (shadowed != null) { + t5.remove$1(0, module); + t12 = shadowed.variables; + t13 = false; + if (t12.get$isEmpty(t12)) { + t12 = shadowed.functions; + if (t12.get$isEmpty(t12)) { + t12 = shadowed.mixins; + if (t12.get$isEmpty(t12)) { + t12 = shadowed._shadowed_view$_inner; + t12 = t12.get$css(t12); + t12 = J.get$isEmpty$asx(t12.get$children(t12)); + } else + t12 = t13; + } else + t12 = t13; + } else + t12 = t13; + if (!t12) + t5.$indexSet(0, shadowed, t11._1); + } + } + for (t6 = A.MapExtensions_get_pairs(forwardedModules, t6, t7).toList$0(0), t7 = t6.length, _i = 0; _i < t6.length; t6.length === t7 || (0, A.throwConcurrentModificationError)(t6), ++_i) { + t8 = t6[_i]; + module = t8._0; + shadowed = A.ShadowedModuleView_ifNecessary(module, t3, t1, t2, t10); + if (shadowed != null) { + forwardedModules.remove$1(0, module); + t9 = shadowed.variables; + t11 = false; + if (t9.get$isEmpty(t9)) { + t9 = shadowed.functions; + if (t9.get$isEmpty(t9)) { + t9 = shadowed.mixins; + if (t9.get$isEmpty(t9)) { + t9 = shadowed._shadowed_view$_inner; + t9 = t9.get$css(t9); + t9 = J.get$isEmpty$asx(t9.get$children(t9)); + } else + t9 = t11; + } else + t9 = t11; + } else + t9 = t11; + if (!t9) + forwardedModules.$indexSet(0, shadowed, t8._1); + } + } + t5.addAll$1(0, forwarded); + forwardedModules.addAll$1(0, forwarded); + } else { + t6 = _this._async_environment$_nestedForwardedModules; + if (t6 == null) { + _length = t5 - 1; + _list = J.JSArray_JSArray$allocateGrowable(_length, type$.List_Module_AsyncCallable); + for (t5 = type$.JSArray_Module_AsyncCallable, _i = 0; _i < _length; ++_i) + _list[_i] = A._setArrayType([], t5); + _this._async_environment$_nestedForwardedModules = _list; + t5 = _list; + } else + t5 = t6; + B.JSArray_methods.addAll$1(B.JSArray_methods.get$last(t5), new A.LinkedHashMapKeysIterable(forwarded, A._instanceType(forwarded)._eval$1("LinkedHashMapKeysIterable<1>"))); + } + for (t2 = A._LinkedHashSetIterator$(t2, t2._modifications, t2.$ti._precomputed1), t5 = _this._async_environment$_variableIndices, t6 = _this._async_environment$_variableNodes, t7 = t2.$ti._precomputed1; t2.moveNext$0();) { + t8 = t2._collection$_current; + if (t8 == null) + t8 = t7._as(t8); + t5.remove$1(0, t8); + J.remove$1$z(B.JSArray_methods.get$last(t4), t8); + J.remove$1$z(B.JSArray_methods.get$last(t6), t8); + } + for (t2 = A._LinkedHashSetIterator$(t3, t3._modifications, t3.$ti._precomputed1), t3 = _this._async_environment$_functionIndices, t4 = _this._async_environment$_functions, t5 = t2.$ti._precomputed1; t2.moveNext$0();) { + t6 = t2._collection$_current; + if (t6 == null) + t6 = t5._as(t6); + t3.remove$1(0, t6); + J.remove$1$z(B.JSArray_methods.get$last(t4), t6); + } + for (t1 = A._LinkedHashSetIterator$(t1, t1._modifications, t1.$ti._precomputed1), t2 = _this._async_environment$_mixinIndices, t3 = _this._async_environment$_mixins, t4 = t1.$ti._precomputed1; t1.moveNext$0();) { + t5 = t1._collection$_current; + if (t5 == null) + t5 = t4._as(t5); + t2.remove$1(0, t5); + J.remove$1$z(B.JSArray_methods.get$last(t3), t5); + } + }, + getVariable$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) + return _this._async_environment$_getModule$1(namespace).get$variables().$index(0, $name); + if (_this._async_environment$_lastVariableName === $name) { + t1 = _this._async_environment$_lastVariableIndex; + t1.toString; + t1 = _this._async_environment$_variables[t1].$index(0, $name); + return t1 == null ? _this._async_environment$_getVariableFromGlobalModule$1($name) : t1; + } + t1 = _this._async_environment$_variableIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + _this._async_environment$_lastVariableName = $name; + _this._async_environment$_lastVariableIndex = _0_0; + t1 = _this._async_environment$_variables[_0_0].$index(0, $name); + return t1 == null ? _this._async_environment$_getVariableFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._async_environment$_variableIndex$1($name); + if (_1_0 != null) { + _this._async_environment$_lastVariableName = $name; + _this._async_environment$_lastVariableIndex = _1_0; + t1.$indexSet(0, $name, _1_0); + t1 = _this._async_environment$_variables[_1_0].$index(0, $name); + return t1 == null ? _this._async_environment$_getVariableFromGlobalModule$1($name) : t1; + } else + return _this._async_environment$_getVariableFromGlobalModule$1($name); + } + }, + getVariable$1($name) { + return this.getVariable$2$namespace($name, null); + }, + _async_environment$_getVariableFromGlobalModule$1($name) { + return this._async_environment$_fromOneModule$3($name, "variable", new A.AsyncEnvironment__getVariableFromGlobalModule_closure($name)); + }, + getVariableNode$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) + return _this._async_environment$_getModule$1(namespace).get$variableNodes().$index(0, $name); + if (_this._async_environment$_lastVariableName === $name) { + t1 = _this._async_environment$_lastVariableIndex; + t1.toString; + t1 = _this._async_environment$_variableNodes[t1].$index(0, $name); + return t1 == null ? _this._async_environment$_getVariableNodeFromGlobalModule$1($name) : t1; + } + t1 = _this._async_environment$_variableIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + _this._async_environment$_lastVariableName = $name; + _this._async_environment$_lastVariableIndex = _0_0; + t1 = _this._async_environment$_variableNodes[_0_0].$index(0, $name); + return t1 == null ? _this._async_environment$_getVariableNodeFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._async_environment$_variableIndex$1($name); + if (_1_0 != null) { + _this._async_environment$_lastVariableName = $name; + _this._async_environment$_lastVariableIndex = _1_0; + t1.$indexSet(0, $name, _1_0); + t1 = _this._async_environment$_variableNodes[_1_0].$index(0, $name); + return t1 == null ? _this._async_environment$_getVariableNodeFromGlobalModule$1($name) : t1; + } else + return _this._async_environment$_getVariableNodeFromGlobalModule$1($name); + } + }, + _async_environment$_getVariableNodeFromGlobalModule$1($name) { + var t1, t2, _0_0; + for (t1 = this._async_environment$_importedModules, t2 = this._async_environment$_globalModules, t2 = new A.LinkedHashMapKeysIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapKeysIterable<1>")).followedBy$1(0, new A.LinkedHashMapKeysIterable(t2, A._instanceType(t2)._eval$1("LinkedHashMapKeysIterable<1>"))), t2 = new A.FollowedByIterator(J.get$iterator$ax(t2.__internal$_first), t2._second); t2.moveNext$0();) { + t1 = t2._currentIterator; + _0_0 = t1.get$current(t1).get$variableNodes().$index(0, $name); + if (_0_0 != null) + return _0_0; + } + return null; + }, + globalVariableExists$2$namespace($name, namespace) { + if (namespace != null) + return this._async_environment$_getModule$1(namespace).get$variables().containsKey$1($name); + if (B.JSArray_methods.get$first(this._async_environment$_variables).containsKey$1($name)) + return true; + return this._async_environment$_getVariableFromGlobalModule$1($name) != null; + }, + globalVariableExists$1($name) { + return this.globalVariableExists$2$namespace($name, null); + }, + _async_environment$_variableIndex$1($name) { + var t1, i; + for (t1 = this._async_environment$_variables, i = t1.length - 1; i >= 0; --i) + if (t1[i].containsKey$1($name)) + return i; + return null; + }, + setVariable$5$global$namespace($name, value, nodeWithSpan, global, namespace) { + var t1, moduleWithName, nestedForwardedModules, t2, t3, t4, t5, index, _this = this; + if (namespace != null) { + _this._async_environment$_getModule$1(namespace).setVariable$3($name, value, nodeWithSpan); + return; + } + if (global || _this._async_environment$_variables.length === 1) { + _this._async_environment$_variableIndices.putIfAbsent$2($name, new A.AsyncEnvironment_setVariable_closure(_this, $name)); + t1 = _this._async_environment$_variables; + if (!B.JSArray_methods.get$first(t1).containsKey$1($name)) { + moduleWithName = _this._async_environment$_fromOneModule$3($name, "variable", new A.AsyncEnvironment_setVariable_closure0($name)); + if (moduleWithName != null) { + moduleWithName.setVariable$3($name, value, nodeWithSpan); + return; + } + } + J.$indexSet$ax(B.JSArray_methods.get$first(t1), $name, value); + J.$indexSet$ax(B.JSArray_methods.get$first(_this._async_environment$_variableNodes), $name, nodeWithSpan); + return; + } + nestedForwardedModules = _this._async_environment$_nestedForwardedModules; + if (nestedForwardedModules != null && !_this._async_environment$_variableIndices.containsKey$1($name) && _this._async_environment$_variableIndex$1($name) == null) + for (t1 = A._arrayInstanceType(nestedForwardedModules)._eval$1("ReversedListIterable<1>"), t2 = new A.ReversedListIterable(nestedForwardedModules, t1), t2 = new A.ListIterator(t2, t2.get$length(0), t1._eval$1("ListIterator")), t1 = t1._eval$1("ListIterable.E"); t2.moveNext$0();) { + t3 = t2.__internal$_current; + for (t3 = J.get$reversed$ax(t3 == null ? t1._as(t3) : t3), t4 = t3.$ti, t3 = new A.ListIterator(t3, t3.get$length(0), t4._eval$1("ListIterator")), t4 = t4._eval$1("ListIterable.E"); t3.moveNext$0();) { + t5 = t3.__internal$_current; + if (t5 == null) + t5 = t4._as(t5); + if (t5.get$variables().containsKey$1($name)) { + t5.setVariable$3($name, value, nodeWithSpan); + return; + } + } + } + if (_this._async_environment$_lastVariableName === $name) { + t1 = _this._async_environment$_lastVariableIndex; + t1.toString; + index = t1; + } else + index = _this._async_environment$_variableIndices.putIfAbsent$2($name, new A.AsyncEnvironment_setVariable_closure1(_this, $name)); + if (!_this._async_environment$_inSemiGlobalScope && index === 0) { + index = _this._async_environment$_variables.length - 1; + _this._async_environment$_variableIndices.$indexSet(0, $name, index); + } + _this._async_environment$_lastVariableName = $name; + _this._async_environment$_lastVariableIndex = index; + _this._async_environment$_variables[index].$indexSet(0, $name, value); + _this._async_environment$_variableNodes[index].$indexSet(0, $name, nodeWithSpan); + }, + setVariable$4$global($name, value, nodeWithSpan, global) { + return this.setVariable$5$global$namespace($name, value, nodeWithSpan, global, null); + }, + setLocalVariable$3($name, value, nodeWithSpan) { + var index, _this = this, + t1 = _this._async_environment$_variables, + t2 = t1.length; + _this._async_environment$_lastVariableName = $name; + index = _this._async_environment$_lastVariableIndex = t2 - 1; + _this._async_environment$_variableIndices.$indexSet(0, $name, index); + t1[index].$indexSet(0, $name, value); + _this._async_environment$_variableNodes[index].$indexSet(0, $name, nodeWithSpan); + }, + getFunction$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) { + t1 = _this._async_environment$_getModule$1(namespace); + return t1.get$functions(t1).$index(0, $name); + } + t1 = _this._async_environment$_functionIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + t1 = _this._async_environment$_functions[_0_0].$index(0, $name); + return t1 == null ? _this._async_environment$_getFunctionFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._async_environment$_functionIndex$1($name); + if (_1_0 != null) { + t1.$indexSet(0, $name, _1_0); + t1 = _this._async_environment$_functions[_1_0].$index(0, $name); + return t1 == null ? _this._async_environment$_getFunctionFromGlobalModule$1($name) : t1; + } else + return _this._async_environment$_getFunctionFromGlobalModule$1($name); + } + }, + getFunction$1($name) { + return this.getFunction$2$namespace($name, null); + }, + _async_environment$_getFunctionFromGlobalModule$1($name) { + return this._async_environment$_fromOneModule$3($name, "function", new A.AsyncEnvironment__getFunctionFromGlobalModule_closure($name)); + }, + _async_environment$_functionIndex$1($name) { + var t1, i; + for (t1 = this._async_environment$_functions, i = t1.length - 1; i >= 0; --i) + if (t1[i].containsKey$1($name)) + return i; + return null; + }, + getMixin$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) + return _this._async_environment$_getModule$1(namespace).get$mixins().$index(0, $name); + t1 = _this._async_environment$_mixinIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + t1 = _this._async_environment$_mixins[_0_0].$index(0, $name); + return t1 == null ? _this._async_environment$_getMixinFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._async_environment$_mixinIndex$1($name); + if (_1_0 != null) { + t1.$indexSet(0, $name, _1_0); + t1 = _this._async_environment$_mixins[_1_0].$index(0, $name); + return t1 == null ? _this._async_environment$_getMixinFromGlobalModule$1($name) : t1; + } else + return _this._async_environment$_getMixinFromGlobalModule$1($name); + } + }, + _async_environment$_getMixinFromGlobalModule$1($name) { + return this._async_environment$_fromOneModule$3($name, "mixin", new A.AsyncEnvironment__getMixinFromGlobalModule_closure($name)); + }, + _async_environment$_mixinIndex$1($name) { + var t1, i; + for (t1 = this._async_environment$_mixins, i = t1.length - 1; i >= 0; --i) + if (t1[i].containsKey$1($name)) + return i; + return null; + }, + withContent$2($content, callback) { + return this.withContent$body$AsyncEnvironment($content, callback); + }, + withContent$body$AsyncEnvironment($content, callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, oldContent; + var $async$withContent$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + oldContent = $async$self._async_environment$_content; + $async$self._async_environment$_content = $content; + $async$goto = 2; + return A._asyncAwait(callback.call$0(), $async$withContent$2); + case 2: + // returning from await. + $async$self._async_environment$_content = oldContent; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$withContent$2, $async$completer); + }, + asMixin$1(callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, oldInMixin; + var $async$asMixin$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + oldInMixin = $async$self._async_environment$_inMixin; + $async$self._async_environment$_inMixin = true; + $async$goto = 2; + return A._asyncAwait(callback.call$0(), $async$asMixin$1); + case 2: + // returning from await. + $async$self._async_environment$_inMixin = oldInMixin; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$asMixin$1, $async$completer); + }, + scope$1$3$semiGlobal$when(callback, semiGlobal, when, $T) { + return this.scope$body$AsyncEnvironment(callback, semiGlobal, when, $T, $T); + }, + scope$1$1(callback, $T) { + return this.scope$1$3$semiGlobal$when(callback, false, true, $T); + }, + scope$1$2$when(callback, when, $T) { + return this.scope$1$3$semiGlobal$when(callback, false, when, $T); + }, + scope$1$2$semiGlobal(callback, semiGlobal, $T) { + return this.scope$1$3$semiGlobal$when(callback, semiGlobal, true, $T); + }, + scope$body$AsyncEnvironment(callback, semiGlobal, when, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$next = [], $async$self = this, wasInSemiGlobalScope, $name, name0, name1, t1, t2, t3, t4, t5, t6; + var $async$scope$1$3$semiGlobal$when = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + semiGlobal = semiGlobal && $async$self._async_environment$_inSemiGlobalScope; + wasInSemiGlobalScope = $async$self._async_environment$_inSemiGlobalScope; + $async$self._async_environment$_inSemiGlobalScope = semiGlobal; + $async$goto = !when ? 3 : 4; + break; + case 3: + // then + $async$handler = 5; + $async$goto = 8; + return A._asyncAwait(callback.call$0(), $async$scope$1$3$semiGlobal$when); + case 8: + // returning from await. + t1 = $async$result; + $async$returnValue = t1; + $async$next = [1]; + // goto finally + $async$goto = 6; + break; + $async$next.push(7); + // goto finally + $async$goto = 6; + break; + case 5: + // uncaught + $async$next = [2]; + case 6: + // finally + $async$handler = 2; + $async$self._async_environment$_inSemiGlobalScope = wasInSemiGlobalScope; + // goto the next finally handler + $async$goto = $async$next.pop(); + break; + case 7: + // after finally + case 4: + // join + t1 = $async$self._async_environment$_variables; + t2 = type$.String; + B.JSArray_methods.add$1(t1, A.LinkedHashMap_LinkedHashMap$_empty(t2, type$.Value)); + t3 = $async$self._async_environment$_variableNodes; + B.JSArray_methods.add$1(t3, A.LinkedHashMap_LinkedHashMap$_empty(t2, type$.AstNode)); + t4 = $async$self._async_environment$_functions; + t5 = type$.AsyncCallable; + B.JSArray_methods.add$1(t4, A.LinkedHashMap_LinkedHashMap$_empty(t2, t5)); + t6 = $async$self._async_environment$_mixins; + B.JSArray_methods.add$1(t6, A.LinkedHashMap_LinkedHashMap$_empty(t2, t5)); + t5 = $async$self._async_environment$_nestedForwardedModules; + if (t5 != null) + t5.push(A._setArrayType([], type$.JSArray_Module_AsyncCallable)); + $async$handler = 9; + $async$goto = 12; + return A._asyncAwait(callback.call$0(), $async$scope$1$3$semiGlobal$when); + case 12: + // returning from await. + t2 = $async$result; + $async$returnValue = t2; + $async$next = [1]; + // goto finally + $async$goto = 10; + break; + $async$next.push(11); + // goto finally + $async$goto = 10; + break; + case 9: + // uncaught + $async$next = [2]; + case 10: + // finally + $async$handler = 2; + $async$self._async_environment$_inSemiGlobalScope = wasInSemiGlobalScope; + $async$self._async_environment$_lastVariableIndex = $async$self._async_environment$_lastVariableName = null; + for (t1 = J.get$iterator$ax(J.get$keys$z(B.JSArray_methods.removeLast$0(t1))), t2 = $async$self._async_environment$_variableIndices; t1.moveNext$0();) { + $name = t1.get$current(t1); + t2.remove$1(0, $name); + } + B.JSArray_methods.removeLast$0(t3); + for (t1 = J.get$iterator$ax(J.get$keys$z(B.JSArray_methods.removeLast$0(t4))), t2 = $async$self._async_environment$_functionIndices; t1.moveNext$0();) { + name0 = t1.get$current(t1); + t2.remove$1(0, name0); + } + for (t1 = J.get$iterator$ax(J.get$keys$z(B.JSArray_methods.removeLast$0(t6))), t2 = $async$self._async_environment$_mixinIndices; t1.moveNext$0();) { + name1 = t1.get$current(t1); + t2.remove$1(0, name1); + } + t1 = $async$self._async_environment$_nestedForwardedModules; + if (t1 != null) + t1.pop(); + // goto the next finally handler + $async$goto = $async$next.pop(); + break; + case 11: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$scope$1$3$semiGlobal$when, $async$completer); + }, + toImplicitConfiguration$0() { + var t2, t3, t4, i, values, nodes, t5, t6, $name, value, + t1 = type$.String, + configuration = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.ConfiguredValue); + for (t2 = this._async_environment$_variables, t3 = type$.Value, t4 = this._async_environment$_variableNodes, i = 0; i < t2.length; ++i) { + values = t2[i]; + nodes = t4[i]; + for (t5 = A.MapExtensions_get_pairs(values, t1, t3), t5 = t5.get$iterator(t5); t5.moveNext$0();) { + t6 = t5.get$current(t5); + $name = t6._0; + value = t6._1; + t6 = nodes.$index(0, $name); + t6.toString; + configuration.$indexSet(0, $name, new A.ConfiguredValue(value, null, t6)); + } + } + return new A.Configuration(configuration, null); + }, + toModule$3(css, preModuleComments, extensionStore) { + return A._EnvironmentModule__EnvironmentModule0(this, css, preModuleComments, extensionStore, A.NullableExtension_andThen(this._async_environment$_forwardedModules, new A.AsyncEnvironment_toModule_closure())); + }, + toDummyModule$0() { + return A._EnvironmentModule__EnvironmentModule0(this, new A.CssStylesheet(new A.UnmodifiableListView(B.List_empty3, type$.UnmodifiableListView_CssNode), A.SourceFile$decoded(B.List_empty4, "").span$1(0, 0)), B.Map_empty8, B.C_EmptyExtensionStore, A.NullableExtension_andThen(this._async_environment$_forwardedModules, new A.AsyncEnvironment_toDummyModule_closure())); + }, + _async_environment$_getModule$1(namespace) { + var _0_0 = this._async_environment$_modules.$index(0, namespace); + if (_0_0 != null) + return _0_0; + throw A.wrapException(A.SassScriptException$('There is no module with the namespace "' + namespace + '".', null)); + }, + _async_environment$_fromOneModule$1$3($name, type, callback) { + var t1, t2, t3, t4, t5, _1_0, _2_0, value, identity, valueInModule, identityFromModule, module, node, + _0_0 = this._async_environment$_nestedForwardedModules; + if (_0_0 != null) + for (t1 = A._arrayInstanceType(_0_0)._eval$1("ReversedListIterable<1>"), t2 = new A.ReversedListIterable(_0_0, t1), t2 = new A.ListIterator(t2, t2.get$length(0), t1._eval$1("ListIterator")), t1 = t1._eval$1("ListIterable.E"); t2.moveNext$0();) { + t3 = t2.__internal$_current; + for (t3 = J.get$reversed$ax(t3 == null ? t1._as(t3) : t3), t4 = t3.$ti, t3 = new A.ListIterator(t3, t3.get$length(0), t4._eval$1("ListIterator")), t4 = t4._eval$1("ListIterable.E"); t3.moveNext$0();) { + t5 = t3.__internal$_current; + _1_0 = callback.call$1(t5 == null ? t4._as(t5) : t5); + if (_1_0 != null) + return _1_0; + } + } + for (t1 = this._async_environment$_importedModules, t1 = new A.LinkedHashMapKeyIterator(t1, t1.__js_helper$_modifications, t1.__js_helper$_first); t1.moveNext$0();) { + _2_0 = callback.call$1(t1.__js_helper$_current); + if (_2_0 != null) + return _2_0; + } + for (t1 = this._async_environment$_globalModules, t2 = new A.LinkedHashMapKeyIterator(t1, t1.__js_helper$_modifications, t1.__js_helper$_first), t3 = type$.AsyncCallable, value = null, identity = null; t2.moveNext$0();) { + t4 = t2.__js_helper$_current; + valueInModule = callback.call$1(t4); + if (valueInModule == null) + continue; + identityFromModule = t3._is(valueInModule) ? valueInModule : t4.variableIdentity$1($name); + if (identityFromModule.$eq(0, identity)) + continue; + if (value != null) { + t2 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + for (t3 = A.MapExtensions_get_pairs(t1, type$.Module_AsyncCallable, type$.AstNode), t3 = t3.get$iterator(t3), t4 = "includes " + type; t3.moveNext$0();) { + t1 = t3.get$current(t3); + module = t1._0; + node = t1._1; + if (callback.call$1(module) != null) + t2.$indexSet(0, node.get$span(node), t4); + } + throw A.wrapException(A.MultiSpanSassScriptException$("This " + type + string$.x20is_av, type + " use", t2)); + } + identity = identityFromModule; + value = valueInModule; + } + return value; + }, + _async_environment$_fromOneModule$3($name, type, callback) { + return this._async_environment$_fromOneModule$1$3($name, type, callback, type$.dynamic); + } + }; + A.AsyncEnvironment__getVariableFromGlobalModule_closure.prototype = { + call$1(module) { + return module.get$variables().$index(0, this.name); + }, + $signature: 397 + }; + A.AsyncEnvironment_setVariable_closure.prototype = { + call$0() { + var t1 = this.$this; + t1._async_environment$_lastVariableName = this.name; + return t1._async_environment$_lastVariableIndex = 0; + }, + $signature: 10 + }; + A.AsyncEnvironment_setVariable_closure0.prototype = { + call$1(module) { + return module.get$variables().containsKey$1(this.name) ? module : null; + }, + $signature: 412 + }; + A.AsyncEnvironment_setVariable_closure1.prototype = { + call$0() { + var t1 = this.$this, + t2 = t1._async_environment$_variableIndex$1(this.name); + return t2 == null ? t1._async_environment$_variables.length - 1 : t2; + }, + $signature: 10 + }; + A.AsyncEnvironment__getFunctionFromGlobalModule_closure.prototype = { + call$1(module) { + return module.get$functions(module).$index(0, this.name); + }, + $signature: 173 + }; + A.AsyncEnvironment__getMixinFromGlobalModule_closure.prototype = { + call$1(module) { + return module.get$mixins().$index(0, this.name); + }, + $signature: 173 + }; + A.AsyncEnvironment_toModule_closure.prototype = { + call$1(modules) { + return new A.MapKeySet(modules, type$.MapKeySet_Module_AsyncCallable); + }, + $signature: 175 + }; + A.AsyncEnvironment_toDummyModule_closure.prototype = { + call$1(modules) { + return new A.MapKeySet(modules, type$.MapKeySet_Module_AsyncCallable); + }, + $signature: 175 + }; + A._EnvironmentModule0.prototype = { + get$url(_) { + var t1 = this.css; + t1 = t1.get$span(t1); + return t1.get$sourceUrl(t1); + }, + setVariable$3($name, value, nodeWithSpan) { + var t1, t2, + _0_0 = this._async_environment$_modulesByVariable.$index(0, $name); + if (_0_0 != null) { + _0_0.setVariable$3($name, value, nodeWithSpan); + return; + } + t1 = this._async_environment$_environment; + t2 = t1._async_environment$_variables; + if (!B.JSArray_methods.get$first(t2).containsKey$1($name)) + throw A.wrapException(A.SassScriptException$("Undefined variable.", null)); + J.$indexSet$ax(B.JSArray_methods.get$first(t2), $name, value); + J.$indexSet$ax(B.JSArray_methods.get$first(t1._async_environment$_variableNodes), $name, nodeWithSpan); + return; + }, + variableIdentity$1($name) { + var module = this._async_environment$_modulesByVariable.$index(0, $name); + return module == null ? this : module.variableIdentity$1($name); + }, + cloneCss$0() { + var _0_0, _this = this; + if (!_this.transitivelyContainsCss) + return _this; + _0_0 = A.cloneCssStylesheet(_this.css, _this.extensionStore); + return A._EnvironmentModule$_0(_this._async_environment$_environment, _0_0._0, _this.preModuleComments, _0_0._1, _this._async_environment$_modulesByVariable, _this.variables, _this.variableNodes, _this.functions, _this.mixins, true, _this.transitivelyContainsExtensions); + }, + toString$0(_) { + var t1 = this.css, + t2 = t1.get$span(t1); + if (t2.get$sourceUrl(t2) == null) + t1 = ""; + else { + t1 = t1.get$span(t1); + t1 = t1.get$sourceUrl(t1); + t2 = $.$get$context(); + t1.toString; + t1 = t2.prettyUri$1(t1); + } + return t1; + }, + $isModule0: 1, + get$upstream() { + return this.upstream; + }, + get$variables() { + return this.variables; + }, + get$variableNodes() { + return this.variableNodes; + }, + get$functions(receiver) { + return this.functions; + }, + get$mixins() { + return this.mixins; + }, + get$extensionStore() { + return this.extensionStore; + }, + get$css(receiver) { + return this.css; + }, + get$preModuleComments() { + return this.preModuleComments; + }, + get$transitivelyContainsCss() { + return this.transitivelyContainsCss; + }, + get$transitivelyContainsExtensions() { + return this.transitivelyContainsExtensions; + } + }; + A._EnvironmentModule__EnvironmentModule_closure5.prototype = { + call$1(module) { + return module.get$variables(); + }, + $signature: 439 + }; + A._EnvironmentModule__EnvironmentModule_closure6.prototype = { + call$1(module) { + return module.get$variableNodes(); + }, + $signature: 443 + }; + A._EnvironmentModule__EnvironmentModule_closure7.prototype = { + call$1(module) { + return module.get$functions(module); + }, + $signature: 180 + }; + A._EnvironmentModule__EnvironmentModule_closure8.prototype = { + call$1(module) { + return module.get$mixins(); + }, + $signature: 180 + }; + A._EnvironmentModule__EnvironmentModule_closure9.prototype = { + call$1(module) { + return module.get$transitivelyContainsCss(); + }, + $signature: 130 + }; + A._EnvironmentModule__EnvironmentModule_closure10.prototype = { + call$1(module) { + return module.get$transitivelyContainsExtensions(); + }, + $signature: 130 + }; + A.AsyncImportCache.prototype = { + canonicalize$4$baseImporter$baseUrl$forImport(_, url, baseImporter, baseUrl, forImport) { + return this.canonicalize$body$AsyncImportCache(0, url, baseImporter, baseUrl, forImport); + }, + canonicalize$body$AsyncImportCache(_, url, baseImporter, baseUrl, forImport) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl), + $async$returnValue, $async$self = this, t1, resolvedUrl, key, relativeResult, t2, t3, t4, t5, t6, cacheable, i, importer, perImporterKey, t7, _1_0, _1_2_isSet, result, _1_2, _2_0, _2_1, _2_5_isSet, _2_5, _2_3, _2_3_isSet, j; + var $async$canonicalize$4$baseImporter$baseUrl$forImport = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if (A.isBrowser()) + t1 = (baseImporter == null || baseImporter instanceof A.NoOpImporter) && $async$self._async_import_cache$_importers.length === 0; + else + t1 = false; + if (t1) + throw A.wrapException(string$.Custom); + $async$goto = baseImporter != null && url.get$scheme() === "" ? 3 : 4; + break; + case 3: + // then + resolvedUrl = baseUrl == null ? null : baseUrl.resolveUri$1(url); + if (resolvedUrl == null) + resolvedUrl = url; + key = new A._Record_3_forImport(baseImporter, resolvedUrl, forImport); + $async$goto = 5; + return A._asyncAwait(A.putIfAbsentAsync($async$self._async_import_cache$_perImporterCanonicalizeCache, key, new A.AsyncImportCache_canonicalize_closure($async$self, baseImporter, resolvedUrl, baseUrl, forImport, key, url), type$.Record_3_AsyncImporter_and_Uri_and_bool_forImport, type$.nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl), $async$canonicalize$4$baseImporter$baseUrl$forImport); + case 5: + // returning from await. + relativeResult = $async$result; + if (relativeResult != null) { + $async$returnValue = relativeResult; + // goto return + $async$goto = 1; + break; + } + case 4: + // join + key = new A._Record_2_forImport(url, forImport); + t1 = $async$self._async_import_cache$_canonicalizeCache; + if (t1.containsKey$1(key)) { + $async$returnValue = t1.$index(0, key); + // goto return + $async$goto = 1; + break; + } + t2 = $async$self._async_import_cache$_importers, t3 = type$.Record_1_nullable_Object, t4 = $async$self._async_import_cache$_perImporterCanonicalizeCache, t5 = type$.nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl, t6 = type$.Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl, cacheable = true, i = 0; + case 6: + // for condition + if (!(i < t2.length)) { + // goto after for + $async$goto = 8; + break; + } + importer = t2[i]; + perImporterKey = new A._Record_3_forImport(importer, url, forImport); + if (t4.containsKey$1(perImporterKey)) { + t7 = t4.$index(0, perImporterKey); + _1_0 = new A._Record_1(t7 == null ? t5._as(t7) : t7); + } else + _1_0 = null; + _1_2_isSet = t3._is(_1_0); + result = null; + if (_1_2_isSet) { + _1_2 = _1_0._0; + t7 = _1_2 != null; + if (t7) { + t6._as(_1_2); + result = _1_2; + } + } else { + _1_2 = null; + t7 = false; + } + if (t7) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + if (_1_2_isSet) + t7 = _1_2 == null; + else + t7 = false; + if (t7) { + // goto for update + $async$goto = 7; + break; + } + $async$goto = 10; + return A._asyncAwait($async$self._async_import_cache$_canonicalize$4(importer, url, baseUrl, forImport), $async$canonicalize$4$baseImporter$baseUrl$forImport); + case 10: + // returning from await. + _2_0 = $async$result; + _2_1 = _2_0._0; + _2_5_isSet = _2_1 != null; + _2_5 = null; + _2_3 = null; + t7 = false; + if (_2_5_isSet) { + result = _2_1 == null ? t6._as(_2_1) : _2_1; + _2_3 = _2_0._1; + t7 = _2_3; + _2_5 = t7; + t7 = t7 && cacheable; + } else + result = null; + if (t7) { + t1.$indexSet(0, key, result); + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + if (_2_5_isSet) { + t7 = _2_5; + _2_3_isSet = _2_5_isSet; + } else { + _2_3 = _2_0._1; + t7 = _2_3; + _2_3_isSet = true; + } + t7 = t7 && !cacheable; + if (t7) { + t4.$indexSet(0, perImporterKey, _2_1); + if (_2_1 != null) { + $async$returnValue = _2_1; + // goto return + $async$goto = 1; + break; + } + // goto break $label0$1 + $async$goto = 9; + break; + } + t7 = false === (_2_3_isSet ? _2_3 : _2_0._1); + if (t7) { + if (cacheable) { + for (j = 0; j < i; ++j) + t4.$indexSet(0, new A._Record_3_forImport(t2[j], url, forImport), null); + cacheable = false; + } + if (_2_1 != null) { + $async$returnValue = _2_1; + // goto return + $async$goto = 1; + break; + } + } + case 9: + // break $label0$1 + case 7: + // for update + ++i; + // goto for condition + $async$goto = 6; + break; + case 8: + // after for + if (cacheable) + t1.$indexSet(0, key, null); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$canonicalize$4$baseImporter$baseUrl$forImport, $async$completer); + }, + _async_import_cache$_canonicalize$4(importer, url, baseUrl, forImport) { + return this._canonicalize$body$AsyncImportCache(importer, url, baseUrl, forImport); + }, + _canonicalize$body$AsyncImportCache(importer, url, baseUrl, forImport) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_2_nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_and_bool), + $async$returnValue, t1, passContainingUrl, canonicalizeContext, result, cacheable; + var $async$_async_import_cache$_canonicalize$4 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = baseUrl != null ? 3 : 5; + break; + case 3: + // then + $async$goto = url.get$scheme() !== "" ? 6 : 8; + break; + case 6: + // then + t1 = A._Future$value(importer.isNonCanonicalScheme$1(url.get$scheme()), type$.bool); + $async$goto = 9; + return A._asyncAwait(t1, $async$_async_import_cache$_canonicalize$4); + case 9: + // returning from await. + t1 = $async$result; + passContainingUrl = t1; + // goto join + $async$goto = 7; + break; + case 8: + // else + passContainingUrl = true; + case 7: + // join + // goto join + $async$goto = 4; + break; + case 5: + // else + passContainingUrl = false; + case 4: + // join + canonicalizeContext = new A.CanonicalizeContext(forImport, passContainingUrl ? baseUrl : null); + t1 = type$.nullable_Object; + t1 = A.runZoned(new A.AsyncImportCache__canonicalize_closure(importer, url), A.LinkedHashMap_LinkedHashMap$_literal([B.Symbol__canonicalizeContext, canonicalizeContext], t1, t1), type$.FutureOr_nullable_Uri); + $async$goto = 10; + return A._asyncAwait(type$.Future_nullable_Uri._is(t1) ? t1 : A._Future$value(t1, type$.nullable_Uri), $async$_async_import_cache$_canonicalize$4); + case 10: + // returning from await. + result = $async$result; + cacheable = !passContainingUrl || !canonicalizeContext._wasContainingUrlAccessed; + if (result == null) { + $async$returnValue = new A._Record_2(null, cacheable); + // goto return + $async$goto = 1; + break; + } + $async$goto = result.get$scheme() !== "" ? 11 : 13; + break; + case 11: + // then + t1 = A._Future$value(importer.isNonCanonicalScheme$1(result.get$scheme()), type$.bool); + $async$goto = 14; + return A._asyncAwait(t1, $async$_async_import_cache$_canonicalize$4); + case 14: + // returning from await. + t1 = $async$result; + // goto join + $async$goto = 12; + break; + case 13: + // else + t1 = false; + case 12: + // join + if (t1) + throw A.wrapException("Importer " + importer.toString$0(0) + " canonicalized " + url.toString$0(0) + " to " + result.toString$0(0) + string$.x2c_whicu); + $async$returnValue = new A._Record_2(new A._Record_3_originalUrl(importer, result, url), cacheable); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_import_cache$_canonicalize$4, $async$completer); + }, + importCanonical$3$originalUrl(importer, canonicalUrl, originalUrl) { + return this.importCanonical$body$AsyncImportCache(importer, canonicalUrl, originalUrl); + }, + importCanonical$body$AsyncImportCache(importer, canonicalUrl, originalUrl) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Stylesheet), + $async$returnValue, $async$self = this; + var $async$importCanonical$3$originalUrl = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait(A.putIfAbsentAsync($async$self._async_import_cache$_importCache, canonicalUrl, new A.AsyncImportCache_importCanonical_closure($async$self, importer, canonicalUrl, originalUrl), type$.Uri, type$.nullable_Stylesheet), $async$importCanonical$3$originalUrl); + case 3: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$importCanonical$3$originalUrl, $async$completer); + }, + humanize$1(canonicalUrl) { + var t1 = this._async_import_cache$_canonicalizeCache, + t2 = type$.NonNullsIterable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl; + t2 = A.NullableExtension_andThen(A.minBy(new A.MappedIterable(new A.WhereIterable(new A.NonNullsIterable(new A.LinkedHashMapValuesIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapValuesIterable<2>")), t2), new A.AsyncImportCache_humanize_closure(canonicalUrl), t2._eval$1("WhereIterable")), new A.AsyncImportCache_humanize_closure0(), t2._eval$1("MappedIterable")), new A.AsyncImportCache_humanize_closure1()), new A.AsyncImportCache_humanize_closure2(canonicalUrl)); + return t2 == null ? canonicalUrl : t2; + }, + sourceMapUrl$1(_, canonicalUrl) { + var t1 = this._async_import_cache$_resultsCache.$index(0, canonicalUrl); + t1 = t1 == null ? null : t1.get$sourceMapUrl(0); + return t1 == null ? canonicalUrl : t1; + } + }; + A.AsyncImportCache_canonicalize_closure.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl), + $async$returnValue, $async$self = this, t1, t2, _0_0, result; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + t2 = $async$self.baseUrl; + $async$goto = 3; + return A._asyncAwait(t1._async_import_cache$_canonicalize$4($async$self.baseImporter, $async$self.resolvedUrl, t2, $async$self.forImport), $async$call$0); + case 3: + // returning from await. + _0_0 = $async$result; + result = _0_0._0; + _0_0._1; + if (t2 != null) + t1._async_import_cache$_nonCanonicalRelativeUrls.$indexSet(0, $async$self.key, $async$self.url); + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 468 + }; + A.AsyncImportCache__canonicalize_closure.prototype = { + call$0() { + return this.importer.canonicalize$1(0, this.url); + }, + $signature: 182 + }; + A.AsyncImportCache_importCanonical_closure.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Stylesheet), + $async$returnValue, $async$self = this, t1, t2, t3, result; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = Date.now(); + t2 = $async$self.canonicalUrl; + t3 = A._Future$value($async$self.importer.load$1(0, t2), type$.nullable_ImporterResult); + $async$goto = 3; + return A._asyncAwait(t3, $async$call$0); + case 3: + // returning from await. + result = $async$result; + if (result == null) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + t3 = $async$self.$this; + t3._async_import_cache$_loadTimes.$indexSet(0, t2, new A.DateTime(t1, 0, false)); + t3._async_import_cache$_resultsCache.$indexSet(0, t2, result); + t3 = result.contents; + t1 = result.syntax; + t2 = $async$self.originalUrl.resolveUri$1(t2); + $async$returnValue = A.Stylesheet_Stylesheet$parse(t3, t1, t2); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 487 + }; + A.AsyncImportCache_humanize_closure.prototype = { + call$1(result) { + return result._1.$eq(0, this.canonicalUrl); + }, + $signature: 507 + }; + A.AsyncImportCache_humanize_closure0.prototype = { + call$1(result) { + return result._2; + }, + $signature: 509 + }; + A.AsyncImportCache_humanize_closure1.prototype = { + call$1(url) { + return url.get$path(url).length; + }, + $signature: 80 + }; + A.AsyncImportCache_humanize_closure2.prototype = { + call$1(url) { + var t1 = $.$get$url(), + t2 = this.canonicalUrl; + return url.resolve$1(0, A.ParsedPath_ParsedPath$parse(t2.get$path(t2), t1.style).get$basename()); + }, + $signature: 50 + }; + A.AsyncBuiltInCallable.prototype = { + callbackFor$2(positional, names) { + return new A._Record_2(this._parameters, this._async_built_in$_callback); + }, + withDeprecationWarning$1(module) { + return new A.AsyncBuiltInCallable(this.name, this._parameters, new A.AsyncBuiltInCallable_withDeprecationWarning_closure(this, module, null), false); + }, + $isAsyncCallable: 1, + get$name(receiver) { + return this.name; + }, + get$acceptsContent() { + return this.acceptsContent; + } + }; + A.AsyncBuiltInCallable$mixin_closure.prototype = { + call$1($arguments) { + return this.$call$body$AsyncBuiltInCallable$mixin_closure($arguments); + }, + $call$body$AsyncBuiltInCallable$mixin_closure($arguments) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue, $async$self = this, t1; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.callback.call$1($arguments); + $async$goto = 3; + return A._asyncAwait(t1 instanceof A._Future ? t1 : A._Future$value(t1, type$.void), $async$call$1); + case 3: + // returning from await. + $async$returnValue = B.C__SassNull; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 187 + }; + A.AsyncBuiltInCallable_withDeprecationWarning_closure.prototype = { + call$1(args) { + var t1 = this.$this; + A.warnForDeprecation(string$.Global + this.module + "." + t1.name + string$.x20inste, B.Deprecation_1AX); + return t1._async_built_in$_callback.call$1(args); + }, + $signature: 568 + }; + A.BuiltInCallable.prototype = { + callbackFor$2(positional, names) { + var t1, t2, fuzzyMatch, minMismatchDistance, _i, overload, t3, mismatchDistance, t4; + for (t1 = this._overloads, t2 = t1.length, fuzzyMatch = null, minMismatchDistance = null, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + overload = t1[_i]; + t3 = overload._0; + if (t3.matches$2(positional, names)) + return overload; + mismatchDistance = t3.parameters.length - positional; + if (minMismatchDistance != null) { + t3 = Math.abs(mismatchDistance); + t4 = Math.abs(minMismatchDistance); + if (t3 > t4) + continue; + if (t3 === t4 && mismatchDistance < 0) + continue; + } + minMismatchDistance = mismatchDistance; + fuzzyMatch = overload; + } + if (fuzzyMatch != null) + return fuzzyMatch; + throw A.wrapException(A.StateError$("BuiltInCallable " + this.name + " may not have empty overloads.")); + }, + withName$1($name) { + return new A.BuiltInCallable($name, this._overloads, this.acceptsContent); + }, + withDeprecationWarning$2(module, newName) { + var t2, t3, _i, t4, t5, _this = this, + t1 = A._setArrayType([], type$.JSArray_Record_2_ParameterList_and_Value_Function_List_Value); + for (t2 = _this._overloads, t3 = t2.length, _i = 0; _i < t2.length; t2.length === t3 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + t4 = {}; + t5 = t2[_i]; + t4.$function = null; + t4.$function = t5._1; + t1.push(new A._Record_2(t5._0, new A.BuiltInCallable_withDeprecationWarning_closure(t4, _this, module, newName))); + } + return new A.BuiltInCallable(_this.name, t1, _this.acceptsContent); + }, + withDeprecationWarning$1(module) { + return this.withDeprecationWarning$2(module, null); + }, + $isCallable0: 1, + $isAsyncCallable: 1, + $isAsyncBuiltInCallable: 1, + get$name(receiver) { + return this.name; + }, + get$acceptsContent() { + return this.acceptsContent; + } + }; + A.BuiltInCallable$mixin_closure.prototype = { + call$1($arguments) { + this.callback.call$1($arguments); + return B.C__SassNull; + }, + $signature: 4 + }; + A.BuiltInCallable_withDeprecationWarning_closure.prototype = { + call$1(args) { + var _this = this, + t1 = _this.newName; + if (t1 == null) + t1 = _this.$this.name; + A.warnForDeprecation(string$.Global + _this.module + "." + t1 + string$.x20inste, B.Deprecation_1AX); + return _this._box_0.$function.call$1(args); + }, + $signature: 4 + }; + A.PlainCssCallable.prototype = { + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.PlainCssCallable && this.name === other.name; + }, + get$hashCode(_) { + return B.JSString_methods.get$hashCode(this.name); + }, + $isCallable0: 1, + $isAsyncCallable: 1, + get$name(receiver) { + return this.name; + } + }; + A.UserDefinedCallable.prototype = { + get$name(_) { + return this.declaration.name; + }, + $isCallable0: 1, + $isAsyncCallable: 1 + }; + A._compileStylesheet_closure.prototype = { + call$1(url) { + var t1; + if (url === "") { + t1 = this.stylesheet.span; + t1 = A.Uri_Uri$dataFromString(A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1.get$file(t1)._decodedChars, 0, null), 0, null), B.C_Utf8Codec, null).get$_text(); + } else + t1 = this.importCache.sourceMapUrl$1(0, A.Uri_parse(url)).toString$0(0); + return t1; + }, + $signature: 6 + }; + A.CompileResult.prototype = {}; + A.Configuration.prototype = { + throughForward$1($forward) { + var _0_0, _1_0, _2_0, t1, hiddenVariables, + newValues = this._configuration$_values; + if (newValues.get$isEmpty(newValues)) + return B.Configuration_Map_empty_null; + _0_0 = $forward.prefix; + if (_0_0 != null) + newValues = new A.UnprefixedMapView(newValues, _0_0, type$.UnprefixedMapView_ConfiguredValue); + _1_0 = $forward.shownVariables; + if (_1_0 != null) + newValues = new A.LimitedMapView(newValues, _1_0._base.intersection$1(new A.MapKeySet(newValues, type$.MapKeySet_nullable_Object)), type$.LimitedMapView_String_ConfiguredValue); + else { + _2_0 = $forward.hiddenVariables; + if (_2_0 != null) { + t1 = _2_0._base.get$isNotEmpty(0); + hiddenVariables = _2_0; + } else { + hiddenVariables = null; + t1 = false; + } + if (t1) + newValues = A.LimitedMapView$blocklist(newValues, hiddenVariables, type$.String, type$.ConfiguredValue); + } + return this._withValues$1(newValues); + }, + _withValues$1(values) { + var t1 = this.__originalConfiguration; + return new A.Configuration(values, t1 == null ? this : t1); + }, + toString$0(_) { + var t2, t3, + t1 = A._setArrayType([], type$.JSArray_String); + for (t2 = A.MapExtensions_get_pairs(new A.UnmodifiableMapView(this._configuration$_values, type$.UnmodifiableMapView_String_ConfiguredValue), type$.String, type$.ConfiguredValue), t2 = t2.get$iterator(t2); t2.moveNext$0();) { + t3 = t2.get$current(t2); + t1.push("$" + t3._0 + ": " + t3._1.toString$0(0)); + } + return "(" + B.JSArray_methods.join$1(t1, ",") + ")"; + } + }; + A.ExplicitConfiguration.prototype = { + _withValues$1(values) { + var t1 = this.__originalConfiguration; + if (t1 == null) + t1 = this; + return new A.ExplicitConfiguration(this.nodeWithSpan, values, t1); + } + }; + A.ConfiguredValue.prototype = { + toString$0(_) { + return this.value.toString$0(0); + } + }; + A.Deprecation.prototype = { + _enumToString$0() { + return "Deprecation." + this._name; + }, + toString$0(_) { + return this.id; + } + }; + A.Deprecation_fromId_closure.prototype = { + call$1(deprecation) { + return deprecation.id === this.id; + }, + $signature: 648 + }; + A.Environment.prototype = { + closure$0() { + var t4, t5, t6, _this = this, + t1 = _this._forwardedModules, + t2 = _this._nestedForwardedModules, + t3 = _this._variables; + t3 = A._setArrayType(t3.slice(0), A._arrayInstanceType(t3)); + t4 = _this._variableNodes; + t4 = A._setArrayType(t4.slice(0), A._arrayInstanceType(t4)); + t5 = _this._functions; + t5 = A._setArrayType(t5.slice(0), A._arrayInstanceType(t5)); + t6 = _this._mixins; + t6 = A._setArrayType(t6.slice(0), A._arrayInstanceType(t6)); + return A.Environment$_(_this._environment$_modules, _this._namespaceNodes, _this._globalModules, _this._importedModules, t1, t2, _this._allModules, t3, t4, t5, t6, _this._content); + }, + forwardModule$2(module, rule) { + var view, t1, t2, _this = this, + forwardedModules = _this._forwardedModules; + if (forwardedModules == null) + forwardedModules = _this._forwardedModules = A.LinkedHashMap_LinkedHashMap$_empty(type$.Module_Callable, type$.AstNode); + view = A.ForwardedModuleView_ifNecessary(module, rule, type$.Callable); + for (t1 = new A.LinkedHashMapKeyIterator(forwardedModules, forwardedModules.__js_helper$_modifications, forwardedModules.__js_helper$_first); t1.moveNext$0();) { + t2 = t1.__js_helper$_current; + _this._assertNoConflicts$5(view.get$variables(), t2.get$variables(), view, t2, "variable"); + _this._assertNoConflicts$5(view.get$functions(view), t2.get$functions(t2), view, t2, "function"); + _this._assertNoConflicts$5(view.get$mixins(), t2.get$mixins(), view, t2, "mixin"); + } + _this._allModules.push(module); + forwardedModules.$indexSet(0, view, rule); + }, + _assertNoConflicts$5(newMembers, oldMembers, newModule, oldModule, type) { + var larger, smaller, t1, t2, t3, t4, $name, small, large, span; + if (newMembers.get$length(newMembers) < oldMembers.get$length(oldMembers)) { + larger = oldMembers; + smaller = newMembers; + } else { + larger = newMembers; + smaller = oldMembers; + } + for (t1 = type$.String, t2 = A.MapExtensions_get_pairs(smaller, t1, type$.Object), t2 = t2.get$iterator(t2), t3 = type === "variable"; t2.moveNext$0();) { + t4 = t2.get$current(t2); + $name = t4._0; + small = t4._1; + large = larger.$index(0, $name); + if (large == null) + continue; + if (t3 ? newModule.variableIdentity$1($name) === oldModule.variableIdentity$1($name) : J.$eq$(large, small)) + continue; + if (t3) + $name = "$" + $name; + t2 = this._forwardedModules; + if (t2 == null) + span = null; + else { + t2 = t2.$index(0, oldModule); + span = t2 == null ? null : t2.get$span(t2); + } + t2 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, t1); + if (span != null) + t2.$indexSet(0, span, "original @forward"); + throw A.wrapException(A.MultiSpanSassScriptException$("Two forwarded modules both define a " + type + " named " + $name + ".", "new @forward", t2)); + } + }, + importForwards$1(module) { + var forwardedModules, t1, t2, t3, t4, node, t5, t6, t7, t8, t9, t10, _i, t11, shadowed, t12, t13, _length, _list, _this = this, + forwarded = module._environment$_environment._forwardedModules; + if (forwarded == null) + return; + forwardedModules = _this._forwardedModules; + if (forwardedModules != null) { + t1 = type$.Module_Callable; + t2 = type$.AstNode; + t3 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t1 = A.MapExtensions_get_pairs(forwarded, t1, t2), t1 = t1.get$iterator(t1), t2 = _this._globalModules; t1.moveNext$0();) { + t4 = t1.get$current(t1); + module = t4._0; + node = t4._1; + if (!forwardedModules.containsKey$1(module) || !t2.containsKey$1(module)) + t3.$indexSet(0, module, node); + } + forwarded = t3; + } else + forwardedModules = _this._forwardedModules = A.LinkedHashMap_LinkedHashMap$_empty(type$.Module_Callable, type$.AstNode); + t1 = type$.String; + t2 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + for (t3 = new A.LinkedHashMapKeyIterator(forwarded, forwarded.__js_helper$_modifications, forwarded.__js_helper$_first); t3.moveNext$0();) + for (t4 = t3.__js_helper$_current.get$variables(), t4 = J.get$iterator$ax(t4.get$keys(t4)); t4.moveNext$0();) + t2.add$1(0, t4.get$current(t4)); + t3 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + for (t4 = new A.LinkedHashMapKeyIterator(forwarded, forwarded.__js_helper$_modifications, forwarded.__js_helper$_first); t4.moveNext$0();) { + t5 = t4.__js_helper$_current; + for (t5 = t5.get$functions(t5), t5 = J.get$iterator$ax(t5.get$keys(t5)); t5.moveNext$0();) + t3.add$1(0, t5.get$current(t5)); + } + t1 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + for (t4 = new A.LinkedHashMapKeyIterator(forwarded, forwarded.__js_helper$_modifications, forwarded.__js_helper$_first); t4.moveNext$0();) + for (t5 = t4.__js_helper$_current.get$mixins(), t5 = J.get$iterator$ax(t5.get$keys(t5)); t5.moveNext$0();) + t1.add$1(0, t5.get$current(t5)); + t4 = _this._variables; + t5 = t4.length; + if (t5 === 1) { + for (t5 = _this._importedModules, t6 = type$.Module_Callable, t7 = type$.AstNode, t8 = A.MapExtensions_get_pairs(t5, t6, t7).toList$0(0), t9 = t8.length, t10 = type$.Callable, _i = 0; _i < t8.length; t8.length === t9 || (0, A.throwConcurrentModificationError)(t8), ++_i) { + t11 = t8[_i]; + module = t11._0; + shadowed = A.ShadowedModuleView_ifNecessary(module, t3, t1, t2, t10); + if (shadowed != null) { + t5.remove$1(0, module); + t12 = shadowed.variables; + t13 = false; + if (t12.get$isEmpty(t12)) { + t12 = shadowed.functions; + if (t12.get$isEmpty(t12)) { + t12 = shadowed.mixins; + if (t12.get$isEmpty(t12)) { + t12 = shadowed._shadowed_view$_inner; + t12 = t12.get$css(t12); + t12 = J.get$isEmpty$asx(t12.get$children(t12)); + } else + t12 = t13; + } else + t12 = t13; + } else + t12 = t13; + if (!t12) + t5.$indexSet(0, shadowed, t11._1); + } + } + for (t6 = A.MapExtensions_get_pairs(forwardedModules, t6, t7).toList$0(0), t7 = t6.length, _i = 0; _i < t6.length; t6.length === t7 || (0, A.throwConcurrentModificationError)(t6), ++_i) { + t8 = t6[_i]; + module = t8._0; + shadowed = A.ShadowedModuleView_ifNecessary(module, t3, t1, t2, t10); + if (shadowed != null) { + forwardedModules.remove$1(0, module); + t9 = shadowed.variables; + t11 = false; + if (t9.get$isEmpty(t9)) { + t9 = shadowed.functions; + if (t9.get$isEmpty(t9)) { + t9 = shadowed.mixins; + if (t9.get$isEmpty(t9)) { + t9 = shadowed._shadowed_view$_inner; + t9 = t9.get$css(t9); + t9 = J.get$isEmpty$asx(t9.get$children(t9)); + } else + t9 = t11; + } else + t9 = t11; + } else + t9 = t11; + if (!t9) + forwardedModules.$indexSet(0, shadowed, t8._1); + } + } + t5.addAll$1(0, forwarded); + forwardedModules.addAll$1(0, forwarded); + } else { + t6 = _this._nestedForwardedModules; + if (t6 == null) { + _length = t5 - 1; + _list = J.JSArray_JSArray$allocateGrowable(_length, type$.List_Module_Callable); + for (t5 = type$.JSArray_Module_Callable, _i = 0; _i < _length; ++_i) + _list[_i] = A._setArrayType([], t5); + _this._nestedForwardedModules = _list; + t5 = _list; + } else + t5 = t6; + B.JSArray_methods.addAll$1(B.JSArray_methods.get$last(t5), new A.LinkedHashMapKeysIterable(forwarded, A._instanceType(forwarded)._eval$1("LinkedHashMapKeysIterable<1>"))); + } + for (t2 = A._LinkedHashSetIterator$(t2, t2._modifications, t2.$ti._precomputed1), t5 = _this._variableIndices, t6 = _this._variableNodes, t7 = t2.$ti._precomputed1; t2.moveNext$0();) { + t8 = t2._collection$_current; + if (t8 == null) + t8 = t7._as(t8); + t5.remove$1(0, t8); + J.remove$1$z(B.JSArray_methods.get$last(t4), t8); + J.remove$1$z(B.JSArray_methods.get$last(t6), t8); + } + for (t2 = A._LinkedHashSetIterator$(t3, t3._modifications, t3.$ti._precomputed1), t3 = _this._functionIndices, t4 = _this._functions, t5 = t2.$ti._precomputed1; t2.moveNext$0();) { + t6 = t2._collection$_current; + if (t6 == null) + t6 = t5._as(t6); + t3.remove$1(0, t6); + J.remove$1$z(B.JSArray_methods.get$last(t4), t6); + } + for (t1 = A._LinkedHashSetIterator$(t1, t1._modifications, t1.$ti._precomputed1), t2 = _this._mixinIndices, t3 = _this._mixins, t4 = t1.$ti._precomputed1; t1.moveNext$0();) { + t5 = t1._collection$_current; + if (t5 == null) + t5 = t4._as(t5); + t2.remove$1(0, t5); + J.remove$1$z(B.JSArray_methods.get$last(t3), t5); + } + }, + getVariable$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) + return _this._getModule$1(namespace).get$variables().$index(0, $name); + if (_this._lastVariableName === $name) { + t1 = _this._lastVariableIndex; + t1.toString; + t1 = _this._variables[t1].$index(0, $name); + return t1 == null ? _this._getVariableFromGlobalModule$1($name) : t1; + } + t1 = _this._variableIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + _this._lastVariableName = $name; + _this._lastVariableIndex = _0_0; + t1 = _this._variables[_0_0].$index(0, $name); + return t1 == null ? _this._getVariableFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._variableIndex$1($name); + if (_1_0 != null) { + _this._lastVariableName = $name; + _this._lastVariableIndex = _1_0; + t1.$indexSet(0, $name, _1_0); + t1 = _this._variables[_1_0].$index(0, $name); + return t1 == null ? _this._getVariableFromGlobalModule$1($name) : t1; + } else + return _this._getVariableFromGlobalModule$1($name); + } + }, + getVariable$1($name) { + return this.getVariable$2$namespace($name, null); + }, + _getVariableFromGlobalModule$1($name) { + return this._fromOneModule$3($name, "variable", new A.Environment__getVariableFromGlobalModule_closure($name)); + }, + getVariableNode$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) + return _this._getModule$1(namespace).get$variableNodes().$index(0, $name); + if (_this._lastVariableName === $name) { + t1 = _this._lastVariableIndex; + t1.toString; + t1 = _this._variableNodes[t1].$index(0, $name); + return t1 == null ? _this._getVariableNodeFromGlobalModule$1($name) : t1; + } + t1 = _this._variableIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + _this._lastVariableName = $name; + _this._lastVariableIndex = _0_0; + t1 = _this._variableNodes[_0_0].$index(0, $name); + return t1 == null ? _this._getVariableNodeFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._variableIndex$1($name); + if (_1_0 != null) { + _this._lastVariableName = $name; + _this._lastVariableIndex = _1_0; + t1.$indexSet(0, $name, _1_0); + t1 = _this._variableNodes[_1_0].$index(0, $name); + return t1 == null ? _this._getVariableNodeFromGlobalModule$1($name) : t1; + } else + return _this._getVariableNodeFromGlobalModule$1($name); + } + }, + _getVariableNodeFromGlobalModule$1($name) { + var t1, t2, _0_0; + for (t1 = this._importedModules, t2 = this._globalModules, t2 = new A.LinkedHashMapKeysIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapKeysIterable<1>")).followedBy$1(0, new A.LinkedHashMapKeysIterable(t2, A._instanceType(t2)._eval$1("LinkedHashMapKeysIterable<1>"))), t2 = new A.FollowedByIterator(J.get$iterator$ax(t2.__internal$_first), t2._second); t2.moveNext$0();) { + t1 = t2._currentIterator; + _0_0 = t1.get$current(t1).get$variableNodes().$index(0, $name); + if (_0_0 != null) + return _0_0; + } + return null; + }, + globalVariableExists$2$namespace($name, namespace) { + if (namespace != null) + return this._getModule$1(namespace).get$variables().containsKey$1($name); + if (B.JSArray_methods.get$first(this._variables).containsKey$1($name)) + return true; + return this._getVariableFromGlobalModule$1($name) != null; + }, + globalVariableExists$1($name) { + return this.globalVariableExists$2$namespace($name, null); + }, + _variableIndex$1($name) { + var t1, i; + for (t1 = this._variables, i = t1.length - 1; i >= 0; --i) + if (t1[i].containsKey$1($name)) + return i; + return null; + }, + setVariable$5$global$namespace($name, value, nodeWithSpan, global, namespace) { + var t1, moduleWithName, nestedForwardedModules, t2, t3, t4, t5, index, _this = this; + if (namespace != null) { + _this._getModule$1(namespace).setVariable$3($name, value, nodeWithSpan); + return; + } + if (global || _this._variables.length === 1) { + _this._variableIndices.putIfAbsent$2($name, new A.Environment_setVariable_closure(_this, $name)); + t1 = _this._variables; + if (!B.JSArray_methods.get$first(t1).containsKey$1($name)) { + moduleWithName = _this._fromOneModule$3($name, "variable", new A.Environment_setVariable_closure0($name)); + if (moduleWithName != null) { + moduleWithName.setVariable$3($name, value, nodeWithSpan); + return; + } + } + J.$indexSet$ax(B.JSArray_methods.get$first(t1), $name, value); + J.$indexSet$ax(B.JSArray_methods.get$first(_this._variableNodes), $name, nodeWithSpan); + return; + } + nestedForwardedModules = _this._nestedForwardedModules; + if (nestedForwardedModules != null && !_this._variableIndices.containsKey$1($name) && _this._variableIndex$1($name) == null) + for (t1 = A._arrayInstanceType(nestedForwardedModules)._eval$1("ReversedListIterable<1>"), t2 = new A.ReversedListIterable(nestedForwardedModules, t1), t2 = new A.ListIterator(t2, t2.get$length(0), t1._eval$1("ListIterator")), t1 = t1._eval$1("ListIterable.E"); t2.moveNext$0();) { + t3 = t2.__internal$_current; + for (t3 = J.get$reversed$ax(t3 == null ? t1._as(t3) : t3), t4 = t3.$ti, t3 = new A.ListIterator(t3, t3.get$length(0), t4._eval$1("ListIterator")), t4 = t4._eval$1("ListIterable.E"); t3.moveNext$0();) { + t5 = t3.__internal$_current; + if (t5 == null) + t5 = t4._as(t5); + if (t5.get$variables().containsKey$1($name)) { + t5.setVariable$3($name, value, nodeWithSpan); + return; + } + } + } + if (_this._lastVariableName === $name) { + t1 = _this._lastVariableIndex; + t1.toString; + index = t1; + } else + index = _this._variableIndices.putIfAbsent$2($name, new A.Environment_setVariable_closure1(_this, $name)); + if (!_this._inSemiGlobalScope && index === 0) { + index = _this._variables.length - 1; + _this._variableIndices.$indexSet(0, $name, index); + } + _this._lastVariableName = $name; + _this._lastVariableIndex = index; + _this._variables[index].$indexSet(0, $name, value); + _this._variableNodes[index].$indexSet(0, $name, nodeWithSpan); + }, + setVariable$4$global($name, value, nodeWithSpan, global) { + return this.setVariable$5$global$namespace($name, value, nodeWithSpan, global, null); + }, + setLocalVariable$3($name, value, nodeWithSpan) { + var index, _this = this, + t1 = _this._variables, + t2 = t1.length; + _this._lastVariableName = $name; + index = _this._lastVariableIndex = t2 - 1; + _this._variableIndices.$indexSet(0, $name, index); + t1[index].$indexSet(0, $name, value); + _this._variableNodes[index].$indexSet(0, $name, nodeWithSpan); + }, + getFunction$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) { + t1 = _this._getModule$1(namespace); + return t1.get$functions(t1).$index(0, $name); + } + t1 = _this._functionIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + t1 = _this._functions[_0_0].$index(0, $name); + return t1 == null ? _this._getFunctionFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._functionIndex$1($name); + if (_1_0 != null) { + t1.$indexSet(0, $name, _1_0); + t1 = _this._functions[_1_0].$index(0, $name); + return t1 == null ? _this._getFunctionFromGlobalModule$1($name) : t1; + } else + return _this._getFunctionFromGlobalModule$1($name); + } + }, + getFunction$1($name) { + return this.getFunction$2$namespace($name, null); + }, + _getFunctionFromGlobalModule$1($name) { + return this._fromOneModule$3($name, "function", new A.Environment__getFunctionFromGlobalModule_closure($name)); + }, + _functionIndex$1($name) { + var t1, i; + for (t1 = this._functions, i = t1.length - 1; i >= 0; --i) + if (t1[i].containsKey$1($name)) + return i; + return null; + }, + getMixin$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) + return _this._getModule$1(namespace).get$mixins().$index(0, $name); + t1 = _this._mixinIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + t1 = _this._mixins[_0_0].$index(0, $name); + return t1 == null ? _this._getMixinFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._mixinIndex$1($name); + if (_1_0 != null) { + t1.$indexSet(0, $name, _1_0); + t1 = _this._mixins[_1_0].$index(0, $name); + return t1 == null ? _this._getMixinFromGlobalModule$1($name) : t1; + } else + return _this._getMixinFromGlobalModule$1($name); + } + }, + _getMixinFromGlobalModule$1($name) { + return this._fromOneModule$3($name, "mixin", new A.Environment__getMixinFromGlobalModule_closure($name)); + }, + _mixinIndex$1($name) { + var t1, i; + for (t1 = this._mixins, i = t1.length - 1; i >= 0; --i) + if (t1[i].containsKey$1($name)) + return i; + return null; + }, + withContent$2($content, callback) { + var oldContent = this._content; + this._content = $content; + callback.call$0(); + this._content = oldContent; + }, + asMixin$1(callback) { + var oldInMixin = this._inMixin; + this._inMixin = true; + callback.call$0(); + this._inMixin = oldInMixin; + }, + scope$1$3$semiGlobal$when(callback, semiGlobal, when) { + var wasInSemiGlobalScope, $name, name0, name1, t1, t2, t3, t4, t5, t6, _this = this; + semiGlobal = semiGlobal && _this._inSemiGlobalScope; + wasInSemiGlobalScope = _this._inSemiGlobalScope; + _this._inSemiGlobalScope = semiGlobal; + if (!when) + try { + t1 = callback.call$0(); + return t1; + } finally { + _this._inSemiGlobalScope = wasInSemiGlobalScope; + } + t1 = _this._variables; + t2 = type$.String; + B.JSArray_methods.add$1(t1, A.LinkedHashMap_LinkedHashMap$_empty(t2, type$.Value)); + t3 = _this._variableNodes; + B.JSArray_methods.add$1(t3, A.LinkedHashMap_LinkedHashMap$_empty(t2, type$.AstNode)); + t4 = _this._functions; + t5 = type$.Callable; + B.JSArray_methods.add$1(t4, A.LinkedHashMap_LinkedHashMap$_empty(t2, t5)); + t6 = _this._mixins; + B.JSArray_methods.add$1(t6, A.LinkedHashMap_LinkedHashMap$_empty(t2, t5)); + t5 = _this._nestedForwardedModules; + if (t5 != null) + t5.push(A._setArrayType([], type$.JSArray_Module_Callable)); + try { + t2 = callback.call$0(); + return t2; + } finally { + _this._inSemiGlobalScope = wasInSemiGlobalScope; + _this._lastVariableIndex = _this._lastVariableName = null; + for (t1 = J.get$iterator$ax(J.get$keys$z(B.JSArray_methods.removeLast$0(t1))), t2 = _this._variableIndices; t1.moveNext$0();) { + $name = t1.get$current(t1); + t2.remove$1(0, $name); + } + B.JSArray_methods.removeLast$0(t3); + for (t1 = J.get$iterator$ax(J.get$keys$z(B.JSArray_methods.removeLast$0(t4))), t2 = _this._functionIndices; t1.moveNext$0();) { + name0 = t1.get$current(t1); + t2.remove$1(0, name0); + } + for (t1 = J.get$iterator$ax(J.get$keys$z(B.JSArray_methods.removeLast$0(t6))), t2 = _this._mixinIndices; t1.moveNext$0();) { + name1 = t1.get$current(t1); + t2.remove$1(0, name1); + } + t1 = _this._nestedForwardedModules; + if (t1 != null) + t1.pop(); + } + }, + scope$1$1(callback) { + return this.scope$1$3$semiGlobal$when(callback, false, true); + }, + scope$1$2$when(callback, when) { + return this.scope$1$3$semiGlobal$when(callback, false, when); + }, + scope$1$2$semiGlobal(callback, semiGlobal) { + return this.scope$1$3$semiGlobal$when(callback, semiGlobal, true); + }, + toImplicitConfiguration$0() { + var t2, t3, t4, i, values, nodes, t5, t6, $name, value, + t1 = type$.String, + configuration = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.ConfiguredValue); + for (t2 = this._variables, t3 = type$.Value, t4 = this._variableNodes, i = 0; i < t2.length; ++i) { + values = t2[i]; + nodes = t4[i]; + for (t5 = A.MapExtensions_get_pairs(values, t1, t3), t5 = t5.get$iterator(t5); t5.moveNext$0();) { + t6 = t5.get$current(t5); + $name = t6._0; + value = t6._1; + t6 = nodes.$index(0, $name); + t6.toString; + configuration.$indexSet(0, $name, new A.ConfiguredValue(value, null, t6)); + } + } + return new A.Configuration(configuration, null); + }, + toModule$3(css, preModuleComments, extensionStore) { + return A._EnvironmentModule__EnvironmentModule(this, css, preModuleComments, extensionStore, A.NullableExtension_andThen(this._forwardedModules, new A.Environment_toModule_closure())); + }, + toDummyModule$0() { + return A._EnvironmentModule__EnvironmentModule(this, new A.CssStylesheet(new A.UnmodifiableListView(B.List_empty3, type$.UnmodifiableListView_CssNode), A.SourceFile$decoded(B.List_empty4, "").span$1(0, 0)), B.Map_empty0, B.C_EmptyExtensionStore, A.NullableExtension_andThen(this._forwardedModules, new A.Environment_toDummyModule_closure())); + }, + _getModule$1(namespace) { + var _0_0 = this._environment$_modules.$index(0, namespace); + if (_0_0 != null) + return _0_0; + throw A.wrapException(A.SassScriptException$('There is no module with the namespace "' + namespace + '".', null)); + }, + _fromOneModule$1$3($name, type, callback) { + var t1, t2, t3, t4, t5, _1_0, _2_0, value, identity, valueInModule, identityFromModule, module, node, + _0_0 = this._nestedForwardedModules; + if (_0_0 != null) + for (t1 = A._arrayInstanceType(_0_0)._eval$1("ReversedListIterable<1>"), t2 = new A.ReversedListIterable(_0_0, t1), t2 = new A.ListIterator(t2, t2.get$length(0), t1._eval$1("ListIterator")), t1 = t1._eval$1("ListIterable.E"); t2.moveNext$0();) { + t3 = t2.__internal$_current; + for (t3 = J.get$reversed$ax(t3 == null ? t1._as(t3) : t3), t4 = t3.$ti, t3 = new A.ListIterator(t3, t3.get$length(0), t4._eval$1("ListIterator")), t4 = t4._eval$1("ListIterable.E"); t3.moveNext$0();) { + t5 = t3.__internal$_current; + _1_0 = callback.call$1(t5 == null ? t4._as(t5) : t5); + if (_1_0 != null) + return _1_0; + } + } + for (t1 = this._importedModules, t1 = new A.LinkedHashMapKeyIterator(t1, t1.__js_helper$_modifications, t1.__js_helper$_first); t1.moveNext$0();) { + _2_0 = callback.call$1(t1.__js_helper$_current); + if (_2_0 != null) + return _2_0; + } + for (t1 = this._globalModules, t2 = new A.LinkedHashMapKeyIterator(t1, t1.__js_helper$_modifications, t1.__js_helper$_first), t3 = type$.Callable, value = null, identity = null; t2.moveNext$0();) { + t4 = t2.__js_helper$_current; + valueInModule = callback.call$1(t4); + if (valueInModule == null) + continue; + identityFromModule = t3._is(valueInModule) ? valueInModule : t4.variableIdentity$1($name); + if (identityFromModule.$eq(0, identity)) + continue; + if (value != null) { + t2 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + for (t3 = A.MapExtensions_get_pairs(t1, type$.Module_Callable, type$.AstNode), t3 = t3.get$iterator(t3), t4 = "includes " + type; t3.moveNext$0();) { + t1 = t3.get$current(t3); + module = t1._0; + node = t1._1; + if (callback.call$1(module) != null) + t2.$indexSet(0, node.get$span(node), t4); + } + throw A.wrapException(A.MultiSpanSassScriptException$("This " + type + string$.x20is_av, type + " use", t2)); + } + identity = identityFromModule; + value = valueInModule; + } + return value; + }, + _fromOneModule$3($name, type, callback) { + return this._fromOneModule$1$3($name, type, callback, type$.dynamic); + } + }; + A.Environment__getVariableFromGlobalModule_closure.prototype = { + call$1(module) { + return module.get$variables().$index(0, this.name); + }, + $signature: 275 + }; + A.Environment_setVariable_closure.prototype = { + call$0() { + var t1 = this.$this; + t1._lastVariableName = this.name; + return t1._lastVariableIndex = 0; + }, + $signature: 10 + }; + A.Environment_setVariable_closure0.prototype = { + call$1(module) { + return module.get$variables().containsKey$1(this.name) ? module : null; + }, + $signature: 285 + }; + A.Environment_setVariable_closure1.prototype = { + call$0() { + var t1 = this.$this, + t2 = t1._variableIndex$1(this.name); + return t2 == null ? t1._variables.length - 1 : t2; + }, + $signature: 10 + }; + A.Environment__getFunctionFromGlobalModule_closure.prototype = { + call$1(module) { + return module.get$functions(module).$index(0, this.name); + }, + $signature: 194 + }; + A.Environment__getMixinFromGlobalModule_closure.prototype = { + call$1(module) { + return module.get$mixins().$index(0, this.name); + }, + $signature: 194 + }; + A.Environment_toModule_closure.prototype = { + call$1(modules) { + return new A.MapKeySet(modules, type$.MapKeySet_Module_Callable); + }, + $signature: 197 + }; + A.Environment_toDummyModule_closure.prototype = { + call$1(modules) { + return new A.MapKeySet(modules, type$.MapKeySet_Module_Callable); + }, + $signature: 197 + }; + A._EnvironmentModule.prototype = { + get$url(_) { + var t1 = this.css; + t1 = t1.get$span(t1); + return t1.get$sourceUrl(t1); + }, + setVariable$3($name, value, nodeWithSpan) { + var t1, t2, + _0_0 = this._modulesByVariable.$index(0, $name); + if (_0_0 != null) { + _0_0.setVariable$3($name, value, nodeWithSpan); + return; + } + t1 = this._environment$_environment; + t2 = t1._variables; + if (!B.JSArray_methods.get$first(t2).containsKey$1($name)) + throw A.wrapException(A.SassScriptException$("Undefined variable.", null)); + J.$indexSet$ax(B.JSArray_methods.get$first(t2), $name, value); + J.$indexSet$ax(B.JSArray_methods.get$first(t1._variableNodes), $name, nodeWithSpan); + return; + }, + variableIdentity$1($name) { + var module = this._modulesByVariable.$index(0, $name); + return module == null ? this : module.variableIdentity$1($name); + }, + cloneCss$0() { + var _0_0, _this = this; + if (!_this.transitivelyContainsCss) + return _this; + _0_0 = A.cloneCssStylesheet(_this.css, _this.extensionStore); + return A._EnvironmentModule$_(_this._environment$_environment, _0_0._0, _this.preModuleComments, _0_0._1, _this._modulesByVariable, _this.variables, _this.variableNodes, _this.functions, _this.mixins, true, _this.transitivelyContainsExtensions); + }, + toString$0(_) { + var t1 = this.css, + t2 = t1.get$span(t1); + if (t2.get$sourceUrl(t2) == null) + t1 = ""; + else { + t1 = t1.get$span(t1); + t1 = t1.get$sourceUrl(t1); + t2 = $.$get$context(); + t1.toString; + t1 = t2.prettyUri$1(t1); + } + return t1; + }, + $isModule0: 1, + get$upstream() { + return this.upstream; + }, + get$variables() { + return this.variables; + }, + get$variableNodes() { + return this.variableNodes; + }, + get$functions(receiver) { + return this.functions; + }, + get$mixins() { + return this.mixins; + }, + get$extensionStore() { + return this.extensionStore; + }, + get$css(receiver) { + return this.css; + }, + get$preModuleComments() { + return this.preModuleComments; + }, + get$transitivelyContainsCss() { + return this.transitivelyContainsCss; + }, + get$transitivelyContainsExtensions() { + return this.transitivelyContainsExtensions; + } + }; + A._EnvironmentModule__EnvironmentModule_closure.prototype = { + call$1(module) { + return module.get$variables(); + }, + $signature: 302 + }; + A._EnvironmentModule__EnvironmentModule_closure0.prototype = { + call$1(module) { + return module.get$variableNodes(); + }, + $signature: 303 + }; + A._EnvironmentModule__EnvironmentModule_closure1.prototype = { + call$1(module) { + return module.get$functions(module); + }, + $signature: 198 + }; + A._EnvironmentModule__EnvironmentModule_closure2.prototype = { + call$1(module) { + return module.get$mixins(); + }, + $signature: 198 + }; + A._EnvironmentModule__EnvironmentModule_closure3.prototype = { + call$1(module) { + return module.get$transitivelyContainsCss(); + }, + $signature: 129 + }; + A._EnvironmentModule__EnvironmentModule_closure4.prototype = { + call$1(module) { + return module.get$transitivelyContainsExtensions(); + }, + $signature: 129 + }; + A.SassException.prototype = { + get$trace(_) { + return A.Trace$(A._setArrayType([A.frameForSpan(A.SourceSpanException.prototype.get$span.call(this, 0), "root stylesheet", null)], type$.JSArray_Frame), null); + }, + get$span(_) { + return A.SourceSpanException.prototype.get$span.call(this, 0); + }, + withAdditionalSpan$2(span, label) { + return A.MultiSpanSassException$(this._span_exception$_message, A.SourceSpanException.prototype.get$span.call(this, 0), "", A.LinkedHashMap_LinkedHashMap$_literal([span, label], type$.FileSpan, type$.String), this.loadedUrls); + }, + withTrace$1(trace) { + var t1 = A.SourceSpanException.prototype.get$span.call(this, 0), + t2 = A.Set_Set$unmodifiable(this.loadedUrls, type$.Uri); + return new A.SassRuntimeException(trace, t2, this._span_exception$_message, t1); + }, + withLoadedUrls$1(loadedUrls) { + var t1 = A.SourceSpanException.prototype.get$span.call(this, 0), + t2 = A.Set_Set$unmodifiable(loadedUrls, type$.Uri); + return new A.SassException(t2, this._span_exception$_message, t1); + }, + toString$1$color(_, color) { + var t2, _i, frame, t3, _this = this, + buffer = new A.StringBuffer(""), + t1 = "" + ("Error: " + _this._span_exception$_message + "\n"); + buffer._contents = t1; + buffer._contents = t1 + A.SourceSpanException.prototype.get$span.call(_this, 0).highlight$1$color(color); + for (t1 = _this.get$trace(_this).toString$0(0).split("\n"), t2 = t1.length, _i = 0; _i < t2; ++_i) { + frame = t1[_i]; + if (frame.length === 0) + continue; + t3 = buffer._contents += "\n"; + buffer._contents = t3 + (" " + frame); + } + t1 = buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + toString$0(_) { + return this.toString$1$color(0, null); + }, + toCssString$0() { + var commentMessage, stringMessage, rune, + t1 = $._glyphs, + t2 = $._glyphs = B.C_AsciiGlyphSet, + t3 = this.toString$1$color(0, false); + t3 = A.stringReplaceAllUnchecked(t3, "*/", "*\u2215"); + commentMessage = A.stringReplaceAllUnchecked(t3, "\r\n", "\n"); + $._glyphs = t1 === B.C_AsciiGlyphSet ? t2 : B.C_UnicodeGlyphSet; + stringMessage = new A.StringBuffer(""); + for (t1 = new A.RuneIterator(A.serializeValue(new A.SassString(this.toString$1$color(0, false), true), true, true)); t1.moveNext$0();) { + rune = t1._currentCodePoint; + if (rune > 127) { + t2 = A.Primitives_stringFromCharCode(92); + stringMessage._contents += t2; + t2 = B.JSInt_methods.toRadixString$1(rune, 16); + stringMessage._contents += t2; + t2 = A.Primitives_stringFromCharCode(32); + stringMessage._contents += t2; + } else { + t2 = A.Primitives_stringFromCharCode(rune); + stringMessage._contents += t2; + } + } + return "/* " + B.JSArray_methods.join$1(A._setArrayType(commentMessage.split("\n"), type$.JSArray_String), "\n * ") + ' */\n\nbody::before {\n font-family: "Source Code Pro", "SF Mono", Monaco, Inconsolata, "Fira Mono",\n "Droid Sans Mono", monospace, monospace;\n white-space: pre;\n display: block;\n padding: 1em;\n margin-bottom: 1em;\n border-bottom: 2px solid black;\n content: ' + stringMessage.toString$0(0) + ";\n}"; + } + }; + A.MultiSpanSassException.prototype = { + withAdditionalSpan$2(span, label) { + var _this = this, + t1 = A.SourceSpanException.prototype.get$span.call(_this, 0), + t2 = A.LinkedHashMap_LinkedHashMap$of(_this.secondarySpans, type$.FileSpan, type$.String); + t2.$indexSet(0, span, label); + return A.MultiSpanSassException$(_this._span_exception$_message, t1, _this.primaryLabel, t2, _this.loadedUrls); + }, + withTrace$1(trace) { + var _this = this; + return A.MultiSpanSassRuntimeException$(_this._span_exception$_message, A.SourceSpanException.prototype.get$span.call(_this, 0), _this.primaryLabel, _this.secondarySpans, trace, _this.loadedUrls); + }, + withLoadedUrls$1(loadedUrls) { + var _this = this; + return A.MultiSpanSassException$(_this._span_exception$_message, A.SourceSpanException.prototype.get$span.call(_this, 0), _this.primaryLabel, _this.secondarySpans, loadedUrls); + }, + toString$1$color(_, color) { + var t1, t2, _i, frame, t3, _this = this, + useColor = color === true, + buffer = new A.StringBuffer("Error: " + _this._span_exception$_message + "\n"); + A.NullableExtension_andThen(A.Highlighter$multiple(A.SourceSpanException.prototype.get$span.call(_this, 0), _this.primaryLabel, _this.secondarySpans, useColor, null, null).highlight$0(), buffer.get$write(buffer)); + for (t1 = _this.get$trace(_this).toString$0(0).split("\n"), t2 = t1.length, _i = 0; _i < t2; ++_i) { + frame = t1[_i]; + if (frame.length === 0) + continue; + t3 = buffer._contents += "\n"; + buffer._contents = t3 + (" " + frame); + } + t1 = buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + toString$0(_) { + return this.toString$1$color(0, null); + }, + get$primaryLabel() { + return this.primaryLabel; + }, + get$secondarySpans() { + return this.secondarySpans; + } + }; + A.SassRuntimeException.prototype = { + withAdditionalSpan$2(span, label) { + var _this = this; + return A.MultiSpanSassRuntimeException$(_this._span_exception$_message, A.SourceSpanException.prototype.get$span.call(_this, 0), "", A.LinkedHashMap_LinkedHashMap$_literal([span, label], type$.FileSpan, type$.String), _this.trace, _this.loadedUrls); + }, + withLoadedUrls$1(loadedUrls) { + var t1 = A.SourceSpanException.prototype.get$span.call(this, 0), + t2 = A.Set_Set$unmodifiable(loadedUrls, type$.Uri); + return new A.SassRuntimeException(this.trace, t2, this._span_exception$_message, t1); + }, + get$trace(receiver) { + return this.trace; + } + }; + A.MultiSpanSassRuntimeException.prototype = { + withAdditionalSpan$2(span, label) { + var _this = this, + t1 = A.SourceSpanException.prototype.get$span.call(_this, 0), + t2 = A.LinkedHashMap_LinkedHashMap$of(_this.secondarySpans, type$.FileSpan, type$.String); + t2.$indexSet(0, span, label); + return A.MultiSpanSassRuntimeException$(_this._span_exception$_message, t1, _this.primaryLabel, t2, _this.trace, _this.loadedUrls); + }, + withLoadedUrls$1(loadedUrls) { + var _this = this; + return A.MultiSpanSassRuntimeException$(_this._span_exception$_message, A.SourceSpanException.prototype.get$span.call(_this, 0), _this.primaryLabel, _this.secondarySpans, _this.trace, loadedUrls); + }, + $isSassRuntimeException: 1, + get$trace(receiver) { + return this.trace; + } + }; + A.SassFormatException.prototype = { + get$source() { + var t1 = A.SourceSpanException.prototype.get$span.call(this, 0); + return A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1.get$file(t1)._decodedChars, 0, null), 0, null); + }, + withAdditionalSpan$2(span, label) { + return A.MultiSpanSassFormatException$(this._span_exception$_message, A.SourceSpanException.prototype.get$span.call(this, 0), "", A.LinkedHashMap_LinkedHashMap$_literal([span, label], type$.FileSpan, type$.String), this.loadedUrls); + }, + withLoadedUrls$1(loadedUrls) { + var t1 = A.SourceSpanException.prototype.get$span.call(this, 0), + t2 = A.Set_Set$unmodifiable(loadedUrls, type$.Uri); + return new A.SassFormatException(t2, this._span_exception$_message, t1); + }, + $isFormatException: 1, + $isSourceSpanFormatException: 1 + }; + A.MultiSpanSassFormatException.prototype = { + get$source() { + var t1 = A.SourceSpanException.prototype.get$span.call(this, 0); + return A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1.get$file(t1)._decodedChars, 0, null), 0, null); + }, + withAdditionalSpan$2(span, label) { + var _this = this, + t1 = A.SourceSpanException.prototype.get$span.call(_this, 0), + t2 = A.LinkedHashMap_LinkedHashMap$of(_this.secondarySpans, type$.FileSpan, type$.String); + t2.$indexSet(0, span, label); + return A.MultiSpanSassFormatException$(_this._span_exception$_message, t1, _this.primaryLabel, t2, _this.loadedUrls); + }, + withLoadedUrls$1(loadedUrls) { + var _this = this; + return A.MultiSpanSassFormatException$(_this._span_exception$_message, A.SourceSpanException.prototype.get$span.call(_this, 0), _this.primaryLabel, _this.secondarySpans, loadedUrls); + }, + $isFormatException: 1, + $isSassFormatException: 1, + $isSourceSpanFormatException: 1, + $isMultiSourceSpanFormatException: 1 + }; + A.SassScriptException.prototype = { + withSpan$1(span) { + return new A.SassException(B.Set_empty, this.message, span); + }, + toString$0(_) { + return this.message + string$.x0a_BUG_; + }, + get$message(receiver) { + return this.message; + } + }; + A.MultiSpanSassScriptException.prototype = { + withSpan$1(span) { + return A.MultiSpanSassException$(this.message, span, this.primaryLabel, this.secondarySpans, null); + } + }; + A._writeSourceMap_closure.prototype = { + call$1(url) { + return this.options.sourceMapUrl$2(0, A.Uri_parse(url), this.destination).toString$0(0); + }, + $signature: 6 + }; + A.ExecutableOptions.prototype = { + get$interactive() { + var result, _this = this, + value = _this.__ExecutableOptions_interactive_FI; + if (value === $) { + result = new A.ExecutableOptions_interactive_closure(_this).call$0(); + _this.__ExecutableOptions_interactive_FI !== $ && A.throwUnnamedLateFieldADI(); + _this.__ExecutableOptions_interactive_FI = result; + value = result; + } + return value; + }, + get$color() { + var t1 = this._options; + return t1.wasParsed$1("color") ? A._asBool(t1.$index(0, "color")) : A.hasTerminal(); + }, + get$pkgImporters() { + var t2, t3, t4, _null = null, + t1 = A._setArrayType([], type$.JSArray_Importer); + for (t2 = J.get$iterator$ax(type$.List_String._as(this._options.$index(0, "pkg-importer"))); t2.moveNext$0();) { + t2.get$current(t2); + t3 = new A.NodePackageImporter(); + t4 = self.process; + if (t4 == null) + t4 = _null; + else { + t4 = J.get$release$x(t4); + t4 = t4 == null ? _null : J.get$name$x(t4); + } + if (!J.$eq$(t4, "node") && self.document != null && typeof self.document.querySelector == "function") + A.throwExpression(string$.The_No); + t3.__NodePackageImporter__entryPointDirectory_F = $.$get$context().absolute$15(".", _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null); + t1.push(t3); + } + return t1; + }, + get$emitErrorCss() { + var t1 = A._asBoolQ(this._options.$index(0, "error-css")); + if (t1 == null) { + this._ensureSources$0(); + t1 = this._sourcesToDestinations; + t1 = t1.get$values(t1); + t1 = t1.any$1(t1, new A.ExecutableOptions_emitErrorCss_closure()); + } + return t1; + }, + _ensureSources$0() { + var t1, stdin, t2, t3, $directories, t4, t5, t6, colonArgs, positionalArgs, t7, t8, t9, message, target, source, destination, seen, _0_0, _this = this, _null = null, + _s18_ = 'Duplicate source "'; + if (_this._sourcesToDestinations != null) + return; + t1 = _this._options; + stdin = A._asBool(t1.$index(0, "stdin")); + t2 = t1.rest; + if (t2.get$length(0) === 0 && !stdin) + A.ExecutableOptions__fail("Compile Sass to CSS."); + t3 = type$.String; + $directories = A.LinkedHashSet_LinkedHashSet$_empty(t3); + for (t4 = t2.$ti, t5 = t4._eval$1("ListIterator"), t6 = new A.ListIterator(t2, t2.get$length(0), t5), t4 = t4._eval$1("ListBase.E"), colonArgs = false, positionalArgs = false; t6.moveNext$0();) { + t7 = t6.__internal$_current; + if (t7 == null) + t7 = t4._as(t7); + t8 = t7.length; + if (t8 === 0) + A.ExecutableOptions__fail('Invalid argument "".'); + if (A.stringContainsUnchecked(t7, ":", 0)) { + if (t8 > 2) { + t9 = t7.charCodeAt(0); + if (!(t9 >= 97 && t9 <= 122)) + t9 = t9 >= 65 && t9 <= 90; + else + t9 = true; + t9 = t9 && t7.charCodeAt(1) === 58; + } else + t9 = false; + if (t9) { + if (2 > t8) + A.throwExpression(A.RangeError$range(2, 0, t8, _null, _null)); + t8 = A.stringContainsUnchecked(t7, ":", 2); + } else + t8 = true; + } else + t8 = false; + if (t8) + colonArgs = true; + else if (A.dirExists(t7)) + $directories.add$1(0, t7); + else + positionalArgs = true; + } + if (positionalArgs || t2.get$length(0) === 0) { + if (colonArgs) + A.ExecutableOptions__fail('Positional and ":" arguments may not both be used.'); + else if (stdin) { + if (J.get$length$asx(t2._collection$_source) > 1) + A.ExecutableOptions__fail("Only one argument is allowed with --stdin."); + else if (A._asBool(t1.$index(0, "update"))) + A.ExecutableOptions__fail("--update is not allowed with --stdin."); + else if (A._asBool(t1.$index(0, "watch"))) + A.ExecutableOptions__fail("--watch is not allowed with --stdin."); + t1 = t2.get$length(0) === 0 ? _null : t2.get$first(t2); + t2 = type$.dynamic; + t3 = type$.nullable_String; + _this._sourcesToDestinations = A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_literal([null, t1], t2, t2), t3, t3); + } else { + t3 = t2._collection$_source; + t4 = J.getInterceptor$asx(t3); + if (t4.get$length(t3) > 2) + A.ExecutableOptions__fail("Only two positional args may be passed."); + else if ($directories._collection$_length !== 0) { + message = 'Directory "' + A.S($directories.get$first(0)) + '" may not be a positional arg.'; + target = t2.get$last(t2); + A.ExecutableOptions__fail(J.$eq$($directories.get$first(0), t2.get$first(t2)) && !A.fileExists(target) ? message + ('\nTo compile all CSS in "' + A.S($directories.get$first(0)) + '" to "' + target + '", use `sass ' + A.S($directories.get$first(0)) + ":" + target + "`.") : message); + } else { + source = J.$eq$(t2.get$first(t2), "-") ? _null : t2.get$first(t2); + destination = t4.get$length(t3) === 1 ? _null : t2.get$last(t2); + if (destination == null) + if (A._asBool(t1.$index(0, "update"))) + A.ExecutableOptions__fail("--update is not allowed when printing to stdout."); + else if (A._asBool(t1.$index(0, "watch"))) + A.ExecutableOptions__fail("--watch is not allowed when printing to stdout."); + t1 = A.PathMap__create(_null, type$.nullable_String); + t1.$indexSet(0, source, destination); + _this._sourcesToDestinations = new A.UnmodifiableMapView(new A.PathMap(t1, type$.PathMap_nullable_String), type$.UnmodifiableMapView_of_nullable_String_and_nullable_String); + } + } + _this.__ExecutableOptions__sourceDirectoriesToDestinations_F !== $ && A.throwUnnamedLateFieldAI(); + _this.__ExecutableOptions__sourceDirectoriesToDestinations_F = B.Map_empty; + return; + } + if (stdin) + A.ExecutableOptions__fail('--stdin may not be used with ":" arguments.'); + seen = A.LinkedHashSet_LinkedHashSet$_empty(t3); + t1 = A.PathMap__create(_null, t3); + t6 = type$.PathMap_String; + t3 = A.PathMap__create(_null, t3); + for (t2 = new A.ListIterator(t2, t2.get$length(0), t5); t2.moveNext$0();) { + t5 = t2.__internal$_current; + if (t5 == null) + t5 = t4._as(t5); + if ($directories.contains$1(0, t5)) { + if (!seen.add$1(0, t5)) + A.ExecutableOptions__fail(_s18_ + t5 + '".'); + t3.$indexSet(0, t5, t5); + t1.addAll$1(0, _this._listSourceDirectory$2(t5, t5)); + continue; + } + _0_0 = _this._splitSourceAndDestination$1(t5); + source = _0_0._0; + destination = _0_0._1; + if (!seen.add$1(0, source)) + A.ExecutableOptions__fail(_s18_ + source + '".'); + if (source === "-") + t1.$indexSet(0, _null, destination); + else if (A.dirExists(source)) { + t3.$indexSet(0, source, destination); + t1.addAll$1(0, _this._listSourceDirectory$2(source, destination)); + } else + t1.$indexSet(0, source, destination); + } + _this._sourcesToDestinations = new A.UnmodifiableMapView(new A.PathMap(t1, t6), type$.UnmodifiableMapView_of_nullable_String_and_nullable_String); + _this.__ExecutableOptions__sourceDirectoriesToDestinations_F !== $ && A.throwUnnamedLateFieldAI(); + _this.__ExecutableOptions__sourceDirectoriesToDestinations_F = new A.UnmodifiableMapView(new A.PathMap(t3, t6), type$.UnmodifiableMapView_of_nullable_String_and_String); + }, + _splitSourceAndDestination$1(argument) { + var t1, i, t2, t3, nextColon; + for (t1 = argument.length, i = 0; i < t1; ++i) { + t2 = false; + if (i === 1) { + t3 = i - 1; + if (t1 > t3 + 2) { + t2 = argument.charCodeAt(t3); + if (!(t2 >= 97 && t2 <= 122)) + t2 = t2 >= 65 && t2 <= 90; + else + t2 = true; + t2 = t2 && argument.charCodeAt(t3 + 1) === 58; + } + } + if (t2) + continue; + if (argument.charCodeAt(i) === 58) { + t2 = i + 1; + nextColon = B.JSString_methods.indexOf$2(argument, ":", t2); + t3 = false; + if (nextColon === i + 2) + if (t1 > t2 + 2) { + t1 = argument.charCodeAt(t2); + if (!(t1 >= 97 && t1 <= 122)) + t1 = t1 >= 65 && t1 <= 90; + else + t1 = true; + t1 = t1 && argument.charCodeAt(t2 + 1) === 58; + } else + t1 = t3; + else + t1 = t3; + if ((t1 ? B.JSString_methods.indexOf$2(argument, ":", nextColon + 1) : nextColon) !== -1) + A.ExecutableOptions__fail('"' + argument + '" may only contain one ":".'); + return new A._Record_2(B.JSString_methods.substring$2(argument, 0, i), B.JSString_methods.substring$1(argument, t2)); + } + } + throw A.wrapException(A.ArgumentError$('Expected "' + argument + '" to contain a colon.', null)); + }, + _listSourceDirectory$2(source, destination) { + var t2, t3, t4, t5, + t1 = type$.String; + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t2 = J.get$iterator$ax(A.listDir(source, true)), t3 = source === destination; t2.moveNext$0();) { + t4 = t2.get$current(t2); + if (this._isEntrypoint$1(t4)) + t5 = !(t3 && A.ParsedPath_ParsedPath$parse(t4, $.$get$context().style)._splitExtension$1(1)[1] === ".css"); + else + t5 = false; + if (t5) { + t5 = $.$get$context(); + t1.$indexSet(0, t4, A.join(destination, t5.withoutExtension$1(t5.relative$2$from(t4, source)) + ".css", null)); + } + } + return t1; + }, + _isEntrypoint$1(path) { + var extension, + t1 = $.$get$context().style; + if (B.JSString_methods.startsWith$1(A.ParsedPath_ParsedPath$parse(path, t1).get$basename(), "_")) + return false; + extension = A.ParsedPath_ParsedPath$parse(path, t1)._splitExtension$1(1)[1]; + return extension === ".scss" || extension === ".sass" || extension === ".css"; + }, + get$_writeToStdout() { + var t1, _this = this; + _this._ensureSources$0(); + t1 = _this._sourcesToDestinations; + if (t1.get$length(t1) === 1) { + _this._ensureSources$0(); + t1 = _this._sourcesToDestinations; + t1 = t1.get$values(t1); + t1 = t1.get$single(t1) == null; + } else + t1 = false; + return t1; + }, + get$emitSourceMap() { + var _this = this, + _s10_ = "source-map", + _s15_ = "source-map-urls", + _s13_ = "embed-sources", + _s16_ = "embed-source-map", + t1 = _this._options; + if (!A._asBool(t1.$index(0, _s10_))) + if (t1.wasParsed$1(_s15_)) + A.ExecutableOptions__fail("--source-map-urls isn't allowed with --no-source-map."); + else if (t1.wasParsed$1(_s13_)) + A.ExecutableOptions__fail("--embed-sources isn't allowed with --no-source-map."); + else if (t1.wasParsed$1(_s16_)) + A.ExecutableOptions__fail("--embed-source-map isn't allowed with --no-source-map."); + if (!_this.get$_writeToStdout()) + return A._asBool(t1.$index(0, _s10_)); + if (J.$eq$(_this._ifParsed$1(_s15_), "relative")) + A.ExecutableOptions__fail("--source-map-urls=relative isn't allowed when printing to stdout."); + if (A._asBool(t1.$index(0, _s16_))) + return A._asBool(t1.$index(0, _s10_)); + else if (J.$eq$(_this._ifParsed$1(_s10_), true)) + A.ExecutableOptions__fail("When printing to stdout, --source-map requires --embed-source-map."); + else if (t1.wasParsed$1(_s15_)) + A.ExecutableOptions__fail("When printing to stdout, --source-map-urls requires --embed-source-map."); + else if (A._asBool(t1.$index(0, _s13_))) + A.ExecutableOptions__fail("When printing to stdout, --embed-sources requires --embed-source-map."); + else + return false; + }, + sourceMapUrl$2(_, url, destination) { + var t1, path, t2, _null = null; + if (url.get$scheme().length !== 0 && url.get$scheme() !== "file") + return url; + t1 = $.$get$context(); + path = t1.style.pathFromUri$1(A._parseUri(url)); + if (J.$eq$(this._options.$index(0, "source-map-urls"), "relative") && !this.get$_writeToStdout()) { + destination.toString; + t2 = t1.relative$2$from(path, t1.dirname$1(destination)); + } else + t2 = A.absolute(path, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null); + return t1.toUri$1(t2); + }, + get$silenceDeprecations(_) { + var t2, t3, t4, + t1 = A.LinkedHashSet_LinkedHashSet$_empty(type$.Deprecation); + for (t2 = J.get$iterator$ax(type$.List_String._as(this._options.$index(0, "silence-deprecation"))); t2.moveNext$0();) { + t3 = t2.get$current(t2); + t4 = A.Deprecation_fromId(t3); + t1.add$1(0, t4 == null ? A.ExecutableOptions__fail('Invalid deprecation "' + t3 + '".') : t4); + } + return t1; + }, + get$fatalDeprecations(_) { + var t1 = this._fatalDeprecations; + return t1 == null ? this._fatalDeprecations = new A.ExecutableOptions_fatalDeprecations_closure(this).call$0() : t1; + }, + get$futureDeprecations(_) { + var t2, t3, t4, + t1 = A.LinkedHashSet_LinkedHashSet$_empty(type$.Deprecation); + for (t2 = J.get$iterator$ax(type$.List_String._as(this._options.$index(0, "future-deprecation"))); t2.moveNext$0();) { + t3 = t2.get$current(t2); + t4 = A.Deprecation_fromId(t3); + t1.add$1(0, t4 == null ? A.ExecutableOptions__fail('Invalid deprecation "' + t3 + '".') : t4); + } + return t1; + }, + _ifParsed$1($name) { + var t1 = this._options; + return t1.wasParsed$1($name) ? t1.$index(0, $name) : null; + } + }; + A.ExecutableOptions__parser_closure.prototype = { + call$0() { + var t1 = type$.String, + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Option), + t3 = A._setArrayType([], type$.JSArray_Object), + parser = new A.ArgParser(t2, A.LinkedHashMap_LinkedHashMap$_empty(t1, t1), new A.UnmodifiableMapView(t2, type$.UnmodifiableMapView_String_Option), new A.UnmodifiableMapView(A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.ArgParser), type$.UnmodifiableMapView_String_ArgParser), t3, true, null); + parser.addOption$2$hide("precision", true); + parser.addFlag$2$hide("async", true); + t3.push(A.ExecutableOptions__separator("Input and Output")); + parser.addFlag$2$help("stdin", "Read the stylesheet from stdin."); + parser.addFlag$2$help("indented", "Use the indented syntax for input from stdin."); + parser.addMultiOption$5$abbr$help$splitCommas$valueHelp("load-path", "I", "A path to use when resolving imports.\nMay be passed multiple times.", false, "PATH"); + t2 = type$.JSArray_String; + parser.addMultiOption$6$abbr$allowed$allowedHelp$help$valueHelp("pkg-importer", "p", A._setArrayType(["node"], t2), A.LinkedHashMap_LinkedHashMap$_literal(["node", "Load files like Node.js package resolution."], t1, t1), "Built-in importer(s) to use for pkg: URLs.", "TYPE"); + parser.addOption$6$abbr$allowed$defaultsTo$help$valueHelp("style", "s", A._setArrayType(["expanded", "compressed"], t2), "expanded", "Output style.", "NAME"); + parser.addFlag$3$defaultsTo$help("charset", true, "Emit a @charset or BOM for CSS with non-ASCII characters."); + parser.addFlag$3$defaultsTo$help("error-css", null, "When an error occurs, emit a stylesheet describing it.\nDefaults to true when compiling to a file."); + parser.addFlag$3$help$negatable("update", "Only compile out-of-date stylesheets.", false); + t3.push(A.ExecutableOptions__separator("Source Maps")); + parser.addFlag$3$defaultsTo$help("source-map", true, "Whether to generate source maps."); + parser.addOption$4$allowed$defaultsTo$help("source-map-urls", A._setArrayType(["relative", "absolute"], t2), "relative", "How to link from source maps to source files."); + parser.addFlag$3$defaultsTo$help("embed-sources", false, "Embed source file contents in source maps."); + parser.addFlag$3$defaultsTo$help("embed-source-map", false, "Embed source map contents in CSS."); + t3.push(A.ExecutableOptions__separator("Warnings")); + parser.addFlag$3$abbr$help("quiet", "q", "Don't print warnings."); + parser.addFlag$2$help("quiet-deps", "Don't print compiler warnings from dependencies.\nStylesheets imported through load paths count as dependencies."); + parser.addFlag$2$help("verbose", "Print all deprecation warnings even when they're repetitive."); + parser.addMultiOption$2$help("fatal-deprecation", "Deprecations to treat as errors. You may also pass a Sass\nversion to include any behavior deprecated in or before it.\nSee https://sass-lang.com/documentation/breaking-changes for \na complete list."); + parser.addMultiOption$2$help("silence-deprecation", "Deprecations to ignore."); + parser.addMultiOption$2$help("future-deprecation", "Opt in to a deprecation early."); + t3.push(A.ExecutableOptions__separator("Other")); + parser.addFlag$4$abbr$help$negatable("watch", "w", "Watch stylesheets and recompile when they change.", false); + parser.addFlag$2$help("poll", "Manually check for changes rather than using a native watcher.\nOnly valid with --watch."); + parser.addFlag$2$help("stop-on-error", "Don't compile more files once an error is encountered."); + parser.addFlag$4$abbr$help$negatable("interactive", "i", "Run an interactive SassScript shell.", false); + parser.addFlag$3$abbr$help("color", "c", "Whether to use terminal colors for messages."); + parser.addFlag$2$help("unicode", "Whether to use Unicode characters for messages."); + parser.addFlag$2$help("trace", "Print full Dart stack traces for exceptions."); + parser.addFlag$4$abbr$help$negatable("help", "h", "Print this usage information.", false); + parser.addFlag$3$help$negatable("version", "Print the version of Dart Sass.", false); + return parser; + }, + $signature: 308 + }; + A.ExecutableOptions_interactive_closure.prototype = { + call$0() { + var _0_0, + t1 = this.$this._options; + if (!A._asBool(t1.$index(0, "interactive"))) + return false; + _0_0 = A.IterableExtension_firstWhereOrNull(A._setArrayType(["stdin", "indented", "style", "source-map", "source-map-urls", "embed-sources", "embed-source-map", "update", "watch"], type$.JSArray_String), t1.get$wasParsed()); + if (_0_0 != null) + throw A.wrapException(A.UsageException$("--" + _0_0 + " isn't allowed with --interactive.")); + return true; + }, + $signature: 19 + }; + A.ExecutableOptions_emitErrorCss_closure.prototype = { + call$1(destination) { + return destination != null; + }, + $signature: 271 + }; + A.ExecutableOptions_fatalDeprecations_closure.prototype = { + call$0() { + var id, argVersion, sassVersion, t1, t2, _0_0, exception, + deprecations = A.LinkedHashSet_LinkedHashSet$_empty(type$.Deprecation); + for (t1 = J.get$iterator$ax(type$.List_String._as(this.$this._options.$index(0, "fatal-deprecation"))), t2 = type$.FormatException; t1.moveNext$0();) { + id = t1.get$current(t1); + _0_0 = A.Deprecation_fromId(id); + if (_0_0 != null) { + J.add$1$ax(deprecations, _0_0); + continue; + } + try { + argVersion = A.Version_Version$parse(id); + sassVersion = A.Version_Version$parse("1.86.3"); + if (J.compareTo$1$ns(argVersion, sassVersion) > 0) + A.ExecutableOptions__fail("Invalid version " + A.S(argVersion) + ". --fatal-deprecation requires a version less than or equal to the current Dart Sass version."); + J.addAll$1$ax(deprecations, A.Deprecation_forVersion(argVersion)); + } catch (exception) { + if (t2._is(A.unwrapException(exception))) + A.ExecutableOptions__fail('Invalid deprecation "' + A.S(id) + '".'); + else + throw exception; + } + } + return deprecations; + }, + $signature: 317 + }; + A.UsageException.prototype = {$isException: 1, + get$message(receiver) { + return this.message; + } + }; + A.repl_warn.prototype = { + call$1(warning) { + var _0_1, _0_3, deprecation, t1, _0_2, span, _null = null; + $label0$0: { + _0_1 = warning._1; + _0_3 = _null; + deprecation = _null; + t1 = false; + _0_2 = warning._2; + _0_3 = warning._0; + t1 = _0_3 != null; + if (t1) + deprecation = _0_3 == null ? type$.Deprecation._as(_0_3) : _0_3; + span = _0_2; + if (t1) { + A.WarnForDeprecation_warnForDeprecation(this.logger, deprecation, _0_1, span, _null); + break $label0$0; + } + t1 = false; + t1 = _0_3 == null; + span = _0_2; + if (t1) + this.logger.internalWarn$4$deprecation$span$trace(_0_1, _null, span, _null); + } + }, + $signature: 272 + }; + A.watch_closure.prototype = { + call$1(dir) { + for (; !A.dirExists(dir);) + dir = $.$get$context().dirname$1(dir); + return this.dirWatcher.watch$1(0, dir); + }, + $signature: 321 + }; + A._Watcher.prototype = { + _delete$1(path) { + var buffer, t1, exception; + try { + A.deleteFile(path); + buffer = new A.StringBuffer(""); + t1 = this._watch$_options; + if (t1.get$color()) + buffer._contents += "\x1b[33m"; + buffer._contents += "Deleted " + path + "."; + if (t1.get$color()) + buffer._contents += "\x1b[0m"; + A.print(buffer); + } catch (exception) { + if (!(A.unwrapException(exception) instanceof A.FileSystemException)) + throw exception; + } + }, + watch$1(_, watcher) { + return this.watch$body$_Watcher(0, watcher); + }, + watch$body$_Watcher(_, watcher) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$next = [], $async$self = this, batch, $event, extension, t1, toRecompile, success, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, url, _0_0, t2; + var $async$watch$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + t2 = watcher._group.__StreamGroup__controller_A; + t2 === $ && A.throwUnnamedLateFieldNI(); + t2 = new A._StreamIterator(A.checkNotNullable($async$self._debounceEvents$1(new A._ControllerStream(t2, A._instanceType(t2)._eval$1("_ControllerStream<1>"))), "stream", type$.Object)); + $async$handler = 3; + t3 = $async$self._toRecompile, t4 = type$.String, t5 = $async$self._watch$_options, t6 = $async$self._graph, t7 = t6._nodes, t8 = type$.JSArray_StylesheetNode, t9 = t5._options; + case 6: + // for condition + $async$goto = 8; + return A._asyncAwait(t2.moveNext$0(), $async$watch$1); + case 8: + // returning from await. + if (!$async$result) { + // goto after for + $async$goto = 7; + break; + } + batch = t2.get$current(0); + for (t10 = J.get$iterator$ax(batch); t10.moveNext$0();) { + $event = t10.get$current(t10); + t11 = $event.path; + t12 = $.$get$context(); + extension = A.ParsedPath_ParsedPath$parse(t11, t12.style)._splitExtension$1(1)[1]; + if (!J.$eq$(extension, ".sass") && !J.$eq$(extension, ".scss") && !J.$eq$(extension, ".css")) + continue; + switch ($event.type) { + case B.ChangeType_modify: + t11 = $event.path; + t13 = self.process; + if (t13 == null) + t13 = null; + else { + t13 = J.get$release$x(t13); + t13 = t13 == null ? null : J.get$name$x(t13); + } + t13 = J.$eq$(t13, "node") ? self.process : null; + if (!J.$eq$(t13 == null ? null : J.get$platform$x(t13), "win32")) { + t13 = self.process; + if (t13 == null) + t13 = null; + else { + t13 = J.get$release$x(t13); + t13 = t13 == null ? null : J.get$name$x(t13); + } + t13 = J.$eq$(t13, "node") ? self.process : null; + t13 = J.$eq$(t13 == null ? null : J.get$platform$x(t13), "darwin"); + } else + t13 = true; + url = t12.toUri$1(t13 ? A._realCasePath(t12.normalize$1(t12.absolute$15(t11, null, null, null, null, null, null, null, null, null, null, null, null, null, null))) : t12.canonicalize$1(0, t11)); + _0_0 = t7.$index(0, url); + if (_0_0 != null) { + t6.reload$1(url); + $async$self._recompileDownstream$1(A._setArrayType([_0_0], t8)); + } else + $async$self._handleAdd$1(t11); + break; + case B.ChangeType_add: + $async$self._handleAdd$1($event.path); + break; + case B.ChangeType_remove: + $async$self._handleRemove$1($event.path); + break; + } + } + t10 = A.LinkedHashMap_LinkedHashMap(null, null, null, t4, t4); + t10.addAll$1(0, t3); + t1 = t10; + toRecompile = t1; + t3.clear$0(0); + $async$goto = 9; + return A._asyncAwait(A.compileStylesheets(t5, t6, toRecompile, true), $async$watch$1); + case 9: + // returning from await. + success = $async$result; + if (!success && A._asBool(t9.$index(0, "stop-on-error"))) { + $async$next = [1]; + // goto finally + $async$goto = 4; + break; + } + // goto for condition + $async$goto = 6; + break; + case 7: + // after for + $async$next.push(5); + // goto finally + $async$goto = 4; + break; + case 3: + // uncaught + $async$next = [2]; + case 4: + // finally + $async$handler = 2; + $async$goto = 10; + return A._asyncAwait(t2.cancel$0(), $async$watch$1); + case 10: + // returning from await. + // goto the next finally handler + $async$goto = $async$next.pop(); + break; + case 5: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$watch$1, $async$completer); + }, + _handleAdd$1(path) { + var t1, t2, t3, t0, _this = this, _null = null, + destination = _this._destinationFor$1(path); + if (destination != null) + _this._toRecompile.$indexSet(0, path, destination); + t1 = $.$get$FilesystemImporter_cwd(); + t2 = A.isNodeJs() ? self.process : _null; + if (!J.$eq$(t2 == null ? _null : J.get$platform$x(t2), "win32")) { + t2 = A.isNodeJs() ? self.process : _null; + t2 = J.$eq$(t2 == null ? _null : J.get$platform$x(t2), "darwin"); + } else + t2 = true; + if (t2) { + t2 = A.absolute(path, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null); + t3 = $.$get$context(); + t2 = A._realCasePath(t3.normalize$1(t2)); + } else { + t2 = $.$get$context(); + t3 = t2.canonicalize$1(0, path); + t0 = t3; + t3 = t2; + t2 = t0; + } + _this._recompileDownstream$1(_this._graph.addCanonical$3(t1, t3.toUri$1(t2), t3.toUri$1(path))); + }, + _handleRemove$1(path) { + return this._handleRemove$body$_Watcher(path); + }, + _handleRemove$body$_Watcher(path) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t2, t0, url, _0_0, t1; + var $async$_handleRemove$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = A.isNodeJs() ? self.process : null; + if (!J.$eq$(t1 == null ? null : J.get$platform$x(t1), "win32")) { + t1 = A.isNodeJs() ? self.process : null; + t1 = J.$eq$(t1 == null ? null : J.get$platform$x(t1), "darwin"); + } else + t1 = true; + if (t1) { + t1 = A.absolute(path, null, null, null, null, null, null, null, null, null, null, null, null, null, null); + t2 = $.$get$context(); + t1 = A._realCasePath(t2.normalize$1(t1)); + } else { + t1 = $.$get$context(); + t2 = t1.canonicalize$1(0, path); + t0 = t2; + t2 = t1; + t1 = t0; + } + url = t2.toUri$1(t1); + t1 = $async$self._graph; + if (t1._nodes.containsKey$1(url)) { + _0_0 = $async$self._destinationFor$1(path); + if (_0_0 != null) + $async$self._delete$1(_0_0); + } + $async$self._recompileDownstream$1(t1.remove$2(0, $.$get$FilesystemImporter_cwd(), url)); + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$_handleRemove$1, $async$completer); + }, + _debounceEvents$1(events) { + var t1 = type$.WatchEvent; + t1 = A.RateLimit__debounceAggregate(events, A.Duration$(0, 25), A.instantiate1(A.rate_limit___collect$closure(), t1), false, true, t1, type$.List_WatchEvent); + return new A._MapStream(new A._Watcher__debounceEvents_closure(), t1, A._instanceType(t1)._eval$1("_MapStream>")); + }, + _recompileDownstream$1(nodes) { + var t1, t2, t3, t4, t5, t6, _i, + seen = A.LinkedHashSet_LinkedHashSet$_empty(type$.StylesheetNode); + for (t1 = type$.UnmodifiableSetView_StylesheetNode, t2 = this._toRecompile, t3 = type$.JSArray_StylesheetNode; t4 = J.getInterceptor$asx(nodes), t4.get$isNotEmpty(nodes); nodes = t4) { + t5 = A._setArrayType([], t3); + for (t4 = t4.get$iterator(nodes); t4.moveNext$0();) { + t6 = t4.get$current(t4); + if (seen.add$1(0, t6)) + t5.push(t6); + } + t2.addAll$1(0, this._sourceEntrypointsToDestinations$1(t5)); + t4 = A._setArrayType([], t3); + for (t6 = t5.length, _i = 0; _i < t5.length; t5.length === t6 || (0, A.throwConcurrentModificationError)(t5), ++_i) + B.JSArray_methods.addAll$1(t4, new A.UnmodifiableSetView0(t5[_i]._downstream, t1)); + } + }, + _sourceEntrypointsToDestinations$1(nodes) { + var _i, url, source, _0_0, + t1 = type$.String, + entrypoints = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t1 = nodes.length, _i = 0; _i < nodes.length; nodes.length === t1 || (0, A.throwConcurrentModificationError)(nodes), ++_i) { + url = nodes[_i].canonicalUrl; + if (url.get$scheme() !== "file") + continue; + source = $.$get$context().style.pathFromUri$1(A._parseUri(url)); + _0_0 = this._destinationFor$1(source); + if (_0_0 != null) + entrypoints.$indexSet(0, source, _0_0); + } + return entrypoints; + }, + _destinationFor$1(source) { + var t2, _0_0, t3, sourceDir, destinationDir, destination, + t1 = this._watch$_options; + t1._ensureSources$0(); + t2 = type$.String; + _0_0 = t1._sourcesToDestinations.cast$2$0(0, t2, t2).$index(0, source); + if (_0_0 != null) + return _0_0; + t3 = $.$get$context(); + if (B.JSString_methods.startsWith$1(A.ParsedPath_ParsedPath$parse(source, t3.style).get$basename(), "_")) + return null; + t1._ensureSources$0(); + t1 = t1.__ExecutableOptions__sourceDirectoriesToDestinations_F; + t1 === $ && A.throwUnnamedLateFieldNI(); + t2 = A.MapExtensions_get_pairs(t1.cast$2$0(0, t2, t2), t2, t2); + t2 = t2.get$iterator(t2); + for (; t2.moveNext$0();) { + t1 = t2.get$current(t2); + sourceDir = t1._0; + destinationDir = t1._1; + if (t3._isWithinOrEquals$2(sourceDir, source) !== B._PathRelation_within) + continue; + destination = A.join(destinationDir, t3.withoutExtension$1(t3.relative$2$from(source, sourceDir)) + ".css", null); + if (t3._isWithinOrEquals$2(destination, source) !== B._PathRelation_equal) + return destination; + } + return null; + } + }; + A._Watcher__debounceEvents_closure.prototype = { + call$1(buffer) { + var t3, t4, t5, oldType, newType, _1_1, + t1 = type$.ChangeType, + t2 = A.PathMap__create(null, t1); + for (t3 = J.get$iterator$ax(buffer); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t5 = t4.path; + oldType = t2.$index(0, t5); + newType = t4.type; + $label0$0: { + if (oldType == null) { + t4 = newType; + break $label0$0; + } + if (B.ChangeType_remove === newType) { + t4 = B.ChangeType_remove; + break $label0$0; + } + if (B.ChangeType_add === oldType) { + t4 = B.ChangeType_add; + break $label0$0; + } + t4 = B.ChangeType_modify; + break $label0$0; + } + t2.$indexSet(0, t5, t4); + } + t3 = A._setArrayType([], type$.JSArray_WatchEvent); + for (t1 = A.MapExtensions_get_pairs(new A.PathMap(t2, type$.PathMap_ChangeType), type$.nullable_String, t1), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t2 = t1.get$current(t1); + _1_1 = t2._0; + _1_1.toString; + t3.push(new A.WatchEvent(t2._1, _1_1)); + } + return t3; + }, + $signature: 323 + }; + A.EmptyExtensionStore.prototype = { + get$_extensions() { + return A.throwExpression(A.NoSuchMethodError_NoSuchMethodError$withInvocation(this, A.JSInvocationMirror$(B.Symbol__extensions, "get$_empty_extension_store$_extensions", 1, [], [], 0))); + }, + get$_sourceSpecificity() { + return A.throwExpression(A.NoSuchMethodError_NoSuchMethodError$withInvocation(this, A.JSInvocationMirror$(B.Symbol__sourceSpecificity, "get$_empty_extension_store$_sourceSpecificity", 1, [], [], 0))); + }, + get$isEmpty(_) { + return true; + }, + get$simpleSelectors() { + return B.C_EmptyUnmodifiableSet; + }, + extensionsWhereTarget$1(callback) { + return B.List_empty5; + }, + addExtensions$1(extenders) { + throw A.wrapException(A.UnsupportedError$(string$.addExt)); + }, + clone$0() { + return B.Record2_EmptyExtensionStore_Map_empty; + }, + $isExtensionStore: 1 + }; + A.Extension.prototype = { + toString$0(_) { + var t1 = this.extender.toString$0(0), + t2 = this.target.toString$0(0), + t3 = this.isOptional ? " !optional" : ""; + return t1 + " {@extend " + t2 + t3 + "}"; + } + }; + A.Extender.prototype = { + assertCompatibleMediaContext$1(mediaContext) { + var expectedMediaContext, + extension = this._extension; + if (extension == null) + return; + expectedMediaContext = extension.mediaContext; + if (expectedMediaContext == null) + return; + if (mediaContext != null && B.C_ListEquality.equals$2(0, expectedMediaContext, mediaContext)) + return; + throw A.wrapException(A.SassException$(string$.You_ma, extension.span, null)); + }, + toString$0(_) { + return A.serializeSelector(this.selector, true); + } + }; + A.ExtensionStore.prototype = { + get$isEmpty(_) { + return this._extensions.__js_helper$_length === 0; + }, + get$simpleSelectors() { + return new A.MapKeySet(this._selectors, type$.MapKeySet_SimpleSelector); + }, + extensionsWhereTarget$1(callback) { + return new A._SyncStarIterable(this.extensionsWhereTarget$body$ExtensionStore(callback), type$._SyncStarIterable_Extension); + }, + extensionsWhereTarget$body$ExtensionStore($async$callback) { + var $async$self = this; + return function() { + var callback = $async$callback; + var $async$goto = 0, $async$handler = 1, $async$errorStack = [], t1, t2, simple, sources, t3; + return function $async$extensionsWhereTarget$1($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = A.MapExtensions_get_pairs($async$self._extensions, type$.SimpleSelector, type$.Map_ComplexSelector_Extension), t1 = t1.get$iterator(t1); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + t2 = t1.get$current(t1); + simple = t2._0; + sources = t2._1; + if (!callback.call$1(simple)) { + // goto for condition + $async$goto = 2; + break; + } + t2 = sources.get$values(sources), t2 = t2.get$iterator(t2); + case 4: + // for condition + if (!t2.moveNext$0()) { + // goto after for + $async$goto = 5; + break; + } + t3 = t2.get$current(t2); + $async$goto = t3 instanceof A.MergedExtension ? 6 : 8; + break; + case 6: + // then + t3 = t3.unmerge$0(); + $async$goto = 9; + return $async$iterator._yieldStar$1(new A.WhereIterable(t3, new A.ExtensionStore_extensionsWhereTarget_closure(), t3.$ti._eval$1("WhereIterable"))); + case 9: + // after yield + // goto join + $async$goto = 7; + break; + case 8: + // else + $async$goto = !t3.isOptional ? 10 : 11; + break; + case 10: + // then + $async$goto = 12; + return $async$iterator._async$_current = t3, 1; + case 12: + // after yield + case 11: + // join + case 7: + // join + // goto for condition + $async$goto = 4; + break; + case 5: + // after for + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return 0; + case 1: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + }, + addSelector$2(selector, mediaContext) { + var originalSelector, error, stackTrace, t1, exception, t2, t3, t4, modifiableSelector, _this = this; + selector = selector; + originalSelector = selector; + if (!originalSelector.accept$1(B._IsInvisibleVisitor_true)) + _this._originals.addAll$1(0, originalSelector.components); + t1 = _this._extensions; + if (t1.__js_helper$_length !== 0) + try { + selector = _this._extendList$3(originalSelector, t1, mediaContext); + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = error; + t2 = J.getInterceptor$z(t1); + t1 = A.SourceSpanException.prototype.get$span.call(t2, t1).message$1(0, ""); + t2 = error._span_exception$_message; + t3 = error; + t4 = J.getInterceptor$z(t3); + t3 = A.SourceSpanException.prototype.get$span.call(t4, t3); + A.throwWithTrace(new A.SassException(B.Set_empty, "From " + t1 + "\n" + t2, t3), error, stackTrace); + } else + throw exception; + } + modifiableSelector = new A.ModifiableBox(selector, type$.ModifiableBox_SelectorList); + if (mediaContext != null) + _this._mediaContexts.$indexSet(0, modifiableSelector, mediaContext); + _this._registerSelector$2(selector, modifiableSelector); + return new A.Box(modifiableSelector, type$.Box_SelectorList); + }, + _registerSelector$2(list, selector) { + var t1, t2, t3, t4, _i, t5, t6, _i0, t7, t8, _i1, simple, _0_2_isSet, _0_2, t9, selectorInPseudo; + for (t1 = list.components, t2 = t1.length, t3 = this._selectors, t4 = type$.SelectorList, _i = 0; _i < t2; ++_i) + for (t5 = t1[_i].components, t6 = t5.length, _i0 = 0; _i0 < t6; ++_i0) + for (t7 = t5[_i0].selector.components, t8 = t7.length, _i1 = 0; _i1 < t8; ++_i1) { + simple = t7[_i1]; + t3.putIfAbsent$2(simple, new A.ExtensionStore__registerSelector_closure()).add$1(0, selector); + _0_2_isSet = simple instanceof A.PseudoSelector; + if (_0_2_isSet) { + _0_2 = simple.selector; + t9 = _0_2 != null; + } else { + _0_2 = null; + t9 = false; + } + if (t9) { + selectorInPseudo = _0_2_isSet ? _0_2 : simple.selector; + this._registerSelector$2(selectorInPseudo == null ? t4._as(selectorInPseudo) : selectorInPseudo, selector); + } + } + }, + addExtension$4(extender, target, extend, mediaContext) { + var t2, t3, t4, t5, t6, t7, t8, t9, t10, newExtensions, _i, complex, t11, extension, _0_0, t12, newExtensionsByTarget, additionalExtensions, _this = this, + selectors = _this._selectors.$index(0, target), + t1 = _this._extensionsByExtender, + existingExtensions = t1.$index(0, target), + sources = _this._extensions.putIfAbsent$2(target, new A.ExtensionStore_addExtension_closure()); + for (t2 = extender.components, t3 = t2.length, t4 = selectors == null, t5 = _this._sourceSpecificity, t6 = extend.span, t7 = extend.isOptional, t8 = existingExtensions != null, t9 = type$.ComplexSelector, t10 = type$.Extension, newExtensions = null, _i = 0; _i < t3; ++_i) { + complex = t2[_i]; + if (complex.accept$1(B.C__IsUselessVisitor)) + continue; + complex.get$specificity(); + t11 = new A.Extender(complex, false); + extension = t11._extension = new A.Extension(t11, target, mediaContext, t7, t6); + _0_0 = sources.$index(0, complex); + if (_0_0 != null) { + sources.$indexSet(0, complex, A.MergedExtension_merge(_0_0, extension)); + continue; + } + sources.$indexSet(0, complex, extension); + for (t11 = new A._SyncStarIterator(_this._simpleSelectors$1(complex)._outerHelper()); t11.moveNext$0();) { + t12 = t11._async$_current; + J.add$1$ax(t1.putIfAbsent$2(t12, new A.ExtensionStore_addExtension_closure0()), extension); + t5.putIfAbsent$2(t12, new A.ExtensionStore_addExtension_closure1(complex)); + } + if (!t4 || t8) { + if (newExtensions == null) + newExtensions = A.LinkedHashMap_LinkedHashMap$_empty(t9, t10); + newExtensions.$indexSet(0, complex, extension); + } + } + if (newExtensions == null) + return; + t1 = type$.SimpleSelector; + newExtensionsByTarget = A.LinkedHashMap_LinkedHashMap$_literal([target, newExtensions], t1, type$.Map_ComplexSelector_Extension); + if (t8) { + additionalExtensions = _this._extendExistingExtensions$2(existingExtensions, newExtensionsByTarget); + if (additionalExtensions != null) + A.mapAddAll2(newExtensionsByTarget, additionalExtensions, t1, t9, t10); + } + if (!t4) + _this._extendExistingSelectors$2(selectors, newExtensionsByTarget); + }, + _simpleSelectors$1(complex) { + return new A._SyncStarIterable(this._simpleSelectors$body$ExtensionStore(complex), type$._SyncStarIterable_SimpleSelector); + }, + _simpleSelectors$body$ExtensionStore($async$complex) { + var $async$self = this; + return function() { + var complex = $async$complex; + var $async$goto = 0, $async$handler = 1, $async$errorStack = [], t1, t2, t3, _i, t4, t5, _i0, simple, _0_2_isSet, _0_2, t6, selector, t7, _i1; + return function $async$_simpleSelectors$1($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = complex.components, t2 = t1.length, t3 = type$.SelectorList, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + t4 = t1[_i].selector.components, t5 = t4.length, _i0 = 0; + case 5: + // for condition + if (!(_i0 < t5)) { + // goto after for + $async$goto = 7; + break; + } + simple = t4[_i0]; + $async$goto = 8; + return $async$iterator._async$_current = simple, 1; + case 8: + // after yield + _0_2_isSet = simple instanceof A.PseudoSelector; + if (_0_2_isSet) { + _0_2 = simple.selector; + t6 = _0_2 != null; + } else { + _0_2 = null; + t6 = false; + } + $async$goto = t6 ? 9 : 10; + break; + case 9: + // then + selector = _0_2_isSet ? _0_2 : simple.selector; + t6 = (selector == null ? t3._as(selector) : selector).components, t7 = t6.length, _i1 = 0; + case 11: + // for condition + if (!(_i1 < t7)) { + // goto after for + $async$goto = 13; + break; + } + $async$goto = 14; + return $async$iterator._yieldStar$1($async$self._simpleSelectors$1(t6[_i1])); + case 14: + // after yield + case 12: + // for update + ++_i1; + // goto for condition + $async$goto = 11; + break; + case 13: + // after for + case 10: + // join + case 6: + // for update + ++_i0; + // goto for condition + $async$goto = 5; + break; + case 7: + // after for + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return 0; + case 1: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + }, + _extendExistingExtensions$2(extensions, newExtensions) { + var extension, selectors, error, stackTrace, t1, t2, t3, t4, t5, t6, additionalExtensions, _i, t7, exception, t8, t9, selectors0, t10, t11, t12, t13, t14, withExtender, _0_0, _i0, _i1; + for (t1 = J.toList$0$ax(extensions), t2 = t1.length, t3 = this._extensionsByExtender, t4 = type$.SimpleSelector, t5 = type$.Map_ComplexSelector_Extension, t6 = this._extensions, additionalExtensions = null, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + extension = t1[_i]; + t7 = t6.$index(0, extension.target); + t7.toString; + selectors = null; + try { + selectors = this._extendComplex$3(extension.extender.selector, newExtensions, extension.mediaContext); + if (selectors == null) + continue; + } catch (exception) { + t8 = A.unwrapException(exception); + if (t8 instanceof A.SassException) { + error = t8; + stackTrace = A.getTraceFromException(exception); + A.throwWithTrace(error.withAdditionalSpan$2(extension.extender.selector.span, "target selector"), error, stackTrace); + } else + throw exception; + } + t8 = J.get$first$ax(selectors); + t9 = extension.extender.selector; + if (B.C_ListEquality.equals$2(0, t8.leadingCombinators, t9.leadingCombinators) && B.C_ListEquality.equals$2(0, t8.components, t9.components)) { + t8 = selectors; + t9 = A._arrayInstanceType(t8); + selectors0 = new A.SubListIterable(t8, 1, null, t9._eval$1("SubListIterable<1>")); + selectors0.SubListIterable$3(t8, 1, null, t9._precomputed1); + selectors = selectors0; + } + for (t8 = J.get$iterator$ax(selectors); t8.moveNext$0();) { + t9 = t8.get$current(t8); + t10 = extension; + t11 = t10.target; + t12 = t10.span; + t13 = t10.mediaContext; + t10 = t10.isOptional; + t9.get$specificity(); + t14 = new A.Extender(t9, false); + withExtender = t14._extension = new A.Extension(t14, t11, t13, t10, t12); + _0_0 = t7.$index(0, t9); + if (_0_0 != null) + t7.$indexSet(0, t9, A.MergedExtension_merge(_0_0, withExtender)); + else { + t7.$indexSet(0, t9, withExtender); + for (t10 = t9.components, t11 = t10.length, _i0 = 0; _i0 < t11; ++_i0) + for (t12 = t10[_i0].selector.components, t13 = t12.length, _i1 = 0; _i1 < t13; ++_i1) + J.add$1$ax(t3.putIfAbsent$2(t12[_i1], new A.ExtensionStore__extendExistingExtensions_closure()), withExtender); + if (newExtensions.containsKey$1(extension.target)) { + if (additionalExtensions == null) + additionalExtensions = A.LinkedHashMap_LinkedHashMap$_empty(t4, t5); + additionalExtensions.putIfAbsent$2(extension.target, new A.ExtensionStore__extendExistingExtensions_closure0()).$indexSet(0, t9, withExtender); + } + } + } + } + return additionalExtensions; + }, + _extendExistingSelectors$2(selectors, newExtensions) { + var selector, error, stackTrace, t1, t2, oldValue, exception, t3, t4, t5, t6; + for (t1 = selectors.get$iterator(selectors), t2 = this._mediaContexts; t1.moveNext$0();) { + selector = t1.get$current(t1); + oldValue = selector.value; + try { + selector.value = this._extendList$3(selector.value, newExtensions, t2.$index(0, selector)); + } catch (exception) { + t3 = A.unwrapException(exception); + if (t3 instanceof A.SassException) { + error = t3; + stackTrace = A.getTraceFromException(exception); + t3 = selector.value.span.message$1(0, ""); + t4 = error._span_exception$_message; + t5 = error; + t6 = J.getInterceptor$z(t5); + t5 = A.SourceSpanException.prototype.get$span.call(t6, t5); + A.throwWithTrace(new A.SassException(B.Set_empty, "From " + t3 + "\n" + t4, t5), error, stackTrace); + } else + throw exception; + } + if (oldValue === selector.value) + continue; + this._registerSelector$2(selector.value, selector); + } + }, + addExtensions$1(extensionStores) { + var t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, newExtensions, selectorsToExtend, extensionsToExtend, t12, t13, target, newSources, first, extensionsForTarget, t14, selectorsForTarget, t15, _2_0, t16, extender, extension, _this = this, _null = null; + for (t1 = J.get$iterator$ax(extensionStores), t2 = type$.SimpleSelector, t3 = type$.Map_ComplexSelector_Extension, t4 = _this._extensions, t5 = type$.ComplexSelector, t6 = type$.Extension, t7 = _this._selectors, t8 = _this._extensionsByExtender, t9 = type$.JSArray_Extension, t10 = type$.ModifiableBox_SelectorList, t11 = _this._sourceSpecificity, newExtensions = _null, selectorsToExtend = newExtensions, extensionsToExtend = selectorsToExtend; t1.moveNext$0();) { + t12 = t1.get$current(t1); + if (t12.get$isEmpty(t12)) + continue; + t11.addAll$1(0, t12.get$_sourceSpecificity()); + for (t12 = A.MapExtensions_get_pairs(t12.get$_extensions(), t2, t3), t12 = t12.get$iterator(t12); t12.moveNext$0();) { + t13 = t12.get$current(t12); + target = t13._0; + newSources = t13._1; + if (target instanceof A.PlaceholderSelector) { + first = target.name.charCodeAt(0); + t13 = first === 45 || first === 95; + } else + t13 = false; + if (t13) + continue; + extensionsForTarget = t8.$index(0, target); + t13 = extensionsForTarget == null; + if (!t13) { + if (extensionsToExtend == null) { + extensionsToExtend = A._setArrayType([], t9); + t14 = extensionsToExtend; + } else + t14 = extensionsToExtend; + B.JSArray_methods.addAll$1(t14, extensionsForTarget); + } + selectorsForTarget = t7.$index(0, target); + t14 = selectorsForTarget != null; + if (t14) { + if (selectorsToExtend == null) { + selectorsToExtend = A.LinkedHashSet_LinkedHashSet$_empty(t10); + t15 = selectorsToExtend; + } else + t15 = selectorsToExtend; + t15.addAll$1(0, selectorsForTarget); + } + _2_0 = t4.$index(0, target); + if (_2_0 != null) + for (t15 = A.MapExtensions_get_pairs(newSources, t5, t6), t15 = t15.get$iterator(t15); t15.moveNext$0();) { + t16 = t15.get$current(t15); + extender = t16._0; + extension = t16._1; + if (_2_0.containsKey$1(extender)) { + t16 = _2_0.$index(0, extender); + extension = A.MergedExtension_merge(t16 == null ? t6._as(t16) : t16, extension); + _2_0.$indexSet(0, extender, extension); + } else + _2_0.$indexSet(0, extender, extension); + if (!t13 || t14) { + if (newExtensions == null) { + newExtensions = A.LinkedHashMap_LinkedHashMap$_empty(t2, t3); + t16 = newExtensions; + } else + t16 = newExtensions; + t16.putIfAbsent$2(target, new A.ExtensionStore_addExtensions_closure()).$indexSet(0, extender, extension); + } + } + else { + t15 = A.LinkedHashMap_LinkedHashMap(_null, _null, _null, t5, t6); + t15.addAll$1(0, newSources); + t4.$indexSet(0, target, t15); + if (!t13 || t14) { + if (newExtensions == null) { + newExtensions = A.LinkedHashMap_LinkedHashMap$_empty(t2, t3); + t13 = newExtensions; + } else + t13 = newExtensions; + t14 = A.LinkedHashMap_LinkedHashMap(_null, _null, _null, t5, t6); + t14.addAll$1(0, newSources); + t13.$indexSet(0, target, t14); + } + } + } + } + if (newExtensions != null) { + if (extensionsToExtend != null) + _this._extendExistingExtensions$2(extensionsToExtend, newExtensions); + if (selectorsToExtend != null) + _this._extendExistingSelectors$2(selectorsToExtend, newExtensions); + } + }, + _extendList$3(list, extensions, mediaQueryContext) { + var t1, t2, t3, extended, i, complex, result, t4; + for (t1 = list.components, t2 = t1.length, t3 = type$.JSArray_ComplexSelector, extended = null, i = 0; i < t2; ++i) { + complex = t1[i]; + result = this._extendComplex$3(complex, extensions, mediaQueryContext); + if (result == null) { + if (extended != null) + extended.push(complex); + } else { + if (extended == null) + if (i === 0) + extended = A._setArrayType([], t3); + else { + t4 = B.JSArray_methods.sublist$2(t1, 0, i); + extended = A._setArrayType(t4.slice(0), A._arrayInstanceType(t4)); + } + B.JSArray_methods.addAll$1(extended, result); + } + } + if (extended == null) + return list; + t1 = this._originals; + return A.SelectorList$(this._trim$2(extended, t1.get$contains(t1)), list.span); + }, + _extendList$2(list, extensions) { + return this._extendList$3(list, extensions, null); + }, + _extendComplex$3(complex, extensions, mediaQueryContext) { + var isOriginal, t3, t4, t5, t6, t7, t8, t9, t10, extendedNotExpanded, i, component, extended, t11, t12, t13, t14, _box_0 = {}, + t1 = complex.leadingCombinators, + t2 = t1.length; + if (t2 > 1) + return null; + isOriginal = this._originals.contains$1(0, complex); + for (t3 = complex.components, t4 = t3.length, t5 = type$.JSArray_List_ComplexSelector, t6 = complex.lineBreak, t7 = !t6, t8 = complex.span, t9 = type$.JSArray_ComplexSelector, t2 = t2 === 0, t10 = type$.JSArray_ComplexSelectorComponent, extendedNotExpanded = null, i = 0; i < t4; ++i) { + component = t3[i]; + extended = this._extendCompound$4$inOriginal(component, extensions, mediaQueryContext, isOriginal); + if (extended == null) { + if (extendedNotExpanded != null) + extendedNotExpanded.push(A._setArrayType([A.ComplexSelector$(B.List_empty0, A._setArrayType([component], t10), t8, t6)], t9)); + } else if (extendedNotExpanded != null) + extendedNotExpanded.push(extended); + else if (i !== 0) { + t11 = A._arrayInstanceType(t3); + t12 = new A.SubListIterable(t3, 0, i, t11._eval$1("SubListIterable<1>")); + t12.SubListIterable$3(t3, 0, i, t11._precomputed1); + extendedNotExpanded = A._setArrayType([A._setArrayType([A.ComplexSelector$(t1, t12, t8, t6)], t9), extended], t5); + } else if (t2) + extendedNotExpanded = A._setArrayType([extended], t5); + else { + t11 = A._setArrayType([], t9); + for (t12 = J.get$iterator$ax(extended); t12.moveNext$0();) { + t13 = t12.get$current(t12); + t14 = t13.leadingCombinators; + if (t14.length === 0 || B.C_ListEquality.equals$2(0, t1, t14)) { + t14 = t13.components; + t11.push(A.ComplexSelector$(t1, t14, t8, !t7 || t13.lineBreak)); + } + } + extendedNotExpanded = A._setArrayType([t11], t5); + } + } + if (extendedNotExpanded == null) + return null; + _box_0.first = true; + t1 = type$.ComplexSelector; + t1 = J.expand$1$1$ax(A.paths(extendedNotExpanded, t1), new A.ExtensionStore__extendComplex_closure(_box_0, this, complex), t1); + return A.List_List$of(t1, true, t1.$ti._eval$1("Iterable.E")); + }, + _extendCompound$4$inOriginal(component, extensions, mediaQueryContext, inOriginal) { + var t3, t4, t5, t6, t7, t8, t9, t10, t11, options, i, simple, extended, t12, result, compound, complex, extenderPaths, withCombinators, isOriginal, _this = this, _null = null, + t1 = _this._mode, + targetsUsed = t1 === B.ExtendMode_normal_normal || extensions.__js_helper$_length < 2 ? _null : A.LinkedHashSet_LinkedHashSet$_empty(type$.SimpleSelector), + t2 = component.selector, + simples = t2.components; + for (t3 = simples.length, t4 = type$.JSArray_List_Extender, t5 = type$.JSArray_Extender, t6 = type$.CssValue_Combinator, t7 = type$.JSArray_ComplexSelectorComponent, t8 = A._arrayInstanceType(simples), t9 = t8._precomputed1, t8 = t8._eval$1("SubListIterable<1>"), t10 = component.span, t11 = type$.SimpleSelector, options = _null, i = 0; i < t3; ++i) { + simple = simples[i]; + extended = _this._extendSimple$4(simple, extensions, mediaQueryContext, targetsUsed); + if (extended == null) { + if (options != null) + options.push(A._setArrayType([_this._extenderForSimple$1(simple)], t5)); + } else { + if (options == null) { + options = A._setArrayType([], t4); + if (i !== 0) { + t12 = new A.SubListIterable(simples, 0, i, t8); + t12.SubListIterable$3(simples, 0, i, t9); + result = A.List_List$from(t12, false, t11); + result.$flags = 3; + t12 = result; + compound = new A.CompoundSelector(t12, t10); + if (t12.length === 0) + A.throwExpression(A.ArgumentError$("components may not be empty.", _null)); + result = A.List_List$from(B.List_empty0, false, t6); + result.$flags = 3; + t12 = A.ComplexSelector$(B.List_empty0, A._setArrayType([new A.ComplexSelectorComponent(compound, result, t10)], t7), t10, false); + _this._sourceSpecificityFor$1(compound); + options.push(A._setArrayType([new A.Extender(t12, true)], t5)); + } + } + B.JSArray_methods.addAll$1(options, extended); + } + } + if (options == null) + return _null; + if (targetsUsed != null && targetsUsed._collection$_length !== extensions.__js_helper$_length) + return _null; + if (options.length === 1) { + for (t1 = J.get$iterator$ax(options[0]), t2 = component.combinators, t3 = type$.JSArray_ComplexSelector, result = _null; t1.moveNext$0();) { + t4 = t1.get$current(t1); + t4.assertCompatibleMediaContext$1(mediaQueryContext); + complex = t4.selector.withAdditionalCombinators$1(t2); + if (complex.accept$1(B.C__IsUselessVisitor)) + continue; + if (result == null) + result = A._setArrayType([], t3); + result.push(complex); + } + return result; + } + extenderPaths = A.paths(options, type$.Extender); + t3 = A._setArrayType([], type$.JSArray_ComplexSelector); + t1 = t1 === B.ExtendMode_replace_replace; + t4 = !t1; + if (t4) + t3.push(A.ComplexSelector$(B.List_empty0, A._setArrayType([new A.ComplexSelectorComponent(A.CompoundSelector$(J.expand$1$1$ax(J.get$first$ax(extenderPaths), new A.ExtensionStore__extendCompound_closure(), t11), t2.span), A.List_List$unmodifiable(component.combinators, t6), t10)], t7), t10, false)); + t2 = J.skip$1$ax(extenderPaths, t1 ? 0 : 1); + t5 = t2.$ti; + t2 = new A.ListIterator(t2, t2.get$length(0), t5._eval$1("ListIterator")); + t6 = component.combinators; + t5 = t5._eval$1("ListIterable.E"); + for (; t2.moveNext$0();) { + t1 = t2.__internal$_current; + extended = _this._unifyExtenders$3(t1 == null ? t5._as(t1) : t1, mediaQueryContext, t10); + if (extended == null) + continue; + for (t1 = J.get$iterator$ax(extended); t1.moveNext$0();) { + withCombinators = t1.get$current(t1).withAdditionalCombinators$1(t6); + if (!withCombinators.accept$1(B.C__IsUselessVisitor)) + t3.push(withCombinators); + } + } + isOriginal = new A.ExtensionStore__extendCompound_closure0(); + return _this._trim$2(t3, inOriginal && t4 ? new A.ExtensionStore__extendCompound_closure1(B.JSArray_methods.get$first(t3)) : isOriginal); + }, + _unifyExtenders$3(extenders, mediaQueryContext, span) { + var t1, t2, t3, originals, originalsLineBreak, t4, complexes, _null = null, + toUnify = A.QueueList$(_null, type$.ComplexSelector); + for (t1 = J.getInterceptor$ax(extenders), t2 = t1.get$iterator(extenders), t3 = type$.JSArray_SimpleSelector, originals = _null, originalsLineBreak = false; t2.moveNext$0();) { + t4 = t2.get$current(t2); + if (t4.isOriginal) { + if (originals == null) + originals = A._setArrayType([], t3); + t4 = t4.selector; + B.JSArray_methods.addAll$1(originals, B.JSArray_methods.get$last(t4.components).selector.components); + originalsLineBreak = originalsLineBreak || t4.lineBreak; + } else { + t4 = t4.selector; + if (t4.accept$1(B.C__IsUselessVisitor)) + return _null; + else + toUnify._queue_list$_add$1(t4); + } + } + if (originals != null) + toUnify.addFirst$1(A.ComplexSelector$(B.List_empty0, A._setArrayType([new A.ComplexSelectorComponent(A.CompoundSelector$(originals, span), A.List_List$unmodifiable(B.List_empty0, type$.CssValue_Combinator), span)], type$.JSArray_ComplexSelectorComponent), span, originalsLineBreak)); + complexes = A.unifyComplex(toUnify, span); + if (complexes == null) + return _null; + for (t1 = t1.get$iterator(extenders); t1.moveNext$0();) + t1.get$current(t1).assertCompatibleMediaContext$1(mediaQueryContext); + return complexes; + }, + _extendSimple$4(simple, extensions, mediaQueryContext, targetsUsed) { + var t2, _1_0, + t1 = new A.ExtensionStore__extendSimple_withoutPseudo(this, extensions, targetsUsed); + if (simple instanceof A.PseudoSelector) + t2 = simple.selector != null; + else + t2 = false; + if (t2) { + _1_0 = this._extendPseudo$3(simple, extensions, mediaQueryContext); + if (_1_0 != null) + return new A.MappedListIterable(_1_0, new A.ExtensionStore__extendSimple_closure(this, t1), A._arrayInstanceType(_1_0)._eval$1("MappedListIterable<1,List>")); + } + return A.NullableExtension_andThen(t1.call$1(simple), new A.ExtensionStore__extendSimple_closure0()); + }, + _extenderForSimple$1(simple) { + var t1 = simple.span; + t1 = A.ComplexSelector$(B.List_empty0, A._setArrayType([new A.ComplexSelectorComponent(A.CompoundSelector$(A._setArrayType([simple], type$.JSArray_SimpleSelector), t1), A.List_List$unmodifiable(B.List_empty0, type$.CssValue_Combinator), t1)], type$.JSArray_ComplexSelectorComponent), t1, false); + this._sourceSpecificity.$index(0, simple); + return new A.Extender(t1, true); + }, + _extendPseudo$3(pseudo, extensions, mediaQueryContext) { + var extended, complexes, t1, result, + selector = pseudo.selector; + if (selector == null) + throw A.wrapException(A.ArgumentError$("Selector " + pseudo.toString$0(0) + " must have a selector argument.", null)); + extended = this._extendList$3(selector, extensions, mediaQueryContext); + if (extended === selector) + return null; + complexes = extended.components; + t1 = pseudo.normalizedName === "not"; + if (t1 && !B.JSArray_methods.any$1(selector.components, new A.ExtensionStore__extendPseudo_closure()) && B.JSArray_methods.any$1(complexes, new A.ExtensionStore__extendPseudo_closure0())) + complexes = new A.WhereIterable(complexes, new A.ExtensionStore__extendPseudo_closure1(), A._arrayInstanceType(complexes)._eval$1("WhereIterable<1>")); + complexes = J.expand$1$1$ax(complexes, new A.ExtensionStore__extendPseudo_closure2(pseudo), type$.ComplexSelector); + if (t1 && selector.components.length === 1) { + t1 = A.MappedIterable_MappedIterable(complexes, new A.ExtensionStore__extendPseudo_closure3(pseudo, selector), complexes.$ti._eval$1("Iterable.E"), type$.PseudoSelector); + result = A.List_List$of(t1, true, A._instanceType(t1)._eval$1("Iterable.E")); + return result.length === 0 ? null : result; + } else + return A._setArrayType([pseudo.withSelector$1(A.SelectorList$(complexes, selector.span))], type$.JSArray_PseudoSelector); + }, + _trim$2(selectors, isOriginal) { + var result, i, t1, t2, numOriginals, _box_0, complex1, j, t3, t4, _i, t5, maxSpecificity; + if (selectors.length > 100) + return selectors; + result = A.QueueList$(null, type$.ComplexSelector); + $label0$0: + for (i = selectors.length - 1, t1 = A._arrayInstanceType(selectors), t2 = t1._precomputed1, t1 = t1._eval$1("SubListIterable<1>"), numOriginals = 0; i >= 0; --i) { + _box_0 = {}; + complex1 = selectors[i]; + if (isOriginal.call$1(complex1)) { + for (j = 0; j < numOriginals; ++j) + if (result.$index(0, j).$eq(0, complex1)) { + A.rotateSlice(result, 0, j + 1); + continue $label0$0; + } + ++numOriginals; + result.addFirst$1(complex1); + continue $label0$0; + } + _box_0.maxSpecificity = 0; + for (t3 = complex1.components, t4 = t3.length, _i = 0, t5 = 0; _i < t4; ++_i, t5 = maxSpecificity) { + maxSpecificity = Math.max(t5, this._sourceSpecificityFor$1(t3[_i].selector)); + _box_0.maxSpecificity = maxSpecificity; + } + if (result.any$1(result, new A.ExtensionStore__trim_closure(_box_0, complex1))) + continue $label0$0; + t3 = new A.SubListIterable(selectors, 0, i, t1); + t3.SubListIterable$3(selectors, 0, i, t2); + if (t3.any$1(0, new A.ExtensionStore__trim_closure0(_box_0, complex1))) + continue $label0$0; + result.addFirst$1(complex1); + } + return result; + }, + _sourceSpecificityFor$1(compound) { + var t1, t2, t3, specificity, _i, t4; + for (t1 = compound.components, t2 = t1.length, t3 = this._sourceSpecificity, specificity = 0, _i = 0; _i < t2; ++_i) { + t4 = t3.$index(0, t1[_i]); + if (t4 == null) + t4 = 0; + specificity = Math.max(specificity, t4); + } + return specificity; + }, + clone$0() { + var t2, t3, t4, _this = this, + t1 = type$.SimpleSelector, + newSelectors = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Set_ModifiableBox_SelectorList), + newMediaContexts = A.LinkedHashMap_LinkedHashMap$_empty(type$.ModifiableBox_SelectorList, type$.List_CssMediaQuery), + oldToNewSelectors = new A.JsIdentityLinkedHashMap(type$.JsIdentityLinkedHashMap_of_SelectorList_and_Box_SelectorList); + _this._selectors.forEach$1(0, new A.ExtensionStore_clone_closure(_this, newSelectors, oldToNewSelectors, newMediaContexts)); + t2 = type$.Extension; + t3 = A.copyMapOfMap(_this._extensions, t1, type$.ComplexSelector, t2); + t2 = A.copyMapOfList(_this._extensionsByExtender, t1, t2); + t1 = new A.JsIdentityLinkedHashMap(type$.JsIdentityLinkedHashMap_SimpleSelector_int); + t1.addAll$1(0, _this._sourceSpecificity); + t4 = new A._LinkedIdentityHashSet(type$._LinkedIdentityHashSet_ComplexSelector); + t4.addAll$1(0, _this._originals); + return new A._Record_2(new A.ExtensionStore(newSelectors, t3, t2, newMediaContexts, t1, t4, B.ExtendMode_normal_normal), oldToNewSelectors); + }, + get$_extensions() { + return this._extensions; + }, + get$_sourceSpecificity() { + return this._sourceSpecificity; + } + }; + A.ExtensionStore_extensionsWhereTarget_closure.prototype = { + call$1(extension) { + return !extension.isOptional; + }, + $signature: 330 + }; + A.ExtensionStore__registerSelector_closure.prototype = { + call$0() { + return A.LinkedHashSet_LinkedHashSet$_empty(type$.ModifiableBox_SelectorList); + }, + $signature: 334 + }; + A.ExtensionStore_addExtension_closure.prototype = { + call$0() { + return A.LinkedHashMap_LinkedHashMap$_empty(type$.ComplexSelector, type$.Extension); + }, + $signature: 128 + }; + A.ExtensionStore_addExtension_closure0.prototype = { + call$0() { + return A._setArrayType([], type$.JSArray_Extension); + }, + $signature: 212 + }; + A.ExtensionStore_addExtension_closure1.prototype = { + call$0() { + return this.complex.get$specificity(); + }, + $signature: 10 + }; + A.ExtensionStore__extendExistingExtensions_closure.prototype = { + call$0() { + return A._setArrayType([], type$.JSArray_Extension); + }, + $signature: 212 + }; + A.ExtensionStore__extendExistingExtensions_closure0.prototype = { + call$0() { + return A.LinkedHashMap_LinkedHashMap$_empty(type$.ComplexSelector, type$.Extension); + }, + $signature: 128 + }; + A.ExtensionStore_addExtensions_closure.prototype = { + call$0() { + return A.LinkedHashMap_LinkedHashMap$_empty(type$.ComplexSelector, type$.Extension); + }, + $signature: 128 + }; + A.ExtensionStore__extendComplex_closure.prototype = { + call$1(path) { + var t1 = this.complex; + return J.map$1$1$ax(A.weave(path, t1.span, t1.lineBreak), new A.ExtensionStore__extendComplex__closure(this._box_0, this.$this, t1), type$.ComplexSelector); + }, + $signature: 341 + }; + A.ExtensionStore__extendComplex__closure.prototype = { + call$1(outputComplex) { + var _this = this, + t1 = _this._box_0; + if (t1.first && _this.$this._originals.contains$1(0, _this.complex)) + _this.$this._originals.add$1(0, outputComplex); + t1.first = false; + return outputComplex; + }, + $signature: 60 + }; + A.ExtensionStore__extendCompound_closure.prototype = { + call$1(extender) { + return B.JSArray_methods.get$last(extender.selector.components).selector.components; + }, + $signature: 347 + }; + A.ExtensionStore__extendCompound_closure0.prototype = { + call$1(_) { + return false; + }, + $signature: 20 + }; + A.ExtensionStore__extendCompound_closure1.prototype = { + call$1(complex) { + return complex.$eq(0, this.original); + }, + $signature: 20 + }; + A.ExtensionStore__extendSimple_withoutPseudo.prototype = { + call$1(simple) { + var t1, t2, + extensionsForSimple = this.extensions.$index(0, simple); + if (extensionsForSimple == null) + return null; + t1 = this.targetsUsed; + if (t1 != null) + t1.add$1(0, simple); + t1 = A._setArrayType([], type$.JSArray_Extender); + t2 = this.$this; + if (t2._mode !== B.ExtendMode_replace_replace) + t1.push(t2._extenderForSimple$1(simple)); + for (t2 = extensionsForSimple.get$values(extensionsForSimple), t2 = t2.get$iterator(t2); t2.moveNext$0();) + t1.push(t2.get$current(t2).extender); + return t1; + }, + $signature: 348 + }; + A.ExtensionStore__extendSimple_closure.prototype = { + call$1(pseudo) { + var t1 = this.withoutPseudo.call$1(pseudo); + return t1 == null ? A._setArrayType([this.$this._extenderForSimple$1(pseudo)], type$.JSArray_Extender) : t1; + }, + $signature: 349 + }; + A.ExtensionStore__extendSimple_closure0.prototype = { + call$1(result) { + return A._setArrayType([result], type$.JSArray_List_Extender); + }, + $signature: 350 + }; + A.ExtensionStore__extendPseudo_closure.prototype = { + call$1(complex) { + return complex.components.length > 1; + }, + $signature: 20 + }; + A.ExtensionStore__extendPseudo_closure0.prototype = { + call$1(complex) { + return complex.components.length === 1; + }, + $signature: 20 + }; + A.ExtensionStore__extendPseudo_closure1.prototype = { + call$1(complex) { + return complex.components.length <= 1; + }, + $signature: 20 + }; + A.ExtensionStore__extendPseudo_closure2.prototype = { + call$1(complex) { + var innerPseudo, innerSelector, + t1 = complex.get$singleCompound(); + if (t1 == null) + innerPseudo = null; + else { + t1 = t1.components; + innerPseudo = t1.length === 1 ? B.JSArray_methods.get$first(t1) : null; + } + if (!(innerPseudo instanceof A.PseudoSelector)) + return A._setArrayType([complex], type$.JSArray_ComplexSelector); + innerSelector = innerPseudo.selector; + if (innerSelector == null) + return A._setArrayType([complex], type$.JSArray_ComplexSelector); + t1 = this.pseudo; + switch (t1.normalizedName) { + case "not": + if (!B.Set_0egh6.contains$1(0, innerPseudo.normalizedName)) + return A._setArrayType([], type$.JSArray_ComplexSelector); + return innerSelector.components; + case "is": + case "matches": + case "where": + case "any": + case "current": + case "nth-child": + case "nth-last-child": + if (innerPseudo.name !== t1.name) + return A._setArrayType([], type$.JSArray_ComplexSelector); + if (innerPseudo.argument != t1.argument) + return A._setArrayType([], type$.JSArray_ComplexSelector); + return innerSelector.components; + case "has": + case "host": + case "host-context": + case "slotted": + return A._setArrayType([complex], type$.JSArray_ComplexSelector); + default: + return A._setArrayType([], type$.JSArray_ComplexSelector); + } + }, + $signature: 351 + }; + A.ExtensionStore__extendPseudo_closure3.prototype = { + call$1(complex) { + return this.pseudo.withSelector$1(A.SelectorList$(A._setArrayType([complex], type$.JSArray_ComplexSelector), this.selector.span)); + }, + $signature: 353 + }; + A.ExtensionStore__trim_closure.prototype = { + call$1(complex2) { + return complex2.get$specificity() >= this._box_0.maxSpecificity && complex2.isSuperselector$1(this.complex1); + }, + $signature: 20 + }; + A.ExtensionStore__trim_closure0.prototype = { + call$1(complex2) { + return complex2.get$specificity() >= this._box_0.maxSpecificity && complex2.isSuperselector$1(this.complex1); + }, + $signature: 20 + }; + A.ExtensionStore_clone_closure.prototype = { + call$2(simple, selectors) { + var t2, t3, t4, t5, t6, t7, newSelector, _0_0, _this = this, + t1 = type$.ModifiableBox_SelectorList, + newSelectorSet = A.LinkedHashSet_LinkedHashSet$_empty(t1); + _this.newSelectors.$indexSet(0, simple, newSelectorSet); + for (t2 = selectors.get$iterator(selectors), t3 = _this.oldToNewSelectors, t4 = type$.Box_SelectorList, t5 = _this.$this._mediaContexts, t6 = _this.newMediaContexts; t2.moveNext$0();) { + t7 = t2.get$current(t2); + newSelector = new A.ModifiableBox(t7.value, t1); + newSelectorSet.add$1(0, newSelector); + t3.$indexSet(0, t7.value, new A.Box(newSelector, t4)); + _0_0 = t5.$index(0, t7); + if (_0_0 != null) + t6.$indexSet(0, newSelector, _0_0); + } + }, + $signature: 354 + }; + A.unifyComplex_closure.prototype = { + call$1(complex) { + return complex.lineBreak; + }, + $signature: 20 + }; + A._weaveParents_closure.prototype = { + call$2(group1, group2) { + var t1, unified; + if (B.C_ListEquality.equals$2(0, group1, group2)) + return group1; + if (A._complexIsParentSuperselector(group1, group2)) + return group2; + if (A._complexIsParentSuperselector(group2, group1)) + return group1; + if (!A._mustUnify(group1, group2)) + return null; + t1 = this.span; + unified = A.unifyComplex(A._setArrayType([A.ComplexSelector$(B.List_empty0, group1, t1, false), A.ComplexSelector$(B.List_empty0, group2, t1, false)], type$.JSArray_ComplexSelector), t1); + if (unified == null) + t1 = null; + else { + t1 = A.IterableExtension_get_singleOrNull(unified); + t1 = t1 == null ? null : t1.components; + } + return t1; + }, + $signature: 356 + }; + A._weaveParents_closure0.prototype = { + call$1(sequence) { + return A._complexIsParentSuperselector(sequence.get$first(sequence), this.group); + }, + $signature: 211 + }; + A._weaveParents_closure1.prototype = { + call$1(sequence) { + return sequence.get$length(0) === 0; + }, + $signature: 211 + }; + A._weaveParents_closure2.prototype = { + call$1(choice) { + return J.get$isNotEmpty$asx(choice); + }, + $signature: 358 + }; + A._mustUnify_closure.prototype = { + call$1(component) { + return B.JSArray_methods.any$1(component.selector.components, new A._mustUnify__closure(this.uniqueSelectors)); + }, + $signature: 53 + }; + A._mustUnify__closure.prototype = { + call$1(simple) { + var t1; + if (!(simple instanceof A.IDSelector)) + t1 = simple instanceof A.PseudoSelector && !simple.isClass; + else + t1 = true; + return t1 && this.uniqueSelectors.contains$1(0, simple); + }, + $signature: 13 + }; + A.paths_closure.prototype = { + call$2(paths, choice) { + var t1 = this.T; + t1 = J.expand$1$1$ax(choice, new A.paths__closure(paths, t1), t1._eval$1("List<0>")); + return A.List_List$of(t1, true, t1.$ti._eval$1("Iterable.E")); + }, + $signature() { + return this.T._eval$1("List>(List>,List<0>)"); + } + }; + A.paths__closure.prototype = { + call$1(option) { + var t1 = this.T; + return J.map$1$1$ax(this.paths, new A.paths___closure(option, t1), t1._eval$1("List<0>")); + }, + $signature() { + return this.T._eval$1("Iterable>(0)"); + } + }; + A.paths___closure.prototype = { + call$1(path) { + var t1 = A.List_List$of(path, true, this.T); + t1.push(this.option); + return t1; + }, + $signature() { + return this.T._eval$1("List<0>(List<0>)"); + } + }; + A.listIsSuperselector_closure.prototype = { + call$1(complex1) { + return B.JSArray_methods.any$1(this.list1, new A.listIsSuperselector__closure(complex1)); + }, + $signature: 20 + }; + A.listIsSuperselector__closure.prototype = { + call$1(complex2) { + return complex2.isSuperselector$1(this.complex1); + }, + $signature: 20 + }; + A.complexIsSuperselector_closure.prototype = { + call$1($parent) { + return $parent.combinators.length > 1; + }, + $signature: 53 + }; + A.complexIsSuperselector_closure0.prototype = { + call$1(component) { + return A._isSupercombinator(this.combinator1, A.IterableExtension_get_firstOrNull(component.combinators)); + }, + $signature: 53 + }; + A._compatibleWithPreviousCombinator_closure.prototype = { + call$1(component) { + var t1 = component.combinators, + t2 = A.IterableExtension_get_firstOrNull(t1); + if (!J.$eq$(t2 == null ? null : t2.value, B.Combinator_55N)) { + t1 = A.IterableExtension_get_firstOrNull(t1); + t1 = J.$eq$(t1 == null ? null : t1.value, B.Combinator_bOP); + } else + t1 = true; + return t1; + }, + $signature: 53 + }; + A.compoundIsSuperselector_closure.prototype = { + call$1(simple1) { + return B.JSArray_methods.any$1(this.compound2.components, simple1.get$isSuperselector()); + }, + $signature: 13 + }; + A._selectorPseudoIsSuperselector_closure.prototype = { + call$1(selector2) { + return A.listIsSuperselector(this.selector1.components, selector2.components); + }, + $signature: 73 + }; + A._selectorPseudoIsSuperselector_closure0.prototype = { + call$1(complex1) { + var t1, t2; + if (complex1.leadingCombinators.length === 0) { + t1 = A._setArrayType([], type$.JSArray_ComplexSelectorComponent); + t2 = this.parents; + if (t2 != null) + B.JSArray_methods.addAll$1(t1, t2); + t2 = this.compound2; + t1.push(new A.ComplexSelectorComponent(t2, A.List_List$unmodifiable(B.List_empty0, type$.CssValue_Combinator), t2.span)); + t1 = A.complexIsSuperselector(complex1.components, t1); + } else + t1 = false; + return t1; + }, + $signature: 20 + }; + A._selectorPseudoIsSuperselector_closure1.prototype = { + call$1(selector2) { + return A.listIsSuperselector(this.selector1.components, selector2.components); + }, + $signature: 73 + }; + A._selectorPseudoIsSuperselector_closure2.prototype = { + call$1(selector2) { + return A.listIsSuperselector(this.selector1.components, selector2.components); + }, + $signature: 73 + }; + A._selectorPseudoIsSuperselector_closure3.prototype = { + call$1(complex) { + if (complex.accept$1(B._IsBogusVisitor_true)) + return false; + return B.JSArray_methods.any$1(this.compound2.components, new A._selectorPseudoIsSuperselector__closure(complex, this.pseudo1)); + }, + $signature: 20 + }; + A._selectorPseudoIsSuperselector__closure.prototype = { + call$1(simple2) { + var t1, selector2, _0_4, _this = this; + $label0$1: { + if (simple2 instanceof A.TypeSelector) { + t1 = B.JSArray_methods.any$1(B.JSArray_methods.get$last(_this.complex.components).selector.components, new A._selectorPseudoIsSuperselector___closure(simple2)); + break $label0$1; + } + if (simple2 instanceof A.IDSelector) { + t1 = B.JSArray_methods.any$1(B.JSArray_methods.get$last(_this.complex.components).selector.components, new A._selectorPseudoIsSuperselector___closure0(simple2)); + break $label0$1; + } + selector2 = null; + t1 = false; + if (simple2 instanceof A.PseudoSelector) { + _0_4 = simple2.selector; + if (_0_4 != null) { + selector2 = _0_4 == null ? type$.SelectorList._as(_0_4) : _0_4; + t1 = simple2.name === _this.pseudo1.name; + } + } + if (t1) { + t1 = A.listIsSuperselector(selector2.components, A._setArrayType([_this.complex], type$.JSArray_ComplexSelector)); + break $label0$1; + } + t1 = false; + break $label0$1; + } + return t1; + }, + $signature: 13 + }; + A._selectorPseudoIsSuperselector___closure.prototype = { + call$1(simple1) { + var t1; + if (simple1 instanceof A.TypeSelector) { + t1 = this.simple2; + t1 = !(t1 instanceof A.TypeSelector && t1.name.$eq(0, simple1.name)); + } else + t1 = false; + return t1; + }, + $signature: 13 + }; + A._selectorPseudoIsSuperselector___closure0.prototype = { + call$1(simple1) { + var t1; + if (simple1 instanceof A.IDSelector) { + t1 = this.simple2; + t1 = !(t1 instanceof A.IDSelector && t1.name === simple1.name); + } else + t1 = false; + return t1; + }, + $signature: 13 + }; + A._selectorPseudoIsSuperselector_closure4.prototype = { + call$1(selector2) { + var t1 = B.C_ListEquality.equals$2(0, this.selector1.components, selector2.components); + return t1; + }, + $signature: 73 + }; + A._selectorPseudoIsSuperselector_closure5.prototype = { + call$1(pseudo2) { + var t1, selector2; + if (!(pseudo2 instanceof A.PseudoSelector)) + return false; + t1 = this.pseudo1; + if (pseudo2.name !== t1.name) + return false; + if (pseudo2.argument != t1.argument) + return false; + selector2 = pseudo2.selector; + if (selector2 == null) + return false; + return A.listIsSuperselector(this.selector1.components, selector2.components); + }, + $signature: 13 + }; + A._selectorPseudoArgs_closure.prototype = { + call$1(pseudo) { + return pseudo.isClass === this.isClass && pseudo.name === this.name; + }, + $signature: 369 + }; + A._selectorPseudoArgs_closure0.prototype = { + call$1(pseudo) { + return pseudo.selector; + }, + $signature: 370 + }; + A.MergedExtension.prototype = { + unmerge$0() { + return new A._SyncStarIterable(this.unmerge$body$MergedExtension(), type$._SyncStarIterable_Extension); + }, + unmerge$body$MergedExtension() { + var $async$self = this; + return function() { + var $async$goto = 0, $async$handler = 1, $async$errorStack = [], right, left; + return function $async$unmerge$0($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + left = $async$self.left; + $async$goto = left instanceof A.MergedExtension ? 2 : 4; + break; + case 2: + // then + $async$goto = 5; + return $async$iterator._yieldStar$1(left.unmerge$0()); + case 5: + // after yield + // goto join + $async$goto = 3; + break; + case 4: + // else + $async$goto = 6; + return $async$iterator._async$_current = left, 1; + case 6: + // after yield + case 3: + // join + right = $async$self.right; + $async$goto = right instanceof A.MergedExtension ? 7 : 9; + break; + case 7: + // then + $async$goto = 10; + return $async$iterator._yieldStar$1(right.unmerge$0()); + case 10: + // after yield + // goto join + $async$goto = 8; + break; + case 9: + // else + $async$goto = 11; + return $async$iterator._async$_current = right, 1; + case 11: + // after yield + case 8: + // join + // implicit return + return 0; + case 1: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + } + }; + A.ExtendMode.prototype = { + _enumToString$0() { + return "ExtendMode." + this._name; + }, + toString$0(_) { + return this.name; + } + }; + A.globalFunctions_closure.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return t1.$index($arguments, 0).get$isTruthy() ? t1.$index($arguments, 1) : t1.$index($arguments, 2); + }, + $signature: 4 + }; + A.global_closure0.prototype = { + call$1(color) { + return B.JSNumber_methods.round$0(color._legacyChannel$2(B.RgbColorSpace_i0P, "red")); + }, + $signature: 63 + }; + A.global_closure1.prototype = { + call$1(color) { + return B.JSNumber_methods.round$0(color._legacyChannel$2(B.RgbColorSpace_i0P, "green")); + }, + $signature: 63 + }; + A.global_closure2.prototype = { + call$1(color) { + return B.JSNumber_methods.round$0(color._legacyChannel$2(B.RgbColorSpace_i0P, "blue")); + }, + $signature: 63 + }; + A.global_closure3.prototype = { + call$1($arguments) { + return A._rgb("rgb", $arguments); + }, + $signature: 4 + }; + A.global_closure4.prototype = { + call$1($arguments) { + return A._rgb("rgb", $arguments); + }, + $signature: 4 + }; + A.global_closure5.prototype = { + call$1($arguments) { + return A._rgbTwoArg("rgb", $arguments); + }, + $signature: 4 + }; + A.global_closure6.prototype = { + call$1($arguments) { + return A._parseChannels("rgb", J.$index$asx($arguments, 0), "channels", B.RgbColorSpace_i0P); + }, + $signature: 4 + }; + A.global_closure7.prototype = { + call$1($arguments) { + return A._rgb("rgba", $arguments); + }, + $signature: 4 + }; + A.global_closure8.prototype = { + call$1($arguments) { + return A._rgb("rgba", $arguments); + }, + $signature: 4 + }; + A.global_closure9.prototype = { + call$1($arguments) { + return A._rgbTwoArg("rgba", $arguments); + }, + $signature: 4 + }; + A.global_closure10.prototype = { + call$1($arguments) { + return A._parseChannels("rgba", J.$index$asx($arguments, 0), "channels", B.RgbColorSpace_i0P); + }, + $signature: 4 + }; + A.global_closure11.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + if (!(t1.$index($arguments, 0) instanceof A.SassNumber) && !t1.$index($arguments, 0).get$isSpecialNumber()) + A.warnForDeprecation(string$.Globalci, B.Deprecation_1AX); + return A._invert($arguments, true); + }, + $signature: 4 + }; + A.global_closure12.prototype = { + call$1(color) { + return color._legacyChannel$2(B.HslColorSpace_JQ2, "hue"); + }, + $signature: 51 + }; + A.global_closure13.prototype = { + call$1(color) { + return color._legacyChannel$2(B.HslColorSpace_JQ2, "saturation"); + }, + $signature: 51 + }; + A.global_closure14.prototype = { + call$1(color) { + return color._legacyChannel$2(B.HslColorSpace_JQ2, "lightness"); + }, + $signature: 51 + }; + A.global_closure15.prototype = { + call$1($arguments) { + return A._hsl("hsl", $arguments); + }, + $signature: 4 + }; + A.global_closure16.prototype = { + call$1($arguments) { + return A._hsl("hsl", $arguments); + }, + $signature: 4 + }; + A.global_closure17.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0).get$isVar() || t1.$index($arguments, 1).get$isVar()) + return A._functionString("hsl", $arguments); + else + throw A.wrapException(A.SassScriptException$("Missing argument $lightness.", null)); + }, + $signature: 17 + }; + A.global_closure18.prototype = { + call$1($arguments) { + return A._parseChannels("hsl", J.$index$asx($arguments, 0), "channels", B.HslColorSpace_JQ2); + }, + $signature: 4 + }; + A.global_closure19.prototype = { + call$1($arguments) { + return A._hsl("hsla", $arguments); + }, + $signature: 4 + }; + A.global_closure20.prototype = { + call$1($arguments) { + return A._hsl("hsla", $arguments); + }, + $signature: 4 + }; + A.global_closure21.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0).get$isVar() || t1.$index($arguments, 1).get$isVar()) + return A._functionString("hsla", $arguments); + else + throw A.wrapException(A.SassScriptException$("Missing argument $lightness.", null)); + }, + $signature: 17 + }; + A.global_closure22.prototype = { + call$1($arguments) { + return A._parseChannels("hsla", J.$index$asx($arguments, 0), "channels", B.HslColorSpace_JQ2); + }, + $signature: 4 + }; + A.global_closure23.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0) instanceof A.SassNumber || t1.$index($arguments, 0).get$isSpecialNumber()) + return A._functionString("grayscale", $arguments); + else { + A.warnForDeprecation(string$.Globalcg, B.Deprecation_1AX); + return A._grayscale(t1.$index($arguments, 0)); + } + }, + $signature: 4 + }; + A.global_closure24.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + degrees = A._angleValue(t1.$index($arguments, 1), "degrees"); + if (!color._space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$(string$.adjusto, null)); + A.warnForDeprecation(string$.adjustd + A.SassNumber_SassNumber(degrees, "deg").toString$0(0) + string$.x29x0a_Mor_, B.Deprecation_cyE); + return color.changeHsl$1$hue(color._legacyChannel$2(B.HslColorSpace_JQ2, "hue") + degrees); + }, + $signature: 25 + }; + A.global_closure25.prototype = { + call$1($arguments) { + var result, + _s9_ = "lightness", + t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + amount = t1.$index($arguments, 1).assertNumber$1("amount"); + if (!color._space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$(string$.lighte, null)); + t1 = color._legacyChannel$2(B.HslColorSpace_JQ2, _s9_) + amount.valueInRange$3(0, 100, "amount"); + result = color.changeHsl$1$lightness(isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 100)); + A.warnForDeprecation("lighten() is deprecated. " + A._suggestScaleAndAdjust(color, amount._number$_value, _s9_) + string$.x0a_Morex3ac, B.Deprecation_cyE); + return result; + }, + $signature: 25 + }; + A.global_closure26.prototype = { + call$1($arguments) { + var result, + _s9_ = "lightness", + t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + amount = t1.$index($arguments, 1).assertNumber$1("amount"); + if (!color._space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$(string$.darken, null)); + t1 = color._legacyChannel$2(B.HslColorSpace_JQ2, _s9_) - amount.valueInRange$3(0, 100, "amount"); + result = color.changeHsl$1$lightness(isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 100)); + A.warnForDeprecation("darken() is deprecated. " + A._suggestScaleAndAdjust(color, -amount._number$_value, _s9_) + string$.x0a_Morex3ac, B.Deprecation_cyE); + return result; + }, + $signature: 25 + }; + A.global_closure27.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0) instanceof A.SassNumber || t1.$index($arguments, 0).get$isSpecialNumber()) + return A._functionString("saturate", $arguments); + return new A.SassString("saturate(" + A.serializeValue(t1.$index($arguments, 0).assertNumber$1("amount"), false, true) + ")", false); + }, + $signature: 17 + }; + A.global_closure28.prototype = { + call$1($arguments) { + var t1, color, amount, result, + _s10_ = "saturation"; + A.warnForDeprecation(string$.Globalcad, B.Deprecation_1AX); + t1 = J.getInterceptor$asx($arguments); + color = t1.$index($arguments, 0).assertColor$1("color"); + amount = t1.$index($arguments, 1).assertNumber$1("amount"); + if (!color._space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$(string$.satura, null)); + t1 = color._legacyChannel$2(B.HslColorSpace_JQ2, _s10_) + amount.valueInRange$3(0, 100, "amount"); + result = color.changeHsl$1$saturation(isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 100)); + A.warnForDeprecation("saturate() is deprecated. " + A._suggestScaleAndAdjust(color, amount._number$_value, _s10_) + string$.x0a_Morex3ac, B.Deprecation_cyE); + return result; + }, + $signature: 25 + }; + A.global_closure29.prototype = { + call$1($arguments) { + var result, + _s10_ = "saturation", + t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + amount = t1.$index($arguments, 1).assertNumber$1("amount"); + if (!color._space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$(string$.desatu, null)); + t1 = color._legacyChannel$2(B.HslColorSpace_JQ2, _s10_) - amount.valueInRange$3(0, 100, "amount"); + result = color.changeHsl$1$saturation(isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 100)); + A.warnForDeprecation("desaturate() is deprecated. " + A._suggestScaleAndAdjust(color, -amount._number$_value, _s10_) + string$.x0a_Morex3ac, B.Deprecation_cyE); + return result; + }, + $signature: 25 + }; + A.global_closure30.prototype = { + call$1($arguments) { + return A._opacify("opacify", $arguments); + }, + $signature: 25 + }; + A.global_closure31.prototype = { + call$1($arguments) { + return A._opacify("fade-in", $arguments); + }, + $signature: 25 + }; + A.global_closure32.prototype = { + call$1($arguments) { + return A._transparentize("transparentize", $arguments); + }, + $signature: 25 + }; + A.global_closure33.prototype = { + call$1($arguments) { + return A._transparentize("fade-out", $arguments); + }, + $signature: 25 + }; + A.global_closure34.prototype = { + call$1($arguments) { + var _0_0 = J.$index$asx($arguments, 0), + t1 = false; + if (_0_0 instanceof A.SassString) + if (!_0_0._hasQuotes) + t1 = B.JSString_methods.contains$1(_0_0._string$_text, $.$get$_microsoftFilterStart()); + if (t1) + return A._functionString("alpha", $arguments); + if (_0_0 instanceof A.SassColor && !_0_0._space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$(string$.alpha_, null)); + A.warnForDeprecation(string$.Globalcal, B.Deprecation_1AX); + t1 = _0_0.assertColor$1("color").alphaOrNull; + return A.SassNumber_SassNumber(t1 == null ? 0 : t1, null); + }, + $signature: 4 + }; + A.global_closure35.prototype = { + call$1($arguments) { + var t1, + argList = J.$index$asx($arguments, 0).get$asList(); + if (argList.length !== 0 && B.JSArray_methods.every$1(argList, new A.global__closure())) + return A._functionString("alpha", $arguments); + t1 = argList.length; + if (t1 === 0) + throw A.wrapException(A.SassScriptException$("Missing argument $color.", null)); + else + throw A.wrapException(A.SassScriptException$("Only 1 argument allowed, but " + t1 + " were passed.", null)); + }, + $signature: 17 + }; + A.global__closure.prototype = { + call$1(argument) { + return argument instanceof A.SassString && !argument._hasQuotes && B.JSString_methods.contains$1(argument._string$_text, $.$get$_microsoftFilterStart()); + }, + $signature: 72 + }; + A.global_closure36.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0) instanceof A.SassNumber || t1.$index($arguments, 0).get$isSpecialNumber()) + return A._functionString("opacity", $arguments); + A.warnForDeprecation(string$.Globalco, B.Deprecation_1AX); + t1 = t1.$index($arguments, 0).assertColor$1("color").alphaOrNull; + return A.SassNumber_SassNumber(t1 == null ? 0 : t1, null); + }, + $signature: 4 + }; + A.global_closure37.prototype = { + call$1($arguments) { + return A._parseChannels("color", J.$index$asx($arguments, 0), "description", null); + }, + $signature: 4 + }; + A.global_closure38.prototype = { + call$1($arguments) { + return A._parseChannels("hwb", J.$index$asx($arguments, 0), "channels", B.HwbColorSpace_guQ); + }, + $signature: 4 + }; + A.global_closure39.prototype = { + call$1($arguments) { + return A._parseChannels("lab", J.$index$asx($arguments, 0), "channels", B.LabColorSpace_2nT); + }, + $signature: 4 + }; + A.global_closure40.prototype = { + call$1($arguments) { + return A._parseChannels("lch", J.$index$asx($arguments, 0), "channels", B.LchColorSpace_Bpv); + }, + $signature: 4 + }; + A.global_closure41.prototype = { + call$1($arguments) { + return A._parseChannels("oklab", J.$index$asx($arguments, 0), "channels", B.OklabColorSpace_540); + }, + $signature: 4 + }; + A.global_closure42.prototype = { + call$1($arguments) { + return A._parseChannels("oklch", J.$index$asx($arguments, 0), "channels", B.OklchColorSpace_9Gj); + }, + $signature: 4 + }; + A.module_closure1.prototype = { + call$1(color) { + return B.JSNumber_methods.round$0(color._legacyChannel$2(B.RgbColorSpace_i0P, "red")); + }, + $signature: 63 + }; + A.module_closure2.prototype = { + call$1(color) { + return B.JSNumber_methods.round$0(color._legacyChannel$2(B.RgbColorSpace_i0P, "green")); + }, + $signature: 63 + }; + A.module_closure3.prototype = { + call$1(color) { + return B.JSNumber_methods.round$0(color._legacyChannel$2(B.RgbColorSpace_i0P, "blue")); + }, + $signature: 63 + }; + A.module_closure4.prototype = { + call$1($arguments) { + var result = A._invert($arguments, false); + if (result instanceof A.SassString) + A.warnForDeprecation("Passing a number (" + J.$index$asx($arguments, 0).toString$0(0) + string$.x29x20to_ci + result.toString$0(0), B.Deprecation_u0j); + return result; + }, + $signature: 4 + }; + A.module_closure5.prototype = { + call$1(color) { + return color._legacyChannel$2(B.HslColorSpace_JQ2, "hue"); + }, + $signature: 51 + }; + A.module_closure6.prototype = { + call$1(color) { + return color._legacyChannel$2(B.HslColorSpace_JQ2, "saturation"); + }, + $signature: 51 + }; + A.module_closure7.prototype = { + call$1(color) { + return color._legacyChannel$2(B.HslColorSpace_JQ2, "lightness"); + }, + $signature: 51 + }; + A.module_closure8.prototype = { + call$1($arguments) { + var result, + t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0) instanceof A.SassNumber) { + result = A._functionString("grayscale", t1.take$1($arguments, 1)); + A.warnForDeprecation("Passing a number (" + t1.$index($arguments, 0).toString$0(0) + string$.x29x20to_cg + result.toString$0(0), B.Deprecation_u0j); + return result; + } + return A._grayscale(t1.$index($arguments, 0)); + }, + $signature: 4 + }; + A.module_closure9.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + t2 = type$.JSArray_Value; + return A._parseChannels("hwb", A.SassList$(A._setArrayType([A.SassList$(A._setArrayType([t1.$index($arguments, 0), t1.$index($arguments, 1), t1.$index($arguments, 2)], t2), B.ListSeparator_qSL, false), t1.$index($arguments, 3)], t2), B.ListSeparator_bRz, false), null, B.HwbColorSpace_guQ); + }, + $signature: 4 + }; + A.module_closure10.prototype = { + call$1($arguments) { + return A._parseChannels("hwb", J.$index$asx($arguments, 0), "channels", B.HwbColorSpace_guQ); + }, + $signature: 4 + }; + A.module_closure11.prototype = { + call$1(color) { + return color._legacyChannel$2(B.HwbColorSpace_guQ, "whiteness"); + }, + $signature: 51 + }; + A.module_closure12.prototype = { + call$1(color) { + return color._legacyChannel$2(B.HwbColorSpace_guQ, "blackness"); + }, + $signature: 51 + }; + A.module_closure13.prototype = { + call$1($arguments) { + var result, + _0_0 = J.$index$asx($arguments, 0), + t1 = false; + if (_0_0 instanceof A.SassString) + if (!_0_0._hasQuotes) + t1 = B.JSString_methods.contains$1(_0_0._string$_text, $.$get$_microsoftFilterStart()); + if (t1) { + result = A._functionString("alpha", $arguments); + A.warnForDeprecation(string$.Using_c + result.toString$0(0), B.Deprecation_u0j); + return result; + } + if (_0_0 instanceof A.SassColor && !_0_0._space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$(string$.color_a, null)); + t1 = _0_0.assertColor$1("color").alphaOrNull; + return A.SassNumber_SassNumber(t1 == null ? 0 : t1, null); + }, + $signature: 4 + }; + A.module_closure14.prototype = { + call$1($arguments) { + var result, + t1 = J.getInterceptor$asx($arguments); + if (B.JSArray_methods.every$1(t1.$index($arguments, 0).get$asList(), new A.module__closure2())) { + result = A._functionString("alpha", $arguments); + A.warnForDeprecation(string$.Using_c + result.toString$0(0), B.Deprecation_u0j); + return result; + } + throw A.wrapException(A.SassScriptException$("Only 1 argument allowed, but " + t1.get$length($arguments) + " were passed.", null)); + }, + $signature: 17 + }; + A.module__closure2.prototype = { + call$1(argument) { + return argument instanceof A.SassString && !argument._hasQuotes && B.JSString_methods.contains$1(argument._string$_text, $.$get$_microsoftFilterStart()); + }, + $signature: 72 + }; + A.module_closure15.prototype = { + call$1($arguments) { + var result, + t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0) instanceof A.SassNumber) { + result = A._functionString("opacity", $arguments); + A.warnForDeprecation("Passing a number (" + t1.$index($arguments, 0).toString$0(0) + string$.x20to_co + result.toString$0(0), B.Deprecation_u0j); + return result; + } + t1 = t1.$index($arguments, 0).assertColor$1("color").alphaOrNull; + return A.SassNumber_SassNumber(t1 == null ? 0 : t1, null); + }, + $signature: 4 + }; + A.module_closure16.prototype = { + call$1($arguments) { + return new A.SassString(J.get$first$ax($arguments).assertColor$1("color")._space.name, false); + }, + $signature: 17 + }; + A.module_closure17.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return A._colorInSpace(t1.$index($arguments, 0), t1.$index($arguments, 1), false); + }, + $signature: 25 + }; + A.module_closure18.prototype = { + call$1($arguments) { + return J.$index$asx($arguments, 0).assertColor$1("color")._space.get$isLegacyInternal() ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A.module_closure19.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return t1.$index($arguments, 0).assertColor$1("color").isChannelMissing$3$channelName$colorName(A._channelName(t1.$index($arguments, 1)), "channel", "color") ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A.module_closure20.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return A._colorInSpace(t1.$index($arguments, 0), t1.$index($arguments, 1), true).get$isInGamut() ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A.module_closure21.prototype = { + call$1($arguments) { + var space, method, _s5_ = "space", _s6_ = "method", + t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + t2 = t1.$index($arguments, 1); + if (t2.$eq(0, B.C__SassNull)) + space = color._space; + else { + t2 = t2.assertString$1(_s5_); + t2.assertUnquoted$1(_s5_); + space = A.ColorSpace_fromName(t2._string$_text, _s5_); + } + if (t1.$index($arguments, 2).$eq(0, B.C__SassNull)) + throw A.wrapException(A.SassScriptException$(string$.color_t, _s6_)); + t1 = t1.$index($arguments, 2).assertString$1(_s6_); + t1.assertUnquoted$1(_s6_); + method = A.GamutMapMethod_GamutMapMethod$fromName(t1._string$_text); + if (!space.get$isBoundedInternal()) + return color; + t1 = color.toSpace$1(space); + t1 = t1.get$isInGamut() ? t1 : method.map$1(0, t1); + return t1.toSpace$2$legacyMissing(color._space, false); + }, + $signature: 25 + }; + A.module_closure22.prototype = { + call$1($arguments) { + var channelIndex, channelInfo, channelValue, unit, + t1 = J.getInterceptor$asx($arguments), + color = A._colorInSpace(t1.$index($arguments, 0), t1.$index($arguments, 2), true), + channelName = A._channelName(t1.$index($arguments, 1)); + if (channelName === "alpha") { + t1 = color.alphaOrNull; + return A.SassNumber_SassNumber(t1 == null ? 0 : t1, null); + } + t1 = color._space._channels; + channelIndex = B.JSArray_methods.indexWhere$1(t1, new A.module__closure1(channelName)); + if (channelIndex === -1) + throw A.wrapException(A.SassScriptException$("Color " + color.toString$0(0) + " has no channel named " + channelName + ".", "channel")); + channelInfo = t1[channelIndex]; + channelValue = color.get$channels()[channelIndex]; + unit = channelInfo.associatedUnit; + return A.SassNumber_SassNumber(unit === "%" ? channelValue * 100 / type$.LinearChannel._as(channelInfo).max : channelValue, unit); + }, + $signature: 24 + }; + A.module__closure1.prototype = { + call$1(channel) { + return channel.name === this.channelName; + }, + $signature: 108 + }; + A.module_closure23.prototype = { + call$1($arguments) { + var t2, t3, + t1 = J.getInterceptor$asx($arguments), + color1 = t1.$index($arguments, 0).assertColor$1("color1"), + color2 = t1.$index($arguments, 1).assertColor$1("color2"); + t1 = new A.module_closure_toXyzNoMissing(); + if (color1._space === color2._space) { + t1 = color1.channel0OrNull; + t2 = false; + if (t1 == null) + t1 = 0; + t3 = color2.channel0OrNull; + if (A.fuzzyEquals(t1, t3 == null ? 0 : t3)) { + t1 = color1.channel1OrNull; + if (t1 == null) + t1 = 0; + t3 = color2.channel1OrNull; + if (A.fuzzyEquals(t1, t3 == null ? 0 : t3)) { + t1 = color1.channel2OrNull; + if (t1 == null) + t1 = 0; + t3 = color2.channel2OrNull; + if (A.fuzzyEquals(t1, t3 == null ? 0 : t3)) { + t1 = color1.alphaOrNull; + if (t1 == null) + t1 = 0; + t2 = color2.alphaOrNull; + t1 = A.fuzzyEquals(t1, t2 == null ? 0 : t2); + } else + t1 = t2; + } else + t1 = t2; + } else + t1 = t2; + } else + t1 = J.$eq$(t1.call$1(color1), t1.call$1(color2)); + return t1 ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A.module_closure_toXyzNoMissing.prototype = { + call$1(color) { + var _1_1, _1_3, t1, _1_7, channel0, _1_8, channel1, _1_9, channel2, _1_10, alpha, _null = null; + $label0$0: { + _1_1 = color._space; + _1_3 = B.XyzD65ColorSpace_WiJ === _1_1; + t1 = _1_3; + if (t1) + t1 = !(color.channel0OrNull == null || color.channel1OrNull == null || color.channel2OrNull == null || color.alphaOrNull == null); + else + t1 = false; + if (t1) { + t1 = color; + break $label0$0; + } + if (_1_3) { + _1_7 = color.channel0OrNull; + if (_1_7 == null) + _1_7 = 0; + channel0 = _1_7; + _1_8 = color.channel1OrNull; + if (_1_8 == null) + _1_8 = 0; + channel1 = _1_8; + _1_9 = color.channel2OrNull; + if (_1_9 == null) + _1_9 = 0; + channel2 = _1_9; + _1_10 = color.alphaOrNull; + if (_1_10 == null) + _1_10 = 0; + alpha = _1_10; + t1 = A.SassColor$_forSpace(B.XyzD65ColorSpace_WiJ, channel0, channel1, channel2, alpha, _null); + break $label0$0; + } + _1_7 = color.channel0OrNull; + if (_1_7 == null) + _1_7 = 0; + channel0 = _1_7; + _1_8 = color.channel1OrNull; + if (_1_8 == null) + _1_8 = 0; + channel1 = _1_8; + _1_9 = color.channel2OrNull; + if (_1_9 == null) + _1_9 = 0; + channel2 = _1_9; + _1_10 = color.alphaOrNull; + if (_1_10 == null) + _1_10 = 0; + alpha = _1_10; + t1 = _1_1.convert$5(B.XyzD65ColorSpace_WiJ, channel0, channel1, channel2, alpha); + break $label0$0; + } + return t1; + }, + $signature: 415 + }; + A.module_closure24.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return A._colorInSpace(t1.$index($arguments, 0), t1.$index($arguments, 2), true).isChannelPowerless$3$channelName$colorName(A._channelName(t1.$index($arguments, 1)), "channel", "color") ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._mix_closure.prototype = { + call$1($arguments) { + var _s6_ = "weight", + _s41_ = string$.To_usem, + _s29_ = ", you must provide a $method.", + t1 = J.getInterceptor$asx($arguments), + color1 = t1.$index($arguments, 0).assertColor$1("color1"), + color2 = t1.$index($arguments, 1).assertColor$1("color2"), + weight = t1.$index($arguments, 2).assertNumber$1(_s6_); + if (!t1.$index($arguments, 3).$eq(0, B.C__SassNull)) + return color1.interpolate$4$legacyMissing$weight(color2, A.InterpolationMethod_InterpolationMethod$fromValue(t1.$index($arguments, 3), "method"), false, weight.valueInRangeWithUnit$4(0, 100, _s6_, "%") / 100); + A._checkPercent(weight, _s6_); + if (!color1._space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$(_s41_ + color1.toString$0(0) + _s29_, "color1")); + else if (!color2._space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$(_s41_ + color2.toString$0(0) + _s29_, "color2")); + return A._mixLegacy(color1, color2, weight); + }, + $signature: 25 + }; + A._complement_closure.prototype = { + call$1($arguments) { + var space, t3, colorInSpace, t4, t5, t6, _s5_ = "space", + t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + t2 = color._space; + if (t2.get$isLegacyInternal() && t1.$index($arguments, 1).$eq(0, B.C__SassNull)) + space = B.HslColorSpace_JQ2; + else { + t3 = t1.$index($arguments, 1).assertString$1(_s5_); + t3.assertUnquoted$1(_s5_); + space = A.ColorSpace_fromName(t3._string$_text, _s5_); + } + if (!space.get$isPolarInternal()) + throw A.wrapException(A.SassScriptException$("Color space " + space.toString$0(0) + " doesn't have a hue channel.", _s5_)); + colorInSpace = color.toSpace$2$legacyMissing(space, !t1.$index($arguments, 1).$eq(0, B.C__SassNull)); + t1 = space._channels; + t3 = colorInSpace.channel0OrNull; + t4 = colorInSpace.channel1OrNull; + t5 = colorInSpace.channel2OrNull; + t6 = colorInSpace.alphaOrNull; + return (space.get$isLegacyInternal() ? A.SassColor_SassColor$forSpaceInternal(space, A._adjustChannel(colorInSpace, t1[0], t3, A.SassNumber_SassNumber(180, null)), t4, t5, t6) : A.SassColor_SassColor$forSpaceInternal(space, t3, t4, A._adjustChannel(colorInSpace, t1[2], t5, A.SassNumber_SassNumber(180, null)), t6)).toSpace$2$legacyMissing(t2, false); + }, + $signature: 25 + }; + A._adjust_closure.prototype = { + call$1($arguments) { + return A._updateComponents($arguments, true, false, false); + }, + $signature: 25 + }; + A._scale_closure.prototype = { + call$1($arguments) { + return A._updateComponents($arguments, false, false, true); + }, + $signature: 25 + }; + A._change_closure.prototype = { + call$1($arguments) { + return A._updateComponents($arguments, false, true, false); + }, + $signature: 25 + }; + A._ieHexStr_closure.prototype = { + call$1($arguments) { + var t1, t2, t3, t4, t5, + color = J.$index$asx($arguments, 0).assertColor$1("color").toSpace$1(B.RgbColorSpace_i0P); + color = color.get$isInGamut() ? color : B.LocalMindeGamutMap_A2x.map$1(0, color); + t1 = new A._ieHexStr_closure_hexString(); + t2 = color.alphaOrNull; + t2 = A.S(t1.call$1((t2 == null ? 0 : t2) * 255)); + t3 = color.channel0OrNull; + t3 = A.S(t1.call$1(t3 == null ? 0 : t3)); + t4 = color.channel1OrNull; + t4 = A.S(t1.call$1(t4 == null ? 0 : t4)); + t5 = color.channel2OrNull; + return new A.SassString("#" + t2 + t3 + t4 + A.S(t1.call$1(t5 == null ? 0 : t5)), false); + }, + $signature: 17 + }; + A._ieHexStr_closure_hexString.prototype = { + call$1(component) { + return B.JSString_methods.padLeft$2(B.JSInt_methods.toRadixString$1(A.fuzzyRound(component), 16), 2, "0").toUpperCase(); + }, + $signature: 229 + }; + A._updateComponents_closure.prototype = { + call$1(space) { + return this.originalColor.toSpace$2$legacyMissing(space, false); + }, + $signature: 422 + }; + A._updateComponents_closure0.prototype = { + call$1(info) { + return this._box_0.name === info.name; + }, + $signature: 108 + }; + A._changeColor_closure.prototype = { + call$0() { + var t1 = this.alphaArg; + A.warnForDeprecation("$alpha: Passing a unit other than % (" + A.S(t1) + string$.x29x20is_d + t1.unitSuggestion$1("alpha") + string$.x0a_See_, B.Deprecation_jG1); + return t1.valueInRange$3(0, 1, "alpha"); + }, + $signature: 238 + }; + A._adjustColor_closure.prototype = { + call$1(alpha) { + return isNaN(alpha) ? 0 : B.JSNumber_methods.clamp$2(alpha, 0, 1); + }, + $signature: 16 + }; + A._functionString_closure.prototype = { + call$1(argument) { + return A.serializeValue(argument, false, true); + }, + $signature: 452 + }; + A._removedColorFunction_closure.prototype = { + call$1($arguments) { + var t1 = this.name, + t2 = J.getInterceptor$asx($arguments), + t3 = t2.$index($arguments, 0).toString$0(0), + t4 = this.negative ? "-" : ""; + throw A.wrapException(A.SassScriptException$("The function " + t1 + string$.x28__isn + t3 + ", $" + this.argument + ": " + t4 + t2.$index($arguments, 1).toString$0(0) + string$.x29x0a_Moro + t1, null)); + }, + $signature: 457 + }; + A._rgb_closure.prototype = { + call$1(alpha) { + var t1 = A._percentageOrUnitless(alpha.assertNumber$1("alpha"), 1, "alpha"); + return isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 1); + }, + $signature: 243 + }; + A._hsl_closure.prototype = { + call$1(alpha) { + var t1 = A._percentageOrUnitless(alpha.assertNumber$1("alpha"), 1, "alpha"); + return isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 1); + }, + $signature: 243 + }; + A._parseChannels_closure.prototype = { + call$1($name) { + return $name + " channel"; + }, + $signature: 6 + }; + A._parseChannels_closure0.prototype = { + call$1(channel) { + return channel.get$isSpecialNumber(); + }, + $signature: 72 + }; + A._colorFromChannels_closure.prototype = { + call$1(channel0) { + return A._angleValue(channel0, "hue"); + }, + $signature: 125 + }; + A._colorFromChannels_closure0.prototype = { + call$1(channel0) { + return A._angleValue(channel0, "hue"); + }, + $signature: 125 + }; + A._channelFromValue_closure.prototype = { + call$1(value) { + var t1, _0_8, t2, _0_5, _0_8_isSet, upperClamped, t3, + _0_0 = this.channel; + $label0$0: { + t1 = _0_0 instanceof A.LinearChannel; + if (t1 && _0_0.requiresPercent && !value.hasUnit$1("%")) + A.throwExpression(A.SassScriptException$("Expected " + value.toString$0(0) + ' to have unit "%".', _0_0.name)); + _0_8 = null; + t2 = false; + if (t1) { + _0_5 = _0_0.lowerClamped; + _0_8_isSet = !_0_5; + if (_0_8_isSet) { + _0_8 = _0_0.upperClamped; + t2 = !_0_8; + } + } else { + _0_5 = null; + _0_8_isSet = false; + } + if (t2) { + t1 = A._percentageOrUnitless(value, _0_0.max, _0_0.name); + break $label0$0; + } + if (t1 && !this.clamp) { + t1 = A._percentageOrUnitless(value, _0_0.max, _0_0.name); + break $label0$0; + } + if (t1) { + upperClamped = _0_8_isSet ? _0_8 : _0_0.upperClamped; + t1 = _0_0.max; + t2 = A._percentageOrUnitless(value, t1, _0_0.name); + t3 = _0_5 ? _0_0.min : -1 / 0; + t1 = upperClamped ? t1 : 1 / 0; + t1 = isNaN(t2) ? t3 : B.JSNumber_methods.clamp$2(t2, t3, t1); + break $label0$0; + } + t1 = B.JSNumber_methods.$mod(value.coerceValueToUnit$2("deg", _0_0.name), 360); + break $label0$0; + } + return t1; + }, + $signature: 125 + }; + A._channelFunction_closure.prototype = { + call$1($arguments) { + var _this = this, + result = A.SassNumber_SassNumber(_this.getter.call$1(J.get$first$ax($arguments).assertColor$1("color")), _this.unit), + t1 = _this.global ? "" : "color.", + t2 = _this.name; + A.warnForDeprecation(t1 + t2 + string$.x28__is_d + t2 + '", $space: ' + _this.space.toString$0(0) + string$.x29x0a_Mor_, B.Deprecation_cyE); + return result; + }, + $signature: 24 + }; + A._suggestScaleAndAdjust_closure.prototype = { + call$1(channel) { + return channel.name === this.channelName; + }, + $signature: 108 + }; + A._length_closure0.prototype = { + call$1($arguments) { + return A.SassNumber_SassNumber(J.$index$asx($arguments, 0).get$asList().length, null); + }, + $signature: 24 + }; + A._nth_closure.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + list = t1.$index($arguments, 0), + index = t1.$index($arguments, 1); + return list.get$asList()[list.sassIndexToListIndex$2(index, "n")]; + }, + $signature: 4 + }; + A._setNth_closure.prototype = { + call$1($arguments) { + var newList, + t1 = J.getInterceptor$asx($arguments), + list = t1.$index($arguments, 0), + index = t1.$index($arguments, 1), + value = t1.$index($arguments, 2); + t1 = list.get$asList(); + newList = A._setArrayType(t1.slice(0), A._arrayInstanceType(t1)); + newList[list.sassIndexToListIndex$2(index, "n")] = value; + return list.withListContents$1(newList); + }, + $signature: 27 + }; + A._join_closure.prototype = { + call$1($arguments) { + var _0_1, _0_4, _0_3, t2, t3, _0_40, separator, bracketed, _null = null, + t1 = J.getInterceptor$asx($arguments), + list1 = t1.$index($arguments, 0), + list2 = t1.$index($arguments, 1), + separatorParam = t1.$index($arguments, 2).assertString$1("separator"), + bracketedParam = t1.$index($arguments, 3), + _1_0 = separatorParam._string$_text; + $label1$1: { + if ("auto" === _1_0) { + _0_1 = list1.get$separator(list1); + _0_4 = list2.get$separator(list2); + $label0$0: { + t1 = _null; + _0_3 = B.ListSeparator_undecided_null_undecided === _0_1; + t2 = _0_3; + if (t2) { + t3 = B.ListSeparator_undecided_null_undecided === _0_4; + _0_40 = _0_4; + } else { + _0_40 = _null; + t3 = false; + } + if (t3) { + t1 = B.ListSeparator_qSL; + break $label0$0; + } + if (_0_3) + separator = t2 ? _0_40 : _0_4; + else + separator = t1; + if (!_0_3) + separator = _0_1; + t1 = separator; + break $label0$0; + } + break $label1$1; + } + if ("space" === _1_0) { + t1 = B.ListSeparator_qSL; + break $label1$1; + } + if ("comma" === _1_0) { + t1 = B.ListSeparator_qVN; + break $label1$1; + } + if ("slash" === _1_0) { + t1 = B.ListSeparator_bRz; + break $label1$1; + } + t1 = A.throwExpression(A.SassScriptException$(string$.x24separ, _null)); + } + bracketed = bracketedParam instanceof A.SassString && bracketedParam._string$_text === "auto" ? list1.get$hasBrackets() : bracketedParam.get$isTruthy(); + t2 = A.List_List$of(list1.get$asList(), true, type$.Value); + B.JSArray_methods.addAll$1(t2, list2.get$asList()); + return A.SassList$(t2, t1, bracketed); + }, + $signature: 27 + }; + A._append_closure0.prototype = { + call$1($arguments) { + var t2, + t1 = J.getInterceptor$asx($arguments), + list = t1.$index($arguments, 0), + value = t1.$index($arguments, 1), + _0_0 = t1.$index($arguments, 2).assertString$1("separator")._string$_text; + $label0$0: { + if ("auto" === _0_0) { + t1 = list.get$separator(list) === B.ListSeparator_undecided_null_undecided ? B.ListSeparator_qSL : list.get$separator(list); + break $label0$0; + } + if ("space" === _0_0) { + t1 = B.ListSeparator_qSL; + break $label0$0; + } + if ("comma" === _0_0) { + t1 = B.ListSeparator_qVN; + break $label0$0; + } + if ("slash" === _0_0) { + t1 = B.ListSeparator_bRz; + break $label0$0; + } + t1 = A.throwExpression(A.SassScriptException$(string$.x24separ, null)); + } + t2 = A.List_List$of(list.get$asList(), true, type$.Value); + t2.push(value); + return list.withListContents$2$separator(t2, t1); + }, + $signature: 27 + }; + A._zip_closure.prototype = { + call$1($arguments) { + var results, result, _box_0 = {}, + t1 = J.$index$asx($arguments, 0).get$asList(), + t2 = A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,List>"), + lists = A.List_List$of(new A.MappedListIterable(t1, new A._zip__closure(), t2), true, t2._eval$1("ListIterable.E")); + if (lists.length === 0) + return B.SassList_BlY; + _box_0.i = 0; + results = A._setArrayType([], type$.JSArray_SassList); + for (t1 = A._arrayInstanceType(lists)._eval$1("MappedListIterable<1,Value>"), t2 = type$.Value; B.JSArray_methods.every$1(lists, new A._zip__closure0(_box_0));) { + result = A.List_List$from(new A.MappedListIterable(lists, new A._zip__closure1(_box_0), t1), false, t2); + result.$flags = 3; + results.push(new A.SassList(result, B.ListSeparator_qSL, false)); + ++_box_0.i; + } + return A.SassList$(results, B.ListSeparator_qVN, false); + }, + $signature: 27 + }; + A._zip__closure.prototype = { + call$1(list) { + return list.get$asList(); + }, + $signature: 500 + }; + A._zip__closure0.prototype = { + call$1(list) { + return this._box_0.i !== J.get$length$asx(list); + }, + $signature: 567 + }; + A._zip__closure1.prototype = { + call$1(list) { + return J.$index$asx(list, this._box_0.i); + }, + $signature: 4 + }; + A._index_closure0.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + index = B.JSArray_methods.indexOf$1(t1.$index($arguments, 0).get$asList(), t1.$index($arguments, 1)); + return index === -1 ? B.C__SassNull : A.SassNumber_SassNumber(index + 1, null); + }, + $signature: 4 + }; + A._separator_closure.prototype = { + call$1($arguments) { + var t1 = J.$index$asx($arguments, 0), + _0_0 = t1.get$separator(t1); + $label0$0: { + if (B.ListSeparator_qVN === _0_0) { + t1 = new A.SassString("comma", false); + break $label0$0; + } + if (B.ListSeparator_bRz === _0_0) { + t1 = new A.SassString("slash", false); + break $label0$0; + } + t1 = new A.SassString("space", false); + break $label0$0; + } + return t1; + }, + $signature: 17 + }; + A._isBracketed_closure.prototype = { + call$1($arguments) { + return J.$index$asx($arguments, 0).get$hasBrackets() ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._slash_closure.prototype = { + call$1($arguments) { + var list = J.$index$asx($arguments, 0).get$asList(); + if (list.length < 2) + throw A.wrapException(A.SassScriptException$("At least two elements are required.", null)); + return A.SassList$(list, B.ListSeparator_bRz, false); + }, + $signature: 27 + }; + A._get_closure.prototype = { + call$1($arguments) { + var value, + t1 = J.getInterceptor$asx($arguments), + map = t1.$index($arguments, 0).assertMap$1("map"), + t2 = A._setArrayType([t1.$index($arguments, 1)], type$.JSArray_Value); + B.JSArray_methods.addAll$1(t2, t1.$index($arguments, 2).get$asList()); + for (t1 = A.IterableExtension_get_exceptLast(t2), t1 = t1.get$iterator(t1); t1.moveNext$0(); map = value) { + value = map._map$_contents.$index(0, t1.get$current(t1)); + if (!(value instanceof A.SassMap)) + return B.C__SassNull; + } + t1 = map._map$_contents.$index(0, B.JSArray_methods.get$last(t2)); + return t1 == null ? B.C__SassNull : t1; + }, + $signature: 4 + }; + A._set_closure.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return A._modify(t1.$index($arguments, 0).assertMap$1("map"), A._setArrayType([t1.$index($arguments, 1)], type$.JSArray_Value), new A._set__closure0($arguments), true); + }, + $signature: 4 + }; + A._set__closure0.prototype = { + call$1(_) { + return J.$index$asx(this.$arguments, 2); + }, + $signature: 42 + }; + A._set_closure0.prototype = { + call$1($arguments) { + var keys, t2, t3, + t1 = J.getInterceptor$asx($arguments), + map = t1.$index($arguments, 0).assertMap$1("map"), + _0_0 = t1.$index($arguments, 1).get$asList(), + _0_1 = _0_0.length; + if (_0_1 <= 0) + throw A.wrapException(A.SassScriptException$("Expected $args to contain a key.", null)); + if (_0_1 === 1) + throw A.wrapException(A.SassScriptException$("Expected $args to contain a value.", null)); + t1 = {}; + keys = t1.value = null; + t2 = _0_1 >= 1; + if (t2) { + t3 = _0_1 - 1; + keys = B.JSArray_methods.sublist$2(_0_0, 0, t3); + t1.value = _0_0[t3]; + } + if (t2) + return A._modify(map, keys, new A._set__closure(t1), true); + throw A.wrapException("[BUG] Unreachable code"); + }, + $signature: 4 + }; + A._set__closure.prototype = { + call$1(_) { + return this._box_0.value; + }, + $signature: 42 + }; + A._merge_closure.prototype = { + call$1($arguments) { + var t2, + t1 = J.getInterceptor$asx($arguments), + map1 = t1.$index($arguments, 0).assertMap$1("map1"), + map2 = t1.$index($arguments, 1).assertMap$1("map2"); + t1 = type$.Value; + t2 = A.LinkedHashMap_LinkedHashMap$of(map1._map$_contents, t1, t1); + t2.addAll$1(0, map2._map$_contents); + return new A.SassMap(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 38 + }; + A._merge_closure0.prototype = { + call$1($arguments) { + var last, t2, keys, _null = null, + t1 = J.getInterceptor$asx($arguments), + map1 = t1.$index($arguments, 0).assertMap$1("map1"), + _0_0 = t1.$index($arguments, 1).get$asList(), + _0_1 = _0_0.length; + if (_0_1 <= 0) + throw A.wrapException(A.SassScriptException$("Expected $args to contain a key.", _null)); + if (_0_1 === 1) + throw A.wrapException(A.SassScriptException$("Expected $args to contain a map.", _null)); + t1 = _0_1 >= 1; + last = _null; + if (t1) { + t2 = _0_1 - 1; + keys = B.JSArray_methods.sublist$2(_0_0, 0, t2); + last = _0_0[t2]; + } else + keys = _null; + if (t1) + return A._modify(map1, keys, new A._merge__closure(last.assertMap$1("map2")), true); + throw A.wrapException("[BUG] Unreachable code"); + }, + $signature: 4 + }; + A._merge__closure.prototype = { + call$1(oldValue) { + var t1, t2, + nestedMap = oldValue.tryMap$0(); + if (nestedMap == null) + return this.map2; + t1 = type$.Value; + t2 = A.LinkedHashMap_LinkedHashMap$of(nestedMap._map$_contents, t1, t1); + t2.addAll$1(0, this.map2._map$_contents); + return new A.SassMap(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 650 + }; + A._deepMerge_closure.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return A._deepMergeImpl(t1.$index($arguments, 0).assertMap$1("map1"), t1.$index($arguments, 1).assertMap$1("map2")); + }, + $signature: 38 + }; + A._deepRemove_closure.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + map = t1.$index($arguments, 0).assertMap$1("map"), + t2 = A._setArrayType([t1.$index($arguments, 1)], type$.JSArray_Value); + B.JSArray_methods.addAll$1(t2, t1.$index($arguments, 2).get$asList()); + return A._modify(map, A.IterableExtension_get_exceptLast(t2), new A._deepRemove__closure(t2), false); + }, + $signature: 4 + }; + A._deepRemove__closure.prototype = { + call$1(value) { + var t1, nestedMap, t2, + _0_0 = value.tryMap$0(); + if (_0_0 != null) { + t1 = _0_0._map$_contents.containsKey$1(B.JSArray_methods.get$last(this.keys)); + nestedMap = _0_0; + } else { + nestedMap = null; + t1 = false; + } + if (t1) { + t1 = type$.Value; + t2 = A.LinkedHashMap_LinkedHashMap$of(nestedMap._map$_contents, t1, t1); + t2.remove$1(0, B.JSArray_methods.get$last(this.keys)); + return new A.SassMap(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + } + return value; + }, + $signature: 42 + }; + A._remove_closure.prototype = { + call$1($arguments) { + return J.$index$asx($arguments, 0).assertMap$1("map"); + }, + $signature: 38 + }; + A._remove_closure0.prototype = { + call$1($arguments) { + var mutableMap, t3, _i, + t1 = J.getInterceptor$asx($arguments), + map = t1.$index($arguments, 0).assertMap$1("map"), + t2 = A._setArrayType([t1.$index($arguments, 1)], type$.JSArray_Value); + B.JSArray_methods.addAll$1(t2, t1.$index($arguments, 2).get$asList()); + t1 = type$.Value; + mutableMap = A.LinkedHashMap_LinkedHashMap$of(map._map$_contents, t1, t1); + for (t3 = t2.length, _i = 0; _i < t2.length; t2.length === t3 || (0, A.throwConcurrentModificationError)(t2), ++_i) + mutableMap.remove$1(0, t2[_i]); + return new A.SassMap(A.ConstantMap_ConstantMap$from(mutableMap, t1, t1)); + }, + $signature: 38 + }; + A._keys_closure.prototype = { + call$1($arguments) { + var t1 = J.$index$asx($arguments, 0).assertMap$1("map")._map$_contents; + return A.SassList$(t1.get$keys(t1), B.ListSeparator_qVN, false); + }, + $signature: 27 + }; + A._values_closure.prototype = { + call$1($arguments) { + var t1 = J.$index$asx($arguments, 0).assertMap$1("map")._map$_contents; + return A.SassList$(t1.get$values(t1), B.ListSeparator_qVN, false); + }, + $signature: 27 + }; + A._hasKey_closure.prototype = { + call$1($arguments) { + var value, + t1 = J.getInterceptor$asx($arguments), + map = t1.$index($arguments, 0).assertMap$1("map"), + t2 = A._setArrayType([t1.$index($arguments, 1)], type$.JSArray_Value); + B.JSArray_methods.addAll$1(t2, t1.$index($arguments, 2).get$asList()); + for (t1 = A.IterableExtension_get_exceptLast(t2), t1 = t1.get$iterator(t1); t1.moveNext$0(); map = value) { + value = map._map$_contents.$index(0, t1.get$current(t1)); + if (!(value instanceof A.SassMap)) + return B.SassBoolean_false; + } + return map._map$_contents.containsKey$1(B.JSArray_methods.get$last(t2)) ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._modify_modifyNestedMap.prototype = { + call$1(map) { + var nestedMap, _this = this, + t1 = type$.Value, + mutableMap = A.LinkedHashMap_LinkedHashMap$of(map._map$_contents, t1, t1), + t2 = _this.keyIterator, + key = t2.get$current(t2); + if (!t2.moveNext$0()) { + t2 = mutableMap.$index(0, key); + if (t2 == null) + t2 = B.C__SassNull; + mutableMap.$indexSet(0, key, _this.modify.call$1(t2)); + return new A.SassMap(A.ConstantMap_ConstantMap$from(mutableMap, t1, t1)); + } + t2 = mutableMap.$index(0, key); + nestedMap = t2 == null ? null : t2.tryMap$0(); + t2 = nestedMap == null; + if (t2 && !_this.addNesting) + return new A.SassMap(A.ConstantMap_ConstantMap$from(mutableMap, t1, t1)); + mutableMap.$indexSet(0, key, _this.call$1(t2 ? B.SassMap_Map_empty : nestedMap)); + return new A.SassMap(A.ConstantMap_ConstantMap$from(mutableMap, t1, t1)); + }, + $signature: 671 + }; + A.global_closure.prototype = { + call$1($arguments) { + var t1, + number = J.$index$asx($arguments, 0).assertNumber$1("number"); + if (number.hasUnit$1("%")) + A.warnForDeprecation(string$.Passinp + number.toString$0(0) + ")\nTo emit a CSS abs() now: abs(#{" + number.toString$0(0) + string$.x7d__Mor, B.Deprecation_pLJ); + else + A.warnForDeprecation(string$.Globalm, B.Deprecation_1AX); + t1 = number.get$numeratorUnits(number); + return A.SassNumber_SassNumber$withUnits(Math.abs(number._number$_value), number.get$denominatorUnits(number), t1); + }, + $signature: 24 + }; + A.module_closure0.prototype = { + call$1(value) { + return Math.abs(value); + }, + $signature: 16 + }; + A._ceil_closure.prototype = { + call$1(value) { + return B.JSNumber_methods.ceil$0(value); + }, + $signature: 16 + }; + A._clamp_closure.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + min = t1.$index($arguments, 0).assertNumber$1("min"), + number = t1.$index($arguments, 1).assertNumber$1("number"), + max = t1.$index($arguments, 2).assertNumber$1("max"); + number.convertValueToMatch$3(min, "number", "min"); + max.convertValueToMatch$3(min, "max", "min"); + if (min.greaterThanOrEquals$1(max).value) + return min; + if (min.greaterThanOrEquals$1(number).value) + return min; + if (number.greaterThanOrEquals$1(max).value) + return max; + return number; + }, + $signature: 24 + }; + A._floor_closure.prototype = { + call$1(value) { + return B.JSNumber_methods.floor$0(value); + }, + $signature: 16 + }; + A._max_closure.prototype = { + call$1($arguments) { + var t1, t2, max, _i, number; + for (t1 = J.$index$asx($arguments, 0).get$asList(), t2 = t1.length, max = null, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + number = t1[_i].assertNumber$0(); + if (max == null || max.lessThan$1(number).value) + max = number; + } + if (max != null) + return max; + throw A.wrapException(A.SassScriptException$("At least one argument must be passed.", null)); + }, + $signature: 24 + }; + A._min_closure.prototype = { + call$1($arguments) { + var t1, t2, min, _i, number; + for (t1 = J.$index$asx($arguments, 0).get$asList(), t2 = t1.length, min = null, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + number = t1[_i].assertNumber$0(); + if (min == null || min.greaterThan$1(number).value) + min = number; + } + if (min != null) + return min; + throw A.wrapException(A.SassScriptException$("At least one argument must be passed.", null)); + }, + $signature: 24 + }; + A._round_closure.prototype = { + call$1(number) { + return B.JSNumber_methods.round$0(number); + }, + $signature: 16 + }; + A._hypot_closure.prototype = { + call$1($arguments) { + var subtotal, i, i0, t3, + t1 = J.$index$asx($arguments, 0).get$asList(), + t2 = A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,SassNumber>"), + numbers = A.List_List$of(new A.MappedListIterable(t1, new A._hypot__closure(), t2), true, t2._eval$1("ListIterable.E")); + t1 = numbers.length; + if (t1 === 0) + throw A.wrapException(A.SassScriptException$("At least one argument must be passed.", null)); + for (subtotal = 0, i = 0; i < t1; i = i0) { + i0 = i + 1; + subtotal += Math.pow(numbers[i].convertValueToMatch$3(numbers[0], "numbers[" + i0 + "]", "numbers[1]"), 2); + } + t1 = Math.sqrt(subtotal); + t2 = numbers[0]; + t3 = t2.get$numeratorUnits(t2); + return A.SassNumber_SassNumber$withUnits(t1, t2.get$denominatorUnits(t2), t3); + }, + $signature: 24 + }; + A._hypot__closure.prototype = { + call$1(argument) { + return argument.assertNumber$0(); + }, + $signature: 672 + }; + A._log_closure.prototype = { + call$1($arguments) { + var base, + _s18_ = " to have no units.", + _null = null, + t1 = J.getInterceptor$asx($arguments), + number = t1.$index($arguments, 0).assertNumber$1("number"); + if (number.get$hasUnits()) + throw A.wrapException(A.SassScriptException$("$number: Expected " + number.toString$0(0) + _s18_, _null)); + else if (t1.$index($arguments, 1).$eq(0, B.C__SassNull)) + return A.SassNumber_SassNumber(Math.log(number._number$_value), _null); + base = t1.$index($arguments, 1).assertNumber$1("base"); + if (base.get$hasUnits()) + throw A.wrapException(A.SassScriptException$("$base: Expected " + base.toString$0(0) + _s18_, _null)); + else + return A.SassNumber_SassNumber(Math.log(number._number$_value) / Math.log(base._number$_value), _null); + }, + $signature: 24 + }; + A._pow_closure.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return A.pow0(t1.$index($arguments, 0).assertNumber$1("base"), t1.$index($arguments, 1).assertNumber$1("exponent")); + }, + $signature: 24 + }; + A._atan2_closure.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + y = t1.$index($arguments, 0).assertNumber$1("y"); + return A.SassNumber_SassNumber$withUnits(Math.atan2(y._number$_value, t1.$index($arguments, 1).assertNumber$1("x").convertValueToMatch$3(y, "x", "y")) * 57.29577951308232, null, A._setArrayType(["deg"], type$.JSArray_String)); + }, + $signature: 24 + }; + A._compatible_closure.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return t1.$index($arguments, 0).assertNumber$1("number1").isComparableTo$1(t1.$index($arguments, 1).assertNumber$1("number2")) ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._isUnitless_closure.prototype = { + call$1($arguments) { + return !J.$index$asx($arguments, 0).assertNumber$1("number").get$hasUnits() ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._unit_closure.prototype = { + call$1($arguments) { + return new A.SassString(J.$index$asx($arguments, 0).assertNumber$1("number").get$unitString(), true); + }, + $signature: 17 + }; + A._percentage_closure.prototype = { + call$1($arguments) { + var number = J.$index$asx($arguments, 0).assertNumber$1("number"); + number.assertNoUnits$1("number"); + return A.SassNumber_SassNumber(number._number$_value * 100, "%"); + }, + $signature: 24 + }; + A._randomFunction_closure.prototype = { + call$1($arguments) { + var limit, limitScalar, + t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0).$eq(0, B.C__SassNull)) + return A.SassNumber_SassNumber($.$get$_random0().nextDouble$0(), null); + limit = t1.$index($arguments, 0).assertNumber$1("limit"); + if (limit.get$hasUnits()) + A.warnForDeprecation(string$.math_r + limit.toString$0(0) + string$.x29x20in_a + limit.get$unitString() + ")) * 1" + limit.get$unitString() + string$.x0a_To_p + limit.get$unitString() + string$.x29x29__Mo, B.Deprecation_jG1); + limitScalar = limit.assertInt$1("limit"); + if (limitScalar < 1) + throw A.wrapException(A.SassScriptException$("$limit: Must be greater than 0, was " + limit.toString$0(0) + ".", null)); + return A.SassNumber_SassNumber($.$get$_random0().nextInt$1(limitScalar) + 1, null); + }, + $signature: 24 + }; + A._div_closure.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + number1 = t1.$index($arguments, 0), + number2 = t1.$index($arguments, 1); + if (!(number1 instanceof A.SassNumber) || !(number2 instanceof A.SassNumber)) + A.warn(string$.math_d); + return number1.dividedBy$1(number2); + }, + $signature: 4 + }; + A._singleArgumentMathFunc_closure.prototype = { + call$1($arguments) { + return this.mathFunc.call$1(J.$index$asx($arguments, 0).assertNumber$1("number")); + }, + $signature: 24 + }; + A._numberFunction_closure.prototype = { + call$1($arguments) { + var number = J.$index$asx($arguments, 0).assertNumber$1("number"), + t1 = this.transform.call$1(number._number$_value), + t2 = number.get$numeratorUnits(number); + return A.SassNumber_SassNumber$withUnits(t1, number.get$denominatorUnits(number), t2); + }, + $signature: 24 + }; + A._shared_closure.prototype = { + call$1($arguments) { + A.warnForDeprecation(string$.The_fe, B.Deprecation_hcg); + return $._features.contains$1(0, J.$index$asx($arguments, 0).assertString$1("feature")._string$_text) ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._shared_closure0.prototype = { + call$1($arguments) { + return new A.SassString(A.serializeValue(J.get$first$ax($arguments), true, true), false); + }, + $signature: 17 + }; + A._shared_closure1.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + _0_0 = t1.$index($arguments, 0); + $label0$0: { + if (_0_0 instanceof A.SassArgumentList) { + t1 = "arglist"; + break $label0$0; + } + if (_0_0 instanceof A.SassBoolean) { + t1 = "bool"; + break $label0$0; + } + if (_0_0 instanceof A.SassColor) { + t1 = "color"; + break $label0$0; + } + if (_0_0 instanceof A.SassList) { + t1 = "list"; + break $label0$0; + } + if (_0_0 instanceof A.SassMap) { + t1 = "map"; + break $label0$0; + } + if (B.C__SassNull === _0_0) { + t1 = "null"; + break $label0$0; + } + if (_0_0 instanceof A.SassNumber) { + t1 = "number"; + break $label0$0; + } + if (_0_0 instanceof A.SassFunction) { + t1 = "function"; + break $label0$0; + } + if (_0_0 instanceof A.SassMixin) { + t1 = "mixin"; + break $label0$0; + } + if (_0_0 instanceof A.SassCalculation) { + t1 = "calculation"; + break $label0$0; + } + if (_0_0 instanceof A.SassString) { + t1 = "string"; + break $label0$0; + } + t1 = A.throwExpression("[BUG] Unknown value type " + t1.$index($arguments, 0).toString$0(0)); + } + return new A.SassString(t1, false); + }, + $signature: 17 + }; + A._shared_closure2.prototype = { + call$1($arguments) { + var t2, t3, t4, + t1 = J.getInterceptor$asx($arguments), + _1_0 = t1.$index($arguments, 0); + if (_1_0 instanceof A.SassArgumentList) { + _1_0._wereKeywordsAccessed = true; + t1 = type$.Value; + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t3 = A.MapExtensions_get_pairs(_1_0._keywords, type$.String, t1), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t2.$indexSet(0, new A.SassString(t4._0, false), t4._1); + } + return new A.SassMap(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + } else + throw A.wrapException("$args: " + t1.$index($arguments, 0).toString$0(0) + " is not an argument list."); + }, + $signature: 38 + }; + A.moduleFunctions_closure.prototype = { + call$1($arguments) { + return new A.SassString(J.$index$asx($arguments, 0).assertCalculation$1("calc").name, true); + }, + $signature: 17 + }; + A.moduleFunctions_closure0.prototype = { + call$1($arguments) { + var t1 = J.$index$asx($arguments, 0).assertCalculation$1("calc").$arguments; + return A.SassList$(new A.MappedListIterable(t1, new A.moduleFunctions__closure(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Value>")), B.ListSeparator_qVN, false); + }, + $signature: 27 + }; + A.moduleFunctions__closure.prototype = { + call$1(argument) { + return argument instanceof A.Value ? argument : new A.SassString(J.toString$0$(argument), false); + }, + $signature: 673 + }; + A.moduleFunctions_closure1.prototype = { + call$1($arguments) { + var _0_2_isSet, _0_2, acceptsContent, t1, _0_5_isSet, _0_5, hasContent, + mixin = J.$index$asx($arguments, 0).assertMixin$1("mixin"), + _0_0 = mixin.callable; + $label0$0: { + _0_2_isSet = type$.AsyncBuiltInCallable._is(_0_0); + if (_0_2_isSet) { + _0_2 = _0_0.get$acceptsContent(); + acceptsContent = _0_2; + } else + acceptsContent = null; + if (!_0_2_isSet) { + _0_2_isSet = _0_0 instanceof A.BuiltInCallable; + if (_0_2_isSet) { + _0_2 = _0_0.acceptsContent; + acceptsContent = _0_2; + } + t1 = _0_2_isSet; + } else + t1 = true; + if (t1) { + t1 = acceptsContent; + break $label0$0; + } + _0_5_isSet = _0_0 instanceof A.UserDefinedCallable; + if (_0_5_isSet) { + _0_5 = _0_0.declaration; + t1 = _0_5 instanceof A.MixinRule; + } else { + _0_5 = null; + t1 = false; + } + if (t1) { + t1 = _0_5_isSet ? _0_5 : _0_0.declaration; + hasContent = type$.MixinRule._as(t1).get$hasContent(); + t1 = hasContent; + break $label0$0; + } + t1 = A.throwExpression(A.UnsupportedError$("Unknown callable type " + mixin.toString$0(0) + ".")); + } + return t1 ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._nest_closure.prototype = { + call$1($arguments) { + var t1 = {}, + selectors = J.$index$asx($arguments, 0).get$asList(); + if (selectors.length === 0) + throw A.wrapException(A.SassScriptException$(string$.x24selec, null)); + t1.first = true; + return new A.MappedListIterable(selectors, new A._nest__closure(t1), A._arrayInstanceType(selectors)._eval$1("MappedListIterable<1,SelectorList>")).reduce$1(0, new A._nest__closure0()).get$asSassList(); + }, + $signature: 27 + }; + A._nest__closure.prototype = { + call$1(selector) { + var t1 = this._box_0, + result = A.SassApiValue_assertSelector(selector, !t1.first, null); + t1.first = false; + return result; + }, + $signature: 204 + }; + A._nest__closure0.prototype = { + call$2($parent, child) { + return child.nestWithin$1($parent); + }, + $signature: 143 + }; + A._append_closure.prototype = { + call$1($arguments) { + var t1, + selectors = J.$index$asx($arguments, 0).get$asList(); + if (selectors.length === 0) + throw A.wrapException(A.SassScriptException$(string$.x24selec, null)); + t1 = A.EvaluationContext_currentOrNull(); + return new A.MappedListIterable(selectors, new A._append__closure(), A._arrayInstanceType(selectors)._eval$1("MappedListIterable<1,SelectorList>")).reduce$1(0, new A._append__closure0((t1 == null ? A.throwExpression(A.StateError$(string$.No_Sass)) : t1).get$currentCallableSpan())).get$asSassList(); + }, + $signature: 27 + }; + A._append__closure.prototype = { + call$1(selector) { + return A.SassApiValue_assertSelector(selector, false, null); + }, + $signature: 204 + }; + A._append__closure0.prototype = { + call$2($parent, child) { + var t1 = child.components, + t2 = this.span; + return A.SelectorList$(new A.MappedListIterable(t1, new A._append___closure($parent, t2), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,ComplexSelector>")), t2).nestWithin$1($parent); + }, + $signature: 143 + }; + A._append___closure.prototype = { + call$1(complex) { + var _0_0, t1, component, rest, newCompound, t2, _null = null; + if (complex.leadingCombinators.length !== 0) + throw A.wrapException(A.SassScriptException$("Can't append " + complex.toString$0(0) + " to " + this.parent.toString$0(0) + ".", _null)); + _0_0 = complex.components; + t1 = _0_0.length >= 1; + if (t1) { + component = _0_0[0]; + rest = B.JSArray_methods.sublist$1(_0_0, 1); + } else { + rest = _null; + component = rest; + } + if (!t1) + throw A.wrapException(A.StateError$("Pattern matching error")); + newCompound = A._prependParent(component.selector); + if (newCompound == null) + throw A.wrapException(A.SassScriptException$("Can't append " + complex.toString$0(0) + " to " + this.parent.toString$0(0) + ".", _null)); + t1 = this.span; + t2 = A._setArrayType([new A.ComplexSelectorComponent(newCompound, A.List_List$unmodifiable(component.combinators, type$.CssValue_Combinator), t1)], type$.JSArray_ComplexSelectorComponent); + B.JSArray_methods.addAll$1(t2, rest); + return A.ComplexSelector$(B.List_empty0, t2, t1, false); + }, + $signature: 60 + }; + A._extend_closure.prototype = { + call$1($arguments) { + var target, source, + _s8_ = "selector", + _s8_0 = "extendee", + _s8_1 = "extender", + t1 = J.getInterceptor$asx($arguments), + selector = A.SassApiValue_assertSelector(t1.$index($arguments, 0), false, _s8_); + selector.assertNotBogus$1$name(_s8_); + target = A.SassApiValue_assertSelector(t1.$index($arguments, 1), false, _s8_0); + target.assertNotBogus$1$name(_s8_0); + source = A.SassApiValue_assertSelector(t1.$index($arguments, 2), false, _s8_1); + source.assertNotBogus$1$name(_s8_1); + t1 = A.EvaluationContext_currentOrNull(); + return A.ExtensionStore__extendOrReplace(selector, source, target, B.ExtendMode_allTargets_allTargets, (t1 == null ? A.throwExpression(A.StateError$(string$.No_Sass)) : t1).get$currentCallableSpan()).get$asSassList(); + }, + $signature: 27 + }; + A._replace_closure.prototype = { + call$1($arguments) { + var target, source, + _s8_ = "selector", + _s8_0 = "original", + _s11_ = "replacement", + t1 = J.getInterceptor$asx($arguments), + selector = A.SassApiValue_assertSelector(t1.$index($arguments, 0), false, _s8_); + selector.assertNotBogus$1$name(_s8_); + target = A.SassApiValue_assertSelector(t1.$index($arguments, 1), false, _s8_0); + target.assertNotBogus$1$name(_s8_0); + source = A.SassApiValue_assertSelector(t1.$index($arguments, 2), false, _s11_); + source.assertNotBogus$1$name(_s11_); + t1 = A.EvaluationContext_currentOrNull(); + return A.ExtensionStore__extendOrReplace(selector, source, target, B.ExtendMode_replace_replace, (t1 == null ? A.throwExpression(A.StateError$(string$.No_Sass)) : t1).get$currentCallableSpan()).get$asSassList(); + }, + $signature: 27 + }; + A._unify_closure.prototype = { + call$1($arguments) { + var selector2, + _s9_ = "selector1", + _s9_0 = "selector2", + t1 = J.getInterceptor$asx($arguments), + selector1 = A.SassApiValue_assertSelector(t1.$index($arguments, 0), false, _s9_); + selector1.assertNotBogus$1$name(_s9_); + selector2 = A.SassApiValue_assertSelector(t1.$index($arguments, 1), false, _s9_0); + selector2.assertNotBogus$1$name(_s9_0); + t1 = selector1.unify$1(selector2); + t1 = t1 == null ? null : t1.get$asSassList(); + return t1 == null ? B.C__SassNull : t1; + }, + $signature: 4 + }; + A._isSuperselector_closure.prototype = { + call$1($arguments) { + var selector2, + t1 = J.getInterceptor$asx($arguments), + selector1 = A.SassApiValue_assertSelector(t1.$index($arguments, 0), false, "super"); + selector1.assertNotBogus$1$name("super"); + selector2 = A.SassApiValue_assertSelector(t1.$index($arguments, 1), false, "sub"); + selector2.assertNotBogus$1$name("sub"); + return A.listIsSuperselector(selector1.components, selector2.components) ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._simpleSelectors_closure.prototype = { + call$1($arguments) { + var t1 = A.SassApiValue_assertCompoundSelector(J.$index$asx($arguments, 0), "selector").components; + return A.SassList$(new A.MappedListIterable(t1, new A._simpleSelectors__closure(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Value>")), B.ListSeparator_qVN, false); + }, + $signature: 27 + }; + A._simpleSelectors__closure.prototype = { + call$1(simple) { + return new A.SassString(A.serializeSelector(simple, true), false); + }, + $signature: 333 + }; + A._parse_closure.prototype = { + call$1($arguments) { + return A.SassApiValue_assertSelector(J.$index$asx($arguments, 0), false, "selector").get$asSassList(); + }, + $signature: 27 + }; + A.module_closure.prototype = { + call$1($arguments) { + var limit, t2, chunks, i, lastEnd, match, t3, + t1 = J.getInterceptor$asx($arguments), + string = t1.$index($arguments, 0).assertString$1("string"), + separator = t1.$index($arguments, 1).assertString$1("separator"); + t1 = t1.$index($arguments, 2).get$realNull(); + limit = t1 == null ? null : t1.assertNumber$1("limit").assertInt$1("limit"); + if (limit != null && limit < 1) + throw A.wrapException(A.SassScriptException$("$limit: Must be 1 or greater, was " + A.S(limit) + ".", null)); + t1 = string._string$_text; + if (t1.length === 0) + return B.SassList_qAD; + else { + t2 = separator._string$_text; + if (t2.length === 0) + return A.SassList$(A.MappedIterable_MappedIterable(new A.Runes(t1), new A.module__closure(string), type$.Runes._eval$1("Iterable.E"), type$.Value), B.ListSeparator_qVN, true); + } + chunks = A._setArrayType([], type$.JSArray_String); + for (t2 = B.JSString_methods.allMatches$1(t2, t1), t2 = new A._StringAllMatchesIterator(t2._input, t2._pattern, t2.__js_helper$_index), i = 0, lastEnd = 0; t2.moveNext$0();) { + match = t2.__js_helper$_current; + t3 = match.start; + chunks.push(B.JSString_methods.substring$2(t1, lastEnd, t3)); + lastEnd = t3 + match.pattern.length; + ++i; + if (i === limit) + break; + } + chunks.push(B.JSString_methods.substring$1(t1, lastEnd)); + return A.SassList$(new A.MappedListIterable(chunks, new A.module__closure0(string), type$.MappedListIterable_String_Value), B.ListSeparator_qVN, true); + }, + $signature: 27 + }; + A.module__closure.prototype = { + call$1(rune) { + return new A.SassString(A.Primitives_stringFromCharCode(rune), this.string._hasQuotes); + }, + $signature: 419 + }; + A.module__closure0.prototype = { + call$1(chunk) { + return new A.SassString(chunk, this.string._hasQuotes); + }, + $signature: 324 + }; + A._unquote_closure.prototype = { + call$1($arguments) { + var string = J.$index$asx($arguments, 0).assertString$1("string"); + if (!string._hasQuotes) + return string; + return new A.SassString(string._string$_text, false); + }, + $signature: 17 + }; + A._quote_closure.prototype = { + call$1($arguments) { + var string = J.$index$asx($arguments, 0).assertString$1("string"); + if (string._hasQuotes) + return string; + return new A.SassString(string._string$_text, true); + }, + $signature: 17 + }; + A._length_closure.prototype = { + call$1($arguments) { + return A.SassNumber_SassNumber(J.$index$asx($arguments, 0).assertString$1("string").get$_sassLength(), null); + }, + $signature: 24 + }; + A._insert_closure.prototype = { + call$1($arguments) { + var indexInt, codeUnitIndex, _s5_ = "index", + t1 = J.getInterceptor$asx($arguments), + string = t1.$index($arguments, 0).assertString$1("string"), + insert = t1.$index($arguments, 1).assertString$1("insert"), + index = t1.$index($arguments, 2).assertNumber$1(_s5_); + index.assertNoUnits$1(_s5_); + indexInt = index.assertInt$1(_s5_); + if (indexInt < 0) + indexInt = Math.max(string.get$_sassLength() + indexInt + 2, 0); + t1 = string._string$_text; + codeUnitIndex = A.codepointIndexToCodeUnitIndex(t1, A._codepointForIndex(indexInt, string.get$_sassLength(), false)); + return new A.SassString(B.JSString_methods.replaceRange$3(t1, codeUnitIndex, codeUnitIndex, insert._string$_text), string._hasQuotes); + }, + $signature: 17 + }; + A._index_closure.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + t2 = t1.$index($arguments, 0).assertString$1("string")._string$_text, + codeUnitIndex = B.JSString_methods.indexOf$1(t2, t1.$index($arguments, 1).assertString$1("substring")._string$_text); + if (codeUnitIndex === -1) + return B.C__SassNull; + return A.SassNumber_SassNumber(A.codeUnitIndexToCodepointIndex(t2, codeUnitIndex) + 1, null); + }, + $signature: 4 + }; + A._slice_closure.prototype = { + call$1($arguments) { + var lengthInCodepoints, endInt, startCodepoint, endCodepoint, + _s8_ = "start-at", + t1 = J.getInterceptor$asx($arguments), + string = t1.$index($arguments, 0).assertString$1("string"), + start = t1.$index($arguments, 1).assertNumber$1(_s8_), + end = t1.$index($arguments, 2).assertNumber$1("end-at"); + start.assertNoUnits$1(_s8_); + end.assertNoUnits$1("end-at"); + lengthInCodepoints = string.get$_sassLength(); + endInt = end.assertInt$0(); + if (endInt === 0) + return string._hasQuotes ? $.$get$_emptyQuoted() : $.$get$_emptyUnquoted(); + startCodepoint = A._codepointForIndex(start.assertInt$0(), lengthInCodepoints, false); + endCodepoint = A._codepointForIndex(endInt, lengthInCodepoints, true); + if (endCodepoint === lengthInCodepoints) + --endCodepoint; + if (endCodepoint < startCodepoint) + return string._hasQuotes ? $.$get$_emptyQuoted() : $.$get$_emptyUnquoted(); + t1 = string._string$_text; + return new A.SassString(B.JSString_methods.substring$2(t1, A.codepointIndexToCodeUnitIndex(t1, startCodepoint), A.codepointIndexToCodeUnitIndex(t1, endCodepoint + 1)), string._hasQuotes); + }, + $signature: 17 + }; + A._toUpperCase_closure.prototype = { + call$1($arguments) { + var t1, t2, i, t3, t4, + string = J.$index$asx($arguments, 0).assertString$1("string"); + for (t1 = string._string$_text, t2 = t1.length, i = 0, t3 = ""; i < t2; ++i) { + t4 = t1.charCodeAt(i); + t3 += A.Primitives_stringFromCharCode(t4 >= 97 && t4 <= 122 ? t4 & 4294967263 : t4); + } + return new A.SassString(t3.charCodeAt(0) == 0 ? t3 : t3, string._hasQuotes); + }, + $signature: 17 + }; + A._toLowerCase_closure.prototype = { + call$1($arguments) { + var t1, t2, i, t3, t4, + string = J.$index$asx($arguments, 0).assertString$1("string"); + for (t1 = string._string$_text, t2 = t1.length, i = 0, t3 = ""; i < t2; ++i) { + t4 = t1.charCodeAt(i); + t3 += A.Primitives_stringFromCharCode(t4 >= 65 && t4 <= 90 ? t4 | 32 : t4); + } + return new A.SassString(t3.charCodeAt(0) == 0 ? t3 : t3, string._hasQuotes); + }, + $signature: 17 + }; + A._uniqueId_closure.prototype = { + call$1($arguments) { + var t1 = $.$get$_previousUniqueId() + ($.$get$_random().nextInt$1(36) + 1); + $._previousUniqueId = t1; + if (t1 > Math.pow(36, 6)) + $._previousUniqueId = B.JSInt_methods.$mod($.$get$_previousUniqueId(), A._asInt(Math.pow(36, 6))); + return new A.SassString("u" + B.JSString_methods.padLeft$2(B.JSInt_methods.toRadixString$1($.$get$_previousUniqueId(), 36), 6, "0"), false); + }, + $signature: 17 + }; + A.ImportCache.prototype = { + canonicalize$4$baseImporter$baseUrl$forImport(_, url, baseImporter, baseUrl, forImport) { + var t1, resolvedUrl, key, relativeResult, t2, t3, t4, t5, t6, cacheable, i, importer, perImporterKey, t7, _1_0, _1_2_isSet, result, _1_2, _2_0, _2_1, _2_5_isSet, _2_5, _2_3, _2_3_isSet, j, _this = this, _null = null; + if (A.isBrowser()) + t1 = (baseImporter == null || baseImporter instanceof A.NoOpImporter) && _this._importers.length === 0; + else + t1 = false; + if (t1) + throw A.wrapException(string$.Custom); + if (baseImporter != null && url.get$scheme() === "") { + resolvedUrl = baseUrl == null ? _null : baseUrl.resolveUri$1(url); + if (resolvedUrl == null) + resolvedUrl = url; + key = new A._Record_3_forImport(baseImporter, resolvedUrl, forImport); + relativeResult = _this._perImporterCanonicalizeCache.putIfAbsent$2(key, new A.ImportCache_canonicalize_closure(_this, baseImporter, resolvedUrl, baseUrl, forImport, key, url)); + if (relativeResult != null) + return relativeResult; + } + key = new A._Record_2_forImport(url, forImport); + t1 = _this._canonicalizeCache; + if (t1.containsKey$1(key)) + return t1.$index(0, key); + for (t2 = _this._importers, t3 = type$.Record_1_nullable_Object, t4 = _this._perImporterCanonicalizeCache, t5 = type$.nullable_Record_3_Importer_and_Uri_and_Uri_originalUrl, t6 = type$.Record_3_Importer_and_Uri_and_Uri_originalUrl, cacheable = true, i = 0; i < t2.length; ++i) { + importer = t2[i]; + perImporterKey = new A._Record_3_forImport(importer, url, forImport); + if (t4.containsKey$1(perImporterKey)) { + t7 = t4.$index(0, perImporterKey); + _1_0 = new A._Record_1(t7 == null ? t5._as(t7) : t7); + } else + _1_0 = _null; + _1_2_isSet = t3._is(_1_0); + result = _null; + if (_1_2_isSet) { + _1_2 = _1_0._0; + t7 = _1_2 != null; + if (t7) { + t6._as(_1_2); + result = _1_2; + } + } else { + _1_2 = _null; + t7 = false; + } + if (t7) + return result; + if (_1_2_isSet) + t7 = _1_2 == null; + else + t7 = false; + if (t7) + continue; + $label0$1: { + _2_0 = _this._canonicalize$4(importer, url, baseUrl, forImport); + _2_1 = _2_0._0; + _2_5_isSet = _2_1 != null; + _2_5 = _null; + _2_3 = _null; + t7 = false; + if (_2_5_isSet) { + result = _2_1 == null ? t6._as(_2_1) : _2_1; + _2_3 = _2_0._1; + t7 = _2_3; + _2_5 = t7; + t7 = t7 && cacheable; + } else + result = _null; + if (t7) { + t1.$indexSet(0, key, result); + return result; + } + if (_2_5_isSet) { + t7 = _2_5; + _2_3_isSet = _2_5_isSet; + } else { + _2_3 = _2_0._1; + t7 = _2_3; + _2_3_isSet = true; + } + t7 = t7 && !cacheable; + if (t7) { + t4.$indexSet(0, perImporterKey, _2_1); + if (_2_1 != null) + return _2_1; + break $label0$1; + } + t7 = false === (_2_3_isSet ? _2_3 : _2_0._1); + if (t7) { + if (cacheable) { + for (j = 0; j < i; ++j) + t4.$indexSet(0, new A._Record_3_forImport(t2[j], url, forImport), _null); + cacheable = false; + } + if (_2_1 != null) + return _2_1; + } + } + } + if (cacheable) + t1.$indexSet(0, key, _null); + return _null; + }, + canonicalize$3$baseImporter$baseUrl(_, url, baseImporter, baseUrl) { + return this.canonicalize$4$baseImporter$baseUrl$forImport(0, url, baseImporter, baseUrl, false); + }, + _canonicalize$4(importer, url, baseUrl, forImport) { + var passContainingUrl, canonicalizeContext, t1, result, cacheable; + if (baseUrl != null) + passContainingUrl = url.get$scheme() === "" || importer.isNonCanonicalScheme$1(url.get$scheme()); + else + passContainingUrl = false; + canonicalizeContext = new A.CanonicalizeContext(forImport, passContainingUrl ? baseUrl : null); + t1 = type$.nullable_Object; + result = A.runZoned(new A.ImportCache__canonicalize_closure(importer, url), A.LinkedHashMap_LinkedHashMap$_literal([B.Symbol__canonicalizeContext, canonicalizeContext], t1, t1), type$.nullable_Uri); + cacheable = !passContainingUrl || !canonicalizeContext._wasContainingUrlAccessed; + if (result == null) + return new A._Record_2(null, cacheable); + if (result.get$scheme() !== "" && importer.isNonCanonicalScheme$1(result.get$scheme())) + throw A.wrapException("Importer " + importer.toString$0(0) + " canonicalized " + url.toString$0(0) + " to " + result.toString$0(0) + string$.x2c_whicu); + return new A._Record_2(new A._Record_3_originalUrl(importer, result, url), cacheable); + }, + importCanonical$3$originalUrl(importer, canonicalUrl, originalUrl) { + return this._importCache.putIfAbsent$2(canonicalUrl, new A.ImportCache_importCanonical_closure(this, importer, canonicalUrl, originalUrl)); + }, + importCanonical$2(importer, canonicalUrl) { + return this.importCanonical$3$originalUrl(importer, canonicalUrl, null); + }, + humanize$1(canonicalUrl) { + var t1 = this._canonicalizeCache, + t2 = type$.NonNullsIterable_Record_3_Importer_and_Uri_and_Uri_originalUrl; + t2 = A.NullableExtension_andThen(A.minBy(new A.MappedIterable(new A.WhereIterable(new A.NonNullsIterable(new A.LinkedHashMapValuesIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapValuesIterable<2>")), t2), new A.ImportCache_humanize_closure(canonicalUrl), t2._eval$1("WhereIterable")), new A.ImportCache_humanize_closure0(), t2._eval$1("MappedIterable")), new A.ImportCache_humanize_closure1()), new A.ImportCache_humanize_closure2(canonicalUrl)); + return t2 == null ? canonicalUrl : t2; + }, + sourceMapUrl$1(_, canonicalUrl) { + var t1 = this._resultsCache.$index(0, canonicalUrl); + t1 = t1 == null ? null : t1.get$sourceMapUrl(0); + return t1 == null ? canonicalUrl : t1; + }, + clearCanonicalize$1(canonicalUrl) { + var t1, t2, t3, t4, _i, key, t5, t6, _i0; + for (t1 = this._canonicalizeCache, t2 = A.List_List$of(new A.LinkedHashMapKeysIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapKeysIterable<1>")), true, type$.Record_2_Uri_and_bool_forImport), t3 = t2.length, t4 = this._importers, _i = 0; _i < t2.length; t2.length === t3 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + key = t2[_i]; + for (t5 = t4.length, t6 = key._0, _i0 = 0; _i0 < t4.length; t4.length === t5 || (0, A.throwConcurrentModificationError)(t4), ++_i0) + if (t4[_i0].couldCanonicalize$2(t6, canonicalUrl)) { + t1.remove$1(0, key); + break; + } + } + for (t1 = this._perImporterCanonicalizeCache, t2 = A.List_List$of(new A.LinkedHashMapKeysIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapKeysIterable<1>")), true, type$.Record_3_Importer_and_Uri_and_bool_forImport), t3 = t2.length, _i = 0; _i < t3; ++_i) { + key = t2[_i]; + if (key._0.couldCanonicalize$2(key._1, canonicalUrl)) + t1.remove$1(0, key); + } + }, + clearImport$1(canonicalUrl) { + this._resultsCache.remove$1(0, canonicalUrl); + this._importCache.remove$1(0, canonicalUrl); + } + }; + A.ImportCache_canonicalize_closure.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this.baseUrl, + _0_0 = t1._canonicalize$4(_this.baseImporter, _this.resolvedUrl, t2, _this.forImport); + if (t2 != null) + t1._nonCanonicalRelativeUrls.$indexSet(0, _this.key, _this.url); + return _0_0._0; + }, + $signature: 123 + }; + A.ImportCache__canonicalize_closure.prototype = { + call$0() { + return this.importer.canonicalize$1(0, this.url); + }, + $signature: 144 + }; + A.ImportCache_importCanonical_closure.prototype = { + call$0() { + var t3, t4, _this = this, + t1 = Date.now(), + t2 = _this.canonicalUrl, + result = _this.importer.load$1(0, t2); + if (result == null) + return null; + t3 = _this.$this; + t3._loadTimes.$indexSet(0, t2, new A.DateTime(t1, 0, false)); + t3._resultsCache.$indexSet(0, t2, result); + t3 = result.contents; + t1 = result.syntax; + t4 = _this.originalUrl; + return A.Stylesheet_Stylesheet$parse(t3, t1, t4 == null ? t2 : t4.resolveUri$1(t2)); + }, + $signature: 112 + }; + A.ImportCache_humanize_closure.prototype = { + call$1(result) { + return result._1.$eq(0, this.canonicalUrl); + }, + $signature: 463 + }; + A.ImportCache_humanize_closure0.prototype = { + call$1(result) { + return result._2; + }, + $signature: 278 + }; + A.ImportCache_humanize_closure1.prototype = { + call$1(url) { + return url.get$path(url).length; + }, + $signature: 80 + }; + A.ImportCache_humanize_closure2.prototype = { + call$1(url) { + var t1 = $.$get$url(), + t2 = this.canonicalUrl; + return url.resolve$1(0, A.ParsedPath_ParsedPath$parse(t2.get$path(t2), t1.style).get$basename()); + }, + $signature: 50 + }; + A.Importer.prototype = { + modificationTime$1(url) { + return new A.DateTime(Date.now(), 0, false); + }, + couldCanonicalize$2(url, canonicalUrl) { + return true; + }, + isNonCanonicalScheme$1(scheme) { + return false; + } + }; + A.AsyncImporter.prototype = {}; + A.CanonicalizeContext.prototype = {}; + A.FilesystemImporter.prototype = { + canonicalize$1(_, url) { + var resolved, _0_0; + if (url.get$scheme() === "file") + resolved = A.resolveImportPath($.$get$context().style.pathFromUri$1(A._parseUri(url))); + else if (url.get$scheme() !== "") + return null; + else { + _0_0 = this._loadPath; + if (_0_0 != null) { + resolved = A.resolveImportPath(A.join(_0_0, $.$get$context().style.pathFromUri$1(A._parseUri(url)), null)); + if (resolved != null && this._loadPathDeprecated) + A.warnForDeprecation(string$.Using_t, B.Deprecation_tms); + } else + return null; + } + return A.NullableExtension_andThen(resolved, new A.FilesystemImporter_canonicalize_closure()); + }, + load$1(_, url) { + var path = $.$get$context().style.pathFromUri$1(A._parseUri(url)), + t1 = A.readFile(path), + t2 = A.Syntax_forPath(path), + t3 = url.get$scheme(); + if (t3 === "") + A.throwExpression(A.ArgumentError$value(url, "sourceMapUrl", "must be absolute")); + return new A.ImporterResult(t1, url, t2); + }, + modificationTime$1(url) { + return A.modificationTime($.$get$context().style.pathFromUri$1(A._parseUri(url))); + }, + couldCanonicalize$2(url, canonicalUrl) { + var t1, t2, basename, canonicalBasename; + if (url.get$scheme() !== "file" && url.get$scheme() !== "") + return false; + if (canonicalUrl.get$scheme() !== "file") + return false; + t1 = $.$get$url(); + t2 = t1.style; + basename = A.ParsedPath_ParsedPath$parse(url.get$path(url), t2).get$basename(); + canonicalBasename = A.ParsedPath_ParsedPath$parse(canonicalUrl.get$path(canonicalUrl), t2).get$basename(); + if (!B.JSString_methods.startsWith$1(basename, "_") && B.JSString_methods.startsWith$1(canonicalBasename, "_")) + canonicalBasename = B.JSString_methods.substring$1(canonicalBasename, 1); + return basename === canonicalBasename || basename === t1.withoutExtension$1(canonicalBasename); + }, + toString$0(_) { + var t1 = this._loadPath; + return t1 == null ? "" : t1; + } + }; + A.FilesystemImporter_canonicalize_closure.prototype = { + call$1(resolved) { + var t2, t0, _null = null, + t1 = A.isNodeJs() ? self.process : _null; + if (!J.$eq$(t1 == null ? _null : J.get$platform$x(t1), "win32")) { + t1 = A.isNodeJs() ? self.process : _null; + t1 = J.$eq$(t1 == null ? _null : J.get$platform$x(t1), "darwin"); + } else + t1 = true; + if (t1) { + t1 = A.absolute(resolved, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null); + t2 = $.$get$context(); + t1 = A._realCasePath(t2.normalize$1(t1)); + } else { + t1 = $.$get$context(); + t2 = t1.canonicalize$1(0, resolved); + t0 = t2; + t2 = t1; + t1 = t0; + } + return t2.toUri$1(t1); + }, + $signature: 122 + }; + A.NoOpImporter.prototype = {}; + A.NodePackageImporter.prototype = { + isNonCanonicalScheme$1(scheme) { + return scheme === "pkg"; + }, + canonicalize$1(_, url) { + var packageName, jsonPath, jsonString, packageManifest, e, t1, t2, t3, t4, baseDirectory, parts, t5, $name, subpath, packageRoot, exception, _1_0, rootPath, subpathInRoot, _this = this, _null = null; + if (url.get$scheme() === "file") + return $.$get$FilesystemImporter_cwd().canonicalize$1(0, url); + if (url.get$scheme() !== "pkg") + return _null; + if (url.get$hasAuthority()) + throw A.wrapException(string$.A_pkg_h); + else { + t1 = $.$get$url(); + t2 = t1.style; + if (t2.rootLength$1(url.get$path(url)) > 0) + throw A.wrapException("A pkg: URL's path must not begin with /."); + else if (url.get$path(url).length === 0) + throw A.wrapException("A pkg: URL must not have an empty path."); + else if (url.get$hasQuery() || url.get$hasFragment()) + throw A.wrapException(string$.A_pkg_q); + } + t3 = A.canonicalizeContext(); + t3._wasContainingUrlAccessed = true; + t3 = t3._containingUrl; + if ((t3 == null ? _null : t3.get$scheme()) === "file") { + t3 = A.canonicalizeContext(); + t3._wasContainingUrlAccessed = true; + t3 = t3._containingUrl; + t3.toString; + t4 = $.$get$context(); + baseDirectory = t4.dirname$1(t4.style.pathFromUri$1(A._parseUri(t3))); + } else { + t3 = _this.__NodePackageImporter__entryPointDirectory_F; + t3 === $ && A.throwUnnamedLateFieldNI(); + baseDirectory = t3; + } + packageName = null; + parts = t1.split$1(0, url.get$path(url)); + t3 = B.JSArray_methods.removeAt$1(parts, 0); + t4 = $.$get$context(); + t3.toString; + t5 = t4.style; + $name = t5.pathFromUri$1(A._parseUri(t3)); + if (B.JSString_methods.startsWith$1($name, "@")) + $name = parts.length !== 0 ? t1.join$2(0, $name, B.JSArray_methods.removeAt$1(parts, 0)) : $name; + subpath = parts.length !== 0 ? t5.pathFromUri$1(A._parseUri(t1.joinAll$1(parts))) : _null; + packageName = $name; + t1 = true; + if (!J.startsWith$1$s(packageName, ".")) + if (!J.contains$1$asx(packageName, "\\")) + if (!J.contains$1$asx(packageName, "%")) + t1 = J.startsWith$1$s(packageName, "@") && !J.contains$1$asx(packageName, t2.get$separator(t2)); + if (t1) + return _null; + packageRoot = _this._resolvePackageRoot$2(packageName, baseDirectory); + if (packageRoot == null) + return _null; + jsonPath = A.join(packageRoot, "package.json", _null); + jsonString = A.readFile(jsonPath); + packageManifest = null; + try { + packageManifest = type$.Map_String_dynamic._as(B.C_JsonCodec.decode$1(jsonString)); + } catch (exception) { + e = A.unwrapException(exception); + t1 = A.S(jsonPath); + t2 = A.S(packageName); + t3 = A.S(e); + throw A.wrapException("Failed to parse " + t1 + ' for "pkg:' + t2 + '": ' + t3); + } + _1_0 = _this._resolvePackageExports$4(packageRoot, subpath, packageManifest, packageName); + if (_1_0 != null) + if (B.Set_FTDN4.contains$1(0, A.ParsedPath_ParsedPath$parse(_1_0, t5)._splitExtension$1(1)[1])) + return t4.toUri$1(t4.canonicalize$1(0, _1_0)); + else { + t1 = subpath == null ? "root" : subpath; + throw A.wrapException("The export for '" + t1 + "' in '" + A.S(packageName) + "' resolved to '" + _1_0 + string$.x27x2c_whi); + } + if (subpath == null) { + rootPath = _this._resolvePackageRootValues$2(packageRoot, packageManifest); + return rootPath != null ? t4.toUri$1(t4.canonicalize$1(0, rootPath)) : _null; + } + subpathInRoot = A.join(packageRoot, subpath, _null); + return $.$get$FilesystemImporter_cwd().canonicalize$1(0, t4.toUri$1(subpathInRoot)); + }, + load$1(_, url) { + return $.$get$FilesystemImporter_cwd().load$1(0, url); + }, + _resolvePackageRoot$2(packageName, baseDirectory) { + var potentialPackage, t1; + for (; true;) { + potentialPackage = A.join(baseDirectory, "node_modules", packageName); + if (A.dirExists(potentialPackage)) + return potentialPackage; + t1 = $.$get$context(); + if (t1.split$1(0, baseDirectory).length === 1) + return null; + baseDirectory = t1.dirname$1(baseDirectory); + } + }, + _resolvePackageRootValues$2(packageRoot, packageManifest) { + var t1, sassValue, _1_0, styleValue, _null = null, + _0_0 = packageManifest.$index(0, "sass"); + if (typeof _0_0 == "string") { + t1 = B.Set_FTDN4.contains$1(0, A.ParsedPath_ParsedPath$parse(_0_0, $.$get$url().style)._splitExtension$1(1)[1]); + sassValue = _0_0; + } else { + sassValue = _null; + t1 = false; + } + if (t1) + return A.join(packageRoot, sassValue, _null); + else { + _1_0 = packageManifest.$index(0, "style"); + if (typeof _1_0 == "string") { + t1 = B.Set_FTDN4.contains$1(0, A.ParsedPath_ParsedPath$parse(_1_0, $.$get$url().style)._splitExtension$1(1)[1]); + styleValue = _1_0; + } else { + styleValue = _null; + t1 = false; + } + if (t1) + return A.join(packageRoot, styleValue, _null); + } + return A.resolveImportPath(A.join(packageRoot, "index", _null)); + }, + _resolvePackageExports$4(packageRoot, subpath, packageManifest, packageName) { + var _0_0, _1_0, _this = this, + exports = packageManifest.$index(0, "exports"); + if (exports == null) + return null; + _0_0 = _this._nodePackageExportsResolve$5(packageRoot, _this._exportsToCheck$1(subpath), exports, subpath, packageName); + if (_0_0 != null) + return _0_0; + if (subpath != null && A.ParsedPath_ParsedPath$parse(subpath, $.$get$url().style)._splitExtension$1(1)[1].length !== 0) + return null; + _1_0 = _this._nodePackageExportsResolve$5(packageRoot, _this._exportsToCheck$2$addIndex(subpath, true), exports, subpath, packageName); + if (_1_0 != null) + return _1_0; + return null; + }, + _nodePackageExportsResolve$5(packageRoot, subpathVariants, exports, subpath, packageName) { + var t1, matches, _1_1, path; + if (type$.Map_String_dynamic._is(exports) && J.any$1$ax(exports.get$keys(exports), new A.NodePackageImporter__nodePackageExportsResolve_closure()) && J.any$1$ax(exports.get$keys(exports), new A.NodePackageImporter__nodePackageExportsResolve_closure0())) + throw A.wrapException("`exports` in " + packageName + string$.x20can_n + J.map$1$1$ax(J.get$keys$z(exports), new A.NodePackageImporter__nodePackageExportsResolve_closure1(), type$.String).join$1(0, ",") + " in " + A.join(packageRoot, "package.json", null) + "."); + t1 = type$.NonNullsIterable_String; + matches = A.List_List$of(new A.NonNullsIterable(new A.MappedListIterable(subpathVariants, new A.NodePackageImporter__nodePackageExportsResolve_closure2(this, exports, packageRoot), A._arrayInstanceType(subpathVariants)._eval$1("MappedListIterable<1,String?>")), t1), true, t1._eval$1("Iterable.E")); + $label0$1: { + _1_1 = matches.length; + if (_1_1 === 1) { + path = matches[0]; + t1 = path; + break $label0$1; + } + if (_1_1 <= 0) { + t1 = null; + break $label0$1; + } + t1 = subpath == null ? "root" : subpath; + t1 = A.throwExpression(string$.Unable + t1 + " in " + packageName + " should be used. \n\nFound:\n" + B.JSArray_methods.join$1(matches, "\n")); + } + return t1; + }, + _compareExpansionKeys$2(keyA, keyB) { + var t1 = B.JSString_methods.contains$1(keyA, "*"), + baseLengthA = t1 ? B.JSString_methods.indexOf$1(keyA, "*") + 1 : keyA.length, + t2 = B.JSString_methods.contains$1(keyB, "*"), + baseLengthB = t2 ? B.JSString_methods.indexOf$1(keyB, "*") + 1 : keyB.length; + if (baseLengthA > baseLengthB) + return -1; + if (baseLengthB > baseLengthA) + return 1; + if (!t1) + return 1; + if (!t2) + return -1; + t1 = keyA.length; + t2 = keyB.length; + if (t1 > t2) + return -1; + if (t2 > t1) + return 1; + return 0; + }, + _packageTargetResolve$4(subpath, exports, packageRoot, patternMatch) { + var t2, string, path, map, key, value, _1_0, array, _2_0, _null = null, + t1 = typeof exports == "string"; + if (t1) { + t2 = !B.JSString_methods.startsWith$1(exports, "./"); + string = exports; + } else { + string = _null; + t2 = false; + } + if (t2) + throw A.wrapException("Export '" + A.S(string) + string$.x27x20must + packageRoot + "'."); + if (t1) { + t2 = patternMatch != null; + string = exports; + } else { + string = _null; + t2 = false; + } + if (t2) { + t1 = J.replaceFirst$2$s(string, "*", patternMatch); + t2 = $.$get$context(); + path = t2.normalize$1(A.join(packageRoot, t2.style.pathFromUri$1(A._parseUri(t1)), _null)); + return A.fileExists(path) ? path : _null; + } + string = t1 ? exports : _null; + if (t1) { + t1 = $.$get$context(); + string.toString; + return A.join(packageRoot, t1.style.pathFromUri$1(A._parseUri(string)), _null); + } + t1 = type$.Map_String_dynamic._is(exports); + map = t1 ? exports : _null; + if (t1) { + for (t1 = A.MapExtensions_get_pairs(map, type$.String, type$.dynamic), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t2 = t1.get$current(t1); + key = t2._0; + value = t2._1; + if (!B.Set_8229z.contains$1(0, key)) + continue; + if (value == null) + continue; + _1_0 = this._packageTargetResolve$4(subpath, value, packageRoot, patternMatch); + if (_1_0 != null) + return _1_0; + } + return _null; + } + if (type$.List_nullable_Object._is(exports) && J.get$length$asx(exports) <= 0) + return _null; + t1 = type$.List_dynamic._is(exports); + array = t1 ? exports : _null; + if (t1) { + for (t1 = J.get$iterator$ax(array); t1.moveNext$0();) { + value = t1.get$current(t1); + if (value == null) + continue; + _2_0 = this._packageTargetResolve$4(subpath, value, packageRoot, patternMatch); + if (_2_0 != null) + return _2_0; + } + return _null; + } + throw A.wrapException("Invalid 'exports' value " + A.S(exports) + " in " + A.join(packageRoot, "package.json", _null) + "."); + }, + _packageTargetResolve$3(subpath, exports, packageRoot) { + return this._packageTargetResolve$4(subpath, exports, packageRoot, null); + }, + _getMainExport$1(exports) { + var t1, t2, t3, map, _0_4, t4, $export; + $label0$0: { + t1 = null; + if (typeof exports == "string") { + t1 = exports; + break $label0$0; + } + if (type$.List_String._is(exports)) { + t1 = exports; + break $label0$0; + } + t2 = type$.Map_String_dynamic._is(exports); + if (t2) { + t3 = !J.any$1$ax(exports.get$keys(exports), new A.NodePackageImporter__getMainExport_closure()); + map = exports; + } else { + map = t1; + t3 = false; + } + if (t3) { + t1 = map; + break $label0$0; + } + t3 = false; + if (t2) { + _0_4 = exports.$index(0, "."); + if (_0_4 == null) + t4 = exports.containsKey$1("."); + else + t4 = true; + if (t4) + t3 = _0_4 != null; + } else + _0_4 = null; + if (t3) { + $export = t2 ? _0_4 : J.$index$asx(exports, "."); + t1 = $export; + break $label0$0; + } + break $label0$0; + } + return t1; + }, + _exportsToCheck$2$addIndex(subpath, addIndex) { + var basename, dirname, t3, t4, _i, path, + t1 = type$.JSArray_String, + paths = A._setArrayType([], t1), + t2 = subpath == null; + if (t2 && addIndex) + subpath = "index"; + else if (!t2 && addIndex) + subpath = A.join(subpath, "index", null); + if (subpath == null) + return A._setArrayType([null], type$.JSArray_nullable_String); + if (B.Set_FTDN4.contains$1(0, A.ParsedPath_ParsedPath$parse(subpath, $.$get$url().style)._splitExtension$1(1)[1])) + paths.push(subpath); + else + B.JSArray_methods.addAll$1(paths, A._setArrayType([subpath, subpath + ".scss", subpath + ".sass", subpath + ".css"], t1)); + t1 = $.$get$context(); + t2 = t1.style; + basename = A.ParsedPath_ParsedPath$parse(subpath, t2).get$basename(); + dirname = t1.dirname$1(subpath); + if (B.JSString_methods.startsWith$1(basename, "_")) + return paths; + t1 = A.List_List$of(paths, true, type$.nullable_String); + for (t3 = paths.length, t4 = dirname === ".", _i = 0; _i < paths.length; paths.length === t3 || (0, A.throwConcurrentModificationError)(paths), ++_i) { + path = paths[_i]; + if (t4) + t1.push("_" + A.ParsedPath_ParsedPath$parse(path, t2).get$basename()); + else + t1.push(A.join(dirname, "_" + A.ParsedPath_ParsedPath$parse(path, t2).get$basename(), null)); + } + return t1; + }, + _exportsToCheck$1(subpath) { + return this._exportsToCheck$2$addIndex(subpath, false); + } + }; + A.NodePackageImporter__nodePackageExportsResolve_closure.prototype = { + call$1(key) { + return B.JSString_methods.startsWith$1(key, "."); + }, + $signature: 5 + }; + A.NodePackageImporter__nodePackageExportsResolve_closure0.prototype = { + call$1(key) { + return !B.JSString_methods.startsWith$1(key, "."); + }, + $signature: 5 + }; + A.NodePackageImporter__nodePackageExportsResolve_closure1.prototype = { + call$1(key) { + return '"' + key + '"'; + }, + $signature: 6 + }; + A.NodePackageImporter__nodePackageExportsResolve_closure2.prototype = { + call$1(variant) { + var t1, matchKey, t2, t3, t4, t5, t6, _i, expansionKey, _0_0, t7, patternBase, patternTrailer, t8, target, _this = this, _null = null; + if (variant == null) { + t1 = _this.$this; + return A.NullableExtension_andThen(t1._getMainExport$1(_this.exports), new A.NodePackageImporter__nodePackageExportsResolve__closure(t1, variant, _this.packageRoot)); + } else { + t1 = _this.exports; + if (!type$.Map_String_dynamic._is(t1) || J.every$1$ax(t1.get$keys(t1), new A.NodePackageImporter__nodePackageExportsResolve__closure0())) + return _null; + } + matchKey = "./" + $.$get$context().toUri$1(variant).toString$0(0); + if (t1.containsKey$1(matchKey) && J.$index$asx(t1, matchKey) != null && !B.JSString_methods.contains$1(matchKey, "*")) { + t1 = J.$index$asx(t1, matchKey); + if (t1 == null) + t1 = type$.Object._as(t1); + return _this.$this._packageTargetResolve$3(matchKey, t1, _this.packageRoot); + } + t2 = A._setArrayType([], type$.JSArray_String); + for (t3 = J.getInterceptor$z(t1), t4 = J.get$iterator$ax(t3.get$keys(t1)); t4.moveNext$0();) { + t5 = t4.get$current(t4); + if (B.JSString_methods.allMatches$1("*", t5).get$length(0) === 1) + t2.push(t5); + } + t4 = _this.$this; + B.JSArray_methods.sort$1(t2, t4.get$_compareExpansionKeys()); + for (t5 = t2.length, t6 = matchKey.length, _i = 0; _i < t2.length; t2.length === t5 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + expansionKey = t2[_i]; + _0_0 = expansionKey.split("*"); + t7 = _0_0.length === 2; + if (t7) { + patternBase = _0_0[0]; + patternTrailer = _0_0[1]; + } else { + patternTrailer = _null; + patternBase = patternTrailer; + } + if (!t7) + throw A.wrapException(A.StateError$("Pattern matching error")); + if (!B.JSString_methods.startsWith$1(matchKey, patternBase)) + continue; + if (matchKey === patternBase) + continue; + t7 = patternTrailer.length; + if (t7 !== 0) + t8 = B.JSString_methods.endsWith$1(matchKey, patternTrailer) && t6 >= expansionKey.length; + else + t8 = true; + if (t8) { + target = t3.$index(t1, expansionKey); + if (target == null) + continue; + return t4._packageTargetResolve$4(variant, target, _this.packageRoot, B.JSString_methods.substring$2(matchKey, patternBase.length, t6 - t7)); + } + } + return _null; + }, + $signature: 147 + }; + A.NodePackageImporter__nodePackageExportsResolve__closure.prototype = { + call$1(mainExport) { + return this.$this._packageTargetResolve$3(this.variant, mainExport, this.packageRoot); + }, + $signature: 148 + }; + A.NodePackageImporter__nodePackageExportsResolve__closure0.prototype = { + call$1(key) { + return !B.JSString_methods.startsWith$1(key, "."); + }, + $signature: 5 + }; + A.NodePackageImporter__getMainExport_closure.prototype = { + call$1(key) { + return B.JSString_methods.startsWith$1(key, "."); + }, + $signature: 5 + }; + A.ImporterResult.prototype = { + get$sourceMapUrl(_) { + return this._sourceMapUrl; + } + }; + A.resolveImportPath_closure.prototype = { + call$0() { + return A._exactlyOne(A._tryPath($.$get$context().withoutExtension$1(this.path) + ".import" + this.extension)); + }, + $signature: 47 + }; + A.resolveImportPath_closure0.prototype = { + call$0() { + return A._exactlyOne(A._tryPathWithExtensions(this.path + ".import")); + }, + $signature: 47 + }; + A._tryPathAsDirectory_closure.prototype = { + call$0() { + return A._exactlyOne(A._tryPathWithExtensions(A.join(this.path, "index.import", null))); + }, + $signature: 47 + }; + A._exactlyOne_closure.prototype = { + call$1(path) { + var t1 = $.$get$context(); + return " " + t1.prettyUri$1(t1.toUri$1(path)); + }, + $signature: 6 + }; + A.InterpolationBuffer.prototype = { + writeCharCode$1(character) { + var t1 = this._interpolation_buffer$_text, + t2 = A.Primitives_stringFromCharCode(character); + t1._contents += t2; + return null; + }, + add$2(_, expression, span) { + this._flushText$0(); + this._interpolation_buffer$_contents.push(expression); + this._spans.push(span); + }, + addInterpolation$1(interpolation) { + var spansToAdd, _0_4_isSet, _0_4, _0_40, first, rest, t2, t3, _this = this, + toAdd = interpolation.contents, + t1 = toAdd.length; + if (t1 === 0) + return; + spansToAdd = interpolation.spans; + _0_4_isSet = t1 >= 1; + if (_0_4_isSet) { + _0_4 = toAdd[0]; + _0_40 = _0_4; + t1 = typeof _0_4 == "string"; + _0_4 = _0_40; + } else { + _0_4 = null; + t1 = false; + } + if (t1) { + first = A._asString(_0_4_isSet ? _0_4 : toAdd[0]); + rest = B.JSArray_methods.sublist$1(toAdd, 1); + t1 = _this._interpolation_buffer$_text; + t1._contents += first; + spansToAdd = A.SubListIterable$(spansToAdd, 1, null, A._arrayInstanceType(spansToAdd)._precomputed1); + toAdd = rest; + } + _this._flushText$0(); + t1 = _this._interpolation_buffer$_contents; + B.JSArray_methods.addAll$1(t1, toAdd); + t2 = _this._spans; + B.JSArray_methods.addAll$1(t2, spansToAdd); + if (typeof B.JSArray_methods.get$last(t1) == "string") { + t3 = _this._interpolation_buffer$_text; + t1 = A.S(t1.pop()); + t3._contents += t1; + t2.pop(); + } + }, + _flushText$0() { + var t1 = this._interpolation_buffer$_text, + t2 = t1._contents; + if (t2.length === 0) + return; + this._interpolation_buffer$_contents.push(t2.charCodeAt(0) == 0 ? t2 : t2); + this._spans.push(null); + t1._contents = ""; + }, + interpolation$1(span) { + var t1 = A.List_List$of(this._interpolation_buffer$_contents, true, type$.Object), + t2 = this._interpolation_buffer$_text, + t3 = t2._contents; + if (t3.length !== 0) + t1.push(t3.charCodeAt(0) == 0 ? t3 : t3); + t3 = A.List_List$of(this._spans, true, type$.nullable_FileSpan); + if (t2._contents.length !== 0) + t3.push(null); + return A.Interpolation$(t1, t3, span); + }, + toString$0(_) { + var t1, t2, _i, t3, element; + for (t1 = this._interpolation_buffer$_contents, t2 = t1.length, _i = 0, t3 = ""; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + element = t1[_i]; + t3 = typeof element == "string" ? t3 + element : t3 + "#{" + A.S(element) + A.Primitives_stringFromCharCode(125); + } + t1 = t3 + this._interpolation_buffer$_text.toString$0(0); + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + }; + A.InterpolationMap.prototype = { + mapException$1(error) { + var source, startIndex, endIndex, t3, t4, _this = this, + target = error.get$span(error), + t1 = _this._interpolation, + t2 = t1.contents; + if (t2.length === 0) + return new A.SourceSpanFormatException(error.get$source(), error._span_exception$_message, t1.span); + source = _this.mapSpan$1(target); + startIndex = _this._indexInContents$1(target.get$start(target)); + endIndex = _this._indexInContents$1(target.get$end(target)); + t1 = error._span_exception$_message; + if (!A.SubListIterable$(t2, startIndex, null, A._arrayInstanceType(t2)._precomputed1).take$1(0, endIndex - startIndex + 1).any$1(0, new A.InterpolationMap_mapException_closure())) + return new A.SourceSpanFormatException(error.get$source(), t1, source); + else { + t2 = type$.SourceSpan; + t3 = type$.String; + t4 = A.LinkedHashMap_LinkedHashMap$_literal([target, "error in interpolated output"], t2, t3); + return new A.MultiSourceSpanFormatException(error.get$source(), "", A.ConstantMap_ConstantMap$from(t4, t2, t3), t1, source); + } + }, + mapSpan$1(target) { + var _0_10, t1, _0_2_isSet, _0_20, t2, start, end, _this = this, _null = null, + _0_1 = _this._mapLocation$1(target.get$start(target)), + _0_2 = _this._mapLocation$1(target.get$end(target)); + $label0$0: { + _0_10 = _0_1; + t1 = type$.FileSpan; + _0_2_isSet = t1._is(_0_1); + _0_20 = _null; + t2 = false; + if (_0_2_isSet) { + t1._as(_0_10); + _0_20 = _0_2; + t2 = t1._is(_0_2); + start = _0_10; + _0_1 = start; + } else { + start = _null; + _0_1 = _0_10; + } + if (t2) { + t1 = start.expand$1(0, t1._as(_0_2_isSet ? _0_20 : _0_2)); + break $label0$0; + } + t2 = false; + if (t1._is(_0_1)) { + if (_0_2_isSet) + t2 = _0_20; + else { + t2 = _0_2; + _0_20 = t2; + _0_2_isSet = true; + } + t2 = t2 instanceof A.FileLocation; + start = _0_1; + } else + start = _null; + if (t2) { + t1 = _0_2_isSet ? _0_20 : _0_2; + type$.FileLocation._as(t1); + t1 = _this._interpolation.span.file.span$2(0, _this._expandInterpolationSpanLeft$1(start.get$start(start)), t1.offset); + break $label0$0; + } + t2 = false; + if (_0_1 instanceof A.FileLocation) { + if (_0_2_isSet) + t2 = _0_20; + else { + t2 = _0_2; + _0_20 = t2; + _0_2_isSet = true; + } + t2 = t1._is(t2); + start = _0_1; + } else + start = _null; + if (t2) { + end = t1._as(_0_2_isSet ? _0_20 : _0_2); + t1 = _this._interpolation.span.file.span$2(0, start.offset, _this._expandInterpolationSpanRight$1(end.get$end(end))); + break $label0$0; + } + t1 = false; + if (_0_1 instanceof A.FileLocation) { + if (_0_2_isSet) + t1 = _0_20; + else { + t1 = _0_2; + _0_20 = t1; + _0_2_isSet = true; + } + t1 = t1 instanceof A.FileLocation; + start = _0_1; + } else + start = _null; + if (t1) { + t1 = _0_2_isSet ? _0_20 : _0_2; + type$.FileLocation._as(t1); + t1 = _this._interpolation.span.file.span$2(0, start.offset, t1.offset); + break $label0$0; + } + t1 = A.throwExpression("[BUG] Unreachable"); + } + return t1; + }, + _mapLocation$1(target) { + var index, _0_0, t3, t4, previousLocation, _this = this, + t1 = _this._interpolation, + t2 = t1.contents; + if (t2.length === 0) + return t1.span; + index = _this._indexInContents$1(target); + _0_0 = t2[index]; + if (_0_0 instanceof A.Expression) + return _0_0.get$span(_0_0); + t3 = index === 0; + t1 = t1.span; + t4 = t1.file; + if (t3) + previousLocation = A.FileLocation$_(t4, t1._file$_start); + else { + t1 = type$.Expression._as(t2[index - 1]); + t1 = t1.get$span(t1); + previousLocation = A.FileLocation$_(t4, _this._expandInterpolationSpanRight$1(t1.get$end(t1))); + } + t1 = t3 ? 0 : _this._targetLocations[index - 1].get$offset(); + return A.FileLocation$_(previousLocation.file, previousLocation.offset + (target.offset - t1)); + }, + _indexInContents$1(target) { + var t1, t2, t3, i; + for (t1 = this._targetLocations, t2 = t1.length, t3 = target.offset, i = 0; i < t2; ++i) + if (t3 < t1[i].get$offset()) + return i; + return this._interpolation.contents.length - 1; + }, + _expandInterpolationSpanLeft$1(start) { + var i0, prev, char, + source = start.file._decodedChars, + i = start.offset - 1; + for (; i >= 0;) { + i0 = i - 1; + prev = source[i]; + if (prev === 123) { + if (source[i0] === 35) { + i = i0; + break; + } + i = i0; + } else if (prev === 47) { + i = i0 - 1; + if (source[i0] === 42) + for (; true;) { + i0 = i - 1; + if (source[i] !== 42) { + i = i0; + continue; + } + i = i0; + do { + i0 = i - 1; + char = source[i]; + if (char === 42) { + i = i0; + continue; + } else + break; + } while (true); + if (char === 47) { + i = i0; + break; + } + i = i0; + } + } else + i = i0; + } + return i; + }, + _expandInterpolationSpanRight$1(end) { + var t1, i0, next, second, t2, char, + source = end.file._decodedChars, + i = end.offset; + for (t1 = source.length; i < t1;) { + i0 = i + 1; + next = source[i]; + if (next === 125) { + i = i0; + break; + } + if (next === 47) { + i = i0 + 1; + second = source[i0]; + if (second === 47) { + while (true) { + i0 = i + 1; + t2 = source[i]; + if (!!(t2 === 10 || t2 === 13 || t2 === 12)) + break; + i = i0; + } + i = i0; + } else if (second === 42) + for (; true;) { + i0 = i + 1; + if (source[i] !== 42) { + i = i0; + continue; + } + i = i0; + do { + i0 = i + 1; + char = source[i]; + if (char === 42) { + i = i0; + continue; + } else + break; + } while (true); + if (char === 47) { + i = i0; + break; + } + i = i0; + } + } else + i = i0; + } + return i; + } + }; + A.InterpolationMap_mapException_closure.prototype = { + call$1($content) { + return $content instanceof A.Expression; + }, + $signature: 77 + }; + A._realCasePath_helper.prototype = { + call$2(path, realPath) { + var dirname = $.$get$context().dirname$1(path); + if (dirname === path) + return path; + return $._realCaseCache.putIfAbsent$2(path, new A._realCasePath_helper_closure(path, realPath, this, dirname)); + }, + call$1(path) { + return this.call$2(path, null); + }, + $signature: 149 + }; + A._realCasePath_helper_closure.prototype = { + call$0() { + var realPathNonNull, realDirname, basename, matches, t1, _0_0, match, realPathNonNull0, exception, _this = this, + t2 = _this.path; + if (!A.linkExists(t2)) { + realPathNonNull = null; + try { + realPathNonNull0 = _this.realPath; + realPathNonNull = realPathNonNull0 == null ? A.realpath(t2) : realPathNonNull0; + } catch (exception) { + if (A.unwrapException(exception) instanceof A.FileSystemException) + return t2; + else + throw exception; + } + t1 = realPathNonNull; + t2 = $.$get$context(); + return A.join(_this.helper.call$2(_this.dirname, t2.dirname$1(t1)), A.ParsedPath_ParsedPath$parse(realPathNonNull, t2.style).get$basename(), null); + } + realDirname = _this.helper.call$1(_this.dirname); + basename = A.ParsedPath_ParsedPath$parse(t2, $.$get$context().style).get$basename(); + try { + matches = J.where$1$ax(A.listDir(realDirname, false), new A._realCasePath_helper__closure(basename)).toList$0(0); + t1 = null; + _0_0 = matches; + $label0$0: { + match = null; + if (J.get$length$asx(_0_0) === 1) { + match = J.$index$asx(_0_0, 0); + t1 = match; + break $label0$0; + } + t1 = A.join(realDirname, basename, null); + break $label0$0; + } + t1 = t1; + return t1; + } catch (exception) { + if (A.unwrapException(exception) instanceof A.FileSystemException) + return t2; + else + throw exception; + } + }, + $signature: 26 + }; + A._realCasePath_helper__closure.prototype = { + call$1(realPath) { + return A.equalsIgnoreCase(A.ParsedPath_ParsedPath$parse(realPath, $.$get$context().style).get$basename(), this.basename); + }, + $signature: 5 + }; + A.FileSystemException.prototype = { + toString$0(_) { + var t1 = $.$get$context(); + return t1.prettyUri$1(t1.toUri$1(this.path)) + ": " + this.message; + }, + get$message(receiver) { + return this.message; + } + }; + A._readFile_closure.prototype = { + call$0() { + return J.readFileSync$2$x(A.fs(), this.path, this.encoding); + }, + $signature: 59 + }; + A.writeFile_closure.prototype = { + call$0() { + return J.writeFileSync$2$x(A.fs(), this.path, this.contents); + }, + $signature: 0 + }; + A.deleteFile_closure.prototype = { + call$0() { + return J.unlinkSync$1$x(A.fs(), this.path); + }, + $signature: 0 + }; + A.readStdin_closure.prototype = { + call$1(result) { + this._box_0.contents = result; + this.completer.complete$1(result); + }, + $signature: 111 + }; + A.readStdin_closure0.prototype = { + call$1(chunk) { + this.sink.add$1(0, type$.List_int._as(chunk)); + }, + call$0() { + return this.call$1(null); + }, + "call*": "call$1", + $requiredArgCount: 0, + $defaultValues() { + return [null]; + }, + $signature: 91 + }; + A.readStdin_closure1.prototype = { + call$1(arg) { + this.sink.close$0(0); + }, + call$0() { + return this.call$1(null); + }, + "call*": "call$1", + $requiredArgCount: 0, + $defaultValues() { + return [null]; + }, + $signature: 91 + }; + A.readStdin_closure2.prototype = { + call$1(e) { + A.printError("Failed to read from stdin"); + A.printError(e); + e.toString; + this.completer.completeError$1(e); + }, + call$0() { + return this.call$1(null); + }, + "call*": "call$1", + $requiredArgCount: 0, + $defaultValues() { + return [null]; + }, + $signature: 91 + }; + A.fileExists_closure.prototype = { + call$0() { + var error, systemError, exception, + t1 = this.path; + if (!J.existsSync$1$x(A.fs(), t1)) + return false; + try { + t1 = J.isFile$0$x(J.statSync$1$x(A.fs(), t1)); + return t1; + } catch (exception) { + error = A.unwrapException(exception); + systemError = type$.JsSystemError._as(error); + if (J.$eq$(J.get$code$x(systemError), "ENOENT")) + return false; + throw exception; + } + }, + $signature: 19 + }; + A.dirExists_closure.prototype = { + call$0() { + var error, systemError, exception, + t1 = this.path; + if (!J.existsSync$1$x(A.fs(), t1)) + return false; + try { + t1 = J.isDirectory$0$x(J.statSync$1$x(A.fs(), t1)); + return t1; + } catch (exception) { + error = A.unwrapException(exception); + systemError = type$.JsSystemError._as(error); + if (J.$eq$(J.get$code$x(systemError), "ENOENT")) + return false; + throw exception; + } + }, + $signature: 19 + }; + A.linkExists_closure.prototype = { + call$0() { + var error, systemError, t1, exception; + try { + t1 = J.isSymbolicLink$0$x(J.lstatSync$1$x(A.fs(), this.path)); + return t1; + } catch (exception) { + error = A.unwrapException(exception); + systemError = type$.JsSystemError._as(error); + if (J.$eq$(J.get$code$x(systemError), "ENOENT")) + return false; + throw exception; + } + }, + $signature: 19 + }; + A.ensureDir_closure.prototype = { + call$0() { + var error, systemError, exception, t1; + try { + J.mkdirSync$1$x(A.fs(), this.path); + } catch (exception) { + error = A.unwrapException(exception); + systemError = type$.JsSystemError._as(error); + if (J.$eq$(J.get$code$x(systemError), "EEXIST")) + return; + if (!J.$eq$(J.get$code$x(systemError), "ENOENT")) + throw exception; + t1 = this.path; + A.ensureDir($.$get$context().dirname$1(t1)); + J.mkdirSync$1$x(A.fs(), t1); + } + }, + $signature: 0 + }; + A.listDir_closure.prototype = { + call$0() { + var t1 = this.path; + if (!this.recursive) + return J.map$1$1$ax(J.readdirSync$1$x(A.fs(), t1), new A.listDir__closure(t1), type$.String).super$Iterable$where(0, new A.listDir__closure0()); + else + return new A.listDir_closure_list().call$1(t1); + }, + $signature: 152 + }; + A.listDir__closure.prototype = { + call$1(child) { + return A.join(this.path, A._asString(child), null); + }, + $signature: 134 + }; + A.listDir__closure0.prototype = { + call$1(child) { + return !A.dirExists(child); + }, + $signature: 5 + }; + A.listDir_closure_list.prototype = { + call$1($parent) { + return J.expand$1$1$ax(J.readdirSync$1$x(A.fs(), $parent), new A.listDir__list_closure($parent, this), type$.String); + }, + $signature: 153 + }; + A.listDir__list_closure.prototype = { + call$1(child) { + var path = A.join(this.parent, A._asString(child), null); + return A.dirExists(path) ? this.list.call$1(path) : A._setArrayType([path], type$.JSArray_String); + }, + $signature: 154 + }; + A.realpath_closure.prototype = { + call$0() { + return J.native$1$x(J.get$realpathSync$x(A.fs()), this.path); + }, + $signature: 26 + }; + A.modificationTime_closure.prototype = { + call$0() { + var t1 = J.getTime$0$x(J.get$mtime$x(J.statSync$1$x(A.fs(), this.path))); + if (t1 < -864e13 || t1 > 864e13) + A.throwExpression(A.RangeError$range(t1, -864e13, 864e13, "millisecondsSinceEpoch", null)); + A.checkNotNullable(false, "isUtc", type$.bool); + return new A.DateTime(t1, 0, false); + }, + $signature: 155 + }; + A.watchDir_closure0.prototype = { + call$2(error, events) { + var t1, t2, t3, t4, t5, lastEvent; + if (error != null) { + t1 = this._box_0.controller; + if (t1 != null) + t1.addError$1(error); + } else + for (t1 = J.get$iterator$ax(events), t2 = this._box_0; t1.moveNext$0();) { + t3 = t1.get$current(t1); + switch (t3.type) { + case "create": + t4 = t2.controller; + if (t4 != null) { + t3 = new A.WatchEvent(B.ChangeType_add, t3.path); + t5 = t4._state; + if (t5 >= 4) + A.throwExpression(t4._badEventState$0()); + if ((t5 & 1) !== 0) + t4._sendData$1(t3); + else if ((t5 & 3) === 0) { + t4 = t4._ensurePendingEvents$0(); + t3 = new A._DelayedData(t3); + lastEvent = t4.lastPendingEvent; + if (lastEvent == null) + t4.firstPendingEvent = t4.lastPendingEvent = t3; + else { + lastEvent.set$next(t3); + t4.lastPendingEvent = t3; + } + } + } + break; + case "update": + t4 = t2.controller; + if (t4 != null) { + t3 = new A.WatchEvent(B.ChangeType_modify, t3.path); + t5 = t4._state; + if (t5 >= 4) + A.throwExpression(t4._badEventState$0()); + if ((t5 & 1) !== 0) + t4._sendData$1(t3); + else if ((t5 & 3) === 0) { + t4 = t4._ensurePendingEvents$0(); + t3 = new A._DelayedData(t3); + lastEvent = t4.lastPendingEvent; + if (lastEvent == null) + t4.firstPendingEvent = t4.lastPendingEvent = t3; + else { + lastEvent.set$next(t3); + t4.lastPendingEvent = t3; + } + } + } + break; + case "delete": + t4 = t2.controller; + if (t4 != null) { + t3 = new A.WatchEvent(B.ChangeType_remove, t3.path); + t5 = t4._state; + if (t5 >= 4) + A.throwExpression(t4._badEventState$0()); + if ((t5 & 1) !== 0) + t4._sendData$1(t3); + else if ((t5 & 3) === 0) { + t4 = t4._ensurePendingEvents$0(); + t3 = new A._DelayedData(t3); + lastEvent = t4.lastPendingEvent; + if (lastEvent == null) + t4.firstPendingEvent = t4.lastPendingEvent = t3; + else { + lastEvent.set$next(t3); + t4.lastPendingEvent = t3; + } + } + } + break; + } + } + }, + $signature: 340 + }; + A.watchDir_closure.prototype = { + call$0() { + this.subscription.unsubscribe(); + }, + $signature: 1 + }; + A.watchDir_closure1.prototype = { + call$2(path, _) { + var t1 = this._box_0.controller; + return t1 == null ? null : t1.add$1(0, new A.WatchEvent(B.ChangeType_add, path)); + }, + call$1(path) { + return this.call$2(path, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 156 + }; + A.watchDir_closure2.prototype = { + call$2(path, _) { + var t1 = this._box_0.controller; + return t1 == null ? null : t1.add$1(0, new A.WatchEvent(B.ChangeType_modify, path)); + }, + call$1(path) { + return this.call$2(path, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 156 + }; + A.watchDir_closure3.prototype = { + call$1(path) { + var t1 = this._box_0.controller; + return t1 == null ? null : t1.add$1(0, new A.WatchEvent(B.ChangeType_remove, path)); + }, + $signature: 111 + }; + A.watchDir_closure4.prototype = { + call$1(error) { + var t1 = this._box_0.controller; + return t1 == null ? null : t1.addError$1(error); + }, + $signature: 95 + }; + A.watchDir_closure5.prototype = { + call$0() { + var controller = A.StreamController_StreamController(new A.watchDir__closure(this.watcher), null, null, null, false, type$.WatchEvent); + this._box_0.controller = controller; + this.completer.complete$1(new A._ControllerStream(controller, A._instanceType(controller)._eval$1("_ControllerStream<1>"))); + }, + $signature: 1 + }; + A.watchDir__closure.prototype = { + call$0() { + J.close$0$x(this.watcher); + }, + $signature: 1 + }; + A.JSArray0.prototype = {}; + A.Chokidar.prototype = {}; + A.ChokidarOptions.prototype = {}; + A.ChokidarWatcher.prototype = {}; + A.JSFunction.prototype = {}; + A.ImmutableList.prototype = {}; + A.ImmutableMap.prototype = {}; + A.NodeImporterResult.prototype = {}; + A.RenderContext.prototype = {}; + A.RenderContextOptions.prototype = {}; + A.RenderContextResult.prototype = {}; + A.RenderContextResultStats.prototype = {}; + A.JSModule.prototype = {}; + A.JSModuleRequire.prototype = {}; + A.ParcelWatcher_subscribe_closure.prototype = { + call$2(error, events) { + var t1 = type$.List_JSObject._is(events) ? events : new A.CastList(events, A._arrayInstanceType(events)._eval$1("CastList<1,JSObject>")); + this.callback.call$2(error, t1); + }, + $signature: 357 + }; + A.JSClass.prototype = {}; + A.JSUrl.prototype = {}; + A._PropertyDescriptor.prototype = {}; + A._RequireMain.prototype = {}; + A.LoggerWithDeprecationType.prototype = { + warn$4$deprecation$span$trace(_, message, deprecation, span, trace) { + this.internalWarn$4$deprecation$span$trace(message, deprecation ? B.Deprecation_KtC : null, span, trace); + }, + warn$1(_, message) { + return this.warn$4$deprecation$span$trace(0, message, false, null, null); + }, + warn$3$span$trace(_, message, span, trace) { + return this.warn$4$deprecation$span$trace(0, message, false, span, trace); + } + }; + A._QuietLogger.prototype = { + warn$4$deprecation$span$trace(_, message, deprecation, span, trace) { + }, + warn$1(_, message) { + return this.warn$4$deprecation$span$trace(0, message, false, null, null); + }, + warn$3$span$trace(_, message, span, trace) { + return this.warn$4$deprecation$span$trace(0, message, false, span, trace); + }, + debug$2(_, message, span) { + } + }; + A.DeprecationProcessingLogger.prototype = { + validate$0() { + var t1, t2, t3, t4, _this = this, _null = null; + for (t1 = _this.fatalDeprecations, t1 = t1.get$iterator(t1), t2 = _this.silenceDeprecations; t1.moveNext$0();) { + t3 = t1.get$current(t1); + t4 = t2.contains$1(0, t3); + if (t4) { + t3 = t3.toString$0(0); + _this.internalWarn$4$deprecation$span$trace("Ignoring setting to silence " + t3 + string$.x20deprex2c, _null, _null, _null); + continue; + } + } + for (t1 = A._LinkedHashSetIterator$(t2, t2._modifications, A._instanceType(t2)._precomputed1), t2 = t1.$ti._precomputed1, t3 = _this.futureDeprecations; t1.moveNext$0();) { + t4 = t1._collection$_current; + if (B.Deprecation_KtC === (t4 == null ? t2._as(t4) : t4)) { + _this.internalWarn$4$deprecation$span$trace(string$.User_a, _null, _null, _null); + continue; + } + } + for (t1 = A._LinkedHashSetIterator$(t3, t3._modifications, A._instanceType(t3)._precomputed1), t2 = t1.$ti._precomputed1; t1.moveNext$0();) { + t3 = t1._collection$_current; + t3 = (t3 == null ? t2._as(t3) : t3).toString$0(0); + _this.internalWarn$4$deprecation$span$trace(t3 + string$.x20is_noaf, _null, _null, _null); + } + }, + internalWarn$4$deprecation$span$trace(message, deprecation, span, trace) { + if (deprecation != null) + this._handleDeprecation$4$span$trace(deprecation, message, span, trace); + else + this._inner.warn$3$span$trace(0, message, span, trace); + }, + _handleDeprecation$4$span$trace(deprecation, message, span, trace) { + var _0_3_isSet, _0_3, t1, span0, t2, count, _1_0, _this = this, _null = null; + if (_this.fatalDeprecations.contains$1(0, deprecation)) { + message += string$.x0a_This + deprecation.toString$0(0) + string$.x20deprex20; + $label0$0: { + _0_3_isSet = span != null; + _0_3 = _null; + t1 = false; + if (_0_3_isSet) { + span0 = span == null ? type$.FileSpan._as(span) : span; + t1 = trace != null; + _0_3 = trace; + } else + span0 = _null; + if (t1) { + if (_0_3_isSet) + trace = _0_3; + t1 = A.SassRuntimeException$(message, span0, trace == null ? type$.Trace._as(trace) : trace, _null); + break $label0$0; + } + t1 = false; + if (span != null) + t1 = (_0_3_isSet ? _0_3 : trace) == null; + else + span = _null; + if (t1) { + t1 = A.SassException$(message, span, _null); + break $label0$0; + } + t1 = A.SassScriptException$(message, _null); + break $label0$0; + } + throw A.wrapException(t1); + } + if (_this.silenceDeprecations.contains$1(0, deprecation)) + return; + if (_this.limitRepetition) { + t1 = _this._warningCounts; + t2 = t1.$index(0, deprecation); + count = (t2 == null ? 0 : t2) + 1; + t1.$indexSet(0, deprecation, count); + if (count > 5) + return; + } + _1_0 = _this._inner; + if (_1_0 instanceof A.LoggerWithDeprecationType) + _1_0.internalWarn$4$deprecation$span$trace(message, deprecation, span, trace); + else + _1_0.warn$4$deprecation$span$trace(0, message, true, span, trace); + }, + debug$2(_, message, span) { + return this._inner.debug$2(0, message, span); + }, + summarize$1$js(js) { + var t1 = this._warningCounts, + t2 = A._instanceType(t1)._eval$1("LinkedHashMapValuesIterable<2>"), + total = A.IterableIntegerExtension_get_sum(new A.MappedIterable(new A.WhereIterable(new A.LinkedHashMapValuesIterable(t1, t2), new A.DeprecationProcessingLogger_summarize_closure(), t2._eval$1("WhereIterable")), new A.DeprecationProcessingLogger_summarize_closure0(), t2._eval$1("MappedIterable"))); + if (total > 0) { + t1 = js ? "" : string$.x0aRun_i; + this._inner.warn$1(0, "" + total + string$.x20repet + t1); + } + } + }; + A.DeprecationProcessingLogger_summarize_closure.prototype = { + call$1(count) { + return count > 5; + }, + $signature: 48 + }; + A.DeprecationProcessingLogger_summarize_closure0.prototype = { + call$1(count) { + return count - 5; + }, + $signature: 157 + }; + A.StderrLogger.prototype = { + internalWarn$4$deprecation$span$trace(message, deprecation, span, trace) { + var t3, + result = new A.StringBuffer(""), + t1 = deprecation != null, + showDeprecation = t1 && deprecation !== B.Deprecation_KtC, + t2 = this.color; + if (t2) { + t3 = result._contents = "" + "\x1b[33m\x1b[1m"; + t3 = result._contents = (t1 ? result._contents = t3 + "Deprecation " : t3) + "Warning\x1b[0m"; + if (showDeprecation) { + t1 = t3 + (" [\x1b[34m" + A.S(deprecation) + "\x1b[0m]"); + result._contents = t1; + } else + t1 = t3; + } else { + t3 = result._contents = (t1 ? result._contents = "" + "DEPRECATION " : "") + "WARNING"; + if (showDeprecation) { + t1 = t3 + (" [" + A.S(deprecation) + "]"); + result._contents = t1; + } else + t1 = t3; + } + if (span == null) + t1 = result._contents = t1 + (": " + message + "\n"); + else if (trace != null) { + t1 += ": " + message + "\n\n" + span.highlight$1$color(t2) + "\n"; + result._contents = t1; + } else { + t1 += " on " + span.message$2$color(0, "\n" + message, t2) + "\n"; + result._contents = t1; + } + if (trace != null) + result._contents = t1 + (A.indent(B.JSString_methods.trimRight$0(trace.toString$0(0)), 4) + "\n"); + A.printError(result); + }, + debug$2(_, message, span) { + var url, t3, t4, + t1 = span.file, + t2 = span._file$_start; + if (A.FileLocation$_(t1, t2).file.url == null) + url = "-"; + else { + t3 = A.FileLocation$_(t1, t2).file.url; + t4 = $.$get$context(); + t3.toString; + url = t4.prettyUri$1(t3); + } + t1 = A.FileLocation$_(t1, t2); + t1 = t1.file.getLine$1(t1.offset); + t2 = this.color ? "\x1b[1mDebug\x1b[0m" : "DEBUG"; + t2 = "" + (url + ":" + (t1 + 1) + " ") + t2 + (": " + message); + A.printError(t2.charCodeAt(0) == 0 ? t2 : t2); + } + }; + A.TrackingLogger.prototype = { + warn$4$deprecation$span$trace(_, message, deprecation, span, trace) { + this._emittedWarning = true; + this._tracking$_logger.warn$4$deprecation$span$trace(0, message, deprecation, span, trace); + }, + warn$1(_, message) { + return this.warn$4$deprecation$span$trace(0, message, false, null, null); + }, + warn$3$span$trace(_, message, span, trace) { + return this.warn$4$deprecation$span$trace(0, message, false, span, trace); + }, + debug$2(_, message, span) { + this._emittedDebug = true; + this._tracking$_logger.debug$2(0, message, span); + } + }; + A.BuiltInModule.prototype = { + get$upstream() { + return B.List_empty7; + }, + get$variableNodes() { + return B.Map_empty4; + }, + get$extensionStore() { + return B.C_EmptyExtensionStore; + }, + get$css(_) { + return new A.CssStylesheet(B.List_empty3, A.SourceFile$decoded(B.List_empty4, this.url).span$2(0, 0, 0)); + }, + get$preModuleComments() { + return B.Map_empty2; + }, + get$transitivelyContainsCss() { + return false; + }, + get$transitivelyContainsExtensions() { + return false; + }, + setVariable$3($name, value, nodeWithSpan) { + if (!this.variables.containsKey$1($name)) + throw A.wrapException(A.SassScriptException$("Undefined variable.", null)); + throw A.wrapException(A.SassScriptException$("Cannot modify built-in variable.", null)); + }, + variableIdentity$1($name) { + return this; + }, + cloneCss$0() { + return this; + }, + $isModule0: 1, + get$url(receiver) { + return this.url; + }, + get$functions(receiver) { + return this.functions; + }, + get$mixins() { + return this.mixins; + }, + get$variables() { + return this.variables; + } + }; + A.ForwardedModuleView.prototype = { + get$url(_) { + var t1 = this._forwarded_view$_inner; + return t1.get$url(t1); + }, + get$upstream() { + return this._forwarded_view$_inner.get$upstream(); + }, + get$extensionStore() { + return this._forwarded_view$_inner.get$extensionStore(); + }, + get$css(_) { + var t1 = this._forwarded_view$_inner; + return t1.get$css(t1); + }, + get$preModuleComments() { + return this._forwarded_view$_inner.get$preModuleComments(); + }, + get$transitivelyContainsCss() { + return this._forwarded_view$_inner.get$transitivelyContainsCss(); + }, + get$transitivelyContainsExtensions() { + return this._forwarded_view$_inner.get$transitivelyContainsExtensions(); + }, + setVariable$3($name, value, nodeWithSpan) { + var t2, _1_0, _2_0, + _s19_ = "Undefined variable.", + t1 = this._rule, + _0_0 = t1.shownVariables; + if (_0_0 != null) + t2 = !_0_0._base.contains$1(0, $name); + else + t2 = false; + if (t2) + throw A.wrapException(A.SassScriptException$(_s19_, null)); + else { + _1_0 = t1.hiddenVariables; + if (_1_0 != null) + t2 = _1_0._base.contains$1(0, $name); + else + t2 = false; + if (t2) + throw A.wrapException(A.SassScriptException$(_s19_, null)); + } + _2_0 = t1.prefix; + if (_2_0 != null) { + if (!B.JSString_methods.startsWith$1($name, _2_0)) + throw A.wrapException(A.SassScriptException$(_s19_, null)); + $name = B.JSString_methods.substring$1($name, _2_0.length); + } + return this._forwarded_view$_inner.setVariable$3($name, value, nodeWithSpan); + }, + variableIdentity$1($name) { + var _0_0 = this._rule.prefix; + if (_0_0 != null) + $name = B.JSString_methods.substring$1($name, _0_0.length); + return this._forwarded_view$_inner.variableIdentity$1($name); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.ForwardedModuleView && this._forwarded_view$_inner.$eq(0, other._forwarded_view$_inner) && this._rule === other._rule; + }, + get$hashCode(_) { + var t1 = this._forwarded_view$_inner; + return (t1.get$hashCode(t1) ^ A.Primitives_objectHashCode(this._rule)) >>> 0; + }, + cloneCss$0() { + return A.ForwardedModuleView$(this._forwarded_view$_inner.cloneCss$0(), this._rule, this.$ti._precomputed1); + }, + toString$0(_) { + return "forwarded " + this._forwarded_view$_inner.toString$0(0); + }, + $isModule0: 1, + get$variables() { + return this.variables; + }, + get$variableNodes() { + return this.variableNodes; + }, + get$functions(receiver) { + return this.functions; + }, + get$mixins() { + return this.mixins; + } + }; + A.ShadowedModuleView.prototype = { + get$url(_) { + var t1 = this._shadowed_view$_inner; + return t1.get$url(t1); + }, + get$upstream() { + return this._shadowed_view$_inner.get$upstream(); + }, + get$extensionStore() { + return this._shadowed_view$_inner.get$extensionStore(); + }, + get$css(_) { + var t1 = this._shadowed_view$_inner; + return t1.get$css(t1); + }, + get$preModuleComments() { + return this._shadowed_view$_inner.get$preModuleComments(); + }, + get$transitivelyContainsCss() { + return this._shadowed_view$_inner.get$transitivelyContainsCss(); + }, + get$transitivelyContainsExtensions() { + return this._shadowed_view$_inner.get$transitivelyContainsExtensions(); + }, + setVariable$3($name, value, nodeWithSpan) { + if (!this.variables.containsKey$1($name)) + throw A.wrapException(A.SassScriptException$("Undefined variable.", null)); + else + this._shadowed_view$_inner.setVariable$3($name, value, nodeWithSpan); + }, + variableIdentity$1($name) { + return this._shadowed_view$_inner.variableIdentity$1($name); + }, + $eq(_, other) { + var t1, t2, t3, _this = this; + if (other == null) + return false; + t1 = false; + if (other instanceof A.ShadowedModuleView) + if (_this._shadowed_view$_inner.$eq(0, other._shadowed_view$_inner)) { + t2 = _this.variables; + t2 = t2.get$keys(t2); + t3 = other.variables; + if (B.C_IterableEquality.equals$2(0, t2, t3.get$keys(t3))) { + t2 = _this.functions; + t2 = t2.get$keys(t2); + t3 = other.functions; + if (B.C_IterableEquality.equals$2(0, t2, t3.get$keys(t3))) { + t1 = _this.mixins; + t1 = t1.get$keys(t1); + t2 = other.mixins; + t2 = B.C_IterableEquality.equals$2(0, t1, t2.get$keys(t2)); + t1 = t2; + } + } + } + return t1; + }, + get$hashCode(_) { + var t1 = this._shadowed_view$_inner; + return t1.get$hashCode(t1); + }, + cloneCss$0() { + var _this = this; + return new A.ShadowedModuleView(_this._shadowed_view$_inner.cloneCss$0(), _this.variables, _this.variableNodes, _this.functions, _this.mixins, _this.$ti); + }, + toString$0(_) { + return "shadowed " + this._shadowed_view$_inner.toString$0(0); + }, + $isModule0: 1, + get$variables() { + return this.variables; + }, + get$variableNodes() { + return this.variableNodes; + }, + get$functions(receiver) { + return this.functions; + }, + get$mixins() { + return this.mixins; + } + }; + A.AtRootQueryParser.prototype = { + parse$0(_) { + return this.wrapSpanFormatException$1(new A.AtRootQueryParser_parse_closure(this)); + } + }; + A.AtRootQueryParser_parse_closure.prototype = { + call$0() { + var include, atRules, + t1 = this.$this, + t2 = t1.scanner; + t2.expectChar$1(40); + t1.whitespace$1$consumeNewlines(true); + include = t1.scanIdentifier$1("with"); + if (!include) + t1.expectIdentifier$2$name("without", '"with" or "without"'); + t1.whitespace$1$consumeNewlines(true); + t2.expectChar$1(58); + t1.whitespace$1$consumeNewlines(true); + atRules = A.LinkedHashSet_LinkedHashSet$_empty(type$.String); + do { + atRules.add$1(0, t1.identifier$0().toLowerCase()); + t1.whitespace$1$consumeNewlines(true); + } while (t1.lookingAtIdentifier$0()); + t2.expectChar$1(41); + t2.expectDone$0(); + return new A.AtRootQuery(include, atRules, atRules.contains$1(0, "all"), atRules.contains$1(0, "rule")); + }, + $signature: 398 + }; + A._disallowedFunctionNames_closure.prototype = { + call$1($function) { + return $function.name; + }, + $signature: 417 + }; + A.CssParser.prototype = { + get$plainCss() { + return true; + }, + silentComment$0() { + var t1, t2, _this = this; + if (_this._inExpression) + return false; + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + _this.super$Parser$silentComment(); + _this.error$2(0, string$.Silent, t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + atRule$2$root(child, root) { + var $name, _0_0, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expectChar$1(64); + $name = _this.interpolatedIdentifier$0(); + _this.whitespace$1$consumeNewlines(true); + _0_0 = $name.get$asPlain(); + $label0$0: { + if ("at-root" === _0_0 || "content" === _0_0 || "debug" === _0_0 || "each" === _0_0 || "error" === _0_0 || "extend" === _0_0 || "for" === _0_0 || "function" === _0_0 || "if" === _0_0 || "include" === _0_0 || "mixin" === _0_0 || "return" === _0_0 || "warn" === _0_0 || "while" === _0_0) + _this._forbiddenAtRule$1(start); + if ("import" === _0_0) { + t1 = _this._cssImportRule$1(start); + break $label0$0; + } + if ("media" === _0_0) { + t1 = _this.mediaRule$1(start); + break $label0$0; + } + if ("-moz-document" === _0_0) { + t1 = _this.mozDocumentRule$2(start, $name); + break $label0$0; + } + if ("supports" === _0_0) { + t1 = _this.supportsRule$1(start); + break $label0$0; + } + t1 = _this.unknownAtRule$2(start, $name); + break $label0$0; + } + return t1; + }, + _forbiddenAtRule$1(start) { + this.almostAnyValue$0(); + this.error$2(0, "This at-rule isn't allowed in plain CSS.", this.scanner.spanFrom$1(start)); + }, + _cssImportRule$1(start) { + var _0_0, t3, string, $name, _0_3, _0_4, t4, _0_8, t5, modifiers, _this = this, _null = null, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + _1_0 = t1.peekChar$0(); + $label1$1: { + if (117 === _1_0 || 85 === _1_0) { + _0_0 = _this.dynamicUrl$0(); + $label0$0: { + if (_0_0 instanceof A.StringExpression) { + t3 = _0_0.text; + break $label0$0; + } + string = _null; + t3 = false; + if (_0_0 instanceof A.InterpolatedFunctionExpression) { + $name = _0_0.name; + _0_3 = _0_0.$arguments; + _0_4 = _0_3.positional; + t4 = _0_4; + if (t4.length === 1) { + _0_8 = _0_4[0]; + t4 = _0_8; + if (t4 instanceof A.StringExpression) { + type$.StringExpression._as(_0_8); + t4 = _0_3.named; + if (t4.get$isEmpty(t4)) + if (_0_3.rest == null) + t3 = _0_3.keywordRest == null; + string = _0_8; + } + } + } else + $name = _null; + if (t3) { + t3 = new A.StringBuffer(""); + t4 = new A.InterpolationBuffer(t3, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t4.addInterpolation$1($name); + t5 = A.Primitives_stringFromCharCode(40); + t3._contents += t5; + t4.addInterpolation$1(string.asInterpolation$0()); + t5 = A.Primitives_stringFromCharCode(41); + t3._contents += t5; + t4 = t4.interpolation$1(_0_0.span); + t3 = t4; + break $label0$0; + } + t3 = _this.error$2(0, "Unsupported plain CSS import.", _0_0.get$span(_0_0)); + } + break $label1$1; + } + t3 = _this.interpolatedString$0().asInterpolation$1$static(true); + break $label1$1; + } + _this.whitespace$1$consumeNewlines(true); + modifiers = _this.tryImportModifiers$0(); + _this.expectStatementSeparator$1("@import rule"); + t2 = A._setArrayType([new A.StaticImport(t3, modifiers, t1.spanFrom$1(new A._SpanScannerState(t1, t2)))], type$.JSArray_Import); + t1 = t1.spanFrom$1(start); + return new A.ImportRule(A.List_List$unmodifiable(t2, type$.Import), t1); + }, + parentheses$0() { + var expression, + t1 = this.scanner, + t2 = t1._string_scanner$_position; + t1.expectChar$1(40); + this.whitespace$1$consumeNewlines(true); + expression = this.expressionUntilComma$0(); + t1.expectChar$1(41); + return new A.ParenthesizedExpression(expression, t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + identifierLike$0() { + var t2, allowEmptySecondArg, $arguments, t3, t4, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + identifier = _this.interpolatedIdentifier$0(), + plain = identifier.get$asPlain(), + lower = plain.toLowerCase(), + _0_0 = _this.trySpecialFunction$2(lower, start); + if (_0_0 != null) + return _0_0; + t2 = t1._string_scanner$_position; + if (t1.scanChar$1(46)) + return _this.namespacedExpression$2(plain, start); + if (!t1.scanChar$1(40)) + return new A.StringExpression(identifier, false); + allowEmptySecondArg = lower === "var"; + $arguments = A._setArrayType([], type$.JSArray_Expression); + if (!t1.scanChar$1(41)) { + do { + _this.whitespace$1$consumeNewlines(true); + if (allowEmptySecondArg && $arguments.length === 1 && t1.peekChar$0() === 41) { + t3 = A.FileLocation$_(t1._sourceFile, t1._string_scanner$_position); + t4 = t3.offset; + t4 = A._FileSpan$(t3.file, t4, t4); + $arguments.push(new A.StringExpression(new A.Interpolation(A.List_List$unmodifiable([""], type$.Object), B.List_null, t4), false)); + break; + } + $arguments.push(_this.expressionUntilComma$1$singleEquals(true)); + _this.whitespace$1$consumeNewlines(true); + } while (t1.scanChar$1(44)); + t1.expectChar$1(41); + } + if ($.$get$_disallowedFunctionNames().contains$1(0, plain)) + _this.error$2(0, string$.This_f, t1.spanFrom$1(start)); + t2 = t1.spanFrom$1(new A._SpanScannerState(t1, t2)); + t3 = type$.Expression; + t4 = A.List_List$unmodifiable($arguments, t3); + t3 = A.ConstantMap_ConstantMap$from(B.Map_empty5, type$.String, t3); + t1 = t1.spanFrom$1(start); + return new A.FunctionExpression(null, A.stringReplaceAllUnchecked(plain, "_", "-"), plain, new A.ArgumentList(t4, t3, null, null, t2), t1); + }, + namespacedExpression$2(namespace, start) { + var expression = this.super$StylesheetParser$namespacedExpression(namespace, start); + this.error$2(0, string$.Modulen, expression.get$span(expression)); + } + }; + A.KeyframeSelectorParser.prototype = { + parse$0(_) { + return this.wrapSpanFormatException$1(new A.KeyframeSelectorParser_parse_closure(this)); + }, + _percentage$0() { + var $self, _0_0, + t1 = this.scanner, + t2 = t1.scanChar$1(43) ? "" + A.Primitives_stringFromCharCode(43) : "", + second = t1.peekChar$0(); + if (!(second != null && second >= 48 && second <= 57) && second !== 46) + t1.error$1(0, "Expected number."); + while (true) { + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + break; + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + } + if (t1.peekChar$0() === 46) { + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + while (true) { + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + break; + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + } + } + if (this.scanIdentChar$1(101)) { + t2 += A.Primitives_stringFromCharCode(101); + _0_0 = t1.peekChar$0(); + if (43 === _0_0 || 45 === _0_0) + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + t1.error$1(0, "Expected digit."); + do { + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + $self = t1.peekChar$0(); + } while ($self != null && $self >= 48 && $self <= 57); + } + t1.expectChar$1(37); + t2 += A.Primitives_stringFromCharCode(37); + return t2.charCodeAt(0) == 0 ? t2 : t2; + } + }; + A.KeyframeSelectorParser_parse_closure.prototype = { + call$0() { + var selectors = A._setArrayType([], type$.JSArray_String), + t1 = this.$this, + t2 = t1.scanner; + do { + t1.whitespace$1$consumeNewlines(true); + if (t1.lookingAtIdentifier$0()) + if (t1.scanIdentifier$1("from")) + selectors.push("from"); + else { + t1.expectIdentifier$2$name("to", '"to" or "from"'); + selectors.push("to"); + } + else + selectors.push(t1._percentage$0()); + t1.whitespace$1$consumeNewlines(true); + } while (t2.scanChar$1(44)); + t2.expectDone$0(); + return selectors; + }, + $signature: 138 + }; + A.MediaQueryParser.prototype = { + parse$0(_) { + return this.wrapSpanFormatException$1(new A.MediaQueryParser_parse_closure(this)); + }, + _mediaQuery$0() { + var conditions, conjunction, t1, identifier1, identifier2, type, modifier, _this = this, _null = null, _s3_ = "and"; + if (_this.scanner.peekChar$0() === 40) { + conditions = A._setArrayType([_this._mediaInParens$0()], type$.JSArray_String); + _this.whitespace$1$consumeNewlines(true); + if (_this.scanIdentifier$1(_s3_)) { + _this.expectWhitespace$0(); + B.JSArray_methods.addAll$1(conditions, _this._mediaLogicSequence$1(_s3_)); + conjunction = true; + } else { + t1 = _this.scanIdentifier$1("or"); + if (t1) { + _this.expectWhitespace$0(); + B.JSArray_methods.addAll$1(conditions, _this._mediaLogicSequence$1("or")); + } + conjunction = !t1; + } + return A.CssMediaQuery$condition(conditions, conjunction); + } + identifier1 = _this.identifier$0(); + if (A.equalsIgnoreCase(identifier1, "not")) { + _this.expectWhitespace$0(); + if (!_this.lookingAtIdentifier$0()) + return A.CssMediaQuery$condition(A._setArrayType(["(not " + _this._mediaInParens$0() + ")"], type$.JSArray_String), _null); + } + _this.whitespace$1$consumeNewlines(true); + if (!_this.lookingAtIdentifier$0()) + return A.CssMediaQuery$type(identifier1, _null, _null); + identifier2 = _this.identifier$0(); + if (A.equalsIgnoreCase(identifier2, _s3_)) { + _this.expectWhitespace$0(); + type = identifier1; + modifier = _null; + } else { + _this.whitespace$1$consumeNewlines(true); + if (_this.scanIdentifier$1(_s3_)) + _this.expectWhitespace$0(); + else + return A.CssMediaQuery$type(identifier2, _null, identifier1); + type = identifier2; + modifier = identifier1; + } + if (_this.scanIdentifier$1("not")) { + _this.expectWhitespace$0(); + return A.CssMediaQuery$type(type, A._setArrayType(["(not " + _this._mediaInParens$0() + ")"], type$.JSArray_String), modifier); + } + return A.CssMediaQuery$type(type, _this._mediaLogicSequence$1(_s3_), modifier); + }, + _mediaLogicSequence$1(operator) { + var t1, t2, _this = this, + result = A._setArrayType([], type$.JSArray_String); + for (t1 = _this.scanner; true;) { + t1.expectChar$2$name(40, "media condition in parentheses"); + t2 = _this.declarationValue$0(); + t1.expectChar$1(41); + result.push("(" + t2 + ")"); + _this.whitespace$1$consumeNewlines(true); + if (!_this.scanIdentifier$1(operator)) + return result; + _this.expectWhitespace$0(); + } + }, + _mediaInParens$0() { + var t2, + t1 = this.scanner; + t1.expectChar$2$name(40, "media condition in parentheses"); + t2 = this.declarationValue$0(); + t1.expectChar$1(41); + return "(" + t2 + ")"; + } + }; + A.MediaQueryParser_parse_closure.prototype = { + call$0() { + var queries = A._setArrayType([], type$.JSArray_CssMediaQuery), + t1 = this.$this, + t2 = t1.scanner; + do { + t1.whitespace$1$consumeNewlines(true); + queries.push(t1._mediaQuery$0()); + t1.whitespace$1$consumeNewlines(true); + } while (t2.scanChar$1(44)); + t2.expectDone$0(); + return queries; + }, + $signature: 418 + }; + A.Parser.prototype = { + _parseIdentifier$0() { + return this.wrapSpanFormatException$1(new A.Parser__parseIdentifier_closure(this)); + }, + _isVariableDeclarationLike$0() { + var _this = this, + t1 = _this.scanner; + if (!t1.scanChar$1(36)) + return false; + if (!_this.lookingAtIdentifier$0()) + return false; + _this.identifier$0(); + _this.whitespace$1$consumeNewlines(true); + return t1.scanChar$1(58); + }, + whitespace$1$consumeNewlines(consumeNewlines) { + do + this.whitespaceWithoutComments$1$consumeNewlines(consumeNewlines); + while (this.scanComment$0()); + }, + whitespaceWithoutComments$1$consumeNewlines(consumeNewlines) { + var t3, + t1 = this.scanner, + t2 = t1.string.length; + while (true) { + if (t1._string_scanner$_position !== t2) { + t3 = t1.peekChar$0(); + t3 = t3 === 32 || t3 === 9 || t3 === 10 || t3 === 13 || t3 === 12; + } else + t3 = false; + if (!t3) + break; + t1.readChar$0(); + } + }, + spaces$0() { + var t3, + t1 = this.scanner, + t2 = t1.string.length; + while (true) { + if (t1._string_scanner$_position !== t2) { + t3 = t1.peekChar$0(); + t3 = t3 === 32 || t3 === 9; + } else + t3 = false; + if (!t3) + break; + t1.readChar$0(); + } + }, + scanComment$0() { + var _0_0, + t1 = this.scanner; + if (t1.peekChar$0() !== 47) + return false; + _0_0 = t1.peekChar$1(1); + if (47 === _0_0) + return this.silentComment$0(); + if (42 === _0_0) { + this.loudComment$0(); + return true; + } + return false; + }, + expectWhitespace$1$consumeNewlines(consumeNewlines) { + var t2, t3, + t1 = this.scanner; + if (t1._string_scanner$_position !== t1.string.length) { + t2 = t1.peekChar$0(); + t3 = !(t2 === 32 || t2 === 9 || t2 === 10 || t2 === 13 || t2 === 12 || this.scanComment$0()); + t2 = t3; + } else + t2 = true; + if (t2) + t1.error$1(0, "Expected whitespace."); + this.whitespace$1$consumeNewlines(consumeNewlines); + }, + expectWhitespace$0() { + return this.expectWhitespace$1$consumeNewlines(false); + }, + silentComment$0() { + var t2, t3, + t1 = this.scanner; + t1.expect$1("//"); + t2 = t1.string.length; + while (true) { + if (t1._string_scanner$_position !== t2) { + t3 = t1.peekChar$0(); + t3 = !(t3 === 10 || t3 === 13 || t3 === 12); + } else + t3 = false; + if (!t3) + break; + t1.readChar$0(); + } + return true; + }, + loudComment$0() { + var next, + t1 = this.scanner; + t1.expect$1("/*"); + for (; true;) { + if (t1.readChar$0() !== 42) + continue; + do + next = t1.readChar$0(); + while (next === 42); + if (next === 47) + break; + } + }, + identifier$2$normalize$unit(normalize, unit) { + var t2, _0_0, _this = this, + _s20_ = "Expected identifier.", + text = new A.StringBuffer(""), + t1 = _this.scanner; + if (t1.scanChar$1(45)) { + t2 = text._contents = "" + A.Primitives_stringFromCharCode(45); + if (t1.scanChar$1(45)) { + text._contents = t2 + A.Primitives_stringFromCharCode(45); + _this._identifierBody$3$normalize$unit(text, normalize, unit); + t1 = text._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + } else + t2 = ""; + $label0$0: { + _0_0 = t1.peekChar$0(); + if (_0_0 == null) + t1.error$1(0, _s20_); + if (95 === _0_0 && normalize) { + t1.readChar$0(); + text._contents = t2 + A.Primitives_stringFromCharCode(45); + break $label0$0; + } + if (_0_0 === 95 || A.CharacterExtension_get_isAlphabetic(_0_0) || _0_0 >= 128) { + text._contents = t2 + A.Primitives_stringFromCharCode(t1.readChar$0()); + break $label0$0; + } + if (92 === _0_0) { + text._contents = t2 + _this.escape$1$identifierStart(true); + break $label0$0; + } + t1.error$1(0, _s20_); + } + _this._identifierBody$3$normalize$unit(text, normalize, unit); + t1 = text._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + identifier$0() { + return this.identifier$2$normalize$unit(false, false); + }, + identifier$1$normalize(normalize) { + return this.identifier$2$normalize$unit(normalize, false); + }, + identifier$1$unit(unit) { + return this.identifier$2$normalize$unit(false, unit); + }, + _identifierBody$3$normalize$unit(text, normalize, unit) { + var t1, _1_0, _0_0, t2; + for (t1 = this.scanner; true;) { + _1_0 = t1.peekChar$0(); + if (_1_0 == null) + break; + if (45 === _1_0 && unit) { + _0_0 = t1.peekChar$1(1); + if (46 !== _0_0) + t2 = A._isInt(_0_0) && _0_0 >= 48 && _0_0 <= 57; + else + t2 = true; + if (t2) + break; + t2 = A.Primitives_stringFromCharCode(t1.readChar$0()); + text._contents += t2; + continue; + } + if (95 === _1_0 && normalize) { + t1.readChar$0(); + t2 = A.Primitives_stringFromCharCode(45); + text._contents += t2; + continue; + } + if (_1_0 !== 95) { + if (!(_1_0 >= 97 && _1_0 <= 122)) + t2 = _1_0 >= 65 && _1_0 <= 90; + else + t2 = true; + t2 = t2 || _1_0 >= 128; + } else + t2 = true; + if (!t2) + t2 = _1_0 >= 48 && _1_0 <= 57 || _1_0 === 45; + else + t2 = true; + if (t2) { + t2 = A.Primitives_stringFromCharCode(t1.readChar$0()); + text._contents += t2; + continue; + } + if (92 === _1_0) { + t2 = this.escape$0(); + text._contents += t2; + continue; + } + break; + } + }, + _identifierBody$1(text) { + return this._identifierBody$3$normalize$unit(text, false, false); + }, + string$0() { + var buffer, _0_0, t2, + t1 = this.scanner, + quote = t1.readChar$0(); + if (quote !== 39 && quote !== 34) + t1.error$2$position(0, "Expected string.", t1._string_scanner$_position - 1); + buffer = new A.StringBuffer(""); + for (; true;) { + _0_0 = t1.peekChar$0(); + if (_0_0 === quote) { + t1.readChar$0(); + break; + } + if (_0_0 == null || _0_0 === 10 || _0_0 === 13 || _0_0 === 12) + t1.error$1(0, "Expected " + A.Primitives_stringFromCharCode(quote) + "."); + if (92 === _0_0) { + t2 = t1.peekChar$1(1); + if (t2 === 10 || t2 === 13 || t2 === 12) { + t1.readChar$0(); + t1.readChar$0(); + } else { + t2 = A.Primitives_stringFromCharCode(A.consumeEscapedCharacter(t1)); + buffer._contents += t2; + } + continue; + } + t2 = A.Primitives_stringFromCharCode(t1.readChar$0()); + buffer._contents += t2; + } + t1 = buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + declarationValue$1$allowEmpty(allowEmpty) { + var t1, t2, t3, wroteNewline, next, wroteNewline0, t4, start, end, _0_0, _this = this, + buffer = new A.StringBuffer(""), + brackets = A._setArrayType([], type$.JSArray_int); + for (t1 = _this.scanner, t2 = _this.get$loudComment(), t3 = _this.get$string(), wroteNewline = false; true;) { + next = t1.peekChar$0(); + if (next == null) + break; + wroteNewline0 = false; + if (92 === next) { + t4 = _this.escape$1$identifierStart(true); + buffer._contents += t4; + wroteNewline = wroteNewline0; + continue; + } + if (34 === next || 39 === next) { + start = t1._string_scanner$_position; + t3.call$0(); + end = t1._string_scanner$_position; + buffer._contents += B.JSString_methods.substring$2(t1.string, start, end); + wroteNewline = wroteNewline0; + continue; + } + if (47 === next) { + if (t1.peekChar$1(1) === 42) { + start = t1._string_scanner$_position; + t2.call$0(); + end = t1._string_scanner$_position; + buffer._contents += B.JSString_methods.substring$2(t1.string, start, end); + } else { + t4 = A.Primitives_stringFromCharCode(t1.readChar$0()); + buffer._contents += t4; + } + wroteNewline = wroteNewline0; + continue; + } + if (32 === next || 9 === next) { + if (!wroteNewline) { + t4 = t1.peekChar$1(1); + t4 = !(t4 === 32 || t4 === 9 || t4 === 10 || t4 === 13 || t4 === 12); + } else + t4 = true; + if (t4) { + t4 = A.Primitives_stringFromCharCode(32); + buffer._contents += t4; + } + t1.readChar$0(); + continue; + } + if (10 === next || 13 === next || 12 === next) { + t4 = t1.peekChar$1(-1); + if (!(t4 === 10 || t4 === 13 || t4 === 12)) + buffer._contents += "\n"; + t1.readChar$0(); + wroteNewline = true; + continue; + } + if (40 === next || 123 === next || 91 === next) { + t4 = A.Primitives_stringFromCharCode(next); + buffer._contents += t4; + brackets.push(A.opposite(t1.readChar$0())); + wroteNewline = wroteNewline0; + continue; + } + if (41 === next || 125 === next || 93 === next) { + if (brackets.length === 0) + break; + t4 = A.Primitives_stringFromCharCode(next); + buffer._contents += t4; + t1.expectChar$1(brackets.pop()); + wroteNewline = wroteNewline0; + continue; + } + if (59 === next) { + if (brackets.length === 0) + break; + t4 = A.Primitives_stringFromCharCode(t1.readChar$0()); + buffer._contents += t4; + continue; + } + if (117 === next || 85 === next) { + _0_0 = _this.tryUrl$0(); + if (_0_0 != null) + buffer._contents += _0_0; + else { + t4 = A.Primitives_stringFromCharCode(t1.readChar$0()); + buffer._contents += t4; + } + wroteNewline = wroteNewline0; + continue; + } + if (_this.lookingAtIdentifier$0()) { + t4 = _this.identifier$0(); + buffer._contents += t4; + } else { + t4 = A.Primitives_stringFromCharCode(t1.readChar$0()); + buffer._contents += t4; + } + wroteNewline = wroteNewline0; + } + if (brackets.length !== 0) + t1.expectChar$1(B.JSArray_methods.get$last(brackets)); + if (!allowEmpty && buffer._contents.length === 0) + t1.error$1(0, "Expected token."); + t1 = buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + declarationValue$0() { + return this.declarationValue$1$allowEmpty(false); + }, + tryUrl$0() { + var buffer, _0_0, t2, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + if (!_this.scanIdentifier$1("url")) + return null; + if (!t1.scanChar$1(40)) { + t1.set$state(start); + return null; + } + _this.whitespace$1$consumeNewlines(true); + buffer = new A.StringBuffer(""); + buffer._contents = "" + "url("; + for (; true;) { + _0_0 = t1.peekChar$0(); + if (_0_0 == null) + break; + if (92 === _0_0) { + t2 = _this.escape$0(); + buffer._contents += t2; + continue; + } + t2 = true; + if (37 !== _0_0) + if (38 !== _0_0) + if (35 !== _0_0) + t2 = _0_0 >= 42 && _0_0 <= 126 || _0_0 >= 128; + if (t2) { + t2 = A.Primitives_stringFromCharCode(t1.readChar$0()); + buffer._contents += t2; + continue; + } + if (_0_0 === 32 || _0_0 === 9 || _0_0 === 10 || _0_0 === 13 || _0_0 === 12) { + _this.whitespace$1$consumeNewlines(true); + if (t1.peekChar$0() !== 41) + break; + continue; + } + if (41 === _0_0) { + t2 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2 = buffer._contents += t2; + return t2.charCodeAt(0) == 0 ? t2 : t2; + } + break; + } + t1.set$state(start); + return null; + }, + variableName$0() { + this.scanner.expectChar$1(36); + return this.identifier$1$normalize(true); + }, + escape$1$identifierStart(identifierStart) { + var value, _0_0, i, next, t2, exception, + _s25_ = "Expected escape sequence.", + t1 = this.scanner, + start = t1._string_scanner$_position; + t1.expectChar$1(92); + value = 0; + $label0$1: { + _0_0 = t1.peekChar$0(); + if (_0_0 == null) + t1.error$1(0, _s25_); + if (_0_0 === 10 || _0_0 === 13 || _0_0 === 12) + t1.error$1(0, _s25_); + if (A.CharacterExtension_get_isHex(_0_0)) { + for (i = 0; i < 6; ++i) { + next = t1.peekChar$0(); + if (next != null) { + t2 = true; + if (!(next >= 48 && next <= 57)) + if (!(next >= 97 && next <= 102)) + t2 = next >= 65 && next <= 70; + t2 = !t2; + } else + t2 = true; + if (t2) + break; + value *= 16; + value += A.asHex(t1.readChar$0()); + } + this.scanCharIf$1(new A.Parser_escape_closure()); + break $label0$1; + } + value = t1.readChar$0(); + } + if (identifierStart) { + t2 = value; + t2 = t2 === 95 || A.CharacterExtension_get_isAlphabetic(t2) || t2 >= 128; + } else { + t2 = value; + if (!(t2 === 95 || A.CharacterExtension_get_isAlphabetic(t2) || t2 >= 128)) + t2 = t2 >= 48 && t2 <= 57 || t2 === 45; + else + t2 = true; + } + if (t2) + try { + t2 = A.Primitives_stringFromCharCode(value); + return t2; + } catch (exception) { + if (type$.RangeError._is(A.unwrapException(exception))) + t1.error$3$length$position(0, "Invalid Unicode code point.", t1._string_scanner$_position - start, start); + else + throw exception; + } + else { + t1 = true; + if (!(value <= 31)) + if (!J.$eq$(value, 127)) + if (identifierStart) { + t1 = value; + t1 = t1 >= 48 && t1 <= 57; + } else + t1 = false; + if (t1) { + t1 = "" + A.Primitives_stringFromCharCode(92); + if (value > 15) + t1 += A.Primitives_stringFromCharCode(A.hexCharFor(B.JSNumber_methods._shrOtherPositive$1(value, 4))); + t1 = t1 + A.Primitives_stringFromCharCode(A.hexCharFor(value & 15)) + A.Primitives_stringFromCharCode(32); + return t1.charCodeAt(0) == 0 ? t1 : t1; + } else + return A.String_String$fromCharCodes(A._setArrayType([92, value], type$.JSArray_int), 0, null); + } + }, + escape$0() { + return this.escape$1$identifierStart(false); + }, + scanCharIf$1(condition) { + var t1 = this.scanner; + if (!condition.call$1(t1.peekChar$0())) + return false; + t1.readChar$0(); + return true; + }, + scanIdentChar$2$caseSensitive(char, caseSensitive) { + var t3, + t1 = new A.Parser_scanIdentChar_matches(caseSensitive, char), + t2 = this.scanner, + _0_0 = t2.peekChar$0(); + if (_0_0 != null) { + t3 = t1.call$1(_0_0); + t3 = t3; + } else + t3 = false; + if (t3) { + t2.readChar$0(); + return true; + } + if (92 === _0_0) { + t3 = t2._string_scanner$_position; + if (t1.call$1(A.consumeEscapedCharacter(t2))) + return true; + t2.set$state(new A._SpanScannerState(t2, t3)); + } + return false; + }, + scanIdentChar$1(char) { + return this.scanIdentChar$2$caseSensitive(char, false); + }, + expectIdentChar$1(letter) { + var t1; + if (this.scanIdentChar$2$caseSensitive(letter, false)) + return; + t1 = this.scanner; + t1.error$2$position(0, 'Expected "' + A.Primitives_stringFromCharCode(letter) + '".', t1._string_scanner$_position); + }, + lookingAtIdentifier$1($forward) { + var t1, _1_0, t2, _0_0; + if ($forward == null) + $forward = 0; + t1 = this.scanner; + _1_0 = t1.peekChar$1($forward); + $label0$0: { + if (A._isInt(_1_0)) + t2 = _1_0 === 95 || A.CharacterExtension_get_isAlphabetic(_1_0) || _1_0 >= 128; + else + t2 = false; + if (t2 || 92 === _1_0) { + t1 = true; + break $label0$0; + } + if (45 === _1_0) { + _0_0 = t1.peekChar$1($forward + 1); + $label1$1: { + if (A._isInt(_0_0)) + t1 = _0_0 === 95 || A.CharacterExtension_get_isAlphabetic(_0_0) || _0_0 >= 128; + else + t1 = false; + t1 = t1 || 92 === _0_0 || 45 === _0_0; + if (t1) + break $label1$1; + break $label1$1; + } + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + lookingAtIdentifier$0() { + return this.lookingAtIdentifier$1(null); + }, + lookingAtIdentifierBody$0() { + var t1, + next = this.scanner.peekChar$0(); + if (next != null) { + if (!(next === 95 || A.CharacterExtension_get_isAlphabetic(next) || next >= 128)) + t1 = next >= 48 && next <= 57 || next === 45; + else + t1 = true; + t1 = t1 || next === 92; + } else + t1 = false; + return t1; + }, + scanIdentifier$2$caseSensitive(text, caseSensitive) { + var t1, t2, _this = this; + if (!_this.lookingAtIdentifier$0()) + return false; + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + if (_this._consumeIdentifier$2(text, caseSensitive) && !_this.lookingAtIdentifierBody$0()) + return true; + else { + t1.set$state(new A._SpanScannerState(t1, t2)); + return false; + } + }, + scanIdentifier$1(text) { + return this.scanIdentifier$2$caseSensitive(text, false); + }, + _consumeIdentifier$2(text, caseSensitive) { + var t1, t2, t3; + for (t1 = new A.CodeUnits(text), t2 = type$.CodeUnits, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t3 = t1.__internal$_current; + if (!this.scanIdentChar$2$caseSensitive(t3 == null ? t2._as(t3) : t3, caseSensitive)) + return false; + } + return true; + }, + expectIdentifier$2$name(text, $name) { + var t1, start, t2, t3, t4, t5, t6; + if ($name == null) + $name = '"' + text + '"'; + t1 = this.scanner; + start = t1._string_scanner$_position; + for (t2 = new A.CodeUnits(text), t3 = type$.CodeUnits, t2 = new A.ListIterator(t2, t2.get$length(0), t3._eval$1("ListIterator")), t4 = "Expected " + $name, t5 = t4 + ".", t3 = t3._eval$1("ListBase.E"); t2.moveNext$0();) { + t6 = t2.__internal$_current; + if (this.scanIdentChar$2$caseSensitive(t6 == null ? t3._as(t6) : t6, false)) + continue; + t1.error$2$position(0, t5, start); + } + if (!this.lookingAtIdentifierBody$0()) + return; + t1.error$2$position(0, t4, start); + }, + expectIdentifier$1(text) { + return this.expectIdentifier$2$name(text, null); + }, + rawText$1(consumer) { + var t1 = this.scanner, + start = t1._string_scanner$_position; + consumer.call$0(); + return t1.substring$1(0, start); + }, + spanFrom$1(state) { + var span = this.scanner.spanFrom$1(state); + return this._interpolationMap == null ? span : new A.LazyFileSpan(new A.Parser_spanFrom_closure(this, span)); + }, + error$3(_, message, span, trace) { + var exception = new A.StringScannerException(this.scanner.string, message, span); + if (trace == null) + throw A.wrapException(exception); + else + A.throwWithTrace(exception, this.get$error(this), trace); + }, + error$2(_, message, span) { + return this.error$3(0, message, span, null); + }, + withErrorMessage$1$2(message, callback) { + var error, stackTrace, t1, exception; + try { + t1 = callback.call$0(); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.SourceSpanFormatException._is(t1)) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = J.get$span$z(error); + A.throwWithTrace(new A.SourceSpanFormatException(error.get$source(), message, t1), error, stackTrace); + } else + throw exception; + } + }, + withErrorMessage$2(message, callback) { + return this.withErrorMessage$1$2(message, callback, type$.dynamic); + }, + wrapSpanFormatException$1$1(callback) { + var error, stackTrace, map, error0, stackTrace0, span, secondarySpans, t1, t2, span0, description, _0_0, error1, stackTrace1, span1, t3, exception, t4, _this = this, + _s8_ = "expected"; + try { + try { + t3 = callback.call$0(); + return t3; + } catch (exception) { + t3 = A.unwrapException(exception); + if (type$.SourceSpanFormatException._is(t3)) { + error = t3; + stackTrace = A.getTraceFromException(exception); + map = _this._interpolationMap; + if (map == null) + throw exception; + A.throwWithTrace(map.mapException$1(error), error, stackTrace); + } else + throw exception; + } + } catch (exception) { + t3 = A.unwrapException(exception); + if (type$.MultiSourceSpanFormatException._is(t3)) { + error0 = t3; + stackTrace0 = A.getTraceFromException(exception); + span = J.get$span$z(error0); + t3 = type$.FileSpan; + t4 = type$.String; + secondarySpans = error0.get$secondarySpans().cast$2$0(0, t3, t4); + if (A.startsWithIgnoreCase(error0._span_exception$_message, _s8_)) { + span = _this._adjustExceptionSpan$1(span); + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t3, t4); + for (t3 = A.MapExtensions_get_pairs(secondarySpans, t3, t4), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t2 = t3.get$current(t3); + span0 = null; + description = null; + _0_0 = t2; + span0 = _0_0._0; + description = _0_0._1; + J.$indexSet$ax(t1, _this._adjustExceptionSpan$1(span0), description); + } + secondarySpans = t1; + } + A.throwWithTrace(A.MultiSpanSassFormatException$(error0._span_exception$_message, span, error0.get$primaryLabel(), secondarySpans, null), error0, stackTrace0); + } else if (type$.SourceSpanFormatException._is(t3)) { + error1 = t3; + stackTrace1 = A.getTraceFromException(exception); + span1 = J.get$span$z(error1); + if (A.startsWithIgnoreCase(error1._span_exception$_message, _s8_)) + span1 = _this._adjustExceptionSpan$1(span1); + t1 = error1._span_exception$_message; + t2 = span1; + A.throwWithTrace(new A.SassFormatException(B.Set_empty, t1, t2), error1, stackTrace1); + } else + throw exception; + } + }, + wrapSpanFormatException$1(callback) { + return this.wrapSpanFormatException$1$1(callback, type$.dynamic); + }, + _adjustExceptionSpan$1(span) { + var start, t1; + if (span.get$length(span) > 0) + return span; + start = this._firstNewlineBefore$1(span.get$start(span)); + if (start.$eq(0, span.get$start(span))) + t1 = span; + else { + t1 = start.offset; + t1 = A._FileSpan$(start.file, t1, t1); + } + return t1; + }, + _firstNewlineBefore$1($location) { + var lastNewline, codeUnit, + t1 = $location.file, + t2 = $location.offset, + text = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1._decodedChars, 0, t2), 0, null), + index = t2 - 1; + for (lastNewline = null; index >= 0;) { + codeUnit = text.charCodeAt(index); + if (!(codeUnit === 32 || codeUnit === 9 || codeUnit === 10 || codeUnit === 13 || codeUnit === 12)) { + if (lastNewline == null) + t1 = $location; + else { + t2 = new A.FileLocation(t1, lastNewline); + t2.FileLocation$_$2(t1, lastNewline); + t1 = t2; + } + return t1; + } + if (codeUnit === 10 || codeUnit === 13 || codeUnit === 12) + lastNewline = index; + --index; + } + return $location; + } + }; + A.Parser__parseIdentifier_closure.prototype = { + call$0() { + var t1 = this.$this, + result = t1.identifier$0(); + t1.scanner.expectDone$0(); + return result; + }, + $signature: 26 + }; + A.Parser_escape_closure.prototype = { + call$1(char) { + return char === 32 || char === 9 || char === 10 || char === 13 || char === 12; + }, + $signature: 30 + }; + A.Parser_scanIdentChar_matches.prototype = { + call$1(actual) { + var t1 = this.char; + return this.caseSensitive ? actual === t1 : A.characterEqualsIgnoreCase(t1, actual); + }, + $signature: 48 + }; + A.Parser_spanFrom_closure.prototype = { + call$0() { + var t1 = this.$this._interpolationMap; + if (t1 == null) + t1 = type$.InterpolationMap._as(t1); + return t1.mapSpan$1(this.span); + }, + $signature: 29 + }; + A.SassParser.prototype = { + get$currentIndentation() { + return this._currentIndentation; + }, + get$indented() { + return true; + }, + styleRuleSelector$0() { + var t4, + t1 = this.scanner, + t2 = t1._string_scanner$_position, + t3 = new A.StringBuffer(""), + buffer = new A.InterpolationBuffer(t3, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + do { + buffer.addInterpolation$1(this.almostAnyValue$1$omitComments(true)); + t4 = A.Primitives_stringFromCharCode(10); + t4 = t3._contents += t4; + } while (B.JSString_methods.endsWith$1(B.JSString_methods.trimRight$0(t4.charCodeAt(0) == 0 ? t4 : t4), ",") && this.scanCharIf$1(new A.SassParser_styleRuleSelector_closure())); + return buffer.interpolation$1(t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + expectStatementSeparator$1($name) { + var t1, _this = this, + trailingSemicolon = _this._tryTrailingSemicolon$0(); + if (!_this.atEndOfStatement$0()) + _this._expectNewline$1$trailingSemicolon(trailingSemicolon); + if (_this._peekIndentation$0() <= _this._currentIndentation) + return; + t1 = $name == null ? "here" : "beneath a " + $name; + _this.scanner.error$2$position(0, "Nothing may be indented " + t1 + ".", _this._nextIndentationEnd.position); + }, + expectStatementSeparator$0() { + return this.expectStatementSeparator$1(null); + }, + atEndOfStatement$0() { + var t1 = this.scanner.peekChar$0(); + if (t1 == null) + t1 = null; + else + t1 = t1 === 10 || t1 === 13 || t1 === 12; + return t1 !== false; + }, + lookingAtChildren$0() { + return this.atEndOfStatement$0() && this._peekIndentation$0() > this._currentIndentation; + }, + importArgument$0() { + var url, span, innerError, stackTrace, t1, _0_0, start, next, t2, exception, _this = this; + $label0$0: { + t1 = _this.scanner; + _0_0 = t1.peekChar$0(); + if (117 === _0_0 || 85 === _0_0) { + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + if (_this.scanIdentifier$1("url")) + if (t1.scanChar$1(40)) { + t1.set$state(start); + return _this.super$StylesheetParser$importArgument(); + } else + t1.set$state(start); + break $label0$0; + } + if (39 === _0_0 || 34 === _0_0) + return _this.super$StylesheetParser$importArgument(); + } + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + next = t1.peekChar$0(); + while (true) { + t2 = false; + if (next != null) + if (next !== 44) + if (next !== 59) + t2 = !(next === 10 || next === 13 || next === 12); + if (!t2) + break; + t1.readChar$0(); + next = t1.peekChar$0(); + } + url = t1.substring$1(0, start.position); + span = t1.spanFrom$1(start); + if (_this.isPlainImportUrl$1(url)) + return new A.StaticImport(new A.Interpolation(A.List_List$unmodifiable([A.serializeValue(new A.SassString(url, true), true, true)], type$.Object), B.List_null, span), null, span); + else + try { + t1 = _this.parseImportUrl$1(url); + return new A.DynamicImport(t1, span); + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.FormatException._is(t1)) { + innerError = t1; + stackTrace = A.getTraceFromException(exception); + _this.error$3(0, "Invalid URL: " + J.get$message$x(innerError), span, stackTrace); + } else + throw exception; + } + }, + scanElse$1(ifIndentation) { + var t1, t2, startIndentation, startNextIndentation, startNextIndentationEnd, _this = this; + if (_this._peekIndentation$0() !== ifIndentation) + return false; + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + startIndentation = _this._currentIndentation; + startNextIndentation = _this._nextIndentation; + startNextIndentationEnd = _this._nextIndentationEnd; + _this._readIndentation$0(); + if (t1.scanChar$1(64) && _this.scanIdentifier$1("else")) + return true; + t1.set$state(new A._SpanScannerState(t1, t2)); + _this._currentIndentation = startIndentation; + _this._nextIndentation = startNextIndentation; + _this._nextIndentationEnd = startNextIndentationEnd; + return false; + }, + children$1(_, child) { + var children = A._setArrayType([], type$.JSArray_Statement); + this._whileIndentedLower$1(new A.SassParser_children_closure(this, child, children)); + return children; + }, + statements$1(statement) { + var statements, t2, _1_0, + t1 = this.scanner, + _0_0 = t1.peekChar$0(); + if (9 === _0_0 || 32 === _0_0) + t1.error$3$length$position(0, string$.Indent, t1._string_scanner$_position, 0); + statements = A._setArrayType([], type$.JSArray_Statement); + for (t2 = t1.string.length; t1._string_scanner$_position !== t2;) { + _1_0 = this._child$1(statement); + if (_1_0 != null) + statements.push(_1_0); + this._readIndentation$0(); + } + return statements; + }, + _child$1(child) { + var _0_0, _this = this, + t1 = _this.scanner, + _1_0 = t1.peekChar$0(); + $label0$0: { + if (13 === _1_0 || 10 === _1_0 || 12 === _1_0) { + t1 = null; + break $label0$0; + } + if (36 === _1_0) { + t1 = _this.variableDeclarationWithoutNamespace$0(); + break $label0$0; + } + if (47 === _1_0) { + _0_0 = t1.peekChar$1(1); + $label1$1: { + if (47 === _0_0) { + t1 = _this._silentComment$0(); + break $label1$1; + } + if (42 === _0_0) { + t1 = _this._loudComment$0(); + break $label1$1; + } + t1 = child.call$0(); + break $label1$1; + } + break $label0$0; + } + t1 = child.call$0(); + break $label0$0; + } + return t1; + }, + _silentComment$0() { + var buffer, parentIndentation, t3, t4, t5, commentPrefix, i, t6, i0, t7, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position; + t1.expect$1("//"); + buffer = new A.StringBuffer(""); + parentIndentation = _this._currentIndentation; + t3 = t1.string.length; + t4 = 1 + parentIndentation; + t5 = 2 + parentIndentation; + $label0$0: + do { + commentPrefix = t1.scanChar$1(47) ? "///" : "//"; + for (i = commentPrefix.length; true;) { + t6 = buffer._contents += commentPrefix; + for (i0 = i; i0 < _this._currentIndentation - parentIndentation; ++i0) { + t6 += A.Primitives_stringFromCharCode(32); + buffer._contents = t6; + } + while (true) { + if (t1._string_scanner$_position !== t3) { + t7 = t1.peekChar$0(); + t7 = !(t7 === 10 || t7 === 13 || t7 === 12); + } else + t7 = false; + if (!t7) + break; + t6 += A.Primitives_stringFromCharCode(t1.readChar$0()); + buffer._contents = t6; + } + buffer._contents = t6 + "\n"; + if (_this._peekIndentation$0() < parentIndentation) + break $label0$0; + if (_this._peekIndentation$0() === parentIndentation) { + if (t1.peekChar$1(t4) === 47 && t1.peekChar$1(t5) === 47) + _this._readIndentation$0(); + break; + } + _this._readIndentation$0(); + } + } while (t1.scan$1("//")); + t3 = buffer._contents; + return _this.lastSilentComment = new A.SilentComment(t3.charCodeAt(0) == 0 ? t3 : t3, t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + _loudComment$0() { + var t2, t3, t4, buffer, parentIndentation, t5, t6, first, beginningOfComment, t7, end, i, _1_0, _0_0, endPosition, span, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expect$1("/*"); + t2 = new A.StringBuffer(""); + t3 = A._setArrayType([], type$.JSArray_Object); + t4 = A._setArrayType([], type$.JSArray_nullable_FileSpan); + buffer = new A.InterpolationBuffer(t2, t3, t4); + t2._contents = "" + "/*"; + parentIndentation = _this._currentIndentation; + for (t5 = t1.string, t6 = t5.length, first = true; true; first = false) { + if (first) { + beginningOfComment = t1._string_scanner$_position; + _this.spaces$0(); + t7 = t1.peekChar$0(); + if (t7 === 10 || t7 === 13 || t7 === 12) { + _this._readIndentation$0(); + t7 = A.Primitives_stringFromCharCode(32); + t2._contents += t7; + } else { + end = t1._string_scanner$_position; + t2._contents += B.JSString_methods.substring$2(t5, beginningOfComment, end); + } + } else { + t7 = t2._contents += "\n"; + t2._contents = t7 + " * "; + } + for (i = 3; i < _this._currentIndentation - parentIndentation; ++i) { + t7 = A.Primitives_stringFromCharCode(32); + t2._contents += t7; + } + for (; t1._string_scanner$_position !== t6;) { + _1_0 = t1.peekChar$0(); + if (10 === _1_0 || 13 === _1_0 || 12 === _1_0) + break; + if (35 === _1_0) { + if (t1.peekChar$1(1) === 123) { + _0_0 = _this.singleInterpolation$0(); + buffer._flushText$0(); + t3.push(_0_0._0); + t4.push(_0_0._1); + } else { + t7 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t7; + } + continue; + } + if (42 === _1_0) { + if (t1.peekChar$1(1) === 47) { + t3 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t3; + t3 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t3; + endPosition = t1._string_scanner$_position; + t2 = t1._sourceFile; + t3 = start.position; + span = new A._FileSpan(t2, t3, endPosition); + span._FileSpan$3(t2, t3, endPosition); + _this.whitespace$1$consumeNewlines(false); + while (true) { + t2 = t1.peekChar$0(); + if (!((t2 === 10 || t2 === 13 || t2 === 12) && _this._peekIndentation$0() > parentIndentation)) + break; + for (; _this._lookingAtDoubleNewline$0();) + _this._expectNewline$0(); + _this._readIndentation$0(); + _this.whitespace$1$consumeNewlines(false); + } + if (t1._string_scanner$_position !== t6) { + t2 = t1.peekChar$0(); + t2 = !(t2 === 10 || t2 === 13 || t2 === 12); + } else + t2 = false; + if (t2) { + t2 = t1._string_scanner$_position; + while (true) { + if (t1._string_scanner$_position !== t6) { + t3 = t1.peekChar$0(); + t3 = !(t3 === 10 || t3 === 13 || t3 === 12); + } else + t3 = false; + if (!t3) + break; + t1.readChar$0(); + } + throw A.wrapException(A.MultiSpanSassFormatException$("Unexpected text after end of comment", t1.spanFrom$1(new A._SpanScannerState(t1, t2)), "extra text", A.LinkedHashMap_LinkedHashMap$_literal([span, "comment"], type$.FileSpan, type$.String), null)); + } else + return new A.LoudComment(buffer.interpolation$1(span)); + } else { + t7 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t7; + } + continue; + } + t7 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t7; + } + if (_this._peekIndentation$0() <= parentIndentation) + break; + for (; _this._lookingAtDoubleNewline$0();) { + _this._expectNewline$0(); + t7 = t2._contents += "\n"; + t2._contents = t7 + " *"; + } + _this._readIndentation$0(); + } + return new A.LoudComment(buffer.interpolation$1(t1.spanFrom$1(start))); + }, + whitespaceWithoutComments$1$consumeNewlines(consumeNewlines) { + var t1, t2, next, t3; + for (t1 = this.scanner, t2 = t1.string.length; t1._string_scanner$_position !== t2;) { + next = t1.peekChar$0(); + if (consumeNewlines) + t3 = !(next === 32 || next === 9 || next === 10 || next === 13 || next === 12); + else + t3 = !(next === 32 || next === 9); + if (t3) + break; + t1.readChar$0(); + } + }, + _expectNewline$1$trailingSemicolon(trailingSemicolon) { + var t1 = this.scanner, + _0_0 = t1.peekChar$0(); + if (13 === _0_0) { + t1.readChar$0(); + if (t1.peekChar$0() === 10) + t1.readChar$0(); + return; + } + if (10 === _0_0 || 12 === _0_0) { + t1.readChar$0(); + return; + } + t1.error$1(0, trailingSemicolon ? string$.multip : "expected newline."); + }, + _expectNewline$0() { + return this._expectNewline$1$trailingSemicolon(false); + }, + _lookingAtDoubleNewline$0() { + var t2, _0_0, + t1 = this.scanner, + _1_0 = t1.peekChar$0(); + $label1$1: { + t2 = false; + if (13 === _1_0) { + _0_0 = t1.peekChar$1(1); + $label0$0: { + if (10 === _0_0) { + t1 = t1.peekChar$1(2); + t1 = t1 === 10 || t1 === 13 || t1 === 12; + break $label0$0; + } + if (13 === _0_0 || 12 === _0_0) { + t1 = true; + break $label0$0; + } + t1 = t2; + break $label0$0; + } + break $label1$1; + } + if (10 === _1_0 || 12 === _1_0) { + t1 = t1.peekChar$1(1); + t1 = t1 === 10 || t1 === 13 || t1 === 12; + break $label1$1; + } + t1 = t2; + break $label1$1; + } + return t1; + }, + _whileIndentedLower$1(body) { + var t1, t2, childIndentation, indentation, t3, t4, _this = this, + parentIndentation = _this._currentIndentation; + for (t1 = _this.scanner, t2 = t1._sourceFile, childIndentation = null; _this._peekIndentation$0() > parentIndentation;) { + indentation = _this._readIndentation$0(); + if (childIndentation == null) + childIndentation = indentation; + if (childIndentation !== indentation) { + t3 = t1._string_scanner$_position; + t4 = t2.getColumn$1(t3); + t1.error$3$length$position(0, "Inconsistent indentation, expected " + childIndentation + " spaces.", t2.getColumn$1(t1._string_scanner$_position), t3 - t4); + } + body.call$0(); + } + }, + _readIndentation$0() { + var t1, _this = this, + currentIndentation = _this._nextIndentation; + if (currentIndentation == null) + currentIndentation = _this._nextIndentation = _this._peekIndentation$0(); + _this._currentIndentation = currentIndentation; + t1 = _this._nextIndentationEnd; + t1.toString; + _this.scanner.set$state(t1); + _this._nextIndentationEnd = _this._nextIndentation = null; + return currentIndentation; + }, + _peekIndentation$0() { + var t1, t2, t3, start, containsTab, containsSpace, nextIndentation, _1_0, t4, _this = this, + _0_0 = _this._nextIndentation; + if (_0_0 != null) + return _0_0; + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + t3 = t1.string.length; + if (t2 === t3) { + _this._nextIndentation = 0; + _this._nextIndentationEnd = new A._SpanScannerState(t1, t2); + return 0; + } + start = new A._SpanScannerState(t1, t2); + if (!_this.scanCharIf$1(new A.SassParser__peekIndentation_closure())) + t1.error$2$position(0, "Expected newline.", t1._string_scanner$_position); + containsTab = A._Cell$(); + containsSpace = A._Cell$(); + nextIndentation = A._Cell$(); + do { + containsSpace.__late_helper$_value = containsTab.__late_helper$_value = false; + nextIndentation.__late_helper$_value = 0; + for (; true;) { + $label0$0: { + _1_0 = t1.peekChar$0(); + if (32 === _1_0) { + containsSpace.__late_helper$_value = true; + break $label0$0; + } + if (9 === _1_0) { + containsTab.__late_helper$_value = true; + break $label0$0; + } + break; + } + t2 = nextIndentation.__late_helper$_value; + if (t2 === nextIndentation) + A.throwExpression(A.LateError$localNI("")); + nextIndentation.__late_helper$_value = t2 + 1; + t1.readChar$0(); + } + t2 = t1._string_scanner$_position; + if (t2 === t3) { + _this._nextIndentation = 0; + _this._nextIndentationEnd = new A._SpanScannerState(t1, t2); + t1.set$state(start); + return 0; + } + } while (_this.scanCharIf$1(new A.SassParser__peekIndentation_closure0())); + t2 = containsTab._readLocal$0(); + t3 = containsSpace._readLocal$0(); + if (t2) { + if (t3) { + t2 = t1._string_scanner$_position; + t3 = t1._sourceFile; + t4 = t3.getColumn$1(t2); + t1.error$3$length$position(0, "Tabs and spaces may not be mixed.", t3.getColumn$1(t1._string_scanner$_position), t2 - t4); + } else if (_this._spaces === true) { + t2 = t1._string_scanner$_position; + t3 = t1._sourceFile; + t4 = t3.getColumn$1(t2); + t1.error$3$length$position(0, "Expected spaces, was tabs.", t3.getColumn$1(t1._string_scanner$_position), t2 - t4); + } + } else if (t3 && _this._spaces === false) { + t2 = t1._string_scanner$_position; + t3 = t1._sourceFile; + t4 = t3.getColumn$1(t2); + t1.error$3$length$position(0, "Expected tabs, was spaces.", t3.getColumn$1(t1._string_scanner$_position), t2 - t4); + } + _this._nextIndentation = nextIndentation._readLocal$0(); + if (nextIndentation._readLocal$0() > 0) + if (_this._spaces == null) + _this._spaces = containsSpace._readLocal$0(); + _this._nextIndentationEnd = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.set$state(start); + return nextIndentation._readLocal$0(); + }, + _tryTrailingSemicolon$0() { + if (this.scanCharIf$1(new A.SassParser__tryTrailingSemicolon_closure())) { + this.whitespace$1$consumeNewlines(false); + return true; + } + return false; + } + }; + A.SassParser_styleRuleSelector_closure.prototype = { + call$1(char) { + return char === 10 || char === 13 || char === 12; + }, + $signature: 30 + }; + A.SassParser_children_closure.prototype = { + call$0() { + var _0_0 = this.$this._child$1(this.child); + if (_0_0 != null) + this.children.push(_0_0); + }, + $signature: 0 + }; + A.SassParser__peekIndentation_closure.prototype = { + call$1(char) { + return char === 10 || char === 13 || char === 12; + }, + $signature: 30 + }; + A.SassParser__peekIndentation_closure0.prototype = { + call$1(char) { + return char === 10 || char === 13 || char === 12; + }, + $signature: 30 + }; + A.SassParser__tryTrailingSemicolon_closure.prototype = { + call$1(char) { + return char === 59; + }, + $signature: 30 + }; + A.ScssParser.prototype = { + get$indented() { + return false; + }, + get$currentIndentation() { + return 0; + }, + styleRuleSelector$0() { + return this.almostAnyValue$0(); + }, + expectStatementSeparator$1($name) { + var t1, _0_0; + this.whitespaceWithoutComments$1$consumeNewlines(true); + t1 = this.scanner; + if (t1._string_scanner$_position === t1.string.length) + return; + _0_0 = t1.peekChar$0(); + if (59 === _0_0 || 125 === _0_0) + return; + t1.expectChar$1(59); + }, + expectStatementSeparator$0() { + return this.expectStatementSeparator$1(null); + }, + atEndOfStatement$0() { + var next = this.scanner.peekChar$0(); + return next == null || next === 59 || next === 125 || next === 123; + }, + lookingAtChildren$0() { + return this.scanner.peekChar$0() === 123; + }, + scanElse$1(ifIndentation) { + var t3, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position; + _this.whitespace$1$consumeNewlines(true); + t3 = t1._string_scanner$_position; + if (t1.scanChar$1(64)) { + if (_this.scanIdentifier$2$caseSensitive("else", true)) + return true; + if (_this.scanIdentifier$2$caseSensitive("elseif", true)) { + _this.warnings.push(new A._Record_3_deprecation_message_span(B.Deprecation_hAa, string$.x40elsei, t1.spanFrom$1(new A._SpanScannerState(t1, t3)))); + t1.set$position(t1._string_scanner$_position - 2); + return true; + } + } + t1.set$state(new A._SpanScannerState(t1, t2)); + return false; + }, + children$1(_, child) { + var children, _this = this, + t1 = _this.scanner; + t1.expectChar$1(123); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + children = A._setArrayType([], type$.JSArray_Statement); + for (; true;) + switch (t1.peekChar$0()) { + case 36: + children.push(_this.variableDeclarationWithoutNamespace$0()); + break; + case 47: + switch (t1.peekChar$1(1)) { + case 47: + children.push(_this._scss$_silentComment$0()); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + break; + case 42: + children.push(_this._scss$_loudComment$0()); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + break; + default: + children.push(child.call$0()); + } + break; + case 59: + t1.readChar$0(); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + break; + case 125: + t1.expectChar$1(125); + return children; + default: + children.push(child.call$0()); + } + }, + statements$1(statement) { + var t1, t2, _0_0, _1_0, _this = this, + statements = A._setArrayType([], type$.JSArray_Statement); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + for (t1 = _this.scanner, t2 = t1.string.length; t1._string_scanner$_position !== t2;) + switch (t1.peekChar$0()) { + case 36: + statements.push(_this.variableDeclarationWithoutNamespace$0()); + break; + case 47: + switch (t1.peekChar$1(1)) { + case 47: + statements.push(_this._scss$_silentComment$0()); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + break; + case 42: + statements.push(_this._scss$_loudComment$0()); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + break; + default: + _0_0 = statement.call$0(); + if (_0_0 != null) + statements.push(_0_0); + } + break; + case 59: + t1.readChar$0(); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + break; + default: + _1_0 = statement.call$0(); + if (_1_0 != null) + statements.push(_1_0); + } + return statements; + }, + _scss$_silentComment$0() { + var t2, t3, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expect$1("//"); + t2 = t1.string.length; + do { + while (true) { + if (t1._string_scanner$_position !== t2) { + t3 = t1.readChar$0(); + t3 = !(t3 === 10 || t3 === 13 || t3 === 12); + } else + t3 = false; + if (!t3) + break; + } + if (t1._string_scanner$_position === t2) + break; + _this.spaces$0(); + } while (t1.scan$1("//")); + if (_this.get$plainCss()) + _this.error$2(0, string$.Silent, t1.spanFrom$1(start)); + return _this.lastSilentComment = new A.SilentComment(t1.substring$1(0, start.position), t1.spanFrom$1(start)); + }, + _scss$_loudComment$0() { + var t3, t4, t5, buffer, _0_0, t6, endPosition, + t1 = this.scanner, + t2 = t1._string_scanner$_position; + t1.expect$1("/*"); + t3 = new A.StringBuffer(""); + t4 = A._setArrayType([], type$.JSArray_Object); + t5 = A._setArrayType([], type$.JSArray_nullable_FileSpan); + buffer = new A.InterpolationBuffer(t3, t4, t5); + t3._contents = "" + "/*"; + $label0$1: + for (; true;) + switch (t1.peekChar$0()) { + case 35: + if (t1.peekChar$1(1) === 123) { + _0_0 = this.singleInterpolation$0(); + buffer._flushText$0(); + t4.push(_0_0._0); + t5.push(_0_0._1); + } else { + t6 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t6; + } + break; + case 42: + t6 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t6; + if (t1.peekChar$0() !== 47) + continue $label0$1; + t4 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t4; + endPosition = t1._string_scanner$_position; + t3 = t1._sourceFile; + t4 = new A._SpanScannerState(t1, t2).position; + t1 = new A._FileSpan(t3, t4, endPosition); + t1._FileSpan$3(t3, t4, endPosition); + return new A.LoudComment(buffer.interpolation$1(t1)); + case 13: + t1.readChar$0(); + if (t1.peekChar$0() !== 10) { + t6 = A.Primitives_stringFromCharCode(10); + t3._contents += t6; + } + break; + case 12: + t1.readChar$0(); + t6 = A.Primitives_stringFromCharCode(10); + t3._contents += t6; + break; + default: + t6 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t6; + } + } + }; + A.SelectorParser.prototype = { + parse$0(_) { + return this.wrapSpanFormatException$1(new A.SelectorParser_parse_closure(this)); + }, + parseCompoundSelector$0() { + return this.wrapSpanFormatException$1(new A.SelectorParser_parseCompoundSelector_closure(this)); + }, + _selectorList$0() { + var t4, t5, lineBreak, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + t3 = t1._sourceFile, + previousLine = t3.getLine$1(t2), + components = A._setArrayType([_this._complexSelector$0()], type$.JSArray_ComplexSelector); + _this.whitespace$1$consumeNewlines(true); + for (t4 = t1.string.length; t1.scanChar$1(44);) { + _this.whitespace$1$consumeNewlines(true); + if (t1.peekChar$0() === 44) + continue; + t5 = t1._string_scanner$_position; + if (t5 === t4) + break; + lineBreak = t3.getLine$1(t5) !== previousLine; + if (lineBreak) + previousLine = t3.getLine$1(t1._string_scanner$_position); + components.push(_this._complexSelector$1$lineBreak(lineBreak)); + } + return A.SelectorList$(components, _this.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + _complexSelector$1$lineBreak(lineBreak) { + var t4, lastCompound, initialCombinators, _0_0, t5, result, _this = this, + _s18_ = "expected selector.", + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + componentStart = new A._SpanScannerState(t1, t2), + t3 = type$.JSArray_CssValue_Combinator, + combinators = A._setArrayType([], t3), + components = A._setArrayType([], type$.JSArray_ComplexSelectorComponent); + for (t4 = type$.CssValue_Combinator, lastCompound = null, initialCombinators = null; true;) { + _this.whitespace$1$consumeNewlines(true); + _0_0 = t1.peekChar$0(); + if (43 === _0_0) { + t5 = t1._string_scanner$_position; + t1.readChar$0(); + combinators.push(new A.CssValue(B.Combinator_bOP, _this.spanFrom$1(new A._SpanScannerState(t1, t5)), t4)); + continue; + } + if (62 === _0_0) { + t5 = t1._string_scanner$_position; + t1.readChar$0(); + combinators.push(new A.CssValue(B.Combinator_0mp, _this.spanFrom$1(new A._SpanScannerState(t1, t5)), t4)); + continue; + } + if (126 === _0_0) { + t5 = t1._string_scanner$_position; + t1.readChar$0(); + combinators.push(new A.CssValue(B.Combinator_55N, _this.spanFrom$1(new A._SpanScannerState(t1, t5)), t4)); + continue; + } + if (_0_0 == null) + break; + t5 = true; + if (91 !== _0_0) + if (46 !== _0_0) + if (35 !== _0_0) + if (37 !== _0_0) + if (58 !== _0_0) + if (38 !== _0_0) + if (42 !== _0_0) + if (124 !== _0_0) + t5 = _this.lookingAtIdentifier$0(); + if (t5) { + if (lastCompound != null) { + t5 = _this.spanFrom$1(componentStart); + result = A.List_List$from(combinators, false, t4); + result.$flags = 3; + components.push(new A.ComplexSelectorComponent(lastCompound, result, t5)); + } else if (combinators.length !== 0) { + componentStart = new A._SpanScannerState(t1, t1._string_scanner$_position); + initialCombinators = combinators; + } + lastCompound = _this._compoundSelector$0(); + combinators = A._setArrayType([], t3); + if (t1.peekChar$0() === 38) + t1.error$1(0, string$.x22x26__ma); + continue; + } + break; + } + t3 = combinators.length !== 0; + if (t3 && _this._plainCss) + t1.error$1(0, _s18_); + else if (lastCompound != null) { + t3 = _this.spanFrom$1(componentStart); + components.push(new A.ComplexSelectorComponent(lastCompound, A.List_List$unmodifiable(combinators, t4), t3)); + } else if (t3) + initialCombinators = combinators; + else + t1.error$1(0, _s18_); + t3 = initialCombinators == null ? B.List_empty0 : initialCombinators; + return A.ComplexSelector$(t3, components, _this.spanFrom$1(new A._SpanScannerState(t1, t2)), lineBreak); + }, + _complexSelector$0() { + return this._complexSelector$1$lineBreak(false); + }, + _compoundSelector$0() { + var t3, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + components = A._setArrayType([_this._simpleSelector$0()], type$.JSArray_SimpleSelector); + for (t3 = _this._plainCss; _this._isSimpleSelectorStart$1(t1.peekChar$0());) + components.push(_this._simpleSelector$1$allowParent(t3)); + return A.CompoundSelector$(components, _this.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + _simpleSelector$1$allowParent(allowParent) { + var t2, $name, text, t3, suffix, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + if (allowParent == null) + allowParent = _this._allowParent; + switch (t1.peekChar$0()) { + case 91: + return _this._attributeSelector$0(); + case 46: + t2 = t1._string_scanner$_position; + t1.expectChar$1(46); + return new A.ClassSelector(_this.identifier$0(), _this.spanFrom$1(new A._SpanScannerState(t1, t2))); + case 35: + t2 = t1._string_scanner$_position; + t1.expectChar$1(35); + return new A.IDSelector(_this.identifier$0(), _this.spanFrom$1(new A._SpanScannerState(t1, t2))); + case 37: + t2 = t1._string_scanner$_position; + t1.expectChar$1(37); + $name = _this.identifier$0(); + t2 = _this.spanFrom$1(new A._SpanScannerState(t1, t2)); + if (_this._plainCss) + _this.error$2(0, string$.Placeh, t1.spanFrom$1(start)); + return new A.PlaceholderSelector($name, t2); + case 58: + return _this._pseudoSelector$0(); + case 38: + t2 = t1._string_scanner$_position; + t1.expectChar$1(38); + if (_this.lookingAtIdentifierBody$0()) { + text = new A.StringBuffer(""); + _this._identifierBody$1(text); + if (text._contents.length === 0) + t1.error$1(0, "Expected identifier body."); + t3 = text._contents; + suffix = t3.charCodeAt(0) == 0 ? t3 : t3; + } else + suffix = null; + if (_this._plainCss && suffix != null) + t1.error$3$length$position(0, string$.Parent, t1._string_scanner$_position - t2, t2); + t2 = _this.spanFrom$1(new A._SpanScannerState(t1, t2)); + if (!allowParent) + _this.error$2(0, "Parent selectors aren't allowed here.", t1.spanFrom$1(start)); + return new A.ParentSelector(suffix, t2); + default: + return _this._typeOrUniversalSelector$0(); + } + }, + _simpleSelector$0() { + return this._simpleSelector$1$allowParent(null); + }, + _attributeSelector$0() { + var $name, operator, next, value, modifier, _this = this, _null = null, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expectChar$1(91); + _this.whitespace$1$consumeNewlines(true); + $name = _this._attributeName$0(); + _this.whitespace$1$consumeNewlines(true); + if (t1.scanChar$1(93)) + return new A.AttributeSelector($name, _null, _null, _null, _this.spanFrom$1(start)); + operator = _this._attributeOperator$0(); + _this.whitespace$1$consumeNewlines(true); + next = t1.peekChar$0(); + value = next === 39 || next === 34 ? _this.string$0() : _this.identifier$0(); + _this.whitespace$1$consumeNewlines(true); + next = t1.peekChar$0(); + modifier = next != null && A.CharacterExtension_get_isAlphabetic(next) ? A.Primitives_stringFromCharCode(t1.readChar$0()) : _null; + t1.expectChar$1(93); + return new A.AttributeSelector($name, operator, value, modifier, _this.spanFrom$1(start)); + }, + _attributeName$0() { + var nameOrNamespace, _this = this, + t1 = _this.scanner; + if (t1.scanChar$1(42)) { + t1.expectChar$1(124); + return new A.QualifiedName(_this.identifier$0(), "*"); + } + if (t1.scanChar$1(124)) + return new A.QualifiedName(_this.identifier$0(), ""); + nameOrNamespace = _this.identifier$0(); + if (t1.peekChar$0() !== 124 || t1.peekChar$1(1) === 61) + return new A.QualifiedName(nameOrNamespace, null); + t1.readChar$0(); + return new A.QualifiedName(_this.identifier$0(), nameOrNamespace); + }, + _attributeOperator$0() { + var t1 = this.scanner, + t2 = t1._string_scanner$_position; + switch (t1.readChar$0()) { + case 61: + return B.AttributeOperator_Lvy; + case 126: + t1.expectChar$1(61); + return B.AttributeOperator_fp2; + case 124: + t1.expectChar$1(61); + return B.AttributeOperator_iyP; + case 94: + t1.expectChar$1(61); + return B.AttributeOperator_JzP; + case 36: + t1.expectChar$1(61); + return B.AttributeOperator_U1W; + case 42: + t1.expectChar$1(61); + return B.AttributeOperator_GWq; + default: + t1.error$2$position(0, 'Expected "]".', t2); + } + }, + _pseudoSelector$0() { + var element, $name, unvendored, argument, selector, t2, _this = this, _null = null, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expectChar$1(58); + element = t1.scanChar$1(58); + $name = _this.identifier$0(); + if (!t1.scanChar$1(40)) + return A.PseudoSelector$($name, _this.spanFrom$1(start), _null, element, _null); + _this.whitespace$1$consumeNewlines(true); + unvendored = A.unvendor($name); + argument = _null; + selector = _null; + if (element) + if ($._selectorPseudoElements.contains$1(0, unvendored)) + selector = _this._selectorList$0(); + else + argument = _this.declarationValue$1$allowEmpty(true); + else if ($._selectorPseudoClasses.contains$1(0, unvendored)) + selector = _this._selectorList$0(); + else if (unvendored === "nth-child" || unvendored === "nth-last-child") { + argument = _this._aNPlusB$0(); + _this.whitespace$1$consumeNewlines(true); + t2 = t1.peekChar$1(-1); + if ((t2 === 32 || t2 === 9 || t2 === 10 || t2 === 13 || t2 === 12) && t1.peekChar$0() !== 41) { + _this.expectIdentifier$1("of"); + argument += " of"; + _this.whitespace$1$consumeNewlines(true); + selector = _this._selectorList$0(); + } + } else + argument = B.JSString_methods.trimRight$0(_this.declarationValue$1$allowEmpty(true)); + t1.expectChar$1(41); + return A.PseudoSelector$($name, _this.spanFrom$1(start), argument, element, selector); + }, + _aNPlusB$0() { + var t1, _0_0, t2, $self, next, _this = this; + $label0$0: { + t1 = _this.scanner; + _0_0 = t1.peekChar$0(); + if (101 === _0_0 || 69 === _0_0) { + _this.expectIdentifier$1("even"); + return "even"; + } + if (111 === _0_0 || 79 === _0_0) { + _this.expectIdentifier$1("odd"); + return "odd"; + } + if (43 === _0_0 || 45 === _0_0) { + t2 = "" + A.Primitives_stringFromCharCode(t1.readChar$0()); + break $label0$0; + } + t2 = ""; + } + $self = t1.peekChar$0(); + if ($self != null && $self >= 48 && $self <= 57) { + do { + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + $self = t1.peekChar$0(); + } while ($self != null && $self >= 48 && $self <= 57); + _this.whitespace$1$consumeNewlines(true); + if (!_this.scanIdentChar$1(110)) + return t2.charCodeAt(0) == 0 ? t2 : t2; + } else + _this.expectIdentChar$1(110); + t2 += A.Primitives_stringFromCharCode(110); + _this.whitespace$1$consumeNewlines(true); + next = t1.peekChar$0(); + if (next !== 43 && next !== 45) + return t2.charCodeAt(0) == 0 ? t2 : t2; + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + _this.whitespace$1$consumeNewlines(true); + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + t1.error$1(0, "Expected a number."); + do { + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + $self = t1.peekChar$0(); + } while ($self != null && $self >= 48 && $self <= 57); + return t2.charCodeAt(0) == 0 ? t2 : t2; + }, + _typeOrUniversalSelector$0() { + var nameOrNamespace, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + if (t1.scanChar$1(42)) { + if (!t1.scanChar$1(124)) + return new A.UniversalSelector(null, _this.spanFrom$1(start)); + return t1.scanChar$1(42) ? new A.UniversalSelector("*", _this.spanFrom$1(start)) : new A.TypeSelector(new A.QualifiedName(_this.identifier$0(), "*"), _this.spanFrom$1(start)); + } else if (t1.scanChar$1(124)) + return t1.scanChar$1(42) ? new A.UniversalSelector("", _this.spanFrom$1(start)) : new A.TypeSelector(new A.QualifiedName(_this.identifier$0(), ""), _this.spanFrom$1(start)); + nameOrNamespace = _this.identifier$0(); + if (!t1.scanChar$1(124)) + return new A.TypeSelector(new A.QualifiedName(nameOrNamespace, null), _this.spanFrom$1(start)); + else if (t1.scanChar$1(42)) + return new A.UniversalSelector(nameOrNamespace, _this.spanFrom$1(start)); + else + return new A.TypeSelector(new A.QualifiedName(_this.identifier$0(), nameOrNamespace), _this.spanFrom$1(start)); + }, + _isSimpleSelectorStart$1(character) { + var t1; + $label0$0: { + if (42 === character || 91 === character || 46 === character || 35 === character || 37 === character || 58 === character) { + t1 = true; + break $label0$0; + } + if (38 === character) { + t1 = this._plainCss; + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + } + }; + A.SelectorParser_parse_closure.prototype = { + call$0() { + var t1 = this.$this, + selector = t1._selectorList$0(); + t1 = t1.scanner; + if (t1._string_scanner$_position !== t1.string.length) + t1.error$1(0, "expected selector."); + return selector; + }, + $signature: 448 + }; + A.SelectorParser_parseCompoundSelector_closure.prototype = { + call$0() { + var t1 = this.$this, + compound = t1._compoundSelector$0(); + t1 = t1.scanner; + if (t1._string_scanner$_position !== t1.string.length) + t1.error$1(0, "expected selector."); + return compound; + }, + $signature: 451 + }; + A.StylesheetParser.prototype = { + parse$0(_) { + return this.wrapSpanFormatException$1(new A.StylesheetParser_parse_closure(this)); + }, + parseParameterList$0() { + return this._parseSingleProduction$1$1(new A.StylesheetParser_parseParameterList_closure(this), type$.ParameterList); + }, + parseVariableDeclaration$0() { + return new A._Record_2(this._parseSingleProduction$1$1(new A.StylesheetParser_parseVariableDeclaration_closure(this), type$.VariableDeclaration), this.warnings); + }, + parseUseRule$0() { + return new A._Record_2(this._parseSingleProduction$1$1(new A.StylesheetParser_parseUseRule_closure(this), type$.UseRule), this.warnings); + }, + _parseSingleProduction$1$1(production, $T) { + return this.wrapSpanFormatException$1(new A.StylesheetParser__parseSingleProduction_closure(this, production, $T)); + }, + _statement$1$root(root) { + var t2, _this = this, + t1 = _this.scanner, + _0_0 = t1.peekChar$0(); + if (64 === _0_0) + return _this.atRule$2$root(new A.StylesheetParser__statement_closure(_this), root); + if (43 === _0_0) { + if (!_this.get$indented() || !_this.lookingAtIdentifier$1(1)) + return _this._styleRule$0(); + _this._isUseAllowed = false; + t2 = t1._string_scanner$_position; + t1.readChar$0(); + return _this._includeRule$1(new A._SpanScannerState(t1, t2)); + } + if (61 === _0_0) { + if (!_this.get$indented()) + return _this._styleRule$0(); + _this._isUseAllowed = false; + t2 = t1._string_scanner$_position; + t1.readChar$0(); + _this.whitespace$1$consumeNewlines(true); + return _this._mixinRule$1(new A._SpanScannerState(t1, t2)); + } + if (125 === _0_0) + t1.error$2$length(0, 'unmatched "}".', 1); + return _this._inStyleRule || _this._stylesheet$_inUnknownAtRule || _this._stylesheet$_inMixin || _this._inContentBlock ? _this._declarationOrStyleRule$0() : _this._variableDeclarationOrStyleRule$0(); + }, + _statement$0() { + return this._statement$1$root(false); + }, + _variableDeclarationWithNamespace$0() { + var t1 = this.scanner, + t2 = t1._string_scanner$_position, + namespace = this.identifier$0(); + t1.expectChar$1(46); + return this.variableDeclarationWithoutNamespace$2(namespace, new A._SpanScannerState(t1, t2)); + }, + variableDeclarationWithoutNamespace$2(namespace, start_) { + var t1, start, $name, t2, value, flagStart, t3, guarded, global, _0_0, endPosition, t4, t5, t6, declaration, _this = this, + precedingComment = _this.lastSilentComment; + _this.lastSilentComment = null; + if (start_ == null) { + t1 = _this.scanner; + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + } else + start = start_; + $name = _this.variableName$0(); + t1 = namespace != null; + if (t1) + _this._assertPublic$2($name, new A.StylesheetParser_variableDeclarationWithoutNamespace_closure(_this, start)); + if (_this.get$plainCss()) + _this.error$2(0, string$.Sassx20v, _this.scanner.spanFrom$1(start)); + _this.whitespace$1$consumeNewlines(true); + t2 = _this.scanner; + t2.expectChar$1(58); + _this.whitespace$1$consumeNewlines(true); + value = _this._expression$0(); + flagStart = new A._SpanScannerState(t2, t2._string_scanner$_position); + for (t3 = _this.warnings, guarded = false, global = false; t2.scanChar$1(33);) { + $label0$0: { + _0_0 = _this.identifier$0(); + if ("default" === _0_0) { + if (guarded) { + endPosition = t2._string_scanner$_position; + t4 = t2._sourceFile; + t5 = flagStart.position; + t6 = new A._FileSpan(t4, t5, endPosition); + t6._FileSpan$3(t4, t5, endPosition); + t3.push(new A._Record_3_deprecation_message_span(B.Deprecation_0NP, string$.x21defau, t6)); + } + guarded = true; + break $label0$0; + } + if ("global" === _0_0) { + if (t1) { + endPosition = t2._string_scanner$_position; + t4 = t2._sourceFile; + t5 = flagStart.position; + t6 = new A._FileSpan(t4, t5, endPosition); + t6._FileSpan$3(t4, t5, endPosition); + _this.error$2(0, string$.x21globai, t6); + } else if (global) { + endPosition = t2._string_scanner$_position; + t4 = t2._sourceFile; + t5 = flagStart.position; + t6 = new A._FileSpan(t4, t5, endPosition); + t6._FileSpan$3(t4, t5, endPosition); + t3.push(new A._Record_3_deprecation_message_span(B.Deprecation_0NP, string$.x21globas, t6)); + } + global = true; + break $label0$0; + } + endPosition = t2._string_scanner$_position; + t4 = t2._sourceFile; + t5 = flagStart.position; + t6 = new A._FileSpan(t4, t5, endPosition); + t6._FileSpan$3(t4, t5, endPosition); + _this.error$2(0, "Invalid flag name.", t6); + } + _this.whitespace$1$consumeNewlines(false); + flagStart = new A._SpanScannerState(t2, t2._string_scanner$_position); + } + _this.expectStatementSeparator$1("variable declaration"); + declaration = A.VariableDeclaration$($name, value, t2.spanFrom$1(start), precedingComment, global, guarded, namespace); + if (global) + _this._globalVariables.putIfAbsent$2($name, new A.StylesheetParser_variableDeclarationWithoutNamespace_closure0(declaration)); + return declaration; + }, + variableDeclarationWithoutNamespace$0() { + return this.variableDeclarationWithoutNamespace$2(null, null); + }, + _variableDeclarationOrStyleRule$0() { + var t1, t2, variableOrInterpolation, t3, _this = this; + if (_this.get$plainCss()) + return _this._styleRule$0(); + if (_this.get$indented() && _this.scanner.scanChar$1(92)) + return _this._styleRule$0(); + if (!_this.lookingAtIdentifier$0()) + return _this._styleRule$0(); + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + variableOrInterpolation = _this._variableDeclarationOrInterpolation$0(); + if (variableOrInterpolation instanceof A.VariableDeclaration) + t1 = variableOrInterpolation; + else { + t3 = new A.InterpolationBuffer(new A.StringBuffer(""), A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t3.addInterpolation$1(type$.Interpolation._as(variableOrInterpolation)); + t2 = _this._styleRule$2(t3, new A._SpanScannerState(t1, t2)); + t1 = t2; + } + return t1; + }, + _declarationOrStyleRule$0() { + var t1, t2, declarationOrBuffer, _this = this; + if (_this.get$indented() && _this.scanner.scanChar$1(92)) + return _this._styleRule$0(); + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + declarationOrBuffer = _this._declarationOrBuffer$0(); + return declarationOrBuffer instanceof A.Statement ? declarationOrBuffer : _this._styleRule$2(type$.InterpolationBuffer._as(declarationOrBuffer), new A._SpanScannerState(t1, t2)); + }, + _declarationOrBuffer$0() { + var midBuffer, couldBeSelector, beforeDeclaration, value, additional, t2, t3, variableOrInterpolation, t4, $name, postColonWhitespace, _0_0, exception, _1_0, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + nameBuffer = new A.InterpolationBuffer(new A.StringBuffer(""), A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)), + startsWithPunctuation = _this._lookingAtPotentialPropertyHack$0(); + if (startsWithPunctuation) { + t2 = t1.readChar$0(); + t3 = nameBuffer._interpolation_buffer$_text; + t2 = A.Primitives_stringFromCharCode(t2); + t3._contents += t2; + t2 = _this.rawText$1(new A.StylesheetParser__declarationOrBuffer_closure(_this)); + t3 = nameBuffer._interpolation_buffer$_text; + t3._contents += t2; + } + if (!_this._lookingAtInterpolatedIdentifier$0()) + return nameBuffer; + variableOrInterpolation = startsWithPunctuation ? _this.interpolatedIdentifier$0() : _this._variableDeclarationOrInterpolation$0(); + if (variableOrInterpolation instanceof A.VariableDeclaration) + return variableOrInterpolation; + else + nameBuffer.addInterpolation$1(type$.Interpolation._as(variableOrInterpolation)); + _this._isUseAllowed = false; + if (t1.matches$1("/*")) { + t2 = _this.rawText$1(_this.get$loudComment()); + t3 = nameBuffer._interpolation_buffer$_text; + t3._contents += t2; + } + midBuffer = new A.StringBuffer(""); + t2 = midBuffer; + t3 = _this.rawText$1(new A.StylesheetParser__declarationOrBuffer_closure0(_this)); + t2._contents += t3; + t3 = t1._string_scanner$_position; + if (!t1.scanChar$1(58)) { + if (midBuffer._contents.length !== 0) { + t1 = nameBuffer._interpolation_buffer$_text; + t2 = A.Primitives_stringFromCharCode(32); + t1._contents += t2; + } + return nameBuffer; + } + t2 = midBuffer; + t4 = A.Primitives_stringFromCharCode(58); + t2._contents += t4; + $name = nameBuffer.interpolation$1(t1.spanFrom$2(start, new A._SpanScannerState(t1, t3))); + if (B.JSString_methods.startsWith$1($name.get$initialPlain(), "--")) { + t2 = _this._interpolatedDeclarationValue$1$silentComments(false); + _this.expectStatementSeparator$1("custom property"); + return A.Declaration$($name, new A.StringExpression(t2, false), t1.spanFrom$1(start)); + } + if (t1.scanChar$1(58)) { + t1 = nameBuffer; + t2 = t1._interpolation_buffer$_text; + t3 = A.S(midBuffer); + t2._contents += t3; + t3 = A.Primitives_stringFromCharCode(58); + t2._contents += t3; + return t1; + } else if (_this.get$indented() && _this._lookingAtInterpolatedIdentifier$0()) { + t1 = nameBuffer; + t2 = t1._interpolation_buffer$_text; + t3 = A.S(midBuffer); + t2._contents += t3; + return t1; + } + postColonWhitespace = _this.rawText$1(new A.StylesheetParser__declarationOrBuffer_closure1(_this)); + _0_0 = _this._tryDeclarationChildren$2($name, start); + if (_0_0 != null) + return _0_0; + midBuffer._contents += postColonWhitespace; + couldBeSelector = postColonWhitespace.length === 0 && _this._lookingAtInterpolatedIdentifier$0(); + beforeDeclaration = new A._SpanScannerState(t1, t1._string_scanner$_position); + value = null; + try { + value = _this._expression$0(); + if (_this.lookingAtChildren$0()) { + if (couldBeSelector) + _this.expectStatementSeparator$0(); + } else if (!_this.atEndOfStatement$0()) + _this.expectStatementSeparator$0(); + } catch (exception) { + if (type$.FormatException._is(A.unwrapException(exception))) { + if (!couldBeSelector) + throw exception; + t1.set$state(beforeDeclaration); + additional = _this.almostAnyValue$0(); + if (!_this.get$indented() && t1.peekChar$0() === 59) + throw exception; + t1 = nameBuffer._interpolation_buffer$_text; + t2 = A.S(midBuffer); + t1._contents += t2; + nameBuffer.addInterpolation$1(additional); + return nameBuffer; + } else + throw exception; + } + _1_0 = _this._tryDeclarationChildren$3$value($name, start, value); + if (_1_0 != null) + return _1_0; + else { + _this.expectStatementSeparator$0(); + return A.Declaration$($name, value, t1.spanFrom$1(start)); + } + }, + _variableDeclarationOrInterpolation$0() { + var t1, start, identifier, t2, buffer, _this = this; + if (!_this.lookingAtIdentifier$0()) + return _this.interpolatedIdentifier$0(); + t1 = _this.scanner; + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + identifier = _this.identifier$0(); + if (t1.matches$1(".$")) { + t1.readChar$0(); + return _this.variableDeclarationWithoutNamespace$2(identifier, start); + } else { + t2 = new A.StringBuffer(""); + buffer = new A.InterpolationBuffer(t2, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t2._contents = "" + identifier; + if (_this._lookingAtInterpolatedIdentifierBody$0()) + buffer.addInterpolation$1(_this.interpolatedIdentifier$0()); + return buffer.interpolation$1(t1.spanFrom$1(start)); + } + }, + _styleRule$2(buffer, start_) { + var t2, start, interpolation, wasInStyleRule, _this = this, t1 = {}; + _this._isUseAllowed = false; + if (start_ == null) { + t2 = _this.scanner; + start = new A._SpanScannerState(t2, t2._string_scanner$_position); + } else + start = start_; + interpolation = t1.interpolation = _this.styleRuleSelector$0(); + if (buffer != null) { + buffer.addInterpolation$1(interpolation); + t2 = t1.interpolation = buffer.interpolation$1(_this.scanner.spanFrom$1(start)); + } else + t2 = interpolation; + if (t2.contents.length === 0) + _this.scanner.error$1(0, 'expected "}".'); + wasInStyleRule = _this._inStyleRule; + _this._inStyleRule = true; + return _this._withChildren$3(_this.get$_statement(), start, new A.StylesheetParser__styleRule_closure(t1, _this, wasInStyleRule, start)); + }, + _styleRule$0() { + return this._styleRule$2(null, null); + }, + _propertyOrVariableDeclaration$1$parseCustomProperties(parseCustomProperties) { + var t2, nameBuffer, t3, $name, variableOrInterpolation, _0_0, value, _1_0, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + if (_this._lookingAtPotentialPropertyHack$0()) { + t2 = new A.StringBuffer(""); + nameBuffer = new A.InterpolationBuffer(t2, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t3 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t3; + t3 = _this.rawText$1(new A.StylesheetParser__propertyOrVariableDeclaration_closure(_this)); + t2._contents += t3; + nameBuffer.addInterpolation$1(_this.interpolatedIdentifier$0()); + $name = nameBuffer.interpolation$1(t1.spanFrom$1(start)); + } else if (!_this.get$plainCss()) { + variableOrInterpolation = _this._variableDeclarationOrInterpolation$0(); + if (variableOrInterpolation instanceof A.VariableDeclaration) + return variableOrInterpolation; + else + type$.Interpolation._as(variableOrInterpolation); + $name = variableOrInterpolation; + } else + $name = _this.interpolatedIdentifier$0(); + _this.whitespace$1$consumeNewlines(false); + t1.expectChar$1(58); + _this.whitespace$1$consumeNewlines(false); + _0_0 = _this._tryDeclarationChildren$2($name, start); + if (_0_0 != null) + return _0_0; + value = _this._expression$0(); + _1_0 = _this._tryDeclarationChildren$3$value($name, start, value); + if (_1_0 != null) + return _1_0; + else { + _this.expectStatementSeparator$0(); + return A.Declaration$($name, value, t1.spanFrom$1(start)); + } + }, + _tryDeclarationChildren$3$value($name, start, value) { + var _this = this; + if (!_this.lookingAtChildren$0()) + return null; + if (_this.get$plainCss()) + _this.scanner.error$1(0, string$.Nested); + return _this._withChildren$3(_this.get$_declarationChild(), start, new A.StylesheetParser__tryDeclarationChildren_closure($name, value)); + }, + _tryDeclarationChildren$2($name, start) { + return this._tryDeclarationChildren$3$value($name, start, null); + }, + _declarationChild$0() { + return this.scanner.peekChar$0() === 64 ? this._declarationAtRule$0() : this._propertyOrVariableDeclaration$1$parseCustomProperties(false); + }, + atRule$2$root(child, root) { + var $name, wasUseAllowed, value, optional, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expectChar$2$name(64, "@-rule"); + $name = _this.interpolatedIdentifier$0(); + wasUseAllowed = _this._isUseAllowed; + _this._isUseAllowed = false; + switch ($name.get$asPlain()) { + case "at-root": + return _this._atRootRule$1(start); + case "content": + return _this._contentRule$1(start); + case "debug": + return _this._debugRule$1(start); + case "each": + return _this._eachRule$2(start, child); + case "else": + return _this._disallowedAtRule$1(start); + case "error": + return _this._errorRule$1(start); + case "extend": + _this.whitespace$1$consumeNewlines(true); + if (!_this._inStyleRule && !_this._stylesheet$_inMixin && !_this._inContentBlock) + _this.error$2(0, string$.x40exten, t1.spanFrom$1(start)); + value = _this.almostAnyValue$0(); + optional = t1.scanChar$1(33); + if (optional) { + _this.expectIdentifier$1("optional"); + _this.whitespace$1$consumeNewlines(false); + } + _this.expectStatementSeparator$1("@extend rule"); + return new A.ExtendRule(value, optional, t1.spanFrom$1(start)); + case "for": + return _this._forRule$2(start, child); + case "forward": + _this._isUseAllowed = wasUseAllowed; + if (!root) + _this._disallowedAtRule$1(start); + return _this._forwardRule$1(start); + case "function": + return _this._functionRule$1(start); + case "if": + return _this._ifRule$2(start, child); + case "import": + return _this._importRule$1(start); + case "include": + return _this._includeRule$1(start); + case "media": + return _this.mediaRule$1(start); + case "mixin": + return _this._mixinRule$1(start); + case "-moz-document": + return _this.mozDocumentRule$2(start, $name); + case "return": + return _this._disallowedAtRule$1(start); + case "supports": + return _this.supportsRule$1(start); + case "use": + _this._isUseAllowed = wasUseAllowed; + if (!root) + _this._disallowedAtRule$1(start); + return _this._useRule$1(start); + case "warn": + return _this._warnRule$1(start); + case "while": + return _this._whileRule$2(start, child); + default: + return _this.unknownAtRule$2(start, $name); + } + }, + _declarationAtRule$0() { + var _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + _0_0 = _this._plainAtRuleName$0(); + $label0$0: { + if ("content" === _0_0) { + t1 = _this._contentRule$1(start); + break $label0$0; + } + if ("debug" === _0_0) { + t1 = _this._debugRule$1(start); + break $label0$0; + } + if ("each" === _0_0) { + t1 = _this._eachRule$2(start, _this.get$_declarationChild()); + break $label0$0; + } + if ("else" === _0_0) + _this._disallowedAtRule$1(start); + if ("error" === _0_0) { + t1 = _this._errorRule$1(start); + break $label0$0; + } + if ("for" === _0_0) { + t1 = _this._forRule$2(start, _this.get$_declarationChild()); + break $label0$0; + } + if ("if" === _0_0) { + t1 = _this._ifRule$2(start, _this.get$_declarationChild()); + break $label0$0; + } + if ("include" === _0_0) { + t1 = _this._includeRule$1(start); + break $label0$0; + } + if ("warn" === _0_0) { + t1 = _this._warnRule$1(start); + break $label0$0; + } + if ("while" === _0_0) { + t1 = _this._whileRule$2(start, _this.get$_declarationChild()); + break $label0$0; + } + t1 = _this._disallowedAtRule$1(start); + } + return t1; + }, + _functionChild$0() { + var state, variableDeclarationError, stackTrace, statement, t2, exception, t3, start, _0_0, value, _this = this, + t1 = _this.scanner; + if (t1.peekChar$0() !== 64) { + state = new A._SpanScannerState(t1, t1._string_scanner$_position); + try { + t2 = _this._variableDeclarationWithNamespace$0(); + return t2; + } catch (exception) { + t2 = A.unwrapException(exception); + t3 = type$.SourceSpanFormatException; + if (t3._is(t2)) { + variableDeclarationError = t2; + stackTrace = A.getTraceFromException(exception); + t1.set$state(state); + statement = null; + try { + statement = _this._declarationOrStyleRule$0(); + } catch (exception) { + if (t3._is(A.unwrapException(exception))) + throw A.wrapException(variableDeclarationError); + else + throw exception; + } + t2 = statement instanceof A.StyleRule ? "style rules" : "declarations"; + _this.error$3(0, "@function rules may not contain " + t2 + ".", J.get$span$z(statement), stackTrace); + } else + throw exception; + } + } + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + _0_0 = _this._plainAtRuleName$0(); + $label0$0: { + if ("debug" === _0_0) { + t1 = _this._debugRule$1(start); + break $label0$0; + } + if ("each" === _0_0) { + t1 = _this._eachRule$2(start, _this.get$_functionChild()); + break $label0$0; + } + if ("else" === _0_0) + _this._disallowedAtRule$1(start); + if ("error" === _0_0) { + t1 = _this._errorRule$1(start); + break $label0$0; + } + if ("for" === _0_0) { + t1 = _this._forRule$2(start, _this.get$_functionChild()); + break $label0$0; + } + if ("if" === _0_0) { + t1 = _this._ifRule$2(start, _this.get$_functionChild()); + break $label0$0; + } + if ("return" === _0_0) { + _this.whitespace$1$consumeNewlines(true); + value = _this._expression$0(); + _this.expectStatementSeparator$1("@return rule"); + t1 = new A.ReturnRule(value, t1.spanFrom$1(start)); + break $label0$0; + } + if ("warn" === _0_0) { + t1 = _this._warnRule$1(start); + break $label0$0; + } + if ("while" === _0_0) { + t1 = _this._whileRule$2(start, _this.get$_functionChild()); + break $label0$0; + } + t1 = _this._disallowedAtRule$1(start); + } + return t1; + }, + _plainAtRuleName$0() { + this.scanner.expectChar$2$name(64, "@-rule"); + return this.identifier$0(); + }, + _atRootRule$1(start) { + var t1, t2, t3, buffer, t4, _this = this; + _this.whitespace$1$consumeNewlines(false); + t1 = _this.scanner; + if (t1.peekChar$0() === 40) { + t2 = t1._string_scanner$_position; + t3 = new A.StringBuffer(""); + buffer = new A.InterpolationBuffer(t3, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t1.expectChar$1(40); + t4 = A.Primitives_stringFromCharCode(40); + t3._contents += t4; + _this.whitespace$1$consumeNewlines(true); + _this._addOrInject$2(buffer, _this._expression$1$consumeNewlines(true)); + if (t1.scanChar$1(58)) { + _this.whitespace$1$consumeNewlines(true); + t4 = A.Primitives_stringFromCharCode(58); + t3._contents += t4; + t4 = A.Primitives_stringFromCharCode(32); + t3._contents += t4; + _this._addOrInject$2(buffer, _this._expression$1$consumeNewlines(true)); + } + t1.expectChar$1(41); + _this.whitespace$1$consumeNewlines(false); + t4 = A.Primitives_stringFromCharCode(41); + t3._contents += t4; + return _this._withChildren$3(_this.get$_statement(), start, new A.StylesheetParser__atRootRule_closure(buffer.interpolation$1(t1.spanFrom$1(new A._SpanScannerState(t1, t2))))); + } else { + if (!_this.lookingAtChildren$0()) + t2 = _this.get$indented() && _this.atEndOfStatement$0(); + else + t2 = true; + if (t2) + return _this._withChildren$3(_this.get$_statement(), start, new A.StylesheetParser__atRootRule_closure0()); + else + return A.AtRootRule$(A._setArrayType([_this._styleRule$0()], type$.JSArray_Statement), t1.spanFrom$1(start), null); + } + }, + _contentRule$1(start) { + var t1, beforeWhitespace, $arguments, t2, _this = this; + if (!_this._stylesheet$_inMixin) + _this.error$2(0, string$.x40conte, _this.scanner.spanFrom$1(start)); + t1 = _this.scanner; + beforeWhitespace = A.FileLocation$_(t1._sourceFile, t1._string_scanner$_position); + _this.whitespace$1$consumeNewlines(false); + if (t1.peekChar$0() === 40) { + $arguments = _this._argumentInvocation$1$mixin(true); + _this.whitespace$1$consumeNewlines(false); + } else { + t2 = beforeWhitespace.offset; + $arguments = A.ArgumentList$empty(A._FileSpan$(beforeWhitespace.file, t2, t2)); + } + _this.expectStatementSeparator$1("@content rule"); + return new A.ContentRule($arguments, t1.spanFrom$1(start)); + }, + _debugRule$1(start) { + var value, t1, t2, _this = this; + _this.whitespace$1$consumeNewlines(true); + value = _this._expression$0(); + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + _this.expectStatementSeparator$1("@debug rule"); + return new A.DebugRule(value, t1.spanFrom$2(start, new A._SpanScannerState(t1, t2))); + }, + _eachRule$2(start, child) { + var wasInControlDirective, variables, t1, _this = this; + _this.whitespace$1$consumeNewlines(true); + wasInControlDirective = _this._inControlDirective; + _this._inControlDirective = true; + variables = A._setArrayType([_this.variableName$0()], type$.JSArray_String); + _this.whitespace$1$consumeNewlines(true); + for (t1 = _this.scanner; t1.scanChar$1(44);) { + _this.whitespace$1$consumeNewlines(true); + t1.expectChar$1(36); + variables.push(_this.identifier$1$normalize(true)); + _this.whitespace$1$consumeNewlines(true); + } + _this.whitespace$1$consumeNewlines(true); + _this.expectIdentifier$1("in"); + _this.whitespace$1$consumeNewlines(true); + return _this._withChildren$3(child, start, new A.StylesheetParser__eachRule_closure(_this, wasInControlDirective, variables, _this._expression$0())); + }, + _errorRule$1(start) { + var value, t1, t2, _this = this; + _this.whitespace$1$consumeNewlines(true); + value = _this._expression$0(); + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + _this.expectStatementSeparator$1("@error rule"); + return new A.ErrorRule(value, t1.spanFrom$2(start, new A._SpanScannerState(t1, t2))); + }, + _functionRule$1(start) { + var precedingComment, t1, beforeName, $name, parameters, _0_0, _this = this; + _this.whitespace$1$consumeNewlines(true); + precedingComment = _this.lastSilentComment; + _this.lastSilentComment = null; + t1 = _this.scanner; + beforeName = new A._SpanScannerState(t1, t1._string_scanner$_position); + $name = _this.identifier$0(); + if (B.JSString_methods.startsWith$1($name, "--")) + _this.warnings.push(new A._Record_3_deprecation_message_span(B.Deprecation_Kg6, string$.Sassx20_f_, t1.spanFrom$1(beforeName))); + else if (A.equalsIgnoreCase($name, "type")) + _this.warnings.push(new A._Record_3_deprecation_message_span(B.Deprecation_kms, string$.Sassx20_fs, t1.spanFrom$1(beforeName))); + _this.whitespace$1$consumeNewlines(true); + parameters = _this._parameterList$0(); + if (_this._stylesheet$_inMixin || _this._inContentBlock) + _this.error$2(0, string$.Mixinscf, t1.spanFrom$1(start)); + else if (_this._inControlDirective) + _this.error$2(0, string$.Functi, t1.spanFrom$1(start)); + _0_0 = A.unvendor($name); + if ("calc" === _0_0 || "element" === _0_0 || "expression" === _0_0 || "url" === _0_0 || "and" === _0_0 || "or" === _0_0 || "not" === _0_0 || "clamp" === _0_0) + _this.error$2(0, "Invalid function name.", t1.spanFrom$1(start)); + _this.whitespace$1$consumeNewlines(false); + return _this._withChildren$3(_this.get$_functionChild(), start, new A.StylesheetParser__functionRule_closure($name, parameters, precedingComment)); + }, + _forRule$2(start, child) { + var wasInControlDirective, variable, from, _this = this, t1 = {}; + _this.whitespace$1$consumeNewlines(true); + wasInControlDirective = _this._inControlDirective; + _this._inControlDirective = true; + variable = _this.variableName$0(); + _this.whitespace$1$consumeNewlines(true); + _this.expectIdentifier$1("from"); + _this.whitespace$1$consumeNewlines(true); + t1.exclusive = null; + from = _this._expression$2$consumeNewlines$until(true, new A.StylesheetParser__forRule_closure(t1, _this)); + if (t1.exclusive == null) + _this.scanner.error$1(0, 'Expected "to" or "through".'); + _this.whitespace$1$consumeNewlines(true); + return _this._withChildren$3(child, start, new A.StylesheetParser__forRule_closure0(t1, _this, wasInControlDirective, variable, from, _this._expression$0())); + }, + _forwardRule$1(start) { + var url, prefix, hiddenMixinsAndFunctions, hiddenVariables, _0_0, shownMixinsAndFunctions, shownVariables, _1_0, configuration, span, t1, t2, t3, t4, _this = this, _null = null; + _this.whitespace$1$consumeNewlines(true); + url = _this._urlString$0(); + _this.whitespace$1$consumeNewlines(false); + if (_this.scanIdentifier$1("as")) { + _this.whitespace$1$consumeNewlines(true); + prefix = _this.identifier$1$normalize(true); + _this.scanner.expectChar$1(42); + _this.whitespace$1$consumeNewlines(false); + } else + prefix = _null; + hiddenMixinsAndFunctions = _null; + hiddenVariables = _null; + if (_this.scanIdentifier$1("show")) { + _this.whitespace$1$consumeNewlines(true); + _0_0 = _this._memberList$0(); + shownMixinsAndFunctions = _0_0._0; + shownVariables = _0_0._1; + } else { + if (_this.scanIdentifier$1("hide")) { + _this.whitespace$1$consumeNewlines(true); + _1_0 = _this._memberList$0(); + hiddenMixinsAndFunctions = _1_0._0; + hiddenVariables = _1_0._1; + } + shownVariables = _null; + shownMixinsAndFunctions = shownVariables; + } + configuration = _this._stylesheet$_configuration$1$allowGuarded(true); + _this.whitespace$1$consumeNewlines(false); + _this.expectStatementSeparator$1("@forward rule"); + span = _this.scanner.spanFrom$1(start); + if (!_this._isUseAllowed) + _this.error$2(0, string$.x40forwa, span); + if (shownMixinsAndFunctions != null) { + shownVariables.toString; + t1 = type$.String; + t2 = A.LinkedHashSet_LinkedHashSet$of(shownMixinsAndFunctions, t1); + t3 = type$.UnmodifiableSetView_String; + t1 = A.LinkedHashSet_LinkedHashSet$of(shownVariables, t1); + t4 = configuration == null ? B.List_empty10 : A.List_List$unmodifiable(configuration, type$.ConfiguredVariable); + return new A.ForwardRule(url, new A.UnmodifiableSetView0(t2, t3), new A.UnmodifiableSetView0(t1, t3), _null, _null, prefix, t4, span); + } else if (hiddenMixinsAndFunctions != null) { + hiddenVariables.toString; + t1 = type$.String; + t2 = A.LinkedHashSet_LinkedHashSet$of(hiddenMixinsAndFunctions, t1); + t3 = type$.UnmodifiableSetView_String; + t1 = A.LinkedHashSet_LinkedHashSet$of(hiddenVariables, t1); + t4 = configuration == null ? B.List_empty10 : A.List_List$unmodifiable(configuration, type$.ConfiguredVariable); + return new A.ForwardRule(url, _null, _null, new A.UnmodifiableSetView0(t2, t3), new A.UnmodifiableSetView0(t1, t3), prefix, t4, span); + } else + return new A.ForwardRule(url, _null, _null, _null, _null, prefix, configuration == null ? B.List_empty10 : A.List_List$unmodifiable(configuration, type$.ConfiguredVariable), span); + }, + _memberList$0() { + var _this = this, + t1 = type$.String, + identifiers = A.LinkedHashSet_LinkedHashSet$_empty(t1), + variables = A.LinkedHashSet_LinkedHashSet$_empty(t1); + t1 = _this.scanner; + do { + _this.whitespace$1$consumeNewlines(true); + _this.withErrorMessage$2(string$.Expectv, new A.StylesheetParser__memberList_closure(_this, variables, identifiers)); + _this.whitespace$1$consumeNewlines(false); + } while (t1.scanChar$1(44)); + return new A._Record_2(identifiers, variables); + }, + _ifRule$2(start, child) { + var ifIndentation, wasInControlDirective, condition, children, clauses, lastClause, span, _this = this; + _this.whitespace$1$consumeNewlines(true); + ifIndentation = _this.get$currentIndentation(); + wasInControlDirective = _this._inControlDirective; + _this._inControlDirective = true; + condition = _this._expression$0(); + children = _this.children$1(0, child); + _this.whitespaceWithoutComments$1$consumeNewlines(false); + clauses = A._setArrayType([A.IfClause$(condition, children)], type$.JSArray_IfClause); + while (true) { + if (!_this.scanElse$1(ifIndentation)) { + lastClause = null; + break; + } + _this.whitespace$1$consumeNewlines(false); + if (_this.scanIdentifier$1("if")) { + _this.whitespace$1$consumeNewlines(true); + clauses.push(A.IfClause$(_this._expression$0(), _this.children$1(0, child))); + } else { + lastClause = A.ElseClause$(_this.children$1(0, child)); + break; + } + } + _this._inControlDirective = wasInControlDirective; + span = _this.scanner.spanFrom$1(start); + _this.whitespaceWithoutComments$1$consumeNewlines(false); + return new A.IfRule(A.List_List$unmodifiable(clauses, type$.IfClause), lastClause, span); + }, + _importRule$1(start) { + var argument, t3, _this = this, + imports = A._setArrayType([], type$.JSArray_Import), + t1 = _this.scanner, + t2 = _this.warnings; + do { + _this.whitespace$1$consumeNewlines(false); + argument = _this.importArgument$0(); + t3 = argument instanceof A.DynamicImport; + if (t3) + t2.push(new A._Record_3_deprecation_message_span(B.Deprecation_2g5, string$.Sassx20_i, argument.span)); + if ((_this._inControlDirective || _this._stylesheet$_inMixin) && t3) + _this._disallowedAtRule$1(start); + imports.push(argument); + _this.whitespace$1$consumeNewlines(false); + } while (t1.scanChar$1(44)); + _this.expectStatementSeparator$1("@import rule"); + t1 = t1.spanFrom$1(start); + return new A.ImportRule(A.List_List$unmodifiable(imports, type$.Import), t1); + }, + importArgument$0() { + var url, urlSpan, innerError, stackTrace, modifiers, t2, exception, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + _0_0 = t1.peekChar$0(); + if (117 === _0_0 || 85 === _0_0) { + url = _this.dynamicUrl$0(); + _this.whitespace$1$consumeNewlines(false); + modifiers = _this.tryImportModifiers$0(); + t2 = url instanceof A.StringExpression ? url.text : A.Interpolation$(A._setArrayType([url], type$.JSArray_Object), A._setArrayType([url.get$span(url)], type$.JSArray_nullable_FileSpan), url.get$span(url)); + return new A.StaticImport(t2, modifiers, t1.spanFrom$1(start)); + } + url = _this.string$0(); + urlSpan = t1.spanFrom$1(start); + _this.whitespace$1$consumeNewlines(false); + modifiers = _this.tryImportModifiers$0(); + if (_this.isPlainImportUrl$1(url) || modifiers != null) { + t2 = urlSpan; + return new A.StaticImport(new A.Interpolation(A.List_List$unmodifiable([A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t2.file._decodedChars, t2._file$_start, t2._end), 0, null)], type$.Object), B.List_null, urlSpan), modifiers, t1.spanFrom$1(start)); + } else + try { + t1 = _this.parseImportUrl$1(url); + return new A.DynamicImport(t1, urlSpan); + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.FormatException._is(t1)) { + innerError = t1; + stackTrace = A.getTraceFromException(exception); + _this.error$3(0, "Invalid URL: " + J.get$message$x(innerError), urlSpan, stackTrace); + } else + throw exception; + } + }, + parseImportUrl$1(url) { + var t1 = $.$get$windows(); + if (t1.style.rootLength$1(url) > 0 && !$.$get$url().style.isRootRelative$1(url)) + return t1.toUri$1(url).toString$0(0); + A.Uri_parse(url); + return url; + }, + isPlainImportUrl$1(url) { + var _0_0, t1; + if (url.length < 5) + return false; + if (B.JSString_methods.endsWith$1(url, ".css")) + return true; + _0_0 = url.charCodeAt(0); + $label0$0: { + if (47 === _0_0) { + t1 = url.charCodeAt(1) === 47; + break $label0$0; + } + if (104 === _0_0) { + t1 = B.JSString_methods.startsWith$1(url, "http://") || B.JSString_methods.startsWith$1(url, "https://"); + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + tryImportModifiers$0() { + var t1, start, t2, t3, t4, buffer, t5, identifier, $name, query, t6, endPosition, _this = this; + if (!_this._lookingAtInterpolatedIdentifier$0() && _this.scanner.peekChar$0() !== 40) + return null; + t1 = _this.scanner; + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t2 = new A.StringBuffer(""); + t3 = A._setArrayType([], type$.JSArray_Object); + t4 = A._setArrayType([], type$.JSArray_nullable_FileSpan); + buffer = new A.InterpolationBuffer(t2, t3, t4); + for (; true;) + if (_this._lookingAtInterpolatedIdentifier$0()) { + if (!(t3.length === 0 && t2._contents.length === 0)) { + t5 = A.Primitives_stringFromCharCode(32); + t2._contents += t5; + } + identifier = _this.interpolatedIdentifier$0(); + buffer.addInterpolation$1(identifier); + t5 = identifier.get$asPlain(); + $name = t5 == null ? null : t5.toLowerCase(); + if ($name !== "and" && t1.scanChar$1(40)) { + if ($name === "supports") { + query = _this._importSupportsQuery$0(); + t5 = !(query instanceof A.SupportsDeclaration); + if (t5) { + t6 = A.Primitives_stringFromCharCode(40); + t2._contents += t6; + } + t6 = query.get$span(query); + buffer._flushText$0(); + t3.push(new A.SupportsExpression(query)); + t4.push(t6); + if (t5) { + t5 = A.Primitives_stringFromCharCode(41); + t2._contents += t5; + } + } else { + t5 = A.Primitives_stringFromCharCode(40); + t2._contents += t5; + buffer.addInterpolation$1(_this._interpolatedDeclarationValue$3$allowEmpty$allowSemicolon$consumeNewlines(true, true, true)); + t5 = A.Primitives_stringFromCharCode(41); + t2._contents += t5; + } + t1.expectChar$1(41); + _this.whitespace$1$consumeNewlines(false); + } else { + _this.whitespace$1$consumeNewlines(false); + if (t1.scanChar$1(44)) { + t2._contents += ", "; + buffer.addInterpolation$1(_this._mediaQueryList$0()); + endPosition = t1._string_scanner$_position; + t2 = t1._sourceFile; + t3 = start.position; + t1 = new A._FileSpan(t2, t3, endPosition); + t1._FileSpan$3(t2, t3, endPosition); + return buffer.interpolation$1(t1); + } + } + } else if (t1.peekChar$0() === 40) { + if (!(t3.length === 0 && t2._contents.length === 0)) { + t3 = A.Primitives_stringFromCharCode(32); + t2._contents += t3; + } + buffer.addInterpolation$1(_this._mediaQueryList$0()); + endPosition = t1._string_scanner$_position; + t1 = t1._sourceFile; + t2 = start.position; + t3 = new A._FileSpan(t1, t2, endPosition); + t3._FileSpan$3(t1, t2, endPosition); + return buffer.interpolation$1(t3); + } else { + endPosition = t1._string_scanner$_position; + t1 = t1._sourceFile; + t2 = start.position; + t3 = new A._FileSpan(t1, t2, endPosition); + t3._FileSpan$3(t1, t2, endPosition); + return buffer.interpolation$1(t3); + } + }, + _importSupportsQuery$0() { + var t1, t2, _0_0, $name, _this = this; + _this.whitespace$1$consumeNewlines(true); + if (_this.scanIdentifier$1("not")) { + _this.whitespace$1$consumeNewlines(true); + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + return new A.SupportsNegation(_this._supportsConditionInParens$0(), t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + } else { + t1 = _this.scanner; + if (t1.peekChar$0() === 40) + return _this._supportsCondition$1$inParentheses(true); + else { + _0_0 = _this._tryImportSupportsFunction$0(); + if (_0_0 != null) + return _0_0; + t2 = t1._string_scanner$_position; + $name = _this._expression$1$consumeNewlines(true); + t1.expectChar$1(58); + return new A.SupportsDeclaration($name, _this._supportsDeclarationValue$1($name), t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + } + } + }, + _tryImportSupportsFunction$0() { + var t1, start, $name, value, _this = this; + if (!_this._lookingAtInterpolatedIdentifier$0()) + return null; + t1 = _this.scanner; + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + $name = _this.interpolatedIdentifier$0(); + if (!t1.scanChar$1(40)) { + t1.set$state(start); + return null; + } + value = _this._interpolatedDeclarationValue$3$allowEmpty$allowSemicolon$consumeNewlines(true, true, true); + t1.expectChar$1(41); + return new A.SupportsFunction($name, value, t1.spanFrom$1(start)); + }, + _includeRule$1(start) { + var $name, t1, name0, namespace, $arguments, t2, t3, contentParameters, contentParameters_, wasInContentBlock, $content, span, _this = this, _null = null; + _this.whitespace$1$consumeNewlines(true); + $name = _this.identifier$0(); + t1 = _this.scanner; + if (t1.scanChar$1(46)) { + name0 = _this._publicIdentifier$0(); + namespace = $name; + $name = name0; + } else + namespace = _null; + _this.whitespace$1$consumeNewlines(false); + if (t1.peekChar$0() === 40) + $arguments = _this._argumentInvocation$1$mixin(true); + else { + t2 = A.FileLocation$_(t1._sourceFile, t1._string_scanner$_position); + t3 = t2.offset; + $arguments = A.ArgumentList$empty(A._FileSpan$(t2.file, t3, t3)); + } + _this.whitespace$1$consumeNewlines(false); + if (_this.scanIdentifier$1("using")) { + _this.whitespace$1$consumeNewlines(true); + contentParameters = _this._parameterList$0(); + _this.whitespace$1$consumeNewlines(false); + } else + contentParameters = _null; + t2 = contentParameters == null; + if (!t2 || _this.lookingAtChildren$0()) { + if (t2) { + t2 = A.FileLocation$_(t1._sourceFile, t1._string_scanner$_position); + t3 = t2.offset; + contentParameters_ = new A.ParameterList(B.List_empty12, _null, A._FileSpan$(t2.file, t3, t3)); + } else + contentParameters_ = contentParameters; + wasInContentBlock = _this._inContentBlock; + _this._inContentBlock = true; + $content = _this._withChildren$3(_this.get$_statement(), start, new A.StylesheetParser__includeRule_closure(contentParameters_)); + _this._inContentBlock = wasInContentBlock; + } else { + _this.expectStatementSeparator$0(); + $content = _null; + } + t1 = t1.spanFrom$2(start, start); + t2 = $content == null ? $arguments : $content; + span = t1.expand$1(0, t2.get$span(t2)); + return new A.IncludeRule(namespace, A.stringReplaceAllUnchecked($name, "_", "-"), $name, $arguments, $content, span); + }, + mediaRule$1(start) { + var _this = this; + _this.whitespace$1$consumeNewlines(false); + return _this._withChildren$3(_this.get$_statement(), start, new A.StylesheetParser_mediaRule_closure(_this._mediaQueryList$0())); + }, + _mixinRule$1(start) { + var precedingComment, t1, t2, $name, parameters, t3, _this = this; + _this.whitespace$1$consumeNewlines(true); + precedingComment = _this.lastSilentComment; + _this.lastSilentComment = null; + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + $name = _this.identifier$0(); + if (B.JSString_methods.startsWith$1($name, "--")) + _this.warnings.push(new A._Record_3_deprecation_message_span(B.Deprecation_Kg6, string$.Sassx20_m, t1.spanFrom$1(new A._SpanScannerState(t1, t2)))); + _this.whitespace$1$consumeNewlines(false); + if (t1.peekChar$0() === 40) + parameters = _this._parameterList$0(); + else { + t2 = A.FileLocation$_(t1._sourceFile, t1._string_scanner$_position); + t3 = t2.offset; + parameters = new A.ParameterList(B.List_empty12, null, A._FileSpan$(t2.file, t3, t3)); + } + if (_this._stylesheet$_inMixin || _this._inContentBlock) + _this.error$2(0, string$.Mixinscm, t1.spanFrom$1(start)); + else if (_this._inControlDirective) + _this.error$2(0, string$.Mixinsb, t1.spanFrom$1(start)); + _this.whitespace$1$consumeNewlines(false); + _this._stylesheet$_inMixin = true; + return _this._withChildren$3(_this.get$_statement(), start, new A.StylesheetParser__mixinRule_closure(_this, $name, parameters, precedingComment)); + }, + mozDocumentRule$2(start, $name) { + var t1, t2, t3, t4, t5, buffer, _0_0, t6, identifier, _1_0, argument, trailing, endPosition, t7, t8, start0, end, _this = this, _box_0 = {}; + _this.whitespace$1$consumeNewlines(false); + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + t3 = new A.StringBuffer(""); + t4 = A._setArrayType([], type$.JSArray_Object); + t5 = A._setArrayType([], type$.JSArray_nullable_FileSpan); + buffer = new A.InterpolationBuffer(t3, t4, t5); + _box_0.needsDeprecationWarning = false; + for (; true;) { + if (t1.peekChar$0() === 35) { + _0_0 = _this.singleInterpolation$0(); + buffer._flushText$0(); + t4.push(_0_0._0); + t5.push(_0_0._1); + _box_0.needsDeprecationWarning = true; + } else { + t6 = t1._string_scanner$_position; + identifier = _this.identifier$0(); + $label0$0: { + if ("url" === identifier || "url-prefix" === identifier || "domain" === identifier) { + _1_0 = _this._tryUrlContents$2$name(new A._SpanScannerState(t1, t6), identifier); + if (_1_0 != null) + buffer.addInterpolation$1(_1_0); + else { + t1.expectChar$1(40); + _this.whitespace$1$consumeNewlines(false); + argument = _this.interpolatedString$0(); + t1.expectChar$1(41); + t3._contents += identifier; + t6 = A.Primitives_stringFromCharCode(40); + t3._contents += t6; + buffer.addInterpolation$1(argument.asInterpolation$0()); + t6 = A.Primitives_stringFromCharCode(41); + t3._contents += t6; + } + t6 = t3._contents; + trailing = t6.charCodeAt(0) == 0 ? t6 : t6; + if (!B.JSString_methods.endsWith$1(trailing, "url-prefix()") && !B.JSString_methods.endsWith$1(trailing, "url-prefix('')") && !B.JSString_methods.endsWith$1(trailing, 'url-prefix("")')) + _box_0.needsDeprecationWarning = true; + break $label0$0; + } + if ("regexp" === identifier) { + t3._contents += "regexp("; + t1.expectChar$1(40); + buffer.addInterpolation$1(_this.interpolatedString$0().asInterpolation$0()); + t1.expectChar$1(41); + t6 = A.Primitives_stringFromCharCode(41); + t3._contents += t6; + _box_0.needsDeprecationWarning = true; + break $label0$0; + } + endPosition = t1._string_scanner$_position; + t7 = t1._sourceFile; + t8 = new A._FileSpan(t7, t6, endPosition); + t8._FileSpan$3(t7, t6, endPosition); + _this.error$2(0, "Invalid function name.", t8); + } + } + _this.whitespace$1$consumeNewlines(false); + if (!t1.scanChar$1(44)) + break; + t6 = A.Primitives_stringFromCharCode(44); + t3._contents += t6; + start0 = t1._string_scanner$_position; + new A.StylesheetParser_mozDocumentRule_closure(_this).call$0(); + end = t1._string_scanner$_position; + t3._contents += B.JSString_methods.substring$2(t1.string, start0, end); + } + return _this._withChildren$3(_this.get$_statement(), start, new A.StylesheetParser_mozDocumentRule_closure0(_box_0, _this, $name, buffer.interpolation$1(t1.spanFrom$1(new A._SpanScannerState(t1, t2))))); + }, + supportsRule$1(start) { + var condition, _this = this; + _this.whitespace$1$consumeNewlines(false); + condition = _this._supportsCondition$0(); + _this.whitespace$1$consumeNewlines(false); + return _this._withChildren$3(_this.get$_statement(), start, new A.StylesheetParser_supportsRule_closure(condition)); + }, + _useRule$1(start) { + var url, namespace, configuration, span, t1, _this = this; + _this.whitespace$1$consumeNewlines(true); + url = _this._urlString$0(); + _this.whitespace$1$consumeNewlines(false); + namespace = _this._useNamespace$2(url, start); + _this.whitespace$1$consumeNewlines(false); + configuration = _this._stylesheet$_configuration$0(); + _this.whitespace$1$consumeNewlines(false); + span = _this.scanner.spanFrom$1(start); + if (!_this._isUseAllowed) + _this.error$2(0, string$.x40use_r, span); + _this.expectStatementSeparator$1("@use rule"); + t1 = new A.UseRule(url, namespace, configuration == null ? B.List_empty10 : A.List_List$unmodifiable(configuration, type$.ConfiguredVariable), span); + t1.UseRule$4$configuration(url, namespace, span, configuration); + return t1; + }, + _useNamespace$2(url, start) { + var namespace, basename, dot, t1, exception, _this = this; + if (_this.scanIdentifier$1("as")) { + _this.whitespace$1$consumeNewlines(true); + return _this.scanner.scanChar$1(42) ? null : _this.identifier$0(); + } + basename = url.get$pathSegments().length === 0 ? "" : B.JSArray_methods.get$last(url.get$pathSegments()); + dot = B.JSString_methods.indexOf$1(basename, "."); + t1 = B.JSString_methods.startsWith$1(basename, "_") ? 1 : 0; + namespace = B.JSString_methods.substring$2(basename, t1, dot === -1 ? basename.length : dot); + try { + t1 = new A.Parser(A.SpanScanner$(namespace, null), null)._parseIdentifier$0(); + return t1; + } catch (exception) { + if (type$.SassFormatException._is(A.unwrapException(exception))) + _this.error$2(0, 'The default namespace "' + A.S(namespace) + string$.x22x20is_n, _this.scanner.spanFrom$1(start)); + else + throw exception; + } + }, + _stylesheet$_configuration$1$allowGuarded(allowGuarded) { + var variableNames, configuration, t1, t2, $name, expression, t3, guarded, endPosition, t4, t5, span, _this = this; + if (!_this.scanIdentifier$1("with")) + return null; + variableNames = A.LinkedHashSet_LinkedHashSet$_empty(type$.String); + configuration = A._setArrayType([], type$.JSArray_ConfiguredVariable); + _this.whitespace$1$consumeNewlines(true); + t1 = _this.scanner; + t1.expectChar$1(40); + for (; true;) { + _this.whitespace$1$consumeNewlines(true); + t2 = t1._string_scanner$_position; + t1.expectChar$1(36); + $name = _this.identifier$1$normalize(true); + _this.whitespace$1$consumeNewlines(true); + t1.expectChar$1(58); + _this.whitespace$1$consumeNewlines(true); + expression = _this.expressionUntilComma$0(); + t3 = t1._string_scanner$_position; + if (allowGuarded && t1.scanChar$1(33)) { + guarded = _this.identifier$0() === "default"; + if (guarded) + _this.whitespace$1$consumeNewlines(true); + else { + endPosition = t1._string_scanner$_position; + t4 = t1._sourceFile; + t5 = new A._FileSpan(t4, t3, endPosition); + t5._FileSpan$3(t4, t3, endPosition); + _this.error$2(0, "Invalid flag name.", t5); + } + } else + guarded = false; + endPosition = t1._string_scanner$_position; + t3 = t1._sourceFile; + span = new A._FileSpan(t3, t2, endPosition); + span._FileSpan$3(t3, t2, endPosition); + if (variableNames.contains$1(0, $name)) + _this.error$2(0, string$.The_sa, span); + variableNames.add$1(0, $name); + configuration.push(new A.ConfiguredVariable($name, expression, guarded, span)); + if (!t1.scanChar$1(44)) + break; + _this.whitespace$1$consumeNewlines(true); + if (!_this._lookingAtExpression$0()) + break; + } + t1.expectChar$1(41); + return configuration; + }, + _stylesheet$_configuration$0() { + return this._stylesheet$_configuration$1$allowGuarded(false); + }, + _warnRule$1(start) { + var value, t1, t2, _this = this; + _this.whitespace$1$consumeNewlines(true); + value = _this._expression$0(); + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + _this.expectStatementSeparator$1("@warn rule"); + return new A.WarnRule(value, t1.spanFrom$2(start, new A._SpanScannerState(t1, t2))); + }, + _whileRule$2(start, child) { + var wasInControlDirective, _this = this; + _this.whitespace$1$consumeNewlines(true); + wasInControlDirective = _this._inControlDirective; + _this._inControlDirective = true; + return _this._withChildren$3(child, start, new A.StylesheetParser__whileRule_closure(_this, wasInControlDirective, _this._expression$0())); + }, + unknownAtRule$2(start, $name) { + var t2, t3, rule, _this = this, t1 = {}, + wasInUnknownAtRule = _this._stylesheet$_inUnknownAtRule; + _this._stylesheet$_inUnknownAtRule = true; + _this.whitespace$1$consumeNewlines(false); + t1.value = null; + t2 = _this.scanner; + t3 = t2.peekChar$0() !== 33 && !_this.atEndOfStatement$0() ? t1.value = _this._interpolatedDeclarationValue$1$allowOpenBrace(false) : null; + if (_this.lookingAtChildren$0()) + rule = _this._withChildren$3(_this.get$_statement(), start, new A.StylesheetParser_unknownAtRule_closure(t1, $name)); + else { + _this.expectStatementSeparator$0(); + rule = A.AtRule$($name, t2.spanFrom$1(start), null, t3); + } + _this._stylesheet$_inUnknownAtRule = wasInUnknownAtRule; + return rule; + }, + _disallowedAtRule$1(start) { + var _this = this; + _this.whitespace$1$consumeNewlines(false); + _this._interpolatedDeclarationValue$2$allowEmpty$allowOpenBrace(true, false); + _this.error$2(0, "This at-rule is not allowed here.", _this.scanner.spanFrom$1(start)); + }, + _parameterList$0() { + var parameters, named, restParameter, t3, $name, defaultValue, endPosition, t4, t5, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position; + t1.expectChar$1(40); + _this.whitespace$1$consumeNewlines(true); + parameters = A._setArrayType([], type$.JSArray_Parameter); + named = A.LinkedHashSet_LinkedHashSet$_empty(type$.String); + for (; restParameter = null, t1.peekChar$0() === 36;) { + t3 = t1._string_scanner$_position; + t1.expectChar$1(36); + $name = _this.identifier$1$normalize(true); + _this.whitespace$1$consumeNewlines(true); + if (t1.scanChar$1(58)) { + _this.whitespace$1$consumeNewlines(true); + defaultValue = _this.expressionUntilComma$0(); + } else { + if (t1.scanChar$1(46)) { + t1.expectChar$1(46); + t1.expectChar$1(46); + _this.whitespace$1$consumeNewlines(true); + if (t1.scanChar$1(44)) + _this.whitespace$1$consumeNewlines(true); + restParameter = $name; + break; + } + defaultValue = null; + } + endPosition = t1._string_scanner$_position; + t4 = t1._sourceFile; + t5 = new A._FileSpan(t4, t3, endPosition); + t5._FileSpan$3(t4, t3, endPosition); + parameters.push(new A.Parameter($name, defaultValue, t5)); + if (!named.add$1(0, $name)) + _this.error$2(0, "Duplicate parameter.", B.JSArray_methods.get$last(parameters).span); + if (!t1.scanChar$1(44)) + break; + _this.whitespace$1$consumeNewlines(true); + } + t1.expectChar$1(41); + t1 = t1.spanFrom$1(new A._SpanScannerState(t1, t2)); + return new A.ParameterList(A.List_List$unmodifiable(parameters, type$.Parameter), restParameter, t1); + }, + _argumentInvocation$2$allowEmptySecondArg$mixin(allowEmptySecondArg, mixin) { + var positional, t3, t4, named, t5, rest, keywordRest, expression, t6, t7, result, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position; + t1.expectChar$1(40); + _this.whitespace$1$consumeNewlines(true); + positional = A._setArrayType([], type$.JSArray_Expression); + t3 = type$.String; + t4 = type$.Expression; + named = A.LinkedHashMap_LinkedHashMap$_empty(t3, t4); + for (t5 = !mixin, rest = null; keywordRest = null, _this._lookingAtExpression$0();) { + expression = _this.expressionUntilComma$1$singleEquals(t5); + _this.whitespace$1$consumeNewlines(true); + if (expression instanceof A.VariableExpression && t1.scanChar$1(58)) { + _this.whitespace$1$consumeNewlines(true); + t6 = expression.name; + if (named.containsKey$1(t6)) + _this.error$2(0, "Duplicate argument.", expression.span); + named.$indexSet(0, t6, _this.expressionUntilComma$1$singleEquals(t5)); + } else if (t1.scanChar$1(46)) { + t1.expectChar$1(46); + t1.expectChar$1(46); + if (rest != null) { + _this.whitespace$1$consumeNewlines(true); + if (t1.scanChar$1(44)) + _this.whitespace$1$consumeNewlines(true); + keywordRest = expression; + break; + } + rest = expression; + } else if (named.__js_helper$_length !== 0) + _this.error$2(0, string$.Positi, expression.get$span(expression)); + else + positional.push(expression); + _this.whitespace$1$consumeNewlines(true); + if (!t1.scanChar$1(44)) + break; + _this.whitespace$1$consumeNewlines(true); + if (allowEmptySecondArg && positional.length === 1 && named.__js_helper$_length === 0 && rest == null && t1.peekChar$0() === 41) { + t5 = t1._sourceFile; + t6 = t1._string_scanner$_position; + new A.FileLocation(t5, t6).FileLocation$_$2(t5, t6); + t7 = new A._FileSpan(t5, t6, t6); + t7._FileSpan$3(t5, t6, t6); + result = A.List_List$from([""], false, type$.Object); + result.$flags = 3; + positional.push(new A.StringExpression(new A.Interpolation(result, B.List_null, t7), false)); + break; + } + } + t1.expectChar$1(41); + t1 = t1.spanFrom$1(new A._SpanScannerState(t1, t2)); + return new A.ArgumentList(A.List_List$unmodifiable(positional, t4), A.ConstantMap_ConstantMap$from(named, t3, t4), rest, keywordRest, t1); + }, + _argumentInvocation$0() { + return this._argumentInvocation$2$allowEmptySecondArg$mixin(false, false); + }, + _argumentInvocation$1$allowEmptySecondArg(allowEmptySecondArg) { + return this._argumentInvocation$2$allowEmptySecondArg$mixin(allowEmptySecondArg, false); + }, + _argumentInvocation$1$mixin(mixin) { + return this._argumentInvocation$2$allowEmptySecondArg$mixin(false, mixin); + }, + _expression$4$bracketList$consumeNewlines$singleEquals$until(bracketList, consumeNewlines, singleEquals, until) { + var t2, beforeBracket, start, wasInExpression, wasInParentheses, resetState, resolveOneOperation, resolveOperations, addSingleExpression, addOperator, resolveSpaceExpressions, t3, t4, _3_0, _1_0, t5, _3_28, _2_0, _3_32, _3_40, commaExpressions, spaceExpressions, singleExpression, _this = this, + _s20_ = "Expected expression.", + _box_0 = {}, + t1 = until != null; + if (t1 && until.call$0()) + _this.scanner.error$1(0, _s20_); + if (bracketList) { + t2 = _this.scanner; + beforeBracket = new A._SpanScannerState(t2, t2._string_scanner$_position); + t2.expectChar$1(91); + _this.whitespace$1$consumeNewlines(true); + if (t2.scanChar$1(93)) { + t1 = A._setArrayType([], type$.JSArray_Expression); + t2 = t2.spanFrom$1(beforeBracket); + return new A.ListExpression(A.List_List$unmodifiable(t1, type$.Expression), B.ListSeparator_undecided_null_undecided, true, t2); + } + } else + beforeBracket = null; + t2 = _this.scanner; + start = new A._SpanScannerState(t2, t2._string_scanner$_position); + wasInExpression = _this._inExpression; + wasInParentheses = _this._inParentheses; + _this._inExpression = true; + _box_0.operands_ = _box_0.operators_ = _box_0.spaceExpressions_ = _box_0.commaExpressions_ = null; + _box_0.allowSlash = true; + _box_0.singleExpression_ = _this._singleExpression$0(); + resetState = new A.StylesheetParser__expression_resetState(_box_0, _this, start); + resolveOneOperation = new A.StylesheetParser__expression_resolveOneOperation(_box_0, _this); + resolveOperations = new A.StylesheetParser__expression_resolveOperations(_box_0, resolveOneOperation); + addSingleExpression = new A.StylesheetParser__expression_addSingleExpression(_box_0, _this, resetState, resolveOperations); + addOperator = new A.StylesheetParser__expression_addOperator(_box_0, _this, resolveOneOperation, addSingleExpression); + resolveSpaceExpressions = new A.StylesheetParser__expression_resolveSpaceExpressions(_box_0, _this, resolveOperations); + for (t3 = !consumeNewlines, t4 = type$.JSArray_Expression; true;) { + _this.whitespace$1$consumeNewlines(!t3 || bracketList); + if (t1 && until.call$0()) + break; + _3_0 = t2.peekChar$0(); + if (_3_0 == null) + break; + if (40 === _3_0) { + addSingleExpression.call$1(_this.parentheses$0()); + continue; + } + if (91 === _3_0) { + addSingleExpression.call$1(_this._expression$1$bracketList(true)); + continue; + } + if (36 === _3_0) { + addSingleExpression.call$1(_this._variable$0()); + continue; + } + if (38 === _3_0) { + addSingleExpression.call$1(_this._selector$0()); + continue; + } + if (39 === _3_0 || 34 === _3_0) { + addSingleExpression.call$1(_this.interpolatedString$0()); + continue; + } + if (35 === _3_0) { + addSingleExpression.call$1(_this._hashExpression$0()); + continue; + } + if (61 === _3_0) { + t2.readChar$0(); + if (singleEquals && t2.peekChar$0() !== 61) + addOperator.call$1(B.BinaryOperator_Kyq); + else { + t2.expectChar$1(61); + addOperator.call$1(B.BinaryOperator_r84); + } + continue; + } + if (33 === _3_0) { + $label0$1: { + _1_0 = t2.peekChar$1(1); + if (61 === _1_0) { + t2.readChar$0(); + t2.readChar$0(); + addOperator.call$1(B.BinaryOperator_qGq); + break $label0$1; + } + t5 = true; + if (_1_0 != null) + if (105 !== _1_0) + if (73 !== _1_0) + t5 = _1_0 === 32 || _1_0 === 9 || _1_0 === 10 || _1_0 === 13 || _1_0 === 12; + if (t5) { + addSingleExpression.call$1(_this._importantExpression$0()); + break $label0$1; + } + break; + } + continue; + } + if (60 === _3_0) { + t2.readChar$0(); + addOperator.call$1(t2.scanChar$1(61) ? B.BinaryOperator_FPG : B.BinaryOperator_qHy); + continue; + } + if (62 === _3_0) { + t2.readChar$0(); + addOperator.call$1(t2.scanChar$1(61) ? B.BinaryOperator_JiR : B.BinaryOperator_o8O); + continue; + } + if (42 === _3_0) { + t2.readChar$0(); + addOperator.call$1(B.BinaryOperator_tht); + continue; + } + _3_28 = 43 === _3_0; + if (_3_28 && _box_0.singleExpression_ == null) { + addSingleExpression.call$1(_this._unaryOperation$0()); + continue; + } + if (_3_28) { + t2.readChar$0(); + addOperator.call$1(B.BinaryOperator_Swh); + continue; + } + if (45 === _3_0) { + _2_0 = t2.peekChar$1(1); + if (A._isInt(_2_0) && _2_0 >= 48 && _2_0 <= 57 || 46 === _2_0) + if (_box_0.singleExpression_ != null) { + t5 = t2.peekChar$1(-1); + t5 = t5 === 32 || t5 === 9 || t5 === 10 || t5 === 13 || t5 === 12; + } else + t5 = true; + else + t5 = false; + if (t5) + addSingleExpression.call$1(_this._number$0()); + else if (_this._lookingAtInterpolatedIdentifier$0()) + addSingleExpression.call$1(_this.identifierLike$0()); + else if (_box_0.singleExpression_ == null) + addSingleExpression.call$1(_this._unaryOperation$0()); + else { + t2.readChar$0(); + addOperator.call$1(B.BinaryOperator_QG1); + } + continue; + } + _3_32 = 47 === _3_0; + if (_3_32 && _box_0.singleExpression_ == null) { + addSingleExpression.call$1(_this._unaryOperation$0()); + continue; + } + if (_3_32) { + t2.readChar$0(); + addOperator.call$1(B.BinaryOperator_Mh5); + continue; + } + if (37 === _3_0) { + t2.readChar$0(); + addOperator.call$1(B.BinaryOperator_s7T); + continue; + } + if (_3_0 >= 48 && _3_0 <= 57) { + addSingleExpression.call$1(_this._number$0()); + continue; + } + _3_40 = 46 === _3_0; + if (_3_40 && t2.peekChar$1(1) === 46) + break; + if (_3_40) { + addSingleExpression.call$1(_this._number$0()); + continue; + } + if (97 === _3_0 && !_this.get$plainCss() && _this.scanIdentifier$1("and")) { + addOperator.call$1(B.BinaryOperator_uke); + continue; + } + if (111 === _3_0 && !_this.get$plainCss() && _this.scanIdentifier$1("or")) { + addOperator.call$1(B.BinaryOperator_tKu); + continue; + } + if ((117 === _3_0 || 85 === _3_0) && t2.peekChar$1(1) === 43) { + addSingleExpression.call$1(_this._unicodeRange$0()); + continue; + } + if (!(_3_0 >= 97 && _3_0 <= 122)) + t5 = _3_0 >= 65 && _3_0 <= 90 || 95 === _3_0 || 92 === _3_0 || _3_0 >= 128; + else + t5 = true; + if (t5) { + addSingleExpression.call$1(_this.identifierLike$0()); + continue; + } + if (44 === _3_0) { + if (_this._inParentheses) { + _this._inParentheses = false; + if (_box_0.allowSlash) { + resetState.call$0(); + continue; + } + } + commaExpressions = _box_0.commaExpressions_; + if (commaExpressions == null) + commaExpressions = _box_0.commaExpressions_ = A._setArrayType([], t4); + if (_box_0.singleExpression_ == null) + t2.error$1(0, _s20_); + resolveSpaceExpressions.call$0(); + t5 = _box_0.singleExpression_; + t5.toString; + commaExpressions.push(t5); + t2.readChar$0(); + _box_0.allowSlash = true; + _box_0.singleExpression_ = null; + continue; + } + break; + } + if (bracketList) + t2.expectChar$1(93); + commaExpressions = _box_0.commaExpressions_; + spaceExpressions = _box_0.spaceExpressions_; + if (commaExpressions != null) { + resolveSpaceExpressions.call$0(); + _this._inParentheses = wasInParentheses; + singleExpression = _box_0.singleExpression_; + if (singleExpression != null) + commaExpressions.push(singleExpression); + _this._inExpression = wasInExpression; + t1 = t2.spanFrom$1(beforeBracket == null ? start : beforeBracket); + return new A.ListExpression(A.List_List$unmodifiable(commaExpressions, type$.Expression), B.ListSeparator_qVN, bracketList, t1); + } else if (bracketList && spaceExpressions != null) { + resolveOperations.call$0(); + _this._inExpression = wasInExpression; + t1 = _box_0.singleExpression_; + t1.toString; + spaceExpressions.push(t1); + beforeBracket.toString; + t2 = t2.spanFrom$1(beforeBracket); + return new A.ListExpression(A.List_List$unmodifiable(spaceExpressions, type$.Expression), B.ListSeparator_qSL, true, t2); + } else { + resolveSpaceExpressions.call$0(); + if (bracketList) { + t1 = _box_0.singleExpression_; + t1.toString; + t4 = A._setArrayType([t1], t4); + beforeBracket.toString; + t2 = t2.spanFrom$1(beforeBracket); + _box_0.singleExpression_ = new A.ListExpression(A.List_List$unmodifiable(t4, type$.Expression), B.ListSeparator_undecided_null_undecided, true, t2); + } + _this._inExpression = wasInExpression; + t1 = _box_0.singleExpression_; + t1.toString; + return t1; + } + }, + _expression$0() { + return this._expression$4$bracketList$consumeNewlines$singleEquals$until(false, false, false, null); + }, + _expression$1$consumeNewlines(consumeNewlines) { + return this._expression$4$bracketList$consumeNewlines$singleEquals$until(false, consumeNewlines, false, null); + }, + _expression$3$consumeNewlines$singleEquals$until(consumeNewlines, singleEquals, until) { + return this._expression$4$bracketList$consumeNewlines$singleEquals$until(false, consumeNewlines, singleEquals, until); + }, + _expression$1$bracketList(bracketList) { + return this._expression$4$bracketList$consumeNewlines$singleEquals$until(bracketList, false, false, null); + }, + _expression$2$consumeNewlines$until(consumeNewlines, until) { + return this._expression$4$bracketList$consumeNewlines$singleEquals$until(false, consumeNewlines, false, until); + }, + expressionUntilComma$1$singleEquals(singleEquals) { + return this._expression$3$consumeNewlines$singleEquals$until(true, singleEquals, new A.StylesheetParser_expressionUntilComma_closure(this)); + }, + expressionUntilComma$0() { + return this.expressionUntilComma$1$singleEquals(false); + }, + _isSlashOperand$1(expression) { + var t1 = true; + if (!(expression instanceof A.NumberExpression)) + if (!(expression instanceof A.FunctionExpression)) + t1 = expression instanceof A.BinaryOperationExpression && expression.allowsSlash; + return t1; + }, + _singleExpression$0() { + var next, t2, _this = this, + _s20_ = "Expected expression.", + t1 = _this.scanner, + _0_0 = t1.peekChar$0(); + $label0$0: { + if (_0_0 == null) + t1.error$1(0, _s20_); + if (40 === _0_0) { + t1 = _this.parentheses$0(); + break $label0$0; + } + if (47 === _0_0) { + t1 = _this._unaryOperation$0(); + break $label0$0; + } + if (46 === _0_0) { + t1 = _this._number$0(); + break $label0$0; + } + if (91 === _0_0) { + t1 = _this._expression$1$bracketList(true); + break $label0$0; + } + if (36 === _0_0) { + t1 = _this._variable$0(); + break $label0$0; + } + if (38 === _0_0) { + t1 = _this._selector$0(); + break $label0$0; + } + if (39 === _0_0 || 34 === _0_0) { + t1 = _this.interpolatedString$0(); + break $label0$0; + } + if (35 === _0_0) { + t1 = _this._hashExpression$0(); + break $label0$0; + } + if (43 === _0_0) { + next = t1.peekChar$1(1); + t1 = next != null && next >= 48 && next <= 57 || next === 46 ? _this._number$0() : _this._unaryOperation$0(); + break $label0$0; + } + if (45 === _0_0) { + t1 = _this._minusExpression$0(); + break $label0$0; + } + if (33 === _0_0) { + t1 = _this._importantExpression$0(); + break $label0$0; + } + if (37 === _0_0) { + t2 = t1._string_scanner$_position; + t1.readChar$0(); + t2 = t1.spanFrom$1(new A._SpanScannerState(t1, t2)); + t2 = new A.StringExpression(new A.Interpolation(A.List_List$unmodifiable(["%"], type$.Object), B.List_null, t2), false); + t1 = t2; + break $label0$0; + } + if ((117 === _0_0 || 85 === _0_0) && t1.peekChar$1(1) === 43) { + t1 = _this._unicodeRange$0(); + break $label0$0; + } + if (_0_0 >= 48 && _0_0 <= 57) { + t1 = _this._number$0(); + break $label0$0; + } + if (!(_0_0 >= 97 && _0_0 <= 122)) + t2 = _0_0 >= 65 && _0_0 <= 90 || 95 === _0_0 || 92 === _0_0 || _0_0 >= 128; + else + t2 = true; + if (t2) { + t1 = _this.identifierLike$0(); + break $label0$0; + } + t1 = t1.error$1(0, _s20_); + } + return t1; + }, + parentheses$0() { + var start, first, expressions, t1, t2, _this = this, + wasInParentheses = _this._inParentheses; + _this._inParentheses = true; + try { + t1 = _this.scanner; + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expectChar$1(40); + _this.whitespace$1$consumeNewlines(true); + if (!_this._lookingAtExpression$0()) { + t1.expectChar$1(41); + t2 = A._setArrayType([], type$.JSArray_Expression); + t1 = t1.spanFrom$1(start); + t2 = A.List_List$unmodifiable(t2, type$.Expression); + return new A.ListExpression(t2, B.ListSeparator_undecided_null_undecided, false, t1); + } + first = _this.expressionUntilComma$0(); + if (t1.scanChar$1(58)) { + _this.whitespace$1$consumeNewlines(true); + t1 = _this._stylesheet$_map$2(first, start); + return t1; + } + if (!t1.scanChar$1(44)) { + t1.expectChar$1(41); + t1 = t1.spanFrom$1(start); + return new A.ParenthesizedExpression(first, t1); + } + _this.whitespace$1$consumeNewlines(true); + expressions = A._setArrayType([first], type$.JSArray_Expression); + for (; true;) { + if (!_this._lookingAtExpression$0()) + break; + J.add$1$ax(expressions, _this.expressionUntilComma$0()); + if (!t1.scanChar$1(44)) + break; + _this.whitespace$1$consumeNewlines(true); + } + t1.expectChar$1(41); + t1 = t1.spanFrom$1(start); + t2 = A.List_List$unmodifiable(expressions, type$.Expression); + return new A.ListExpression(t2, B.ListSeparator_qVN, false, t1); + } finally { + _this._inParentheses = wasInParentheses; + } + }, + _stylesheet$_map$2(first, start) { + var t1, key, _this = this, + pairs = A._setArrayType([new A._Record_2(first, _this.expressionUntilComma$0())], type$.JSArray_Record_2_Expression_and_Expression); + for (t1 = _this.scanner; t1.scanChar$1(44);) { + _this.whitespace$1$consumeNewlines(true); + if (!_this._lookingAtExpression$0()) + break; + key = _this.expressionUntilComma$0(); + t1.expectChar$1(58); + _this.whitespace$1$consumeNewlines(true); + pairs.push(new A._Record_2(key, _this.expressionUntilComma$0())); + } + t1.expectChar$1(41); + t1 = t1.spanFrom$1(start); + return new A.MapExpression(A.List_List$unmodifiable(pairs, type$.Record_2_Expression_and_Expression), t1); + }, + _hashExpression$0() { + var start, t2, identifier, buffer, t3, _this = this, + t1 = _this.scanner; + if (t1.peekChar$1(1) === 123) + return _this.identifierLike$0(); + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expectChar$1(35); + t2 = t1.peekChar$0(); + if (t2 == null) + t2 = null; + else + t2 = t2 >= 48 && t2 <= 57; + if (t2 === true) + return new A.ColorExpression(_this._hexColorContents$1(start), t1.spanFrom$1(start)); + t2 = t1._string_scanner$_position; + identifier = _this.interpolatedIdentifier$0(); + if (_this._isHexColor$1(identifier)) { + t1.set$state(new A._SpanScannerState(t1, t2)); + return new A.ColorExpression(_this._hexColorContents$1(start), t1.spanFrom$1(start)); + } + t2 = new A.StringBuffer(""); + buffer = new A.InterpolationBuffer(t2, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t3 = A.Primitives_stringFromCharCode(35); + t2._contents += t3; + buffer.addInterpolation$1(identifier); + return new A.StringExpression(buffer.interpolation$1(t1.spanFrom$1(start)), false); + }, + _hexColorContents$1(start) { + var red, green, blue, alpha, digit4, t2, t3, t4, _this = this, + digit1 = _this._hexDigit$0(), + digit2 = _this._hexDigit$0(), + digit3 = _this._hexDigit$0(), + t1 = _this.scanner, + $self = t1.peekChar$0(); + if (!($self != null && A.CharacterExtension_get_isHex($self))) { + red = (digit1 << 4 >>> 0) + digit1; + green = (digit2 << 4 >>> 0) + digit2; + blue = (digit3 << 4 >>> 0) + digit3; + alpha = null; + } else { + digit4 = _this._hexDigit$0(); + $self = t1.peekChar$0(); + t2 = $self != null && A.CharacterExtension_get_isHex($self); + t3 = digit1 << 4 >>> 0; + t4 = digit3 << 4 >>> 0; + if (!t2) { + red = t3 + digit1; + green = (digit2 << 4 >>> 0) + digit2; + blue = t4 + digit3; + alpha = ((digit4 << 4 >>> 0) + digit4) / 255; + } else { + red = t3 + digit2; + green = t4 + digit4; + blue = (_this._hexDigit$0() << 4 >>> 0) + _this._hexDigit$0(); + $self = t1.peekChar$0(); + alpha = $self != null && A.CharacterExtension_get_isHex($self) ? ((_this._hexDigit$0() << 4 >>> 0) + _this._hexDigit$0()) / 255 : null; + } + } + t2 = alpha == null; + t3 = t2 ? 1 : alpha; + return A.SassColor_SassColor$rgbInternal(red, green, blue, t3, t2 ? new A.SpanColorFormat(t1.spanFrom$1(start)) : null); + }, + _isHexColor$1(interpolation) { + var _0_2, t1, + plain = interpolation.get$asPlain(); + if (typeof plain == "string") { + _0_2 = plain.length; + t1 = true; + if (3 !== _0_2) + if (4 !== _0_2) + if (6 !== _0_2) + t1 = 8 === _0_2; + } else + t1 = false; + if (t1) { + t1 = new A.CodeUnits(plain); + return t1.every$1(t1, new A.StylesheetParser__isHexColor_closure()); + } else + return false; + }, + _hexDigit$0() { + var t1 = this.scanner, + t2 = t1.peekChar$0(); + t2 = t2 == null ? null : A.CharacterExtension_get_isHex(t2); + return t2 === true ? A.asHex(t1.readChar$0()) : t1.error$1(0, "Expected hex digit."); + }, + _minusExpression$0() { + var _this = this, + _0_0 = _this.scanner.peekChar$1(1); + if (A._isInt(_0_0) && _0_0 >= 48 && _0_0 <= 57 || 46 === _0_0) + return _this._number$0(); + if (_this._lookingAtInterpolatedIdentifier$0()) + return _this.identifierLike$0(); + return _this._unaryOperation$0(); + }, + _importantExpression$0() { + var t1 = this.scanner, + t2 = t1._string_scanner$_position; + t1.readChar$0(); + this.whitespace$1$consumeNewlines(true); + this.expectIdentifier$1("important"); + t2 = t1.spanFrom$1(new A._SpanScannerState(t1, t2)); + return new A.StringExpression(new A.Interpolation(A.List_List$unmodifiable(["!important"], type$.Object), B.List_null, t2), false); + }, + _unaryOperation$0() { + var _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + operator = _this._unaryOperatorFor$1(t1.readChar$0()); + if (operator == null) + t1.error$2$position(0, "Expected unary operator.", t1._string_scanner$_position - 1); + else if (_this.get$plainCss() && operator !== B.UnaryOperator_lZV) + t1.error$3$length$position(0, "Operators aren't allowed in plain CSS.", 1, t1._string_scanner$_position - 1); + _this.whitespace$1$consumeNewlines(true); + return new A.UnaryOperationExpression(operator, _this._singleExpression$0(), t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + _unaryOperatorFor$1(character) { + var t1; + $label0$0: { + if (43 === character) { + t1 = B.UnaryOperator_Rbl; + break $label0$0; + } + if (45 === character) { + t1 = B.UnaryOperator_UCP; + break $label0$0; + } + if (47 === character) { + t1 = B.UnaryOperator_lZV; + break $label0$0; + } + t1 = null; + break $label0$0; + } + return t1; + }, + _number$0() { + var number, unit, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + first = t1.peekChar$0(), + t3 = first !== 43; + if (!t3 || first === 45) + t1.readChar$0(); + if (t1.peekChar$0() !== 46) + _this._consumeNaturalNumber$0(); + _this._tryDecimal$1$allowTrailingDot(t1._string_scanner$_position !== t2 && t3 && first !== 45); + _this._tryExponent$0(); + number = A.double_parse(t1.substring$1(0, t2)); + if (t1.scanChar$1(37)) + unit = "%"; + else { + if (_this.lookingAtIdentifier$0()) + t3 = t1.peekChar$0() !== 45 || t1.peekChar$1(1) !== 45; + else + t3 = false; + unit = t3 ? _this.identifier$1$unit(true) : null; + } + return new A.NumberExpression(number, unit, t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + _consumeNaturalNumber$0() { + var $self, + t1 = this.scanner, + t2 = t1.readChar$0(); + if (!(t2 >= 48 && t2 <= 57)) + t1.error$2$position(0, "Expected digit.", t1._string_scanner$_position - 1); + while (true) { + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + break; + t1.readChar$0(); + } + }, + _tryDecimal$1$allowTrailingDot(allowTrailingDot) { + var $self, + t1 = this.scanner; + if (t1.peekChar$0() !== 46) + return; + $self = t1.peekChar$1(1); + if (!($self != null && $self >= 48 && $self <= 57)) { + if (allowTrailingDot) + return; + t1.error$2$position(0, "Expected digit.", t1._string_scanner$_position + 1); + } + t1.readChar$0(); + while (true) { + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + break; + t1.readChar$0(); + } + }, + _tryExponent$0() { + var next, $self, + t1 = this.scanner, + first = t1.peekChar$0(); + if (first !== 101 && first !== 69) + return; + next = t1.peekChar$1(1); + if (!(next != null && next >= 48 && next <= 57) && next !== 45 && next !== 43) + return; + t1.readChar$0(); + if (43 === next || 45 === next) + t1.readChar$0(); + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + t1.error$1(0, "Expected digit."); + while (true) { + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + break; + t1.readChar$0(); + } + }, + _unicodeRange$0() { + var firstRangeLength, hasQuestionMark, t2, secondRangeLength, _this = this, + _s26_ = "Expected at most 6 digits.", + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + _this.expectIdentChar$1(117); + t1.expectChar$1(43); + for (firstRangeLength = 0; _this.scanCharIf$1(new A.StylesheetParser__unicodeRange_closure());) + ++firstRangeLength; + for (hasQuestionMark = false; t1.scanChar$1(63); hasQuestionMark = true) + ++firstRangeLength; + if (firstRangeLength === 0) + t1.error$1(0, 'Expected hex digit or "?".'); + else if (firstRangeLength > 6) + _this.error$2(0, _s26_, t1.spanFrom$1(start)); + else if (hasQuestionMark) { + t2 = t1.substring$1(0, start.position); + t1 = t1.spanFrom$1(start); + return new A.StringExpression(new A.Interpolation(A.List_List$unmodifiable([t2], type$.Object), B.List_null, t1), false); + } + if (t1.scanChar$1(45)) { + t2 = t1._string_scanner$_position; + for (secondRangeLength = 0; _this.scanCharIf$1(new A.StylesheetParser__unicodeRange_closure0());) + ++secondRangeLength; + if (secondRangeLength === 0) + t1.error$1(0, "Expected hex digit."); + else if (secondRangeLength > 6) + _this.error$2(0, _s26_, t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + } + if (_this._lookingAtInterpolatedIdentifierBody$0()) + t1.error$1(0, "Expected end of identifier."); + t2 = t1.substring$1(0, start.position); + t1 = t1.spanFrom$1(start); + return new A.StringExpression(new A.Interpolation(A.List_List$unmodifiable([t2], type$.Object), B.List_null, t1), false); + }, + _variable$0() { + var _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + $name = _this.variableName$0(); + if (_this.get$plainCss()) + _this.error$2(0, string$.Sassx20v, t1.spanFrom$1(start)); + return new A.VariableExpression(null, $name, t1.spanFrom$1(start)); + }, + _selector$0() { + var t1, start, _this = this; + if (_this.get$plainCss()) + _this.scanner.error$2$length(0, string$.The_pa, 1); + t1 = _this.scanner; + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expectChar$1(38); + if (t1.scanChar$1(38)) { + _this.warnings.push(new A._Record_3_deprecation_message_span(null, string$.In_Sas, t1.spanFrom$1(start))); + t1.set$position(t1._string_scanner$_position - 1); + } + return new A.SelectorExpression(t1.spanFrom$1(start)); + }, + interpolatedString$0() { + var t3, t4, t5, buffer, _1_0, second, t6, _0_0, + t1 = this.scanner, + t2 = t1._string_scanner$_position, + quote = t1.readChar$0(); + if (quote !== 39 && quote !== 34) + t1.error$2$position(0, "Expected string.", t2); + t3 = new A.StringBuffer(""); + t4 = A._setArrayType([], type$.JSArray_Object); + t5 = A._setArrayType([], type$.JSArray_nullable_FileSpan); + buffer = new A.InterpolationBuffer(t3, t4, t5); + for (; true;) { + _1_0 = t1.peekChar$0(); + if (_1_0 === quote) { + t1.readChar$0(); + break; + } + if (_1_0 == null || _1_0 === 10 || _1_0 === 13 || _1_0 === 12) + t1.error$1(0, "Expected " + A.Primitives_stringFromCharCode(quote) + "."); + if (92 === _1_0) { + second = t1.peekChar$1(1); + if (second === 10 || second === 13 || second === 12) { + t1.readChar$0(); + t1.readChar$0(); + if (second === 13) + t1.scanChar$1(10); + } else { + t6 = A.Primitives_stringFromCharCode(A.consumeEscapedCharacter(t1)); + t3._contents += t6; + } + continue; + } + if (35 === _1_0 && t1.peekChar$1(1) === 123) { + _0_0 = this.singleInterpolation$0(); + buffer._flushText$0(); + t4.push(_0_0._0); + t5.push(_0_0._1); + continue; + } + t6 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t6; + } + return new A.StringExpression(buffer.interpolation$1(t1.spanFrom$1(new A._SpanScannerState(t1, t2))), true); + }, + identifierLike$0() { + var invocation, expression, _0_0, t3, t4, t5, _1_0, _2_0, _2_2, _2_4, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + identifier = _this.interpolatedIdentifier$0(), + plain = identifier.get$asPlain(), + lower = A._Cell$(), + t2 = plain != null; + if (t2) { + if (plain === "if" && t1.peekChar$0() === 40) { + invocation = _this._argumentInvocation$0(); + return new A.IfExpression(invocation, identifier.span.expand$1(0, invocation.span)); + } else if (plain === "not") { + _this.whitespace$1$consumeNewlines(true); + expression = _this._singleExpression$0(); + return new A.UnaryOperationExpression(B.UnaryOperator_not_not_not, expression, identifier.span.expand$1(0, expression.get$span(expression))); + } + lower.__late_helper$_value = plain.toLowerCase(); + if (t1.peekChar$0() !== 40) { + switch (plain) { + case "false": + return new A.BooleanExpression(false, identifier.span); + case "null": + return new A.NullExpression(identifier.span); + case "true": + return new A.BooleanExpression(true, identifier.span); + } + _0_0 = $.$get$colorsByName().$index(0, lower._readLocal$0()); + if (_0_0 != null) { + t1 = B.JSNumber_methods.round$0(_0_0._legacyChannel$2(B.RgbColorSpace_i0P, "red")); + t2 = B.JSNumber_methods.round$0(_0_0._legacyChannel$2(B.RgbColorSpace_i0P, "green")); + t3 = B.JSNumber_methods.round$0(_0_0._legacyChannel$2(B.RgbColorSpace_i0P, "blue")); + t4 = _0_0.alphaOrNull; + if (t4 == null) + t4 = 0; + t5 = identifier.span; + return new A.ColorExpression(A.SassColor_SassColor$rgbInternal(t1, t2, t3, t4, new A.SpanColorFormat(t5)), t5); + } + } + _1_0 = _this.trySpecialFunction$2(lower._readLocal$0(), start); + if (_1_0 != null) + return _1_0; + } + _2_0 = t1.peekChar$0(); + _2_2 = 46 === _2_0; + if (_2_2 && t1.peekChar$1(1) === 46) + return new A.StringExpression(identifier, false); + if (_2_2) { + t1.readChar$0(); + if (t2) + return _this.namespacedExpression$2(plain, start); + _this.error$2(0, string$.Interpn, identifier.span); + } + _2_4 = 40 === _2_0; + if (_2_4 && t2) { + t2 = _this._argumentInvocation$1$allowEmptySecondArg(J.$eq$(lower._readLocal$0(), "var")); + t1 = t1.spanFrom$1(start); + return new A.FunctionExpression(null, A.stringReplaceAllUnchecked(plain, "_", "-"), plain, t2, t1); + } + if (_2_4) + return new A.InterpolatedFunctionExpression(identifier, _this._argumentInvocation$0(), t1.spanFrom$1(start)); + return new A.StringExpression(identifier, false); + }, + namespacedExpression$2(namespace, start) { + var $name, t2, t3, _this = this, + t1 = _this.scanner; + if (t1.peekChar$0() === 36) { + $name = _this.variableName$0(); + _this._assertPublic$2($name, new A.StylesheetParser_namespacedExpression_closure(_this, start)); + return new A.VariableExpression(namespace, $name, t1.spanFrom$1(start)); + } + t2 = _this._publicIdentifier$0(); + t3 = _this._argumentInvocation$0(); + t1 = t1.spanFrom$1(start); + return new A.FunctionExpression(namespace, A.stringReplaceAllUnchecked(t2, "_", "-"), t2, t3, t1); + }, + trySpecialFunction$2($name, start) { + var t1, buffer, t2, next, t3, _this = this, + normalized = A.unvendor($name); + $label0$0: { + if (!("calc" === normalized && normalized !== $name && _this.scanner.scanChar$1(40))) + t1 = ("element" === normalized || "expression" === normalized) && _this.scanner.scanChar$1(40); + else + t1 = true; + if (t1) { + t1 = new A.StringBuffer(""); + buffer = new A.InterpolationBuffer(t1, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t1._contents = "" + $name; + t2 = A.Primitives_stringFromCharCode(40); + t1._contents += t2; + break $label0$0; + } + if ("progid" === normalized && _this.scanner.scanChar$1(58)) { + t1 = new A.StringBuffer(""); + buffer = new A.InterpolationBuffer(t1, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t1._contents = "" + $name; + t2 = A.Primitives_stringFromCharCode(58); + t1._contents += t2; + t2 = _this.scanner; + next = t2.peekChar$0(); + while (true) { + if (next != null) { + if (!(next >= 97 && next <= 122)) + t3 = next >= 65 && next <= 90; + else + t3 = true; + t3 = t3 || next === 46; + } else + t3 = false; + if (!t3) + break; + t3 = A.Primitives_stringFromCharCode(t2.readChar$0()); + t1._contents += t3; + next = t2.peekChar$0(); + } + t2.expectChar$1(40); + t2 = A.Primitives_stringFromCharCode(40); + t1._contents += t2; + break $label0$0; + } + if ("url" === normalized) + return A.NullableExtension_andThen(_this._tryUrlContents$1(start), new A.StylesheetParser_trySpecialFunction_closure()); + return null; + } + buffer.addInterpolation$1(_this._interpolatedDeclarationValue$1$allowEmpty(true)); + t1 = _this.scanner; + t1.expectChar$1(41); + t2 = buffer._interpolation_buffer$_text; + t3 = A.Primitives_stringFromCharCode(41); + t2._contents += t3; + return new A.StringExpression(buffer.interpolation$1(t1.spanFrom$1(start)), false); + }, + _tryUrlContents$2$name(start, $name) { + var t3, t4, t5, buffer, t6, _1_0, _1_6, _0_0, endPosition, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position; + if (!t1.scanChar$1(40)) + return null; + _this.whitespaceWithoutComments$1$consumeNewlines(true); + t3 = new A.StringBuffer(""); + t4 = A._setArrayType([], type$.JSArray_Object); + t5 = A._setArrayType([], type$.JSArray_nullable_FileSpan); + buffer = new A.InterpolationBuffer(t3, t4, t5); + t3._contents = "" + ($name == null ? "url" : $name); + t6 = A.Primitives_stringFromCharCode(40); + t3._contents += t6; + for (; true;) { + _1_0 = t1.peekChar$0(); + if (_1_0 == null) + break; + if (92 === _1_0) { + t6 = _this.escape$0(); + t3._contents += t6; + continue; + } + _1_6 = 35 === _1_0; + if (_1_6 && t1.peekChar$1(1) === 123) { + _0_0 = _this.singleInterpolation$0(); + buffer._flushText$0(); + t4.push(_0_0._0); + t5.push(_0_0._1); + continue; + } + t6 = true; + if (33 !== _1_0) + if (37 !== _1_0) + if (38 !== _1_0) + if (!_1_6) + t6 = _1_0 >= 42 && _1_0 <= 126 || _1_0 >= 128; + if (t6) { + t6 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t6; + continue; + } + if (_1_0 === 32 || _1_0 === 9 || _1_0 === 10 || _1_0 === 13 || _1_0 === 12) { + _this.whitespaceWithoutComments$1$consumeNewlines(true); + if (t1.peekChar$0() !== 41) + break; + continue; + } + if (41 === _1_0) { + t2 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t2; + endPosition = t1._string_scanner$_position; + t2 = t1._sourceFile; + t3 = start.position; + t1 = new A._FileSpan(t2, t3, endPosition); + t1._FileSpan$3(t2, t3, endPosition); + return buffer.interpolation$1(t1); + } + break; + } + t1.set$state(new A._SpanScannerState(t1, t2)); + return null; + }, + _tryUrlContents$1(start) { + return this._tryUrlContents$2$name(start, null); + }, + dynamicUrl$0() { + var _0_0, t2, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + _this.expectIdentifier$1("url"); + _0_0 = _this._tryUrlContents$1(start); + if (_0_0 != null) + return new A.StringExpression(_0_0, false); + t2 = t1.spanFrom$1(start); + return new A.InterpolatedFunctionExpression(new A.Interpolation(A.List_List$unmodifiable(["url"], type$.Object), B.List_null, t2), _this._argumentInvocation$0(), t1.spanFrom$1(start)); + }, + almostAnyValue$1$omitComments(omitComments) { + var t4, t5, t6, t7, _2_0, t8, _0_0, _0_2, start, end, _0_4, identifier, _1_0, bracket, char, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + t3 = new A.StringBuffer(""), + buffer = new A.InterpolationBuffer(t3, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)), + brackets = A._setArrayType([], type$.JSArray_int); + for (t4 = t1.string, t5 = t4.length, t6 = !omitComments, t7 = _this.get$loudComment(); true;) + $label0$0: { + _2_0 = t1.peekChar$0(); + if (92 === _2_0) { + t8 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t8; + t8 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t8; + break $label0$0; + } + if (34 === _2_0 || 39 === _2_0) { + buffer.addInterpolation$1(_this.interpolatedString$0().asInterpolation$0()); + break $label0$0; + } + if (47 === _2_0) { + $label1$1: { + _0_0 = t1.peekChar$1(1); + _0_2 = 42 === _0_0; + if (_0_2 && t6) { + start = t1._string_scanner$_position; + t7.call$0(); + end = t1._string_scanner$_position; + t3._contents += B.JSString_methods.substring$2(t4, start, end); + break $label1$1; + } + if (_0_2) { + _this.loudComment$0(); + break $label1$1; + } + _0_4 = 47 === _0_0; + if (_0_4 && t6) { + t8 = _this.get$silentComment(); + start = t1._string_scanner$_position; + t8.call$0(); + end = t1._string_scanner$_position; + t3._contents += B.JSString_methods.substring$2(t4, start, end); + break $label1$1; + } + if (_0_4) { + _this.silentComment$0(); + break $label1$1; + } + t8 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t8; + } + break $label0$0; + } + if (35 === _2_0 && t1.peekChar$1(1) === 123) { + buffer.addInterpolation$1(_this.interpolatedIdentifier$0()); + break $label0$0; + } + if (13 === _2_0 || 10 === _2_0 || 12 === _2_0) { + if (_this.get$indented() && brackets.length === 0) + break; + t8 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t8; + break $label0$0; + } + if (33 === _2_0 || 59 === _2_0 || 123 === _2_0 || 125 === _2_0) + break; + if (117 === _2_0 || 85 === _2_0) { + t8 = t1._string_scanner$_position; + identifier = _this.identifier$0(); + if (identifier !== "url" && identifier !== "url-prefix") { + t3._contents += identifier; + continue; + } + _1_0 = _this._tryUrlContents$2$name(new A._SpanScannerState(t1, t8), identifier); + if (_1_0 != null) + buffer.addInterpolation$1(_1_0); + else { + if ((t8 === 0 ? 1 / t8 < 0 : t8 < 0) || t8 > t5) + A.throwExpression(A.ArgumentError$("Invalid position " + t8, null)); + t1._string_scanner$_position = t8; + t1._lastMatch = null; + t8 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t8; + } + break $label0$0; + } + if (40 === _2_0 || 91 === _2_0) { + bracket = t1.readChar$0(); + t8 = A.Primitives_stringFromCharCode(bracket); + t3._contents += t8; + brackets.push(A.opposite(bracket)); + break $label0$0; + } + if (41 === _2_0 || 93 === _2_0) { + t8 = _2_0 != null; + char = t8 ? _2_0 : null; + } else { + char = null; + t8 = false; + } + if (t8) { + if (brackets.length === 0) + t1.error$1(0, 'Unexpected "' + A.Primitives_stringFromCharCode(char) + '".'); + bracket = brackets.pop(); + t1.expectChar$1(bracket); + t8 = A.Primitives_stringFromCharCode(bracket); + t3._contents += t8; + break $label0$0; + } + if (_2_0 == null) + break; + t8 = _this.lookingAtIdentifier$0(); + if (t8) { + t8 = _this.identifier$0(); + t3._contents += t8; + break $label0$0; + } + t8 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t8; + } + return buffer.interpolation$1(t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + almostAnyValue$0() { + return this.almostAnyValue$1$omitComments(false); + }, + _interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(allowColon, allowEmpty, allowOpenBrace, allowSemicolon, consumeNewlines, silentComments) { + var t4, t5, t6, t7, t8, t9, t10, wroteNewline, _2_0, wroteNewline0, t11, _0_0, start, end, _2_14_isSet, _2_14, t12, _2_18_isSet, _2_20, _2_18, _2_20_isSet, _2_22, bracket, identifier, _1_0, _this = this, _null = null, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + t3 = new A.StringBuffer(""), + buffer = new A.InterpolationBuffer(t3, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)), + brackets = A._setArrayType([], type$.JSArray_int); + for (t4 = !consumeNewlines, t5 = !allowOpenBrace, t6 = t1.string, t7 = t6.length, t8 = !allowColon, t9 = !allowSemicolon, t10 = _this.get$loudComment(), wroteNewline = false; true;) + $label0$0: { + _2_0 = t1.peekChar$0(); + wroteNewline0 = false; + if (92 === _2_0) { + t11 = _this.escape$1$identifierStart(true); + t3._contents += t11; + wroteNewline = wroteNewline0; + break $label0$0; + } + if (34 === _2_0 || 39 === _2_0) { + buffer.addInterpolation$1(_this.interpolatedString$0().asInterpolation$0()); + wroteNewline = wroteNewline0; + break $label0$0; + } + if (47 === _2_0) { + $label1$1: { + _0_0 = t1.peekChar$1(1); + if (42 === _0_0) { + start = t1._string_scanner$_position; + t10.call$0(); + end = t1._string_scanner$_position; + t3._contents += B.JSString_methods.substring$2(t6, start, end); + break $label1$1; + } + if (47 === _0_0 && silentComments) { + _this.silentComment$0(); + break $label1$1; + } + t11 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t11; + } + wroteNewline = wroteNewline0; + break $label0$0; + } + if (35 === _2_0 && t1.peekChar$1(1) === 123) { + buffer.addInterpolation$1(_this.interpolatedIdentifier$0()); + wroteNewline = wroteNewline0; + break $label0$0; + } + _2_14_isSet = 32 !== _2_0; + if (_2_14_isSet) { + _2_14 = 9 === _2_0; + t11 = _2_14; + } else { + _2_14 = _null; + t11 = true; + } + t12 = false; + if (t11) + if (!wroteNewline) { + t11 = t1.peekChar$1(1); + t11 = t11 === 32 || t11 === 9 || t11 === 10 || t11 === 13 || t11 === 12; + } else + t11 = t12; + else + t11 = t12; + if (t11) { + t1.readChar$0(); + break $label0$0; + } + if (_2_14_isSet) + t11 = _2_14; + else + t11 = true; + if (t11) { + t11 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t11; + break $label0$0; + } + _2_18_isSet = 10 !== _2_0; + _2_20 = _null; + t11 = true; + if (_2_18_isSet) { + _2_18 = 13 === _2_0; + _2_20_isSet = !_2_18; + if (_2_20_isSet) { + _2_20 = 12 === _2_0; + t11 = _2_20; + } + } else { + _2_18 = _null; + _2_20_isSet = false; + } + if (t11 && _this.get$indented() && t4 && brackets.length === 0) + break; + t11 = true; + if (_2_18_isSet) + if (!_2_18) + t11 = _2_20_isSet ? _2_20 : 12 === _2_0; + if (t11) { + t11 = t1.peekChar$1(-1); + if (!(t11 === 10 || t11 === 13 || t11 === 12)) + t3._contents += "\n"; + t1.readChar$0(); + wroteNewline = true; + break $label0$0; + } + _2_22 = 123 === _2_0; + if (_2_22 && t5) + break; + if (40 !== _2_0) + t11 = _2_22 || 91 === _2_0; + else + t11 = true; + if (t11) { + bracket = t1.readChar$0(); + t11 = A.Primitives_stringFromCharCode(bracket); + t3._contents += t11; + brackets.push(A.opposite(bracket)); + wroteNewline = wroteNewline0; + break $label0$0; + } + if (41 === _2_0 || 125 === _2_0 || 93 === _2_0) { + if (brackets.length === 0) + break; + bracket = brackets.pop(); + t1.expectChar$1(bracket); + t11 = A.Primitives_stringFromCharCode(bracket); + t3._contents += t11; + wroteNewline = wroteNewline0; + break $label0$0; + } + if (59 === _2_0) { + if (t9 && brackets.length === 0) + break; + t11 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t11; + wroteNewline = wroteNewline0; + break $label0$0; + } + if (58 === _2_0) { + if (t8 && brackets.length === 0) + break; + t11 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t11; + wroteNewline = wroteNewline0; + break $label0$0; + } + if (117 === _2_0 || 85 === _2_0) { + t11 = t1._string_scanner$_position; + identifier = _this.identifier$0(); + if (identifier !== "url" && identifier !== "url-prefix") { + t3._contents += identifier; + wroteNewline = wroteNewline0; + continue; + } + _1_0 = _this._tryUrlContents$2$name(new A._SpanScannerState(t1, t11), identifier); + if (_1_0 != null) + buffer.addInterpolation$1(_1_0); + else { + if ((t11 === 0 ? 1 / t11 < 0 : t11 < 0) || t11 > t7) + A.throwExpression(A.ArgumentError$("Invalid position " + t11, _null)); + t1._string_scanner$_position = t11; + t1._lastMatch = null; + t11 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t11; + } + wroteNewline = wroteNewline0; + break $label0$0; + } + if (_2_0 == null) + break; + t11 = _this.lookingAtIdentifier$0(); + if (t11) { + t11 = _this.identifier$0(); + t3._contents += t11; + wroteNewline = wroteNewline0; + break $label0$0; + } + t11 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t11; + wroteNewline = wroteNewline0; + } + if (brackets.length !== 0) + t1.expectChar$1(B.JSArray_methods.get$last(brackets)); + if (!allowEmpty && buffer._interpolation_buffer$_contents.length === 0 && t3._contents.length === 0) + t1.error$1(0, "Expected token."); + return buffer.interpolation$1(t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + _interpolatedDeclarationValue$1$allowEmpty(allowEmpty) { + return this._interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(true, allowEmpty, true, false, false, true); + }, + _interpolatedDeclarationValue$1$allowOpenBrace(allowOpenBrace) { + return this._interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(true, false, allowOpenBrace, false, false, true); + }, + _interpolatedDeclarationValue$3$allowEmpty$allowSemicolon$consumeNewlines(allowEmpty, allowSemicolon, consumeNewlines) { + return this._interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(true, allowEmpty, true, allowSemicolon, consumeNewlines, true); + }, + _interpolatedDeclarationValue$4$allowColon$allowEmpty$allowSemicolon$consumeNewlines(allowColon, allowEmpty, allowSemicolon, consumeNewlines) { + return this._interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(allowColon, allowEmpty, true, allowSemicolon, consumeNewlines, true); + }, + _interpolatedDeclarationValue$0() { + return this._interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(true, false, true, false, false, true); + }, + _interpolatedDeclarationValue$2$allowEmpty$allowOpenBrace(allowEmpty, allowOpenBrace) { + return this._interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(true, allowEmpty, allowOpenBrace, false, false, true); + }, + _interpolatedDeclarationValue$1$silentComments(silentComments) { + return this._interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(true, false, true, false, false, silentComments); + }, + interpolatedIdentifier$0() { + var t3, _1_0, _0_0, _this = this, + _s20_ = "Expected identifier.", + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + t2 = new A.StringBuffer(""), + buffer = new A.InterpolationBuffer(t2, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + if (t1.scanChar$1(45)) { + t3 = A.Primitives_stringFromCharCode(45); + t2._contents += t3; + if (t1.scanChar$1(45)) { + t3 = A.Primitives_stringFromCharCode(45); + t2._contents += t3; + _this._interpolatedIdentifierBody$1(buffer); + return buffer.interpolation$1(t1.spanFrom$1(start)); + } + } + $label0$0: { + _1_0 = t1.peekChar$0(); + if (_1_0 == null) + t1.error$1(0, _s20_); + if (_1_0 === 95 || A.CharacterExtension_get_isAlphabetic(_1_0) || _1_0 >= 128) { + t3 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t3; + break $label0$0; + } + if (92 === _1_0) { + t3 = _this.escape$1$identifierStart(true); + t2._contents += t3; + break $label0$0; + } + if (35 === _1_0 && t1.peekChar$1(1) === 123) { + _0_0 = _this.singleInterpolation$0(); + buffer.add$2(0, _0_0._0, _0_0._1); + break $label0$0; + } + t1.error$1(0, _s20_); + } + _this._interpolatedIdentifierBody$1(buffer); + return buffer.interpolation$1(t1.spanFrom$1(start)); + }, + _interpolatedIdentifierBody$1(buffer) { + var t1, t2, t3, t4, _1_0, t5, _0_0; + for (t1 = buffer._interpolation_buffer$_contents, t2 = buffer._spans, t3 = this.scanner, t4 = buffer._interpolation_buffer$_text; true;) { + _1_0 = t3.peekChar$0(); + if (_1_0 == null) + break; + t5 = true; + if (95 !== _1_0) + if (45 !== _1_0) { + if (!(_1_0 >= 97 && _1_0 <= 122)) + t5 = _1_0 >= 65 && _1_0 <= 90; + else + t5 = true; + if (!t5) + t5 = _1_0 >= 48 && _1_0 <= 57; + else + t5 = true; + t5 = t5 || _1_0 >= 128; + } + if (t5) { + t5 = A.Primitives_stringFromCharCode(t3.readChar$0()); + t4._contents += t5; + continue; + } + if (92 === _1_0) { + t5 = this.escape$0(); + t4._contents += t5; + continue; + } + if (35 === _1_0 && t3.peekChar$1(1) === 123) { + _0_0 = this.singleInterpolation$0(); + buffer._flushText$0(); + t1.push(_0_0._0); + t2.push(_0_0._1); + continue; + } + break; + } + }, + singleInterpolation$0() { + var contents, span, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position; + t1.expect$1("#{"); + _this.whitespace$1$consumeNewlines(true); + contents = _this._expression$1$consumeNewlines(true); + t1.expectChar$1(125); + span = t1.spanFrom$1(new A._SpanScannerState(t1, t2)); + if (_this.get$plainCss()) + _this.error$2(0, string$.Interpp, span); + return new A._Record_2(contents, span); + }, + _mediaQueryList$0() { + var t4, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + t3 = new A.StringBuffer(""), + buffer = new A.InterpolationBuffer(t3, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + for (; true;) { + _this.whitespace$1$consumeNewlines(false); + _this._stylesheet$_mediaQuery$1(buffer); + _this.whitespace$1$consumeNewlines(false); + if (!t1.scanChar$1(44)) + break; + t4 = A.Primitives_stringFromCharCode(44); + t3._contents += t4; + t4 = A.Primitives_stringFromCharCode(32); + t3._contents += t4; + } + return buffer.interpolation$1(t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + _stylesheet$_mediaQuery$1(buffer) { + var identifier1, t1, t2, identifier2, _this = this, _s3_ = "and"; + if (_this.scanner.peekChar$0() === 40) { + _this._stylesheet$_mediaInParens$1(buffer); + _this.whitespace$1$consumeNewlines(false); + if (_this.scanIdentifier$1(_s3_)) { + buffer._interpolation_buffer$_text._contents += " and "; + _this.expectWhitespace$0(); + _this._stylesheet$_mediaLogicSequence$2(buffer, _s3_); + } else if (_this.scanIdentifier$1("or")) { + buffer._interpolation_buffer$_text._contents += " or "; + _this.expectWhitespace$0(); + _this._stylesheet$_mediaLogicSequence$2(buffer, "or"); + } + return; + } + identifier1 = _this.interpolatedIdentifier$0(); + if (A.equalsIgnoreCase(identifier1.get$asPlain(), "not")) { + _this.expectWhitespace$0(); + if (!_this._lookingAtInterpolatedIdentifier$0()) { + buffer._interpolation_buffer$_text._contents += "not "; + _this._mediaOrInterp$1(buffer); + return; + } + } + _this.whitespace$1$consumeNewlines(false); + buffer.addInterpolation$1(identifier1); + if (!_this._lookingAtInterpolatedIdentifier$0()) + return; + t1 = buffer._interpolation_buffer$_text; + t2 = A.Primitives_stringFromCharCode(32); + t1._contents += t2; + identifier2 = _this.interpolatedIdentifier$0(); + if (A.equalsIgnoreCase(identifier2.get$asPlain(), _s3_)) { + _this.expectWhitespace$0(); + t1._contents += " and "; + } else { + _this.whitespace$1$consumeNewlines(false); + buffer.addInterpolation$1(identifier2); + if (_this.scanIdentifier$1(_s3_)) { + _this.expectWhitespace$0(); + t1._contents += " and "; + } else + return; + } + if (_this.scanIdentifier$1("not")) { + _this.expectWhitespace$0(); + t1._contents += "not "; + _this._mediaOrInterp$1(buffer); + return; + } + _this._stylesheet$_mediaLogicSequence$2(buffer, _s3_); + return; + }, + _stylesheet$_mediaLogicSequence$2(buffer, operator) { + var t1, t2, _this = this; + for (t1 = buffer._interpolation_buffer$_text; true;) { + _this._mediaOrInterp$1(buffer); + _this.whitespace$1$consumeNewlines(false); + if (!_this.scanIdentifier$1(operator)) + return; + _this.expectWhitespace$1$consumeNewlines(false); + t2 = A.Primitives_stringFromCharCode(32); + t2 = t1._contents += t2; + t1._contents = t2 + operator; + t2 = A.Primitives_stringFromCharCode(32); + t1._contents += t2; + } + }, + _mediaOrInterp$1(buffer) { + var _0_0; + if (this.scanner.peekChar$0() === 35) { + _0_0 = this.singleInterpolation$0(); + buffer.add$2(0, _0_0._0, _0_0._1); + } else + this._stylesheet$_mediaInParens$1(buffer); + }, + _stylesheet$_mediaInParens$1(buffer) { + var t2, t3, expressionBefore, expressionAfter, next, t4, expressionMiddle, _this = this, + t1 = _this.scanner; + t1.expectChar$2$name(40, "media condition in parentheses"); + t2 = buffer._interpolation_buffer$_text; + t3 = A.Primitives_stringFromCharCode(40); + t2._contents += t3; + _this.whitespace$1$consumeNewlines(true); + if (t1.peekChar$0() === 40) { + _this._stylesheet$_mediaInParens$1(buffer); + _this.whitespace$1$consumeNewlines(true); + if (_this.scanIdentifier$1("and")) { + t2._contents += " and "; + _this.expectWhitespace$1$consumeNewlines(true); + _this._stylesheet$_mediaLogicSequence$2(buffer, "and"); + } else if (_this.scanIdentifier$1("or")) { + t2._contents += " or "; + _this.expectWhitespace$1$consumeNewlines(true); + _this._stylesheet$_mediaLogicSequence$2(buffer, "or"); + } + } else if (_this.scanIdentifier$1("not")) { + t2._contents += "not "; + _this.expectWhitespace$1$consumeNewlines(true); + _this._mediaOrInterp$1(buffer); + } else { + expressionBefore = _this._expressionUntilComparison$0(); + buffer.add$2(0, expressionBefore, expressionBefore.get$span(expressionBefore)); + if (t1.scanChar$1(58)) { + _this.whitespace$1$consumeNewlines(true); + t3 = A.Primitives_stringFromCharCode(58); + t2._contents += t3; + t3 = A.Primitives_stringFromCharCode(32); + t2._contents += t3; + expressionAfter = _this._expression$1$consumeNewlines(true); + buffer.add$2(0, expressionAfter, expressionAfter.get$span(expressionAfter)); + } else { + next = t1.peekChar$0(); + t3 = 60 !== next; + if (!t3 || 62 === next || 61 === next) { + t4 = A.Primitives_stringFromCharCode(32); + t2._contents += t4; + t4 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t4; + if ((!t3 || 62 === next) && t1.scanChar$1(61)) { + t4 = A.Primitives_stringFromCharCode(61); + t2._contents += t4; + } + t4 = A.Primitives_stringFromCharCode(32); + t2._contents += t4; + _this.whitespace$1$consumeNewlines(true); + expressionMiddle = _this._expressionUntilComparison$0(); + buffer.add$2(0, expressionMiddle, expressionMiddle.get$span(expressionMiddle)); + if (!t3 || 62 === next) { + next.toString; + t3 = t1.scanChar$1(next); + } else + t3 = false; + if (t3) { + t3 = A.Primitives_stringFromCharCode(32); + t2._contents += t3; + t3 = A.Primitives_stringFromCharCode(next); + t2._contents += t3; + if (t1.scanChar$1(61)) { + t3 = A.Primitives_stringFromCharCode(61); + t2._contents += t3; + } + t3 = A.Primitives_stringFromCharCode(32); + t2._contents += t3; + _this.whitespace$1$consumeNewlines(true); + expressionAfter = _this._expressionUntilComparison$0(); + buffer.add$2(0, expressionAfter, expressionAfter.get$span(expressionAfter)); + } + } + } + } + t1.expectChar$1(41); + _this.whitespace$1$consumeNewlines(false); + t1 = A.Primitives_stringFromCharCode(41); + t2._contents += t1; + }, + _expressionUntilComparison$0() { + return this._expression$2$consumeNewlines$until(true, new A.StylesheetParser__expressionUntilComparison_closure(this)); + }, + _supportsCondition$1$inParentheses(inParentheses) { + var condition, operator, right, endPosition, t3, t4, lowerOperator, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position; + if (_this.scanIdentifier$1("not")) { + _this.whitespace$1$consumeNewlines(inParentheses); + return new A.SupportsNegation(_this._supportsConditionInParens$0(), t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + } + condition = _this._supportsConditionInParens$0(); + _this.whitespace$1$consumeNewlines(inParentheses); + for (operator = null; _this.lookingAtIdentifier$0();) { + if (operator != null) + _this.expectIdentifier$1(operator); + else if (_this.scanIdentifier$1("or")) + operator = "or"; + else { + _this.expectIdentifier$1("and"); + operator = "and"; + } + _this.whitespace$1$consumeNewlines(inParentheses); + right = _this._supportsConditionInParens$0(); + endPosition = t1._string_scanner$_position; + t3 = t1._sourceFile; + t4 = new A._FileSpan(t3, t2, endPosition); + t4._FileSpan$3(t3, t2, endPosition); + condition = new A.SupportsOperation(condition, right, operator, t4); + lowerOperator = operator.toLowerCase(); + if (lowerOperator !== "and" && lowerOperator !== "or") + A.throwExpression(A.ArgumentError$value(operator, "operator", 'may only be "and" or "or".')); + _this.whitespace$1$consumeNewlines(inParentheses); + } + return condition; + }, + _supportsCondition$0() { + return this._supportsCondition$1$inParentheses(false); + }, + _supportsConditionInParens$0() { + var $name, nameStart, wasInParentheses, identifier, _1_0, operation, contents, identifier0, t2, $arguments, _0_0, _0_4_isSet, _0_4, _0_40, condition, exception, value, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + if (_this._lookingAtInterpolatedIdentifier$0()) { + identifier0 = _this.interpolatedIdentifier$0(); + t2 = identifier0.get$asPlain(); + if ((t2 == null ? null : t2.toLowerCase()) === "not") + _this.error$2(0, '"not" is not a valid identifier here.', identifier0.span); + if (t1.scanChar$1(40)) { + $arguments = _this._interpolatedDeclarationValue$3$allowEmpty$allowSemicolon$consumeNewlines(true, true, true); + t1.expectChar$1(41); + return new A.SupportsFunction(identifier0, $arguments, t1.spanFrom$1(start)); + } else { + _0_0 = identifier0.contents; + _0_4_isSet = _0_0.length === 1; + if (_0_4_isSet) { + _0_4 = _0_0[0]; + _0_40 = _0_4; + t2 = _0_4 instanceof A.Expression; + _0_4 = _0_40; + } else { + _0_4 = null; + t2 = false; + } + if (t2) { + t2 = _0_4_isSet ? _0_4 : _0_0[0]; + return new A.SupportsInterpolation(type$.Expression._as(t2), t1.spanFrom$1(start)); + } else + _this.error$2(0, "Expected @supports condition.", identifier0.span); + } + } + t1.expectChar$1(40); + _this.whitespace$1$consumeNewlines(true); + if (_this.scanIdentifier$1("not")) { + _this.whitespace$1$consumeNewlines(true); + condition = _this._supportsConditionInParens$0(); + t1.expectChar$1(41); + return new A.SupportsNegation(condition, t1.spanFrom$1(start)); + } else if (t1.peekChar$0() === 40) { + condition = _this._supportsCondition$1$inParentheses(true); + t1.expectChar$1(41); + return condition.withSpan$1(t1.spanFrom$1(start)); + } + $name = null; + nameStart = new A._SpanScannerState(t1, t1._string_scanner$_position); + wasInParentheses = _this._inParentheses; + try { + $name = _this._expression$1$consumeNewlines(true); + t1.expectChar$1(58); + } catch (exception) { + if (type$.FormatException._is(A.unwrapException(exception))) { + t1.set$state(nameStart); + _this._inParentheses = wasInParentheses; + identifier = _this.interpolatedIdentifier$0(); + _1_0 = _this._trySupportsOperation$2(identifier, nameStart); + operation = null; + if (_1_0 != null) { + operation = _1_0; + t1.expectChar$1(41); + t2 = operation; + t1 = t1.spanFrom$1(start); + return A.SupportsOperation$(t2.left, t2.right, t2.operator, t1); + } + t2 = new A.InterpolationBuffer(new A.StringBuffer(""), A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t2.addInterpolation$1(identifier); + t2.addInterpolation$1(_this._interpolatedDeclarationValue$4$allowColon$allowEmpty$allowSemicolon$consumeNewlines(false, true, true, true)); + contents = t2.interpolation$1(t1.spanFrom$1(nameStart)); + if (t1.peekChar$0() === 58) + throw exception; + t1.expectChar$1(41); + return new A.SupportsAnything(contents, t1.spanFrom$1(start)); + } else + throw exception; + } + value = _this._supportsDeclarationValue$1($name); + t1.expectChar$1(41); + return new A.SupportsDeclaration($name, value, t1.spanFrom$1(start)); + }, + _supportsDeclarationValue$1($name) { + var t1 = false; + if ($name instanceof A.StringExpression) + if (!$name.hasQuotes) + t1 = B.JSString_methods.startsWith$1($name.text.get$initialPlain(), "--"); + if (t1) + return new A.StringExpression(this._interpolatedDeclarationValue$0(), false); + else { + this.whitespace$1$consumeNewlines(true); + return this._expression$1$consumeNewlines(true); + } + }, + _trySupportsOperation$2(interpolation, start) { + var expression, beforeWhitespace, t2, t3, operator, operation, right, t4, endPosition, t5, t6, lowerOperator, _this = this, _null = null, + t1 = interpolation.contents; + if (t1.length !== 1) + return _null; + expression = B.JSArray_methods.get$first(t1); + if (!(expression instanceof A.Expression)) + return _null; + t1 = _this.scanner; + beforeWhitespace = new A._SpanScannerState(t1, t1._string_scanner$_position); + _this.whitespace$1$consumeNewlines(true); + for (t2 = start.position, t3 = interpolation.span, operator = _null, operation = operator; _this.lookingAtIdentifier$0();) { + if (operator != null) + _this.expectIdentifier$1(operator); + else if (_this.scanIdentifier$1("and")) + operator = "and"; + else { + if (!_this.scanIdentifier$1("or")) { + if (beforeWhitespace._scanner !== t1) + A.throwExpression(A.ArgumentError$(string$.The_gi, _null)); + t2 = beforeWhitespace.position; + if ((t2 === 0 ? 1 / t2 < 0 : t2 < 0) || t2 > t1.string.length) + A.throwExpression(A.ArgumentError$("Invalid position " + t2, _null)); + t1._string_scanner$_position = t2; + return t1._lastMatch = null; + } + operator = "or"; + } + _this.whitespace$1$consumeNewlines(true); + right = _this._supportsConditionInParens$0(); + t4 = operation == null ? new A.SupportsInterpolation(expression, t3) : operation; + endPosition = t1._string_scanner$_position; + t5 = t1._sourceFile; + t6 = new A._FileSpan(t5, t2, endPosition); + t6._FileSpan$3(t5, t2, endPosition); + operation = new A.SupportsOperation(t4, right, operator, t6); + lowerOperator = operator.toLowerCase(); + if (lowerOperator !== "and" && lowerOperator !== "or") + A.throwExpression(A.ArgumentError$value(operator, "operator", 'may only be "and" or "or".')); + _this.whitespace$1$consumeNewlines(true); + } + return operation; + }, + _lookingAtInterpolatedIdentifier$0() { + var t2, _0_0, + t1 = this.scanner, + _1_0 = t1.peekChar$0(); + $label0$0: { + t2 = false; + if (_1_0 == null) { + t1 = t2; + break $label0$0; + } + if (_1_0 === 95 || A.CharacterExtension_get_isAlphabetic(_1_0) || _1_0 >= 128 || 92 === _1_0) { + t1 = true; + break $label0$0; + } + if (35 === _1_0) { + t1 = t1.peekChar$1(1) === 123; + break $label0$0; + } + if (45 === _1_0) { + _0_0 = t1.peekChar$1(1); + $label1$1: { + if (_0_0 == null) { + t1 = t2; + break $label1$1; + } + if (35 === _0_0) { + t1 = t1.peekChar$1(2) === 123; + break $label1$1; + } + if (_0_0 === 95 || A.CharacterExtension_get_isAlphabetic(_0_0) || _0_0 >= 128 || 92 === _0_0 || 45 === _0_0) { + t1 = true; + break $label1$1; + } + t1 = t2; + break $label1$1; + } + break $label0$0; + } + t1 = t2; + break $label0$0; + } + return t1; + }, + _lookingAtPotentialPropertyHack$0() { + var t1 = this.scanner, + _0_0 = t1.peekChar$0(); + $label0$0: { + if (58 === _0_0 || 42 === _0_0 || 46 === _0_0) { + t1 = true; + break $label0$0; + } + if (35 === _0_0) { + t1 = t1.peekChar$1(1) !== 123; + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + _lookingAtInterpolatedIdentifierBody$0() { + var t2, t3, + t1 = this.scanner, + _0_0 = t1.peekChar$0(); + $label0$0: { + t2 = false; + if (_0_0 == null) { + t1 = t2; + break $label0$0; + } + if (!(_0_0 === 95 || A.CharacterExtension_get_isAlphabetic(_0_0) || _0_0 >= 128)) + t3 = _0_0 >= 48 && _0_0 <= 57 || _0_0 === 45; + else + t3 = true; + if (t3 || 92 === _0_0) { + t1 = true; + break $label0$0; + } + if (35 === _0_0) { + t1 = t1.peekChar$1(1) === 123; + break $label0$0; + } + t1 = t2; + break $label0$0; + } + return t1; + }, + _lookingAtExpression$0() { + var t2, _0_0, + t1 = this.scanner, + _1_0 = t1.peekChar$0(); + $label0$0: { + t2 = true; + if (_1_0 == null) { + t1 = false; + break $label0$0; + } + if (46 === _1_0) { + t1 = t1.peekChar$1(1) !== 46; + break $label0$0; + } + if (33 === _1_0) { + _0_0 = t1.peekChar$1(1); + $label1$1: { + if (_0_0 != null) + if (105 !== _0_0) + if (73 !== _0_0) + t1 = _0_0 === 32 || _0_0 === 9 || _0_0 === 10 || _0_0 === 13 || _0_0 === 12; + else + t1 = t2; + else + t1 = t2; + else + t1 = t2; + if (t1) + break $label1$1; + break $label1$1; + } + break $label0$0; + } + t1 = true; + if (40 !== _1_0) + if (47 !== _1_0) + if (91 !== _1_0) + if (39 !== _1_0) + if (34 !== _1_0) + if (35 !== _1_0) + if (43 !== _1_0) + if (45 !== _1_0) + if (92 !== _1_0) + if (36 !== _1_0) + if (38 !== _1_0) + if (37 !== _1_0) + if (!(_1_0 === 95 || A.CharacterExtension_get_isAlphabetic(_1_0) || _1_0 >= 128)) + t1 = _1_0 >= 48 && _1_0 <= 57; + if (t1) { + t1 = t2; + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + _withChildren$1$3(child, start, create) { + var result = create.call$2(this.children$1(0, child), this.scanner.spanFrom$1(start)); + this.whitespaceWithoutComments$1$consumeNewlines(false); + return result; + }, + _withChildren$3(child, start, create) { + return this._withChildren$1$3(child, start, create, type$.dynamic); + }, + _urlString$0() { + var innerError, stackTrace, t2, exception, + t1 = this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + url = this.string$0(); + try { + t2 = A.Uri_parse(url); + return t2; + } catch (exception) { + t2 = A.unwrapException(exception); + if (type$.FormatException._is(t2)) { + innerError = t2; + stackTrace = A.getTraceFromException(exception); + this.error$3(0, "Invalid URL: " + J.get$message$x(innerError), t1.spanFrom$1(start), stackTrace); + } else + throw exception; + } + }, + _publicIdentifier$0() { + var _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + result = _this.identifier$0(); + _this._assertPublic$2(result, new A.StylesheetParser__publicIdentifier_closure(_this, new A._SpanScannerState(t1, t2))); + return result; + }, + _assertPublic$2(identifier, span) { + var first = identifier.charCodeAt(0); + if (!(first === 45 || first === 95)) + return; + this.error$2(0, string$.Privat, span.call$0()); + }, + _addOrInject$2(buffer, expression) { + if (expression instanceof A.StringExpression && !expression.hasQuotes) + buffer.addInterpolation$1(expression.text); + else + buffer.add$2(0, expression, expression.get$span(expression)); + }, + get$plainCss() { + return false; + } + }; + A.StylesheetParser_parse_closure.prototype = { + call$0() { + var statements, + t1 = this.$this, + t2 = t1.scanner, + t3 = t2._string_scanner$_position; + t2.scanChar$1(65279); + statements = t1.statements$1(new A.StylesheetParser_parse__closure(t1)); + t2.expectDone$0(); + return A.Stylesheet$internal(statements, t2.spanFrom$1(new A._SpanScannerState(t2, t3)), t1.warnings, t1._globalVariables, t1.get$plainCss()); + }, + $signature: 538 + }; + A.StylesheetParser_parse__closure.prototype = { + call$0() { + var t1 = this.$this; + if (t1.scanner.scan$1("@charset")) { + t1.whitespace$1$consumeNewlines(false); + t1.string$0(); + return null; + } + return t1._statement$1$root(true); + }, + $signature: 539 + }; + A.StylesheetParser_parseParameterList_closure.prototype = { + call$0() { + var parameters, + t1 = this.$this, + t2 = t1.scanner; + t2.expectChar$2$name(64, "@-rule"); + t1.identifier$0(); + t1.whitespace$1$consumeNewlines(true); + t1.identifier$0(); + parameters = t1._parameterList$0(); + t1.whitespace$1$consumeNewlines(true); + t2.expectChar$1(123); + return parameters; + }, + $signature: 540 + }; + A.StylesheetParser_parseVariableDeclaration_closure.prototype = { + call$0() { + var t1 = this.$this; + return t1.lookingAtIdentifier$0() ? t1._variableDeclarationWithNamespace$0() : t1.variableDeclarationWithoutNamespace$0(); + }, + $signature: 542 + }; + A.StylesheetParser_parseUseRule_closure.prototype = { + call$0() { + var t1 = this.$this, + t2 = t1.scanner, + t3 = t2._string_scanner$_position; + t2.expectChar$2$name(64, "@-rule"); + t1.expectIdentifier$1("use"); + t1.whitespace$1$consumeNewlines(true); + return t1._useRule$1(new A._SpanScannerState(t2, t3)); + }, + $signature: 565 + }; + A.StylesheetParser__parseSingleProduction_closure.prototype = { + call$0() { + var result = this.production.call$0(); + this.$this.scanner.expectDone$0(); + return result; + }, + $signature() { + return this.T._eval$1("0()"); + } + }; + A.StylesheetParser__statement_closure.prototype = { + call$0() { + return this.$this._statement$0(); + }, + $signature: 121 + }; + A.StylesheetParser_variableDeclarationWithoutNamespace_closure.prototype = { + call$0() { + return this.$this.scanner.spanFrom$1(this.start); + }, + $signature: 29 + }; + A.StylesheetParser_variableDeclarationWithoutNamespace_closure0.prototype = { + call$0() { + return this.declaration.span; + }, + $signature: 29 + }; + A.StylesheetParser__declarationOrBuffer_closure.prototype = { + call$0() { + return this.$this.whitespace$1$consumeNewlines(false); + }, + $signature: 0 + }; + A.StylesheetParser__declarationOrBuffer_closure0.prototype = { + call$0() { + return this.$this.whitespace$1$consumeNewlines(false); + }, + $signature: 0 + }; + A.StylesheetParser__declarationOrBuffer_closure1.prototype = { + call$0() { + return this.$this.whitespace$1$consumeNewlines(false); + }, + $signature: 0 + }; + A.StylesheetParser__styleRule_closure.prototype = { + call$2(children, span) { + var _this = this, + t1 = _this.$this; + if (t1.get$indented() && children.length === 0) + t1.warnings.push(new A._Record_3_deprecation_message_span(null, string$.This_s, _this._box_0.interpolation.span)); + t1._inStyleRule = _this.wasInStyleRule; + return A.StyleRule$(_this._box_0.interpolation, children, t1.scanner.spanFrom$1(_this.start)); + }, + $signature: 604 + }; + A.StylesheetParser__propertyOrVariableDeclaration_closure.prototype = { + call$0() { + return this.$this.whitespace$1$consumeNewlines(false); + }, + $signature: 0 + }; + A.StylesheetParser__tryDeclarationChildren_closure.prototype = { + call$2(children, span) { + return A.Declaration$nested(this.name, children, span, this.value); + }, + $signature: 274 + }; + A.StylesheetParser__atRootRule_closure.prototype = { + call$2(children, span) { + return A.AtRootRule$(children, span, this.query); + }, + $signature: 160 + }; + A.StylesheetParser__atRootRule_closure0.prototype = { + call$2(children, span) { + return A.AtRootRule$(children, span, null); + }, + $signature: 160 + }; + A.StylesheetParser__eachRule_closure.prototype = { + call$2(children, span) { + var _this = this; + _this.$this._inControlDirective = _this.wasInControlDirective; + return A.EachRule$(_this.variables, _this.list, children, span); + }, + $signature: 293 + }; + A.StylesheetParser__functionRule_closure.prototype = { + call$2(children, span) { + return A.FunctionRule$(this.name, this.parameters, children, span, this.precedingComment); + }, + $signature: 295 + }; + A.StylesheetParser__forRule_closure.prototype = { + call$0() { + var t1 = this.$this; + if (!t1.lookingAtIdentifier$0()) + return false; + if (t1.scanIdentifier$1("to")) + return this._box_0.exclusive = true; + else if (t1.scanIdentifier$1("through")) { + this._box_0.exclusive = false; + return true; + } else + return false; + }, + $signature: 19 + }; + A.StylesheetParser__forRule_closure0.prototype = { + call$2(children, span) { + var t1, _this = this; + _this.$this._inControlDirective = _this.wasInControlDirective; + t1 = _this._box_0.exclusive; + t1.toString; + return A.ForRule$(_this.variable, _this.from, _this.to, children, span, t1); + }, + $signature: 296 + }; + A.StylesheetParser__memberList_closure.prototype = { + call$0() { + var t1 = this.$this; + if (t1.scanner.peekChar$0() === 36) + this.variables.add$1(0, t1.variableName$0()); + else + this.identifiers.add$1(0, t1.identifier$1$normalize(true)); + }, + $signature: 1 + }; + A.StylesheetParser__includeRule_closure.prototype = { + call$2(children, span) { + return A.ContentBlock$(this.contentParameters_, children, span); + }, + $signature: 298 + }; + A.StylesheetParser_mediaRule_closure.prototype = { + call$2(children, span) { + return A.MediaRule$(this.query, children, span); + }, + $signature: 299 + }; + A.StylesheetParser__mixinRule_closure.prototype = { + call$2(children, span) { + var _this = this; + _this.$this._stylesheet$_inMixin = false; + return A.MixinRule$(_this.name, _this.parameters, children, span, _this.precedingComment); + }, + $signature: 301 + }; + A.StylesheetParser_mozDocumentRule_closure.prototype = { + call$0() { + return this.$this.whitespace$1$consumeNewlines(false); + }, + $signature: 0 + }; + A.StylesheetParser_mozDocumentRule_closure0.prototype = { + call$2(children, span) { + var _this = this; + if (_this._box_0.needsDeprecationWarning) + _this.$this.warnings.push(new A._Record_3_deprecation_message_span(B.Deprecation_89v, string$.x40_moz_, span)); + return A.AtRule$(_this.name, span, children, _this.value); + }, + $signature: 161 + }; + A.StylesheetParser_supportsRule_closure.prototype = { + call$2(children, span) { + return A.SupportsRule$(this.condition, children, span); + }, + $signature: 307 + }; + A.StylesheetParser__whileRule_closure.prototype = { + call$2(children, span) { + this.$this._inControlDirective = this.wasInControlDirective; + return A.WhileRule$(this.condition, children, span); + }, + $signature: 312 + }; + A.StylesheetParser_unknownAtRule_closure.prototype = { + call$2(children, span) { + return A.AtRule$(this.name, span, children, this._box_0.value); + }, + $signature: 161 + }; + A.StylesheetParser__expression_resetState.prototype = { + call$0() { + var t2, + t1 = this._box_0; + t1.operands_ = t1.operators_ = t1.spaceExpressions_ = t1.commaExpressions_ = null; + t2 = this.$this; + t2.scanner.set$state(this.start); + t1.allowSlash = true; + t1.singleExpression_ = t2._singleExpression$0(); + }, + $signature: 0 + }; + A.StylesheetParser__expression_resolveOneOperation.prototype = { + call$0() { + var t2, t3, t4, t5, t6, t7, _this = this, + t1 = _this._box_0, + operator = t1.operators_.pop(), + left = t1.operands_.pop(), + right = t1.singleExpression_; + if (right == null) { + t2 = _this.$this.scanner; + t3 = operator.operator.length; + t2.error$3$length$position(0, "Expected expression.", t3, t2._string_scanner$_position - t3); + } + if (t1.allowSlash) { + t2 = _this.$this; + t2 = !t2._inParentheses && operator === B.BinaryOperator_Mh5 && t2._isSlashOperand$1(left) && t2._isSlashOperand$1(right); + } else + t2 = false; + if (t2) + t1.singleExpression_ = new A.BinaryOperationExpression(B.BinaryOperator_Mh5, left, right, true); + else { + t1.singleExpression_ = new A.BinaryOperationExpression(operator, left, right, false); + t2 = t1.allowSlash = false; + if (B.BinaryOperator_Swh === operator || B.BinaryOperator_QG1 === operator) { + t3 = _this.$this; + t4 = t3.scanner.string; + t5 = right.get$span(right); + t5 = t5.get$start(t5); + t6 = right.get$span(right); + t7 = operator.operator; + if (B.JSString_methods.substring$2(t4, t5.offset - 1, t6.get$start(t6).offset) === t7) { + t2 = left.get$span(left); + t2 = t4.charCodeAt(t2.get$end(t2).offset); + t2 = t2 === 32 || t2 === 9 || t2 === 10 || t2 === 13 || t2 === 12; + } + if (t2) { + t2 = left.toString$0(0); + t4 = right.toString$0(0); + t5 = left.toString$0(0); + t6 = right.toString$0(0); + t1 = t1.singleExpression_; + t3.warnings.push(new A._Record_3_deprecation_message_span(B.Deprecation_t60, "This operation is parsed as:\n\n " + t2 + " " + t7 + " " + t4 + string$.x0a_but_ + t5 + " (" + t7 + t6 + ")\n\nAdd a space after " + t7 + string$.x20to_cl, t1.get$span(t1))); + } + } + } + }, + $signature: 0 + }; + A.StylesheetParser__expression_resolveOperations.prototype = { + call$0() { + var t1, + operators = this._box_0.operators_; + if (operators == null) + return; + for (t1 = this.resolveOneOperation; operators.length !== 0;) + t1.call$0(); + }, + $signature: 0 + }; + A.StylesheetParser__expression_addSingleExpression.prototype = { + call$1(expression) { + var t2, spaceExpressions, _this = this, + t1 = _this._box_0; + if (t1.singleExpression_ != null) { + t2 = _this.$this; + if (t2._inParentheses) { + t2._inParentheses = false; + if (t1.allowSlash) { + _this.resetState.call$0(); + return; + } + } + spaceExpressions = t1.spaceExpressions_; + if (spaceExpressions == null) + spaceExpressions = t1.spaceExpressions_ = A._setArrayType([], type$.JSArray_Expression); + _this.resolveOperations.call$0(); + t2 = t1.singleExpression_; + t2.toString; + spaceExpressions.push(t2); + t1.allowSlash = true; + } + t1.singleExpression_ = expression; + }, + $signature: 313 + }; + A.StylesheetParser__expression_addOperator.prototype = { + call$1(operator) { + var t2, t3, operators, operands, t4, singleExpression, _this = this, + t1 = _this.$this; + if (t1.get$plainCss() && operator !== B.BinaryOperator_Kyq && operator !== B.BinaryOperator_Swh && operator !== B.BinaryOperator_QG1 && operator !== B.BinaryOperator_tht && operator !== B.BinaryOperator_Mh5) { + t2 = t1.scanner; + t3 = operator.operator.length; + t2.error$3$length$position(0, "Operators aren't allowed in plain CSS.", t3, t2._string_scanner$_position - t3); + } + t2 = _this._box_0; + t2.allowSlash = t2.allowSlash && operator === B.BinaryOperator_Mh5; + operators = t2.operators_; + if (operators == null) + operators = t2.operators_ = A._setArrayType([], type$.JSArray_BinaryOperator); + operands = t2.operands_; + if (operands == null) + operands = t2.operands_ = A._setArrayType([], type$.JSArray_Expression); + t3 = _this.resolveOneOperation; + t4 = operator.precedence; + while (true) { + if (!(operators.length !== 0 && B.JSArray_methods.get$last(operators).precedence >= t4)) + break; + t3.call$0(); + } + singleExpression = t2.singleExpression_; + if (singleExpression == null) { + t3 = t1.scanner; + t4 = operator.operator.length; + t3.error$3$length$position(0, "Expected expression.", t4, t3._string_scanner$_position - t4); + } + t1.whitespace$1$consumeNewlines(true); + if (operator === B.BinaryOperator_s7T && !t1._lookingAtExpression$0()) { + t1 = t1.scanner; + t1 = t1.spanFromPosition$1(t1._string_scanner$_position - 1); + _this.addSingleExpression.call$1(new A.StringExpression(new A.Interpolation(A.List_List$unmodifiable(["%"], type$.Object), B.List_null, t1), false)); + } else { + operators.push(operator); + operands.push(singleExpression); + t2.singleExpression_ = t1._singleExpression$0(); + } + }, + $signature: 316 + }; + A.StylesheetParser__expression_resolveSpaceExpressions.prototype = { + call$0() { + var t1, spaceExpressions, singleExpression, t2; + this.resolveOperations.call$0(); + t1 = this._box_0; + spaceExpressions = t1.spaceExpressions_; + if (spaceExpressions == null) + return; + singleExpression = t1.singleExpression_; + if (singleExpression == null) + this.$this.scanner.error$1(0, "Expected expression."); + spaceExpressions.push(singleExpression); + t2 = B.JSArray_methods.get$first(spaceExpressions); + t2 = t2.get$span(t2).expand$1(0, singleExpression.get$span(singleExpression)); + t1.singleExpression_ = new A.ListExpression(A.List_List$unmodifiable(spaceExpressions, type$.Expression), B.ListSeparator_qSL, false, t2); + t1.spaceExpressions_ = null; + }, + $signature: 0 + }; + A.StylesheetParser_expressionUntilComma_closure.prototype = { + call$0() { + return this.$this.scanner.peekChar$0() === 44; + }, + $signature: 19 + }; + A.StylesheetParser__isHexColor_closure.prototype = { + call$1(char) { + return A.CharacterExtension_get_isHex(char); + }, + $signature: 48 + }; + A.StylesheetParser__unicodeRange_closure.prototype = { + call$1(char) { + return char != null && A.CharacterExtension_get_isHex(char); + }, + $signature: 30 + }; + A.StylesheetParser__unicodeRange_closure0.prototype = { + call$1(char) { + return char != null && A.CharacterExtension_get_isHex(char); + }, + $signature: 30 + }; + A.StylesheetParser_namespacedExpression_closure.prototype = { + call$0() { + return this.$this.scanner.spanFrom$1(this.start); + }, + $signature: 29 + }; + A.StylesheetParser_trySpecialFunction_closure.prototype = { + call$1(contents) { + return new A.StringExpression(contents, false); + }, + $signature: 319 + }; + A.StylesheetParser__expressionUntilComparison_closure.prototype = { + call$0() { + var t1 = this.$this.scanner, + _0_0 = t1.peekChar$0(); + $label0$0: { + if (61 === _0_0) { + t1 = t1.peekChar$1(1) !== 61; + break $label0$0; + } + if (60 === _0_0 || 62 === _0_0) { + t1 = true; + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + $signature: 19 + }; + A.StylesheetParser__publicIdentifier_closure.prototype = { + call$0() { + return this.$this.scanner.spanFrom$1(this.start); + }, + $signature: 29 + }; + A.StylesheetGraph.prototype = { + modifiedSince$3(url, since, baseImporter) { + var node = this._stylesheet_graph$_add$3(url, baseImporter, null); + if (node == null) + return true; + return new A.StylesheetGraph_modifiedSince_transitiveModificationTime(this).call$1(node).isAfter$1(since); + }, + _stylesheet_graph$_add$3(url, baseImporter, baseUrl) { + var importer, canonicalUrl, _this = this, + result = _this._ignoreErrors$1(new A.StylesheetGraph__add_closure(_this, url, baseImporter, baseUrl)); + if (type$.Record_3_nullable_Object_and_nullable_Object_and_nullable_Object_originalUrl._is(result)) { + importer = result._0; + canonicalUrl = result._1; + _this.addCanonical$3(importer, canonicalUrl, result._2); + return _this._nodes.$index(0, canonicalUrl); + } else + return null; + }, + addCanonical$4$recanonicalize(importer, canonicalUrl, originalUrl, recanonicalize) { + var stylesheet, _this = this, + t1 = _this._nodes; + if (t1.$index(0, canonicalUrl) != null) + return B.Set_empty3; + stylesheet = _this._ignoreErrors$1(new A.StylesheetGraph_addCanonical_closure(_this, importer, canonicalUrl, originalUrl)); + if (stylesheet == null) + return B.Set_empty3; + t1.$indexSet(0, canonicalUrl, A.StylesheetNode$_(stylesheet, importer, canonicalUrl, _this._upstreamNodes$3(stylesheet, importer, canonicalUrl))); + return recanonicalize ? _this._recanonicalizeImports$2(importer, canonicalUrl) : B.Set_empty3; + }, + addCanonical$3(importer, canonicalUrl, originalUrl) { + return this.addCanonical$4$recanonicalize(importer, canonicalUrl, originalUrl, true); + }, + _upstreamNodes$3(stylesheet, baseImporter, baseUrl) { + var t6, t7, t8, t9, t10, + t1 = type$.Uri, + active = A.LinkedHashSet_LinkedHashSet$_literal([baseUrl], t1), + t2 = A.LinkedHashSet_LinkedHashSet$_empty(t1), + t3 = A.LinkedHashSet_LinkedHashSet$_empty(t1), + t4 = A.LinkedHashSet_LinkedHashSet$_empty(t1), + t5 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + new A._FindDependenciesVisitor(t2, t3, t4, t5, A.LinkedHashSet_LinkedHashSet$_empty(type$.nullable_String)).visitChildren$1(stylesheet.children); + t6 = type$.UnmodifiableSetView_Uri; + t2 = new A.UnmodifiableSetView0(t2, t6); + t3 = new A.UnmodifiableSetView0(t3, t6); + t4 = new A.UnmodifiableSetView0(t4, t6); + t7 = type$.nullable_StylesheetNode; + t8 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t7); + for (t9 = new A.UnionSet(A.LinkedHashSet_LinkedHashSet$_literal([t2, t3, t4], type$.Set_Uri), type$.UnionSet_Uri).get$_union_set$_iterable(), t9 = t9.get$iterator(t9); t9.moveNext$0();) { + t10 = t9.get$current(t9); + t8.$indexSet(0, t10, this._nodeFor$4(t10, baseImporter, baseUrl, active)); + } + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t7); + for (t2 = new A.DependencyReport(t2, t3, t4, new A.UnmodifiableSetView0(t5, t6)).imports._base.get$iterator(0); t2.moveNext$0();) { + t3 = t2.get$current(0); + t1.$indexSet(0, t3, this._nodeFor$5$forImport(t3, baseImporter, baseUrl, active, true)); + } + return new A._Record_2_imports_modules(t1, t8); + }, + reload$1(canonicalUrl) { + var stylesheet, upstream, _this = this, + node = _this._nodes.$index(0, canonicalUrl); + if (node == null) + throw A.wrapException(A.StateError$(canonicalUrl.toString$0(0) + " is not in the dependency graph.")); + _this._transitiveModificationTimes.clear$0(0); + _this.importCache.clearImport$1(canonicalUrl); + stylesheet = _this._ignoreErrors$1(new A.StylesheetGraph_reload_closure(_this, node, canonicalUrl)); + if (stylesheet == null) + return false; + node._stylesheet = stylesheet; + upstream = _this._upstreamNodes$3(stylesheet, node.importer, canonicalUrl); + node._replaceUpstream$2(upstream._1, upstream._0); + return true; + }, + reloadAllModified$0() { + var node, modified, loadTime, t1, t2, t3, _i, t4, t5, t6, t7, modified0, exception, _this = this; + for (t1 = _this._nodes, t1 = A.List_List$of(new A.LinkedHashMapValuesIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapValuesIterable<2>")), true, type$.StylesheetNode), t2 = t1.length, t3 = _this.importCache._loadTimes, _i = 0; _i < t2; ++_i) { + node = t1[_i]; + modified = false; + try { + loadTime = t3.$index(0, node.canonicalUrl); + if (loadTime != null) { + t4 = node.importer.modificationTime$1(node.canonicalUrl); + t5 = loadTime; + t6 = t4._value; + t7 = t5._value; + if (t6 <= t7) { + t4 = t6 === t7 && t4._microsecond > t5._microsecond; + modified0 = t4; + } else + modified0 = true; + } else + modified0 = false; + modified = modified0; + } catch (exception) { + if (A.unwrapException(exception) instanceof A.FileSystemException) + modified = true; + else + throw exception; + } + if (modified) + if (!_this.reload$1(node.canonicalUrl)) + _this.remove$2(0, node.importer, node.canonicalUrl); + } + }, + remove$2(_, importer, canonicalUrl) { + var toRecompile, _this = this, + node = _this._nodes.remove$1(0, canonicalUrl), + t1 = node != null; + if (t1) { + _this._transitiveModificationTimes.clear$0(0); + _this.importCache.clearImport$1(canonicalUrl); + node._stylesheet_graph$_remove$0(); + } + toRecompile = _this._recanonicalizeImports$2(importer, canonicalUrl); + if (t1) + toRecompile.addAll$1(0, node._downstream); + return toRecompile; + }, + _recanonicalizeImports$2(importer, canonicalUrl) { + var changed, t1, t2, t3, t4, t5, newUpstream, newUpstreamImports, _this = this; + _this.importCache.clearCanonicalize$1(canonicalUrl); + changed = A.LinkedHashSet_LinkedHashSet$_empty(type$.StylesheetNode); + for (t1 = _this._nodes.get$values(0).get$iterator(0), t2 = type$.UnmodifiableMapView_of_Uri_and_nullable_StylesheetNode, t3 = type$.Uri, t4 = type$.nullable_StylesheetNode; t1.moveNext$0();) { + t5 = t1.get$current(0); + newUpstream = _this._recanonicalizeImportsForNode$4$forImport(t5, importer, canonicalUrl, false); + newUpstreamImports = _this._recanonicalizeImportsForNode$4$forImport(t5, importer, canonicalUrl, true); + if (newUpstream.__js_helper$_length !== 0 || newUpstreamImports.__js_helper$_length !== 0) { + changed.add$1(0, t5); + t5._replaceUpstream$2(A.mergeMaps(new A.UnmodifiableMapView(t5._upstream, t2), newUpstream, t3, t4), A.mergeMaps(new A.UnmodifiableMapView(t5._upstreamImports, t2), newUpstreamImports, t3, t4)); + } + } + if (changed._collection$_length !== 0) + _this._transitiveModificationTimes.clear$0(0); + return changed; + }, + _recanonicalizeImportsForNode$4$forImport(node, importer, canonicalUrl, forImport) { + var url, result, t2, newMap, t3, t4, t5, t6, upstream, exception, newCanonicalUrl, + t1 = type$.UnmodifiableMapView_of_Uri_and_nullable_StylesheetNode, + map = forImport ? new A.UnmodifiableMapView(node._upstreamImports, t1) : new A.UnmodifiableMapView(node._upstream, t1); + t1 = type$.Uri; + t2 = type$.nullable_StylesheetNode; + newMap = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t1 = A.MapExtensions_get_pairs(map, t1, t2), t1 = t1.get$iterator(t1), t2 = this._nodes, t3 = this.importCache, t4 = node.importer, t5 = node.canonicalUrl; t1.moveNext$0();) { + t6 = t1.get$current(t1); + url = null; + url = t6._0; + upstream = t6._1; + if (!importer.couldCanonicalize$2(url, canonicalUrl)) + continue; + result = null; + try { + result = t3.canonicalize$4$baseImporter$baseUrl$forImport(0, url, t4, t5, forImport); + } catch (exception) { + } + t6 = result; + newCanonicalUrl = t6 == null ? null : t6._1; + if (J.$eq$(newCanonicalUrl, upstream == null ? null : upstream.canonicalUrl)) + continue; + t6 = url; + newMap.$indexSet(0, t6, result == null ? null : t2.$index(0, newCanonicalUrl)); + } + return newMap; + }, + _nodeFor$5$forImport(url, baseImporter, baseUrl, active, forImport) { + var canonicalUrl, t2, _1_0, stylesheet, t3, t4, node, _this = this, t1 = {}, + result = _this._ignoreErrors$1(new A.StylesheetGraph__nodeFor_closure(_this, url, baseImporter, baseUrl, forImport)); + if (result == null) + return null; + t1.originalUrl = t1.canonicalUrl = t1.importer = null; + t1.importer = result._0; + canonicalUrl = t1.canonicalUrl = result._1; + t1.originalUrl = result._2; + t2 = _this._nodes; + _1_0 = t2.$index(0, canonicalUrl); + if (_1_0 != null) + return _1_0; + if (active.contains$1(0, canonicalUrl)) + return null; + stylesheet = _this._ignoreErrors$1(new A.StylesheetGraph__nodeFor_closure0(t1, _this)); + if (stylesheet == null) + return null; + active.add$1(0, t1.canonicalUrl); + t3 = t1.importer; + t4 = t1.canonicalUrl; + node = A.StylesheetNode$_(stylesheet, t3, t4, _this._upstreamNodes$3(stylesheet, t3, t4)); + active.remove$1(0, t1.canonicalUrl); + t2.$indexSet(0, t1.canonicalUrl, node); + return node; + }, + _nodeFor$4(url, baseImporter, baseUrl, active) { + return this._nodeFor$5$forImport(url, baseImporter, baseUrl, active, false); + }, + _ignoreErrors$1$1(callback) { + var t1, exception; + try { + t1 = callback.call$0(); + return t1; + } catch (exception) { + return null; + } + }, + _ignoreErrors$1(callback) { + return this._ignoreErrors$1$1(callback, type$.dynamic); + } + }; + A.StylesheetGraph_modifiedSince_transitiveModificationTime.prototype = { + call$1(node) { + return this.$this._transitiveModificationTimes.putIfAbsent$2(node.canonicalUrl, new A.StylesheetGraph_modifiedSince_transitiveModificationTime_closure(node, this)); + }, + $signature: 320 + }; + A.StylesheetGraph_modifiedSince_transitiveModificationTime_closure.prototype = { + call$0() { + var t2, t3, upstreamTime, t4, + t1 = this.node, + latest = t1.importer.modificationTime$1(t1.canonicalUrl); + for (t1 = t1._upstream.get$values(0).followedBy$1(0, t1._upstreamImports.get$values(0)).get$iterator(0), t2 = this.transitiveModificationTime; t1.moveNext$0();) { + t3 = t1.get$current(0); + upstreamTime = t3 == null ? new A.DateTime(Date.now(), 0, false) : t2.call$1(t3); + t3 = upstreamTime._value; + t4 = latest._value; + if (t3 <= t4) + t3 = t3 === t4 && upstreamTime._microsecond > latest._microsecond; + else + t3 = true; + if (t3) + latest = upstreamTime; + } + return latest; + }, + $signature: 155 + }; + A.StylesheetGraph__add_closure.prototype = { + call$0() { + var _this = this; + return _this.$this.importCache.canonicalize$3$baseImporter$baseUrl(0, _this.url, _this.baseImporter, _this.baseUrl); + }, + $signature: 123 + }; + A.StylesheetGraph_addCanonical_closure.prototype = { + call$0() { + var _this = this; + return _this.$this.importCache.importCanonical$3$originalUrl(_this.importer, _this.canonicalUrl, _this.originalUrl); + }, + $signature: 112 + }; + A.StylesheetGraph_reload_closure.prototype = { + call$0() { + return this.$this.importCache.importCanonical$2(this.node.importer, this.canonicalUrl); + }, + $signature: 112 + }; + A.StylesheetGraph__nodeFor_closure.prototype = { + call$0() { + var _this = this; + return _this.$this.importCache.canonicalize$4$baseImporter$baseUrl$forImport(0, _this.url, _this.baseImporter, _this.baseUrl, _this.forImport); + }, + $signature: 123 + }; + A.StylesheetGraph__nodeFor_closure0.prototype = { + call$0() { + var t1 = this._box_0; + return this.$this.importCache.importCanonical$3$originalUrl(t1.importer, t1.canonicalUrl, t1.originalUrl); + }, + $signature: 112 + }; + A.StylesheetNode.prototype = { + StylesheetNode$_$4(_stylesheet, importer, canonicalUrl, allUpstream) { + var t1, t2; + for (t1 = this._upstream.get$values(0).followedBy$1(0, this._upstreamImports.get$values(0)).get$iterator(0); t1.moveNext$0();) { + t2 = t1.get$current(0); + if (t2 != null) + t2._downstream.add$1(0, this); + } + }, + _replaceUpstream$2(newUpstream, newUpstreamImports) { + var t3, oldUpstream, newUpstreamSet, _this = this, + t1 = type$.nullable_StylesheetNode, + t2 = A.LinkedHashSet_LinkedHashSet$of(_this._upstream.get$values(0), t1); + t2.addAll$1(0, _this._upstreamImports.get$values(0)); + t3 = type$.StylesheetNode; + oldUpstream = A.SetExtension_removeNull(t2, t3); + t1 = A.LinkedHashSet_LinkedHashSet$of(new A.LinkedHashMapValuesIterable(newUpstream, A._instanceType(newUpstream)._eval$1("LinkedHashMapValuesIterable<2>")), t1); + t1.addAll$1(0, new A.LinkedHashMapValuesIterable(newUpstreamImports, A._instanceType(newUpstreamImports)._eval$1("LinkedHashMapValuesIterable<2>"))); + newUpstreamSet = A.SetExtension_removeNull(t1, t3); + for (t1 = oldUpstream.difference$1(newUpstreamSet), t1 = t1.get$iterator(t1); t1.moveNext$0();) + t1.get$current(t1)._downstream.remove$1(0, _this); + for (t1 = newUpstreamSet.difference$1(oldUpstream), t1 = t1.get$iterator(t1); t1.moveNext$0();) + t1.get$current(t1)._downstream.add$1(0, _this); + _this._upstream = newUpstream; + _this._upstreamImports = newUpstreamImports; + }, + _stylesheet_graph$_remove$0() { + var t1, t2, t3, t4, _i, url, _this = this; + for (t1 = A.LinkedHashSet_LinkedHashSet$of(_this._upstream.get$values(0), type$.nullable_StylesheetNode), t1.addAll$1(0, _this._upstreamImports.get$values(0)), t1 = A._LinkedHashSetIterator$(t1, t1._modifications, A._instanceType(t1)._precomputed1), t2 = t1.$ti._precomputed1; t1.moveNext$0();) { + t3 = t1._collection$_current; + if (t3 == null) + t3 = t2._as(t3); + if (t3 == null) + continue; + t3._downstream.remove$1(0, _this); + } + for (t1 = _this._downstream.get$iterator(0); t1.moveNext$0();) { + t2 = t1.get$current(0); + for (t3 = t2._upstream, t4 = A._instanceType(t3)._eval$1("LinkedHashMapKeysIterable<1>"), t4 = A.List_List$of(new A.LinkedHashMapKeysIterable(t3, t4), true, t4._eval$1("Iterable.E")), t3 = t4.length, _i = 0; _i < t3; ++_i) { + url = t4[_i]; + if (t2._upstream.$index(0, url) === _this) { + t2._upstream.$indexSet(0, url, null); + break; + } + } + for (t3 = t2._upstreamImports, t4 = A._instanceType(t3)._eval$1("LinkedHashMapKeysIterable<1>"), t4 = A.List_List$of(new A.LinkedHashMapKeysIterable(t3, t4), true, t4._eval$1("Iterable.E")), t3 = t4.length, _i = 0; _i < t3; ++_i) { + url = t4[_i]; + if (t2._upstreamImports.$index(0, url) === _this) { + t2._upstreamImports.$indexSet(0, url, null); + break; + } + } + } + }, + toString$0(_) { + var t1 = this._stylesheet.span; + t1 = A.NullableExtension_andThen(t1.get$sourceUrl(t1), A.path__prettyUri$closure()); + return t1 == null ? "" : t1; + } + }; + A.Syntax.prototype = { + _enumToString$0() { + return "Syntax." + this._name; + }, + toString$0(_) { + return this._syntax$_name; + } + }; + A.Box.prototype = { + $eq(_, other) { + if (other == null) + return false; + return this.$ti._is(other) && other._box$_inner === this._box$_inner; + }, + get$hashCode(_) { + return A.Primitives_objectHashCode(this._box$_inner); + } + }; + A.ModifiableBox.prototype = {}; + A.LazyFileSpan.prototype = { + get$span(_) { + var t1 = this._lazy_file_span$_span; + return t1 == null ? this._lazy_file_span$_span = this._builder.call$0() : t1; + }, + compareTo$1(_, other) { + return this.get$span(0).compareTo$1(0, other); + }, + get$context(_) { + var t1 = this.get$span(0); + return t1.get$context(t1); + }, + get$end(_) { + var t1 = this.get$span(0); + return t1.get$end(t1); + }, + expand$1(_, other) { + return this.get$span(0).expand$1(0, other); + }, + get$file(_) { + var t1 = this.get$span(0); + return t1.get$file(t1); + }, + highlight$1$color(color) { + return this.get$span(0).highlight$1$color(color); + }, + get$length(_) { + var t1 = this.get$span(0); + return t1.get$length(t1); + }, + message$2$color(_, message, color) { + return this.get$span(0).message$2$color(0, message, color); + }, + message$1(_, message) { + return this.message$2$color(0, message, null); + }, + get$sourceUrl(_) { + var t1 = this.get$span(0); + return t1.get$sourceUrl(t1); + }, + get$start(_) { + var t1 = this.get$span(0); + return t1.get$start(t1); + }, + get$text() { + return this.get$span(0).get$text(); + }, + $isComparable: 1, + $isFileSpan: 1, + $isSourceSpan: 1, + $isSourceSpanWithContext: 1 + }; + A.LimitedMapView.prototype = { + get$keys(_) { + return this._limited_map_view$_keys; + }, + get$length(_) { + return this._limited_map_view$_keys._collection$_length; + }, + get$isEmpty(_) { + return this._limited_map_view$_keys._collection$_length === 0; + }, + get$isNotEmpty(_) { + return this._limited_map_view$_keys._collection$_length !== 0; + }, + $index(_, key) { + return this._limited_map_view$_keys.contains$1(0, key) ? this._limited_map_view$_map.$index(0, key) : null; + }, + containsKey$1(key) { + return this._limited_map_view$_keys.contains$1(0, key); + }, + remove$1(_, key) { + return this._limited_map_view$_keys.contains$1(0, key) ? this._limited_map_view$_map.remove$1(0, key) : null; + } + }; + A.MapExtensions_get_pairs_closure.prototype = { + call$1(e) { + return new A._Record_2(e.key, e.value); + }, + $signature() { + return this.K._eval$1("@<0>")._bind$1(this.V)._eval$1("+(1,2)(MapEntry<1,2>)"); + } + }; + A.MergedMapView.prototype = { + get$keys(_) { + var t1 = this._mapsByKey; + return new A.LinkedHashMapKeysIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapKeysIterable<1>")); + }, + get$length(_) { + return this._mapsByKey.__js_helper$_length; + }, + get$isEmpty(_) { + return this._mapsByKey.__js_helper$_length === 0; + }, + get$isNotEmpty(_) { + return this._mapsByKey.__js_helper$_length !== 0; + }, + MergedMapView$1(maps, $K, $V) { + var t1, t2, t3, _i, map, t4, t5; + for (t1 = maps.length, t2 = this._mapsByKey, t3 = $K._eval$1("@<0>")._bind$1($V)._eval$1("MergedMapView<1,2>"), _i = 0; _i < maps.length; maps.length === t1 || (0, A.throwConcurrentModificationError)(maps), ++_i) { + map = maps[_i]; + if (t3._is(map)) + for (t4 = map._mapsByKey, t4 = new A.LinkedHashMapValueIterator(t4, t4.__js_helper$_modifications, t4.__js_helper$_first); t4.moveNext$0();) { + t5 = t4.__js_helper$_current; + A.setAll(t2, t5.get$keys(t5), t5); + } + else + A.setAll(t2, map.get$keys(map), map); + } + }, + $index(_, key) { + var t1 = this._mapsByKey.$index(0, this.$ti._precomputed1._as(key)); + return t1 == null ? null : t1.$index(0, key); + }, + $indexSet(_, key, value) { + var _0_0 = this._mapsByKey.$index(0, key); + if (_0_0 != null) + _0_0.$indexSet(0, key, value); + else + throw A.wrapException(A.UnsupportedError$(string$.New_en)); + }, + remove$1(_, key) { + throw A.wrapException(A.UnsupportedError$(string$.Entrie)); + }, + containsKey$1(key) { + return this._mapsByKey.containsKey$1(key); + } + }; + A.MultiDirWatcher.prototype = { + watch$1(_, directory) { + var t1, t2, t3, t4, isParentOfExistingDir, _i, t5, _0_1, t6, future, completer; + for (t1 = this._watchers, t2 = A.MapExtensions_get_pairs(t1, type$.nullable_String, type$.Stream_WatchEvent).toList$0(0), t3 = t2.length, t1 = t1._map, t4 = this._group, isParentOfExistingDir = false, _i = 0; _i < t2.length; t2.length === t3 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + t5 = t2[_i]; + _0_1 = t5._0; + _0_1.toString; + if (!isParentOfExistingDir) { + t6 = $.$get$context(); + t6 = t6._isWithinOrEquals$2(_0_1, directory) === B._PathRelation_equal || t6._isWithinOrEquals$2(_0_1, directory) === B._PathRelation_within; + } else + t6 = false; + if (t6) { + t1 = new A._Future($.Zone__current, type$._Future_void); + t1._asyncComplete$1(null); + return t1; + } + if ($.$get$context()._isWithinOrEquals$2(directory, _0_1) === B._PathRelation_within) { + t1.remove$1(0, _0_1); + t4.remove$1(0, t5._1); + isParentOfExistingDir = true; + } + } + future = A.watchDir(directory, this._poll); + t2 = new A._CompleterStream(type$._CompleterStream_WatchEvent); + completer = new A.StreamCompleter(t2, type$.StreamCompleter_WatchEvent); + future.then$1$2$onError(0, completer.get$setSourceStream(), completer.get$setError(), type$.void); + t1.$indexSet(0, directory, t2); + t4.add$1(0, t2); + return future; + } + }; + A.MultiSpan.prototype = { + get$start(_) { + var t1 = this._multi_span$_primary; + return t1.get$start(t1); + }, + get$end(_) { + var t1 = this._multi_span$_primary; + return t1.get$end(t1); + }, + get$text() { + return this._multi_span$_primary.get$text(); + }, + get$context(_) { + var t1 = this._multi_span$_primary; + return t1.get$context(t1); + }, + get$file(_) { + var t1 = this._multi_span$_primary; + return t1.get$file(t1); + }, + get$length(_) { + var t1 = this._multi_span$_primary; + return t1.get$length(t1); + }, + get$sourceUrl(_) { + var t1 = this._multi_span$_primary; + return t1.get$sourceUrl(t1); + }, + compareTo$1(_, other) { + return this._multi_span$_primary.compareTo$1(0, other); + }, + toString$0(_) { + return this._multi_span$_primary.toString$0(0); + }, + expand$1(_, other) { + return new A.MultiSpan(this._multi_span$_primary.expand$1(0, other), this.primaryLabel, this.secondarySpans); + }, + highlight$1$color(color) { + return A.Highlighter$multiple(this._multi_span$_primary, this.primaryLabel, this.secondarySpans, color === true, null, null).highlight$0(); + }, + message$2$color(_, message, color) { + var t1 = J.$eq$(color, true) || typeof color == "string", + t2 = typeof color == "string" ? color : null; + return A.SourceSpanExtension_messageMultiple(this._multi_span$_primary, message, this.primaryLabel, this.secondarySpans, t1, t2, null); + }, + message$1(_, message) { + return this.message$2$color(0, message, null); + }, + $isComparable: 1, + $isFileSpan: 1, + $isSourceSpan: 1, + $isSourceSpanWithContext: 1 + }; + A.NoSourceMapBuffer.prototype = { + get$length(_) { + return this._no_source_map_buffer$_buffer._contents.length; + }, + forSpan$1$2(span, callback) { + return callback.call$0(); + }, + forSpan$2(span, callback) { + return this.forSpan$1$2(span, callback, type$.dynamic); + }, + write$1(_, object) { + var t1 = this._no_source_map_buffer$_buffer, + t2 = A.S(object); + t1._contents += t2; + return null; + }, + writeCharCode$1(charCode) { + var t1 = this._no_source_map_buffer$_buffer, + t2 = A.Primitives_stringFromCharCode(charCode); + t1._contents += t2; + return null; + }, + toString$0(_) { + var t1 = this._no_source_map_buffer$_buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + buildSourceMap$1$prefix(prefix) { + return A.throwExpression(A.UnsupportedError$(string$.NoSour)); + } + }; + A.PrefixedMapView.prototype = { + get$keys(_) { + return new A._PrefixedKeys(this); + }, + get$length(_) { + var t1 = this._prefixed_map_view$_map; + return t1.get$length(t1); + }, + get$isEmpty(_) { + var t1 = this._prefixed_map_view$_map; + return t1.get$isEmpty(t1); + }, + get$isNotEmpty(_) { + var t1 = this._prefixed_map_view$_map; + return t1.get$isNotEmpty(t1); + }, + $index(_, key) { + return typeof key == "string" && B.JSString_methods.startsWith$1(key, this._prefix) ? this._prefixed_map_view$_map.$index(0, J.substring$1$s(key, this._prefix.length)) : null; + }, + containsKey$1(key) { + return typeof key == "string" && B.JSString_methods.startsWith$1(key, this._prefix) && this._prefixed_map_view$_map.containsKey$1(J.substring$1$s(key, this._prefix.length)); + } + }; + A._PrefixedKeys.prototype = { + get$length(_) { + var t1 = this._view._prefixed_map_view$_map; + return t1.get$length(t1); + }, + get$iterator(_) { + var t1 = this._view._prefixed_map_view$_map; + t1 = J.map$1$1$ax(t1.get$keys(t1), new A._PrefixedKeys_iterator_closure(this), type$.String); + return t1.get$iterator(t1); + }, + contains$1(_, key) { + return this._view.containsKey$1(key); + } + }; + A._PrefixedKeys_iterator_closure.prototype = { + call$1(key) { + return this.$this._view._prefix + key; + }, + $signature: 6 + }; + A.PublicMemberMapView.prototype = { + get$keys(_) { + var t1 = this._public_member_map_view$_inner; + return J.where$1$ax(t1.get$keys(t1), A.utils__isPublic$closure()); + }, + containsKey$1(key) { + return typeof key == "string" && A.isPublic(key) && this._public_member_map_view$_inner.containsKey$1(key); + }, + $index(_, key) { + if (typeof key == "string" && A.isPublic(key)) + return this._public_member_map_view$_inner.$index(0, key); + return null; + } + }; + A.SourceMapBuffer.prototype = { + get$_targetLocation() { + var t1 = this._source_map_buffer$_buffer._contents, + t2 = this._line; + return A.SourceLocation$(t1.length, this._column, t2, null); + }, + get$length(_) { + return this._source_map_buffer$_buffer._contents.length; + }, + forSpan$1$2(span, callback) { + var t1, _this = this, + wasInSpan = _this._inSpan; + _this._inSpan = true; + _this._addEntry$2(span.get$start(span), _this.get$_targetLocation()); + try { + t1 = callback.call$0(); + return t1; + } finally { + _this._inSpan = wasInSpan; + } + }, + forSpan$2(span, callback) { + return this.forSpan$1$2(span, callback, type$.dynamic); + }, + _addEntry$2(source, target) { + var entry, t2, + t1 = this._entries; + if (t1.length !== 0) { + entry = B.JSArray_methods.get$last(t1); + t2 = entry.source; + if (t2.file.getLine$1(t2.offset) === source.file.getLine$1(source.offset) && entry.target.line === target.line) + return; + if (entry.target.offset === target.offset) + return; + } + t1.push(new A.Entry(source, target, null)); + }, + write$1(_, object) { + var t1, i, + string = J.toString$0$(object); + this._source_map_buffer$_buffer._contents += string; + for (t1 = string.length, i = 0; i < t1; ++i) + if (string.charCodeAt(i) === 10) + this._source_map_buffer$_writeLine$0(); + else + ++this._column; + }, + writeCharCode$1(charCode) { + var t1 = this._source_map_buffer$_buffer, + t2 = A.Primitives_stringFromCharCode(charCode); + t1._contents += t2; + if (charCode === 10) + this._source_map_buffer$_writeLine$0(); + else + ++this._column; + }, + _source_map_buffer$_writeLine$0() { + var _this = this, + t1 = _this._entries; + if (B.JSArray_methods.get$last(t1).target.line === _this._line && B.JSArray_methods.get$last(t1).target.column === _this._column) + t1.pop(); + ++_this._line; + _this._column = 0; + if (_this._inSpan) + t1.push(new A.Entry(B.JSArray_methods.get$last(t1).source, _this.get$_targetLocation(), null)); + }, + toString$0(_) { + var t1 = this._source_map_buffer$_buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + buildSourceMap$1$prefix(prefix) { + var i, t2, prefixColumn, _box_0 = {}, + t1 = prefix.length; + if (t1 === 0) + return A.SingleMapping_SingleMapping$fromEntries(this._entries); + _box_0.prefixColumn = _box_0.prefixLines = 0; + for (i = 0, t2 = 0; i < t1; ++i) + if (prefix.charCodeAt(i) === 10) { + ++_box_0.prefixLines; + _box_0.prefixColumn = 0; + t2 = 0; + } else { + prefixColumn = t2 + 1; + _box_0.prefixColumn = prefixColumn; + t2 = prefixColumn; + } + t2 = this._entries; + return A.SingleMapping_SingleMapping$fromEntries(new A.MappedListIterable(t2, new A.SourceMapBuffer_buildSourceMap_closure(_box_0, t1), A._arrayInstanceType(t2)._eval$1("MappedListIterable<1,Entry>"))); + } + }; + A.SourceMapBuffer_buildSourceMap_closure.prototype = { + call$1(entry) { + var t1 = entry.target, + t2 = t1.line, + t3 = this._box_0, + t4 = t3.prefixLines; + t3 = t2 === 0 ? t3.prefixColumn : 0; + return new A.Entry(entry.source, A.SourceLocation$(t1.offset + this.prefixLength, t1.column + t3, t2 + t4, null), entry.identifierName); + }, + $signature: 164 + }; + A.UnprefixedMapView.prototype = { + get$keys(_) { + return new A._UnprefixedKeys(this); + }, + $index(_, key) { + return typeof key == "string" ? this._unprefixed_map_view$_map.$index(0, this._unprefixed_map_view$_prefix + key) : null; + }, + containsKey$1(key) { + return typeof key == "string" && this._unprefixed_map_view$_map.containsKey$1(this._unprefixed_map_view$_prefix + key); + }, + remove$1(_, key) { + var t1 = this._unprefixed_map_view$_map.remove$1(0, this._unprefixed_map_view$_prefix + key); + return t1; + } + }; + A._UnprefixedKeys.prototype = { + get$iterator(_) { + var t1 = this._unprefixed_map_view$_view._unprefixed_map_view$_map; + t1 = J.where$1$ax(t1.get$keys(t1), new A._UnprefixedKeys_iterator_closure(this)).map$1$1(0, new A._UnprefixedKeys_iterator_closure0(this), type$.String); + return t1.get$iterator(t1); + }, + contains$1(_, key) { + return this._unprefixed_map_view$_view.containsKey$1(key); + } + }; + A._UnprefixedKeys_iterator_closure.prototype = { + call$1(key) { + return B.JSString_methods.startsWith$1(key, this.$this._unprefixed_map_view$_view._unprefixed_map_view$_prefix); + }, + $signature: 5 + }; + A._UnprefixedKeys_iterator_closure0.prototype = { + call$1(key) { + return B.JSString_methods.substring$1(key, this.$this._unprefixed_map_view$_view._unprefixed_map_view$_prefix.length); + }, + $signature: 6 + }; + A.indent_closure.prototype = { + call$1(line) { + return B.JSString_methods.$mul(" ", this.indentation) + line; + }, + $signature: 6 + }; + A.flattenVertically_closure.prototype = { + call$1(inner) { + return A.QueueList_QueueList$from(inner, this.T); + }, + $signature() { + return this.T._eval$1("QueueList<0>(Iterable<0>)"); + } + }; + A.flattenVertically_closure0.prototype = { + call$1(queue) { + this.result.push(queue.removeFirst$0()); + return queue.get$length(0) === 0; + }, + $signature() { + return this.T._eval$1("bool(QueueList<0>)"); + } + }; + A.longestCommonSubsequence_backtrack.prototype = { + call$2(i, j) { + var selection, t1, _this = this; + if (i === -1 || j === -1) + return A._setArrayType([], _this.T._eval$1("JSArray<0>")); + selection = _this.selections[i][j]; + if (selection != null) { + t1 = _this.call$2(i - 1, j - 1); + J.add$1$ax(t1, selection); + return t1; + } + t1 = _this.lengths; + return t1[i + 1][j] > t1[i][j + 1] ? _this.call$2(i, j - 1) : _this.call$2(i - 1, j); + }, + $signature() { + return this.T._eval$1("List<0>(int,int)"); + } + }; + A.mapAddAll2_closure.prototype = { + call$2(key, inner) { + var t1 = this.destination, + _0_0 = t1.$index(0, key); + if (_0_0 != null) + _0_0.addAll$1(0, inner); + else + t1.$indexSet(0, key, inner); + }, + $signature() { + return this.K1._eval$1("@<0>")._bind$1(this.K2)._bind$1(this.V)._eval$1("~(1,Map<2,3>)"); + } + }; + A.Value.prototype = { + get$isTruthy() { + return true; + }, + get$separator(_) { + return B.ListSeparator_undecided_null_undecided; + }, + get$hasBrackets() { + return false; + }, + get$asList() { + return A._setArrayType([this], type$.JSArray_Value); + }, + get$lengthAsList() { + return 1; + }, + get$isBlank() { + return false; + }, + get$isSpecialNumber() { + return false; + }, + get$isVar() { + return false; + }, + get$realNull() { + return this; + }, + sassIndexToListIndex$2(sassIndex, $name) { + var t1, index, + indexValue = sassIndex.assertNumber$1($name); + if (indexValue.get$hasUnits()) { + t1 = indexValue.get$unitString(); + A.warnForDeprecation("$" + $name + ": Passing a number with unit " + t1 + string$.x20is_de + indexValue.unitSuggestion$1($name) + string$.x0a_Morex3af, B.Deprecation_jG1); + } + index = indexValue.assertInt$1($name); + if (index === 0) + throw A.wrapException(A.SassScriptException$("List index may not be 0.", $name)); + if (Math.abs(index) > this.get$lengthAsList()) + throw A.wrapException(A.SassScriptException$("Invalid index " + sassIndex.toString$0(0) + " for a list with " + this.get$lengthAsList() + " elements.", $name)); + return index < 0 ? this.get$lengthAsList() + index : index - 1; + }, + assertCalculation$1($name) { + return A.throwExpression(A.SassScriptException$(this.toString$0(0) + " is not a calculation.", $name)); + }, + assertColor$1($name) { + return A.throwExpression(A.SassScriptException$(this.toString$0(0) + " is not a color.", $name)); + }, + assertFunction$1($name) { + return A.throwExpression(A.SassScriptException$(this.toString$0(0) + " is not a function reference.", $name)); + }, + assertMixin$1($name) { + return A.throwExpression(A.SassScriptException$(this.toString$0(0) + " is not a mixin reference.", $name)); + }, + assertMap$1($name) { + return A.throwExpression(A.SassScriptException$(this.toString$0(0) + " is not a map.", $name)); + }, + tryMap$0() { + return null; + }, + assertNumber$1($name) { + return A.throwExpression(A.SassScriptException$(this.toString$0(0) + " is not a number.", $name)); + }, + assertNumber$0() { + return this.assertNumber$1(null); + }, + assertString$1($name) { + return A.throwExpression(A.SassScriptException$(this.toString$0(0) + " is not a string.", $name)); + }, + assertCommonListStyle$2$allowSlash($name, allowSlash) { + var invalidSeparator, buffer, t1, _this = this, + _s8_ = "Expected"; + if (_this.get$separator(_this) !== B.ListSeparator_qVN) + invalidSeparator = !allowSlash && _this.get$separator(_this) === B.ListSeparator_bRz; + else + invalidSeparator = true; + if (!invalidSeparator && !_this.get$hasBrackets()) + return _this.get$asList(); + buffer = new A.StringBuffer(_s8_); + if (_this.get$hasBrackets()) { + t1 = "Expected" + " an unbracketed"; + buffer._contents = t1; + } else + t1 = _s8_; + if (invalidSeparator) { + t1 += _this.get$hasBrackets() ? "," : " a"; + buffer._contents = t1; + t1 = buffer._contents = t1 + " space-"; + t1 = buffer._contents = (allowSlash ? buffer._contents = t1 + " or slash-" : t1) + "separated"; + } + buffer._contents = t1 + (" list, was " + _this.toString$0(0)); + throw A.wrapException(A.SassScriptException$(buffer.toString$0(0), $name)); + }, + _selectorString$1($name) { + var _0_0 = this._selectorStringOrNull$0(); + if (_0_0 != null) + return _0_0; + throw A.wrapException(A.SassScriptException$(this.toString$0(0) + string$.x20is_noav, $name)); + }, + _selectorStringOrNull$0() { + var t1, t2, result, _1_0, _i, complex, string, compound, _this = this, _null = null; + if (_this instanceof A.SassString) + return _this._string$_text; + if (!(_this instanceof A.SassList)) + return _null; + t1 = _this._list$_contents; + t2 = t1.length; + if (t2 === 0) + return _null; + result = A._setArrayType([], type$.JSArray_String); + $label0$1: { + _1_0 = _this._separator; + if (B.ListSeparator_qVN === _1_0) { + for (_i = 0; _i < t2; ++_i) { + complex = t1[_i]; + if (complex instanceof A.SassString) { + result.push(complex._string$_text); + continue; + } + if (complex instanceof A.SassList && B.ListSeparator_qSL === complex._separator) { + string = complex._selectorStringOrNull$0(); + if (string == null) + return _null; + result.push(string); + continue; + } + return _null; + } + break $label0$1; + } + if (B.ListSeparator_bRz === _1_0) + return _null; + for (_i = 0; _i < t2; ++_i) { + compound = t1[_i]; + if (!(compound instanceof A.SassString)) + return _null; + result.push(compound._string$_text); + } + } + return B.JSArray_methods.join$1(result, _1_0 === B.ListSeparator_qVN ? ", " : " "); + }, + withListContents$2$separator(contents, separator) { + var t1 = separator == null ? this.get$separator(this) : separator, + t2 = this.get$hasBrackets(); + return A.SassList$(contents, t1, t2); + }, + withListContents$1(contents) { + return this.withListContents$2$separator(contents, null); + }, + greaterThan$1(other) { + return A.throwExpression(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " > " + other.toString$0(0) + '".', null)); + }, + greaterThanOrEquals$1(other) { + return A.throwExpression(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " >= " + other.toString$0(0) + '".', null)); + }, + lessThan$1(other) { + return A.throwExpression(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " < " + other.toString$0(0) + '".', null)); + }, + lessThanOrEquals$1(other) { + return A.throwExpression(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " <= " + other.toString$0(0) + '".', null)); + }, + times$1(other) { + return A.throwExpression(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " * " + other.toString$0(0) + '".', null)); + }, + modulo$1(other) { + return A.throwExpression(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " % " + other.toString$0(0) + '".', null)); + }, + plus$1(other) { + var t1; + $label0$0: { + if (other instanceof A.SassString) { + t1 = new A.SassString(A.serializeValue(this, false, true) + other._string$_text, other._hasQuotes); + break $label0$0; + } + if (other instanceof A.SassCalculation) + A.throwExpression(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " + " + other.toString$0(0) + '".', null)); + t1 = new A.SassString(A.serializeValue(this, false, true) + A.serializeValue(other, false, true), false); + break $label0$0; + } + return t1; + }, + minus$1(other) { + return other instanceof A.SassCalculation ? A.throwExpression(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " - " + other.toString$0(0) + '".', null)) : new A.SassString(A.serializeValue(this, false, true) + "-" + A.serializeValue(other, false, true), false); + }, + dividedBy$1(other) { + return new A.SassString(A.serializeValue(this, false, true) + "/" + A.serializeValue(other, false, true), false); + }, + unaryPlus$0() { + return new A.SassString("+" + A.serializeValue(this, false, true), false); + }, + unaryMinus$0() { + return new A.SassString("-" + A.serializeValue(this, false, true), false); + }, + unaryNot$0() { + return B.SassBoolean_false; + }, + withoutSlash$0() { + return this; + }, + toString$0(_) { + return A.serializeValue(this, true, true); + } + }; + A.SassArgumentList.prototype = {}; + A.SassBoolean.prototype = { + get$isTruthy() { + return this.value; + }, + accept$1$1(visitor) { + return visitor._serialize$_buffer.write$1(0, String(this.value)); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + unaryNot$0() { + return this.value ? B.SassBoolean_false : B.SassBoolean_true; + } + }; + A.SassCalculation.prototype = { + get$isSpecialNumber() { + return true; + }, + accept$1$1(visitor) { + return visitor.visitCalculation$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + assertCalculation$1($name) { + return this; + }, + plus$1(other) { + if (other instanceof A.SassString) + return this.super$Value$plus(other); + throw A.wrapException(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " + " + other.toString$0(0) + '".', null)); + }, + minus$1(other) { + return A.throwExpression(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " - " + other.toString$0(0) + '".', null)); + }, + unaryPlus$0() { + return A.throwExpression(A.SassScriptException$('Undefined operation "+' + this.toString$0(0) + '".', null)); + }, + unaryMinus$0() { + return A.throwExpression(A.SassScriptException$('Undefined operation "-' + this.toString$0(0) + '".', null)); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.SassCalculation && this.name === other.name && B.C_ListEquality.equals$2(0, this.$arguments, other.$arguments); + }, + get$hashCode(_) { + return B.JSString_methods.get$hashCode(this.name) ^ B.C_ListEquality0.hash$1(this.$arguments); + } + }; + A.SassCalculation__verifyLength_closure.prototype = { + call$1(arg) { + return arg instanceof A.SassString; + }, + $signature: 77 + }; + A.CalculationOperation.prototype = { + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.CalculationOperation && this._operator === other._operator && J.$eq$(this._left, other._left) && J.$eq$(this._right, other._right); + }, + get$hashCode(_) { + return (A.Primitives_objectHashCode(this._operator) ^ J.get$hashCode$(this._left) ^ J.get$hashCode$(this._right)) >>> 0; + }, + toString$0(_) { + var parenthesized = A.serializeValue(new A.SassCalculation("", A._setArrayType([this], type$.JSArray_Object)), true, true); + return B.JSString_methods.substring$2(parenthesized, 1, parenthesized.length - 1); + } + }; + A.CalculationOperator.prototype = { + _enumToString$0() { + return "CalculationOperator." + this._name; + }, + toString$0(_) { + return this.name; + } + }; + A.SassColor.prototype = { + get$channels() { + var t2, t3, + t1 = this.channel0OrNull; + if (t1 == null) + t1 = 0; + t2 = this.channel1OrNull; + if (t2 == null) + t2 = 0; + t3 = this.channel2OrNull; + return A.List_List$unmodifiable([t1, t2, t3 == null ? 0 : t3], type$.double); + }, + get$channelsOrNull() { + return A.List_List$unmodifiable([this.channel0OrNull, this.channel1OrNull, this.channel2OrNull], type$.nullable_double); + }, + get$isChannel0Powerless() { + var t1, t2, _this = this, + _0_0 = _this._space; + $label0$0: { + if (B.HslColorSpace_JQ2 === _0_0) { + t1 = _this.channel1OrNull; + t1 = A.fuzzyEquals(t1 == null ? 0 : t1, 0); + break $label0$0; + } + if (B.HwbColorSpace_guQ === _0_0) { + t1 = _this.channel1OrNull; + if (t1 == null) + t1 = 0; + t2 = _this.channel2OrNull; + t1 += t2 == null ? 0 : t2; + t1 = t1 > 100 || A.fuzzyEquals(t1, 100); + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + get$isChannel2Powerless() { + var t1, + _0_0 = this._space; + $label0$0: { + if (B.LchColorSpace_Bpv === _0_0 || B.OklchColorSpace_9Gj === _0_0) { + t1 = this.channel1OrNull; + t1 = A.fuzzyEquals(t1 == null ? 0 : t1, 0); + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + get$isInGamut() { + var t2, t3, _this = this, + t1 = _this._space; + if (!t1.get$isBoundedInternal()) + return true; + t2 = _this.channel0OrNull; + if (t2 == null) + t2 = 0; + t1 = t1._channels; + t3 = false; + if (_this._isChannelInGamut$2(t2, t1[0])) { + t2 = _this.channel1OrNull; + if (t2 == null) + t2 = 0; + if (_this._isChannelInGamut$2(t2, t1[1])) { + t2 = _this.channel2OrNull; + if (t2 == null) + t2 = 0; + t1 = _this._isChannelInGamut$2(t2, t1[2]); + } else + t1 = t3; + } else + t1 = t3; + return t1; + }, + _isChannelInGamut$2(value, channel) { + var min, max, t1; + $label0$0: { + if (channel instanceof A.LinearChannel) { + min = channel.min; + max = channel.max; + if (value < max || A.fuzzyEquals(value, max)) + t1 = value > min || A.fuzzyEquals(value, min); + else + t1 = false; + break $label0$0; + } + t1 = true; + break $label0$0; + } + return t1; + }, + accept$1$1(visitor) { + return visitor.visitColor$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + assertColor$1($name) { + return this; + }, + assertLegacy$1($name) { + if (this._space.get$isLegacyInternal()) + return; + throw A.wrapException(A.SassScriptException$("Expected " + this.toString$0(0) + string$.x20to_be, $name)); + }, + channel$1(_, channel) { + var t1, _this = this, + channels = _this._space._channels; + if (channel === channels[0].name) { + t1 = _this.channel0OrNull; + return t1 == null ? 0 : t1; + } + if (channel === channels[1].name) { + t1 = _this.channel1OrNull; + return t1 == null ? 0 : t1; + } + if (channel === channels[2].name) { + t1 = _this.channel2OrNull; + return t1 == null ? 0 : t1; + } + if (channel === "alpha") { + t1 = _this.alphaOrNull; + return t1 == null ? 0 : t1; + } + throw A.wrapException(A.SassScriptException$("Color " + _this.toString$0(0) + " doesn't have a channel named \"" + channel + '".', null)); + }, + isChannelMissing$3$channelName$colorName(channel, channelName, colorName) { + var _this = this, + channels = _this._space._channels; + if (channel === channels[0].name) + return _this.channel0OrNull == null; + if (channel === channels[1].name) + return _this.channel1OrNull == null; + if (channel === channels[2].name) + return _this.channel2OrNull == null; + if (channel === "alpha") + return _this.alphaOrNull == null; + throw A.wrapException(A.SassScriptException$("Color " + _this.toString$0(0) + " doesn't have a channel named \"" + channel + '".', channelName)); + }, + isChannelMissing$1(channel) { + return this.isChannelMissing$3$channelName$colorName(channel, null, null); + }, + isChannelPowerless$3$channelName$colorName(channel, channelName, colorName) { + var _this = this, + channels = _this._space._channels; + if (channel === channels[0].name) + return _this.get$isChannel0Powerless(); + if (channel === channels[1].name) + return false; + if (channel === channels[2].name) + return _this.get$isChannel2Powerless(); + if (channel === "alpha") + return false; + throw A.wrapException(A.SassScriptException$("Color " + _this.toString$0(0) + " doesn't have a channel named \"" + channel + '".', channelName)); + }, + _legacyChannel$2(space, channel) { + if (!this._space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$("color." + channel + string$.x28__is_oc, null)); + return this.toSpace$1(space).channel$1(0, channel); + }, + toSpace$2$legacyMissing(space, legacyMissing) { + var t2, converted, t3, t4, _this = this, + t1 = _this._space; + if (t1 === space) + return _this; + t2 = _this.alphaOrNull; + if (t2 == null) + t2 = 0; + converted = t1.convert$5(space, _this.channel0OrNull, _this.channel1OrNull, _this.channel2OrNull, t2); + t1 = false; + if (!legacyMissing) + if (converted._space.get$isLegacyInternal()) + t1 = converted.channel0OrNull == null || converted.channel1OrNull == null || converted.channel2OrNull == null || converted.alphaOrNull == null; + if (t1) { + t1 = converted.channel0OrNull; + if (t1 == null) + t1 = 0; + t2 = converted.channel1OrNull; + if (t2 == null) + t2 = 0; + t3 = converted.channel2OrNull; + if (t3 == null) + t3 = 0; + t4 = converted.alphaOrNull; + if (t4 == null) + t4 = 0; + t4 = A.SassColor_SassColor$forSpaceInternal(converted._space, t1, t2, t3, t4); + t1 = t4; + } else + t1 = converted; + return t1; + }, + toSpace$1(space) { + return this.toSpace$2$legacyMissing(space, true); + }, + changeHsl$3$hue$lightness$saturation(hue, lightness, saturation) { + var t2, t3, t4, t5, _this = this, _null = null, + t1 = _this._space; + if (!t1.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$(string$.color_c, _null)); + t2 = hue == null ? _null : hue; + if (t2 == null) + t2 = _this._legacyChannel$2(B.HslColorSpace_JQ2, "hue"); + t3 = saturation == null ? _null : saturation; + if (t3 == null) + t3 = _this._legacyChannel$2(B.HslColorSpace_JQ2, "saturation"); + t4 = lightness == null ? _null : lightness; + if (t4 == null) + t4 = _this._legacyChannel$2(B.HslColorSpace_JQ2, "lightness"); + t5 = _this.alphaOrNull; + if (t5 == null) + t5 = 0; + return A.SassColor_SassColor$hsl(t2, t3, t4, t5).toSpace$1(t1); + }, + changeHsl$1$saturation(saturation) { + return this.changeHsl$3$hue$lightness$saturation(null, null, saturation); + }, + changeHsl$1$lightness(lightness) { + return this.changeHsl$3$hue$lightness$saturation(null, lightness, null); + }, + changeHsl$1$hue(hue) { + return this.changeHsl$3$hue$lightness$saturation(hue, null, null); + }, + changeAlpha$1(alpha) { + var t2, t3, _this = this, + t1 = _this.channel0OrNull; + if (t1 == null) + t1 = 0; + t2 = _this.channel1OrNull; + if (t2 == null) + t2 = 0; + t3 = _this.channel2OrNull; + if (t3 == null) + t3 = 0; + return A.SassColor_SassColor$forSpaceInternal(_this._space, t1, t2, t3, alpha); + }, + interpolate$4$legacyMissing$weight(other, method, legacyMissing, weight) { + var t1, color1, color2, missing1_0, missing1_1, missing1_2, missing2_0, missing2_1, missing2_2, channel1_0, channel1_1, channel1_2, channel2_0, channel2_1, channel2_2, alpha1, t2, t3, alpha10, alpha2, alpha20, thisMultiplier, t4, t5, otherMultiplier, mixedAlpha, mixed0, mixed1, mixed2, _this = this, _null = null; + if (A.fuzzyEquals(weight, 0)) + return other; + if (A.fuzzyEquals(weight, 1)) + return _this; + t1 = method.space; + color1 = _this.toSpace$1(t1); + color2 = other.toSpace$1(t1); + if (weight < 0 || weight > 1) + throw A.wrapException(A.RangeError$range(weight, 0, 1, "weight", _null)); + missing1_0 = _this._isAnalogousChannelMissing$3(_this, color1, 0); + missing1_1 = _this._isAnalogousChannelMissing$3(_this, color1, 1); + missing1_2 = _this._isAnalogousChannelMissing$3(_this, color1, 2); + missing2_0 = _this._isAnalogousChannelMissing$3(other, color2, 0); + missing2_1 = _this._isAnalogousChannelMissing$3(other, color2, 1); + missing2_2 = _this._isAnalogousChannelMissing$3(other, color2, 2); + channel1_0 = (missing1_0 ? color2 : color1).channel0OrNull; + if (channel1_0 == null) + channel1_0 = 0; + channel1_1 = (missing1_1 ? color2 : color1).channel1OrNull; + if (channel1_1 == null) + channel1_1 = 0; + channel1_2 = (missing1_2 ? color2 : color1).channel2OrNull; + if (channel1_2 == null) + channel1_2 = 0; + channel2_0 = (missing2_0 ? color1 : color2).channel0OrNull; + if (channel2_0 == null) + channel2_0 = 0; + channel2_1 = (missing2_1 ? color1 : color2).channel1OrNull; + if (channel2_1 == null) + channel2_1 = 0; + channel2_2 = (missing2_2 ? color1 : color2).channel2OrNull; + if (channel2_2 == null) + channel2_2 = 0; + alpha1 = _this.alphaOrNull; + t2 = alpha1 == null; + if (t2) { + t3 = other.alphaOrNull; + alpha10 = t3 == null ? 0 : t3; + } else + alpha10 = alpha1; + alpha2 = other.alphaOrNull; + t3 = alpha2 == null; + if (t3) + alpha20 = t2 ? 0 : alpha1; + else + alpha20 = alpha2; + thisMultiplier = (t2 ? 1 : alpha1) * weight; + t4 = t3 ? 1 : alpha2; + t5 = 1 - weight; + otherMultiplier = t4 * t5; + mixedAlpha = t2 && t3 ? _null : alpha10 * weight + alpha20 * t5; + if (missing1_0 && missing2_0) + mixed0 = _null; + else { + t2 = mixedAlpha == null ? 1 : mixedAlpha; + mixed0 = (channel1_0 * thisMultiplier + channel2_0 * otherMultiplier) / t2; + } + if (missing1_1 && missing2_1) + mixed1 = _null; + else { + t2 = mixedAlpha == null ? 1 : mixedAlpha; + mixed1 = (channel1_1 * thisMultiplier + channel2_1 * otherMultiplier) / t2; + } + if (missing1_2 && missing2_2) + mixed2 = _null; + else { + t2 = mixedAlpha == null ? 1 : mixedAlpha; + mixed2 = (channel1_2 * thisMultiplier + channel2_2 * otherMultiplier) / t2; + } + $label0$0: { + if (B.HslColorSpace_JQ2 === t1 || B.HwbColorSpace_guQ === t1) { + if (missing1_0 && missing2_0) + t2 = _null; + else { + t2 = method.hue; + t2.toString; + t2 = _this._interpolateHues$4(channel1_0, channel2_0, t2, weight); + } + t2 = A.SassColor_SassColor$forSpaceInternal(t1, t2, mixed1, mixed2, mixedAlpha); + t1 = t2; + break $label0$0; + } + if (B.LchColorSpace_Bpv === t1 || B.OklchColorSpace_9Gj === t1) { + if (missing1_2 && missing2_2) + t2 = _null; + else { + t2 = method.hue; + t2.toString; + t2 = _this._interpolateHues$4(channel1_2, channel2_2, t2, weight); + } + t2 = A.SassColor_SassColor$forSpaceInternal(t1, mixed0, mixed1, t2, mixedAlpha); + t1 = t2; + break $label0$0; + } + t1 = A.SassColor_SassColor$forSpaceInternal(t1, mixed0, mixed1, mixed2, mixedAlpha); + break $label0$0; + } + return t1.toSpace$2$legacyMissing(_this._space, false); + }, + _isAnalogousChannelMissing$3(original, output, outputChannelIndex) { + var originalChannel; + if (output.get$channelsOrNull()[outputChannelIndex] == null) + return true; + if (original === output) + return false; + originalChannel = A.IterableExtension_firstWhereOrNull(original._space._channels, output._space._channels[outputChannelIndex].get$isAnalogous()); + if (originalChannel == null) + return false; + return original.isChannelMissing$1(originalChannel.name); + }, + _interpolateHues$4(hue1, hue2, method, weight) { + var _0_0, _1_0; + $label1$1: { + if (B.HueInterpolationMethod_0 === method) { + $label0$0: { + _0_0 = hue2 - hue1; + if (_0_0 > 180) { + hue1 += 360; + break $label0$0; + } + if (_0_0 < -180) + hue2 += 360; + } + break $label1$1; + } + if (B.HueInterpolationMethod_1 === method) { + $label2$2: { + _1_0 = hue2 - hue1; + if (_1_0 > 0 && _1_0 < 180) { + hue2 += 360; + break $label2$2; + } + if (_1_0 > -180 && _1_0 <= 0) + hue1 += 360; + } + break $label1$1; + } + if (B.HueInterpolationMethod_2 === method && hue2 < hue1) { + hue2 += 360; + break $label1$1; + } + if (B.HueInterpolationMethod_3 === method && hue1 < hue2) { + hue1 += 360; + break $label1$1; + } + } + return hue1 * weight + hue2 * (1 - weight); + }, + plus$1(other) { + if (!(other instanceof A.SassNumber) && !(other instanceof A.SassColor)) + return this.super$Value$plus(other); + throw A.wrapException(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " + " + other.toString$0(0) + '".', null)); + }, + minus$1(other) { + if (!(other instanceof A.SassNumber) && !(other instanceof A.SassColor)) + return this.super$Value$minus(other); + throw A.wrapException(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " - " + other.toString$0(0) + '".', null)); + }, + dividedBy$1(other) { + if (!(other instanceof A.SassNumber) && !(other instanceof A.SassColor)) + return this.super$Value$dividedBy(other); + throw A.wrapException(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " / " + other.toString$0(0) + '".', null)); + }, + $eq(_, other) { + var t1, t2, _this = this; + if (other == null) + return false; + if (!(other instanceof A.SassColor)) + return false; + t1 = _this._space; + if (t1.get$isLegacyInternal()) { + t2 = other._space; + if (!t2.get$isLegacyInternal()) + return false; + if (!A.fuzzyEqualsNullable(_this.alphaOrNull, other.alphaOrNull)) + return false; + if (t1 === t2) + return A.fuzzyEqualsNullable(_this.channel0OrNull, other.channel0OrNull) && A.fuzzyEqualsNullable(_this.channel1OrNull, other.channel1OrNull) && A.fuzzyEqualsNullable(_this.channel2OrNull, other.channel2OrNull); + else + return _this.toSpace$1(B.RgbColorSpace_i0P).$eq(0, other.toSpace$1(B.RgbColorSpace_i0P)); + } + return t1 === other._space && A.fuzzyEqualsNullable(_this.channel0OrNull, other.channel0OrNull) && A.fuzzyEqualsNullable(_this.channel1OrNull, other.channel1OrNull) && A.fuzzyEqualsNullable(_this.channel2OrNull, other.channel2OrNull) && A.fuzzyEqualsNullable(_this.alphaOrNull, other.alphaOrNull); + }, + get$hashCode(_) { + var rgb, t2, t3, t4, t5, _this = this, + t1 = _this._space; + if (t1.get$isLegacyInternal()) { + rgb = _this.toSpace$1(B.RgbColorSpace_i0P); + t1 = rgb.channel0OrNull; + t1 = A.fuzzyHashCode(t1 == null ? 0 : t1); + t2 = rgb.channel1OrNull; + t2 = A.fuzzyHashCode(t2 == null ? 0 : t2); + t3 = rgb.channel2OrNull; + t3 = A.fuzzyHashCode(t3 == null ? 0 : t3); + t4 = _this.alphaOrNull; + return t1 ^ t2 ^ t3 ^ A.fuzzyHashCode(t4 == null ? 0 : t4); + } else { + t1 = A.Primitives_objectHashCode(t1); + t2 = _this.channel0OrNull; + t2 = A.fuzzyHashCode(t2 == null ? 0 : t2); + t3 = _this.channel1OrNull; + t3 = A.fuzzyHashCode(t3 == null ? 0 : t3); + t4 = _this.channel2OrNull; + t4 = A.fuzzyHashCode(t4 == null ? 0 : t4); + t5 = _this.alphaOrNull; + return (t1 ^ t2 ^ t3 ^ t4 ^ A.fuzzyHashCode(t5 == null ? 0 : t5)) >>> 0; + } + } + }; + A.SassColor$_forSpace_closure.prototype = { + call$1(alpha) { + return A.fuzzyAssertRange(alpha, 0, 1, "alpha"); + }, + $signature: 16 + }; + A._ColorFormatEnum.prototype = { + toString$0(_) { + return "rgbFunction"; + } + }; + A.SpanColorFormat.prototype = {}; + A.ColorChannel.prototype = { + isAnalogous$1(other) { + var _0_6_isSet, t1, _0_60, t2, _0_6_isSet0, + _0_1 = this.name, + _0_6 = other.name; + $label0$0: { + if ("red" !== _0_1) + _0_6_isSet = "x" === _0_1; + else + _0_6_isSet = true; + if (_0_6_isSet) { + if ("red" !== _0_6) + t1 = "x" === _0_6; + else + t1 = true; + _0_60 = _0_6; + } else { + _0_60 = null; + t1 = false; + } + t2 = true; + if (!t1) { + if ("green" !== _0_1) + t1 = "y" === _0_1; + else + t1 = true; + if (t1) { + _0_6_isSet0 = true; + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t1; + } + if ("green" !== t1) { + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t1; + } + t1 = "y" === t1; + } else + t1 = true; + } else + t1 = false; + if (!t1) { + if ("blue" !== _0_1) + t1 = "z" === _0_1; + else + t1 = true; + if (t1) { + _0_6_isSet0 = true; + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t1; + } + if ("blue" !== t1) { + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t1; + } + t1 = "z" === t1; + } else + t1 = true; + } else + t1 = false; + if (!t1) { + if ("chroma" !== _0_1) + t1 = "saturation" === _0_1; + else + t1 = true; + if (t1) { + _0_6_isSet0 = true; + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t1; + } + if ("chroma" !== t1) { + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t1; + } + t1 = "saturation" === t1; + } else + t1 = true; + } else + t1 = false; + if (!t1) { + if ("lightness" === _0_1) { + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_60 = t1; + _0_6_isSet = true; + } + t1 = "lightness" === t1; + } else + t1 = false; + if (!t1) + if ("hue" === _0_1) + t1 = "hue" === (_0_6_isSet ? _0_60 : _0_6); + else + t1 = false; + else + t1 = t2; + } else + t1 = t2; + } else + t1 = t2; + } else + t1 = t2; + } else + t1 = t2; + if (t1) + break $label0$0; + break $label0$0; + } + return t1; + } + }; + A.LinearChannel.prototype = {}; + A.GamutMapMethod.prototype = { + toString$0(_) { + return this.name; + } + }; + A.ClipGamutMap.prototype = { + map$1(_, color) { + var t1 = color._space, + t2 = t1._channels; + return A.SassColor_SassColor$forSpaceInternal(t1, this._clampChannel$2(color.channel0OrNull, t2[0]), this._clampChannel$2(color.channel1OrNull, t2[1]), this._clampChannel$2(color.channel2OrNull, t2[2]), color.alphaOrNull); + }, + _clampChannel$2(value, channel) { + var t1, min; + if (value == null) + t1 = null; + else + $label0$0: { + if (channel instanceof A.LinearChannel) { + min = channel.min; + t1 = isNaN(value) ? min : B.JSNumber_methods.clamp$2(value, min, channel.max); + break $label0$0; + } + t1 = value; + break $label0$0; + } + return t1; + } + }; + A.LocalMindeGamutMap.prototype = { + map$1(_, color) { + var clipped, max, min, minInGamut, chroma, current, e, + originOklch = color.toSpace$1(B.OklchColorSpace_9Gj), + lightness = originOklch.channel0OrNull, + hue = originOklch.channel2OrNull, + alpha = originOklch.alphaOrNull, + t1 = lightness == null, + t2 = t1 ? 0 : lightness; + if (t2 > 1 || A.fuzzyEquals(t2, 1)) { + t1 = color._space; + t2 = color.alphaOrNull; + return t1.get$isLegacyInternal() ? A.SassColor_SassColor$rgbInternal(255, 255, 255, t2, null).toSpace$1(t1) : A.SassColor_SassColor$forSpaceInternal(t1, 1, 1, 1, t2); + } else { + t1 = t1 ? 0 : lightness; + if (t1 < 0 || A.fuzzyEquals(t1, 0)) + return A.SassColor_SassColor$rgbInternal(0, 0, 0, color.alphaOrNull, null).toSpace$1(color._space); + } + clipped = color.get$isInGamut() ? color : B.ClipGamutMap_clip.map$1(0, color); + if (this._deltaEOK$2(clipped, color) < 0.02) + return clipped; + max = originOklch.channel1OrNull; + if (max == null) + max = 0; + for (t1 = color._space, min = 0, minInGamut = true; max - min > 0.0001;) { + chroma = (min + max) / 2; + current = B.OklchColorSpace_9Gj.convert$5(t1, lightness, chroma, hue, alpha); + if (minInGamut && current.get$isInGamut()) { + min = chroma; + continue; + } + clipped = current.get$isInGamut() ? current : B.ClipGamutMap_clip.map$1(0, current); + e = this._deltaEOK$2(clipped, current); + if (e < 0.02) { + if (0.02 - e < 0.0001) + return clipped; + min = chroma; + minInGamut = false; + } else + max = chroma; + } + return clipped; + }, + _deltaEOK$2(color1, color2) { + var t2, t3, t4, + lab1 = color1.toSpace$1(B.OklabColorSpace_540), + lab2 = color2.toSpace$1(B.OklabColorSpace_540), + t1 = lab1.channel0OrNull; + if (t1 == null) + t1 = 0; + t2 = lab2.channel0OrNull; + t1 = Math.pow(t1 - (t2 == null ? 0 : t2), 2); + t2 = lab1.channel1OrNull; + if (t2 == null) + t2 = 0; + t3 = lab2.channel1OrNull; + t2 = Math.pow(t2 - (t3 == null ? 0 : t3), 2); + t3 = lab1.channel2OrNull; + if (t3 == null) + t3 = 0; + t4 = lab2.channel2OrNull; + return Math.sqrt(t1 + t2 + Math.pow(t3 - (t4 == null ? 0 : t4), 2)); + } + }; + A.InterpolationMethod.prototype = { + toString$0(_) { + var t1 = this.hue; + t1 = t1 == null ? "" : " " + t1.toString$0(0) + " hue"; + return this.space.name + t1; + } + }; + A.HueInterpolationMethod.prototype = { + _enumToString$0() { + return "HueInterpolationMethod." + this._name; + } + }; + A.ColorSpace.prototype = { + get$isLegacyInternal() { + return false; + }, + get$isPolarInternal() { + return false; + }, + convert$5(dest, channel0, channel1, channel2, alpha) { + return this.convertLinear$5(dest, channel0, channel1, channel2, alpha); + }, + convertLinear$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, red, green, blue, alpha, missingA, missingB, missingChroma, missingHue, missingLightness) { + var t1, t2, transformedBlue, transformedGreen, transformedRed, linearRed, linearGreen, linearBlue, matrix, _this = this; + $label0$0: { + t1 = B.HslColorSpace_JQ2 !== dest; + if (!t1 || B.HwbColorSpace_guQ === dest) { + t2 = B.SrgbColorSpace_thf; + break $label0$0; + } + if (B.LabColorSpace_2nT === dest || B.LchColorSpace_Bpv === dest) { + t2 = B.XyzD50ColorSpace_2OB; + break $label0$0; + } + if (B.OklabColorSpace_540 === dest || B.OklchColorSpace_9Gj === dest) { + t2 = B.LmsColorSpace_Os3; + break $label0$0; + } + t2 = dest; + break $label0$0; + } + if (t2 === _this) { + transformedBlue = blue; + transformedGreen = green; + transformedRed = red; + } else { + linearRed = _this.toLinear$1(red == null ? 0 : red); + linearGreen = _this.toLinear$1(green == null ? 0 : green); + linearBlue = _this.toLinear$1(blue == null ? 0 : blue); + matrix = _this.transformationMatrix$1(t2); + transformedRed = t2.fromLinear$1(matrix[0] * linearRed + matrix[1] * linearGreen + matrix[2] * linearBlue); + transformedGreen = t2.fromLinear$1(matrix[3] * linearRed + matrix[4] * linearGreen + matrix[5] * linearBlue); + transformedBlue = t2.fromLinear$1(matrix[6] * linearRed + matrix[7] * linearGreen + matrix[8] * linearBlue); + } + $label1$1: { + if (!t1 || B.HwbColorSpace_guQ === dest) { + t1 = B.SrgbColorSpace_thf.convert$8$missingChroma$missingHue$missingLightness(dest, transformedRed, transformedGreen, transformedBlue, alpha, missingChroma, missingHue, missingLightness); + break $label1$1; + } + if (B.LabColorSpace_2nT === dest || B.LchColorSpace_Bpv === dest) { + t1 = B.XyzD50ColorSpace_2OB.convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, transformedRed, transformedGreen, transformedBlue, alpha, missingA, missingB, missingChroma, missingHue, missingLightness); + break $label1$1; + } + if (B.OklabColorSpace_540 === dest || B.OklchColorSpace_9Gj === dest) { + t1 = B.LmsColorSpace_Os3.convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, transformedRed, transformedGreen, transformedBlue, alpha, missingA, missingB, missingChroma, missingHue, missingLightness); + break $label1$1; + } + t1 = red == null ? null : transformedRed; + t2 = green == null ? null : transformedGreen; + t1 = A.SassColor_SassColor$forSpaceInternal(dest, t1, t2, blue == null ? null : transformedBlue, alpha); + break $label1$1; + } + return t1; + }, + convertLinear$5(dest, red, green, blue, alpha) { + return this.convertLinear$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, red, green, blue, alpha, false, false, false, false, false); + }, + toLinear$1(channel) { + return A.throwExpression(A.UnimplementedError$("[BUG] Color space " + this.toString$0(0) + " doesn't support linear conversions.")); + }, + fromLinear$1(channel) { + return A.throwExpression(A.UnimplementedError$("[BUG] Color space " + this.toString$0(0) + " doesn't support linear conversions.")); + }, + transformationMatrix$1(dest) { + return A.throwExpression(A.UnimplementedError$("[BUG] Color space conversion from " + this.toString$0(0) + " to " + dest.toString$0(0) + " not implemented.")); + }, + toString$0(_) { + return this.name; + } + }; + A.A98RgbColorSpace.prototype = { + get$isBoundedInternal() { + return true; + }, + toLinear$1(channel) { + return J.get$sign$in(channel) * Math.pow(Math.abs(channel), 2.19921875); + }, + fromLinear$1(channel) { + return J.get$sign$in(channel) * Math.pow(Math.abs(channel), 0.4547069271758437); + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.SrgbLinearColorSpace_kUj === dest || B.SrgbColorSpace_thf === dest || B.RgbColorSpace_i0P === dest) { + t1 = $.$get$linearA98RgbToLinearSrgb(); + break $label0$0; + } + if (B.DisplayP3ColorSpace_MmT === dest) { + t1 = $.$get$linearA98RgbToLinearDisplayP3(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz === dest) { + t1 = $.$get$linearA98RgbToLinearProphotoRgb(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo === dest) { + t1 = $.$get$linearA98RgbToLinearRec2020(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ === dest) { + t1 = $.$get$linearA98RgbToXyzD65(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB === dest) { + t1 = $.$get$linearA98RgbToXyzD50(); + break $label0$0; + } + if (B.LmsColorSpace_Os3 === dest) { + t1 = $.$get$linearA98RgbToLms(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix(dest); + break $label0$0; + } + return t1; + } + }; + A.DisplayP3ColorSpace.prototype = { + get$isBoundedInternal() { + return true; + }, + toLinear$1(channel) { + return A.srgbAndDisplayP3ToLinear(channel); + }, + fromLinear$1(channel) { + return A.srgbAndDisplayP3FromLinear(channel); + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.SrgbLinearColorSpace_kUj === dest || B.SrgbColorSpace_thf === dest || B.RgbColorSpace_i0P === dest) { + t1 = $.$get$linearDisplayP3ToLinearSrgb(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf2 === dest) { + t1 = $.$get$linearDisplayP3ToLinearA98Rgb(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz === dest) { + t1 = $.$get$linearDisplayP3ToLinearProphotoRgb(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo === dest) { + t1 = $.$get$linearDisplayP3ToLinearRec2020(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ === dest) { + t1 = $.$get$linearDisplayP3ToXyzD65(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB === dest) { + t1 = $.$get$linearDisplayP3ToXyzD50(); + break $label0$0; + } + if (B.LmsColorSpace_Os3 === dest) { + t1 = $.$get$linearDisplayP3ToLms(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix(dest); + break $label0$0; + } + return t1; + } + }; + A.HslColorSpace.prototype = { + get$isBoundedInternal() { + return true; + }, + get$isLegacyInternal() { + return true; + }, + get$isPolarInternal() { + return true; + }, + convert$5(dest, hue, saturation, lightness, alpha) { + var t1 = hue == null, + scaledHue = B.JSNumber_methods.$mod((t1 ? 0 : hue) / 360, 1), + t2 = saturation == null, + scaledSaturation = (t2 ? 0 : saturation) / 100, + t3 = lightness == null, + scaledLightness = (t3 ? 0 : lightness) / 100, + m2 = scaledLightness <= 0.5 ? scaledLightness * (scaledSaturation + 1) : scaledLightness + scaledSaturation - scaledLightness * scaledSaturation, + m1 = scaledLightness * 2 - m2; + return B.SrgbColorSpace_thf.convert$8$missingChroma$missingHue$missingLightness(dest, A.hueToRgb(m1, m2, scaledHue + 0.3333333333333333), A.hueToRgb(m1, m2, scaledHue), A.hueToRgb(m1, m2, scaledHue - 0.3333333333333333), alpha, t2, t1, t3); + } + }; + A.HwbColorSpace.prototype = { + get$isBoundedInternal() { + return true; + }, + get$isLegacyInternal() { + return true; + }, + get$isPolarInternal() { + return true; + }, + convert$5(dest, hue, whiteness, blackness, alpha) { + var t3, t1 = {}, + t2 = hue == null, + scaledHue = B.JSNumber_methods.$mod(t2 ? 0 : hue, 360) / 360, + scaledWhiteness = t1.scaledWhiteness = (whiteness == null ? 0 : whiteness) / 100, + scaledBlackness = (blackness == null ? 0 : blackness) / 100, + sum = scaledWhiteness + scaledBlackness; + if (sum > 1) { + t3 = t1.scaledWhiteness = scaledWhiteness / sum; + scaledBlackness /= sum; + } else + t3 = scaledWhiteness; + t3 = new A.HwbColorSpace_convert_toRgb(t1, 1 - t3 - scaledBlackness); + return B.SrgbColorSpace_thf.convert$6$missingHue(dest, t3.call$1(scaledHue + 0.3333333333333333), t3.call$1(scaledHue), t3.call$1(scaledHue - 0.3333333333333333), alpha, t2); + } + }; + A.HwbColorSpace_convert_toRgb.prototype = { + call$1(hue) { + return A.hueToRgb(0, 1, hue) * this.factor + this._box_0.scaledWhiteness; + }, + $signature: 16 + }; + A.LabColorSpace.prototype = { + get$isBoundedInternal() { + return false; + }, + convert$7$missingChroma$missingHue(dest, lightness, a, b, alpha, missingChroma, missingHue) { + var powerlessAB, t1, missingLightness, f1, t2, t3, t4; + switch (dest) { + case B.LabColorSpace_2nT: + powerlessAB = lightness == null || A.fuzzyEquals(lightness, 0); + t1 = a == null || powerlessAB ? null : a; + return A.SassColor$_forSpace(B.LabColorSpace_2nT, lightness, t1, b == null || powerlessAB ? null : b, alpha, null); + case B.LchColorSpace_Bpv: + return A.labToLch(dest, lightness, a, b, alpha, false, false); + default: + missingLightness = lightness == null; + if (missingLightness) + lightness = 0; + f1 = (lightness + 16) / 116; + t1 = a == null; + t2 = this._convertFToXorZ$1((t1 ? 0 : a) / 500 + f1); + t3 = lightness > 8 ? Math.pow(f1, 3) : lightness / 903.2962962962963; + t4 = b == null; + return B.XyzD50ColorSpace_2OB.convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, t2 * 0.9642956764295677, t3, this._convertFToXorZ$1(f1 - (t4 ? 0 : b) / 200) * 0.8251046025104602, alpha, t1, t4, missingChroma, missingHue, missingLightness); + } + }, + convert$5(dest, lightness, a, b, alpha) { + return this.convert$7$missingChroma$missingHue(dest, lightness, a, b, alpha, false, false); + }, + _convertFToXorZ$1(component) { + var cubed = Math.pow(component, 3) + 0; + return cubed > 0.008856451679035631 ? cubed : (116 * component - 16) / 903.2962962962963; + } + }; + A.LchColorSpace.prototype = { + get$isBoundedInternal() { + return false; + }, + get$isPolarInternal() { + return true; + }, + convert$5(dest, lightness, chroma, hue, alpha) { + var t1 = hue == null, + hueRadians = (t1 ? 0 : hue) * 3.141592653589793 / 180, + t2 = chroma == null, + t3 = t2 ? 0 : chroma, + t4 = Math.cos(hueRadians), + t5 = t2 ? 0 : chroma; + return B.LabColorSpace_2nT.convert$7$missingChroma$missingHue(dest, lightness, t3 * t4, t5 * Math.sin(hueRadians), alpha, t2, t1); + } + }; + A.LmsColorSpace.prototype = { + get$isBoundedInternal() { + return false; + }, + convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, long, medium, short, alpha, missingA, missingB, missingChroma, missingHue, missingLightness) { + var t1, longScaled, mediumScaled, shortScaled, lightness, t2, t3, _null = null; + switch (dest) { + case B.OklabColorSpace_540: + t1 = long == null ? 0 : long; + longScaled = Math.pow(Math.abs(t1), 0.3333333333333333) * J.get$sign$in(t1); + t1 = medium == null ? 0 : medium; + mediumScaled = Math.pow(Math.abs(t1), 0.3333333333333333) * J.get$sign$in(t1); + t1 = short == null ? 0 : short; + shortScaled = Math.pow(Math.abs(t1), 0.3333333333333333) * J.get$sign$in(t1); + t1 = $.$get$lmsToOklab(); + lightness = t1[0] * longScaled + t1[1] * mediumScaled + t1[2] * shortScaled; + t2 = missingLightness ? _null : lightness; + t3 = missingA ? _null : t1[3] * longScaled + t1[4] * mediumScaled + t1[5] * shortScaled; + return A.SassColor$_forSpace(B.OklabColorSpace_540, t2, t3, missingB ? _null : t1[6] * longScaled + t1[7] * mediumScaled + t1[8] * shortScaled, alpha, _null); + case B.OklchColorSpace_9Gj: + t1 = long == null ? 0 : long; + longScaled = Math.pow(Math.abs(t1), 0.3333333333333333) * J.get$sign$in(t1); + t1 = medium == null ? 0 : medium; + mediumScaled = Math.pow(Math.abs(t1), 0.3333333333333333) * J.get$sign$in(t1); + t1 = short == null ? 0 : short; + shortScaled = Math.pow(Math.abs(t1), 0.3333333333333333) * J.get$sign$in(t1); + if (missingLightness) + t1 = _null; + else { + t1 = $.$get$lmsToOklab(); + t1 = t1[0] * longScaled + t1[1] * mediumScaled + t1[2] * shortScaled; + } + t2 = $.$get$lmsToOklab(); + return A.labToLch(dest, t1, t2[3] * longScaled + t2[4] * mediumScaled + t2[5] * shortScaled, t2[6] * longScaled + t2[7] * mediumScaled + t2[8] * shortScaled, alpha, missingChroma, missingHue); + default: + return this.super$ColorSpace$convertLinear(dest, long, medium, short, alpha, missingA, missingB, missingChroma, missingHue, missingLightness); + } + }, + convert$5(dest, long, medium, short, alpha) { + return this.convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, long, medium, short, alpha, false, false, false, false, false); + }, + toLinear$1(channel) { + return channel; + }, + fromLinear$1(channel) { + return channel; + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.SrgbLinearColorSpace_kUj === dest || B.SrgbColorSpace_thf === dest || B.RgbColorSpace_i0P === dest) { + t1 = $.$get$lmsToLinearSrgb(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf2 === dest) { + t1 = $.$get$lmsToLinearA98Rgb(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz === dest) { + t1 = $.$get$lmsToLinearProphotoRgb(); + break $label0$0; + } + if (B.DisplayP3ColorSpace_MmT === dest) { + t1 = $.$get$lmsToLinearDisplayP3(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo === dest) { + t1 = $.$get$lmsToLinearRec2020(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ === dest) { + t1 = $.$get$lmsToXyzD65(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB === dest) { + t1 = $.$get$lmsToXyzD50(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix(dest); + break $label0$0; + } + return t1; + } + }; + A.OklabColorSpace.prototype = { + get$isBoundedInternal() { + return false; + }, + convert$7$missingChroma$missingHue(dest, lightness, a, b, alpha, missingChroma, missingHue) { + var missingLightness, missingA, missingB, t1; + if (dest === B.OklchColorSpace_9Gj) + return A.labToLch(dest, lightness, a, b, alpha, missingChroma, missingHue); + missingLightness = lightness == null; + missingA = a == null; + missingB = b == null; + if (missingLightness) + lightness = 0; + if (missingA) + a = 0; + if (missingB) + b = 0; + t1 = $.$get$oklabToLms(); + return B.LmsColorSpace_Os3.convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, Math.pow(t1[0] * lightness + t1[1] * a + t1[2] * b, 3) + 0, Math.pow(t1[3] * lightness + t1[4] * a + t1[5] * b, 3) + 0, Math.pow(t1[6] * lightness + t1[7] * a + t1[8] * b, 3) + 0, alpha, missingA, missingB, missingChroma, missingHue, missingLightness); + }, + convert$5(dest, lightness, a, b, alpha) { + return this.convert$7$missingChroma$missingHue(dest, lightness, a, b, alpha, false, false); + } + }; + A.OklchColorSpace.prototype = { + get$isBoundedInternal() { + return false; + }, + get$isPolarInternal() { + return true; + }, + convert$5(dest, lightness, chroma, hue, alpha) { + var t1 = hue == null, + hueRadians = (t1 ? 0 : hue) * 3.141592653589793 / 180, + t2 = chroma == null, + t3 = t2 ? 0 : chroma, + t4 = Math.cos(hueRadians), + t5 = t2 ? 0 : chroma; + return B.OklabColorSpace_540.convert$7$missingChroma$missingHue(dest, lightness, t3 * t4, t5 * Math.sin(hueRadians), alpha, t2, t1); + } + }; + A.ProphotoRgbColorSpace.prototype = { + get$isBoundedInternal() { + return true; + }, + toLinear$1(channel) { + var abs = Math.abs(channel); + return abs <= 0.03125 ? channel / 16 : J.get$sign$in(channel) * Math.pow(abs, 1.8); + }, + fromLinear$1(channel) { + var abs = Math.abs(channel); + return abs >= 0.001953125 ? J.get$sign$in(channel) * Math.pow(abs, 0.5555555555555556) : 16 * channel; + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.SrgbLinearColorSpace_kUj === dest || B.SrgbColorSpace_thf === dest || B.RgbColorSpace_i0P === dest) { + t1 = $.$get$linearProphotoRgbToLinearSrgb(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf2 === dest) { + t1 = $.$get$linearProphotoRgbToLinearA98Rgb(); + break $label0$0; + } + if (B.DisplayP3ColorSpace_MmT === dest) { + t1 = $.$get$linearProphotoRgbToLinearDisplayP3(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo === dest) { + t1 = $.$get$linearProphotoRgbToLinearRec2020(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ === dest) { + t1 = $.$get$linearProphotoRgbToXyzD65(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB === dest) { + t1 = $.$get$linearProphotoRgbToXyzD50(); + break $label0$0; + } + if (B.LmsColorSpace_Os3 === dest) { + t1 = $.$get$linearProphotoRgbToLms(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix(dest); + break $label0$0; + } + return t1; + } + }; + A.Rec2020ColorSpace.prototype = { + get$isBoundedInternal() { + return true; + }, + toLinear$1(channel) { + var abs = Math.abs(channel); + return abs < 0.08124285829863151 ? channel / 4.5 : J.get$sign$in(channel) * Math.pow((abs + 1.09929682680944 - 1) / 1.09929682680944, 2.2222222222222223); + }, + fromLinear$1(channel) { + var abs = Math.abs(channel); + return abs > 0.018053968510807 ? J.get$sign$in(channel) * (1.09929682680944 * Math.pow(abs, 0.45) - 0.09929682680944008) : 4.5 * channel; + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.SrgbLinearColorSpace_kUj === dest || B.SrgbColorSpace_thf === dest || B.RgbColorSpace_i0P === dest) { + t1 = $.$get$linearRec2020ToLinearSrgb(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf2 === dest) { + t1 = $.$get$linearRec2020ToLinearA98Rgb(); + break $label0$0; + } + if (B.DisplayP3ColorSpace_MmT === dest) { + t1 = $.$get$linearRec2020ToLinearDisplayP3(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz === dest) { + t1 = $.$get$linearRec2020ToLinearProphotoRgb(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ === dest) { + t1 = $.$get$linearRec2020ToXyzD65(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB === dest) { + t1 = $.$get$linearRec2020ToXyzD50(); + break $label0$0; + } + if (B.LmsColorSpace_Os3 === dest) { + t1 = $.$get$linearRec2020ToLms(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix(dest); + break $label0$0; + } + return t1; + } + }; + A.RgbColorSpace.prototype = { + get$isBoundedInternal() { + return true; + }, + get$isLegacyInternal() { + return true; + }, + convert$5(dest, red, green, blue, alpha) { + var t1 = red == null ? null : red / 255, + t2 = green == null ? null : green / 255; + return B.SrgbColorSpace_thf.convert$5(dest, t1, t2, blue == null ? null : blue / 255, alpha); + }, + toLinear$1(channel) { + return A.srgbAndDisplayP3ToLinear(channel / 255); + }, + fromLinear$1(channel) { + return A.srgbAndDisplayP3FromLinear(channel) * 255; + } + }; + A.SrgbColorSpace.prototype = { + get$isBoundedInternal() { + return true; + }, + convert$8$missingChroma$missingHue$missingLightness(dest, red, green, blue, alpha, missingChroma, missingHue, missingLightness) { + var max, min, delta, hue, lightness, saturation, t1, t2, whiteness, blackness, _null = null; + if (B.HslColorSpace_JQ2 === dest || B.HwbColorSpace_guQ === dest) { + if (red == null) + red = 0; + if (green == null) + green = 0; + if (blue == null) + blue = 0; + max = Math.max(Math.max(red, green), blue); + min = Math.min(Math.min(red, green), blue); + delta = max - min; + if (max === min) + hue = 0; + else if (max === red) + hue = 60 * (green - blue) / delta + 360; + else + hue = max === green ? 60 * (blue - red) / delta + 120 : 60 * (red - green) / delta + 240; + if (dest === B.HslColorSpace_JQ2) { + lightness = (min + max) / 2; + saturation = lightness === 0 || lightness === 1 ? 0 : 100 * (max - lightness) / Math.min(lightness, 1 - lightness); + if (saturation < 0) { + hue += 180; + saturation = Math.abs(saturation); + } + t1 = missingHue || A.fuzzyEquals(saturation, 0) ? _null : B.JSNumber_methods.$mod(hue, 360); + t2 = missingChroma ? _null : saturation; + return A.SassColor_SassColor$forSpaceInternal(dest, t1, t2, missingLightness ? _null : lightness * 100, alpha); + } else { + whiteness = min * 100; + blackness = 100 - max * 100; + if (!missingHue) { + t1 = whiteness + blackness; + t1 = t1 > 100 || A.fuzzyEquals(t1, 100); + } else + t1 = true; + return A.SassColor_SassColor$forSpaceInternal(dest, t1 ? _null : B.JSNumber_methods.$mod(hue, 360), whiteness, blackness, alpha); + } + } + if (B.RgbColorSpace_i0P === dest) { + t1 = red == null ? _null : red * 255; + t2 = green == null ? _null : green * 255; + return A.SassColor_SassColor$rgbInternal(t1, t2, blue == null ? _null : blue * 255, alpha, _null); + } + if (B.SrgbLinearColorSpace_kUj === dest) { + t1 = this.get$toLinear(); + return A.SassColor_SassColor$forSpaceInternal(dest, A.NullableExtension_andThen(red, t1), A.NullableExtension_andThen(green, t1), A.NullableExtension_andThen(blue, t1), alpha); + } + return this.super$ColorSpace$convertLinear(dest, red, green, blue, alpha, false, false, missingChroma, missingHue, missingLightness); + }, + convert$5(dest, red, green, blue, alpha) { + return this.convert$8$missingChroma$missingHue$missingLightness(dest, red, green, blue, alpha, false, false, false); + }, + convert$6$missingHue(dest, red, green, blue, alpha, missingHue) { + return this.convert$8$missingChroma$missingHue$missingLightness(dest, red, green, blue, alpha, false, missingHue, false); + }, + toLinear$1(channel) { + return A.srgbAndDisplayP3ToLinear(channel); + }, + fromLinear$1(channel) { + return A.srgbAndDisplayP3FromLinear(channel); + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.DisplayP3ColorSpace_MmT === dest) { + t1 = $.$get$linearSrgbToLinearDisplayP3(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf2 === dest) { + t1 = $.$get$linearSrgbToLinearA98Rgb(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz === dest) { + t1 = $.$get$linearSrgbToLinearProphotoRgb(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo === dest) { + t1 = $.$get$linearSrgbToLinearRec2020(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ === dest) { + t1 = $.$get$linearSrgbToXyzD65(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB === dest) { + t1 = $.$get$linearSrgbToXyzD50(); + break $label0$0; + } + if (B.LmsColorSpace_Os3 === dest) { + t1 = $.$get$linearSrgbToLms(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix(dest); + break $label0$0; + } + return t1; + } + }; + A.SrgbLinearColorSpace.prototype = { + get$isBoundedInternal() { + return true; + }, + convert$5(dest, red, green, blue, alpha) { + var t1; + $label0$0: { + if (B.RgbColorSpace_i0P === dest || B.HslColorSpace_JQ2 === dest || B.HwbColorSpace_guQ === dest || B.SrgbColorSpace_thf === dest) { + t1 = B.SrgbColorSpace_thf.convert$5(dest, A.NullableExtension_andThen(red, A.utils0__srgbAndDisplayP3FromLinear$closure()), A.NullableExtension_andThen(green, A.utils0__srgbAndDisplayP3FromLinear$closure()), A.NullableExtension_andThen(blue, A.utils0__srgbAndDisplayP3FromLinear$closure()), alpha); + break $label0$0; + } + t1 = this.super$ColorSpace$convert(dest, red, green, blue, alpha); + break $label0$0; + } + return t1; + }, + toLinear$1(channel) { + return channel; + }, + fromLinear$1(channel) { + return channel; + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.DisplayP3ColorSpace_MmT === dest) { + t1 = $.$get$linearSrgbToLinearDisplayP3(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf2 === dest) { + t1 = $.$get$linearSrgbToLinearA98Rgb(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz === dest) { + t1 = $.$get$linearSrgbToLinearProphotoRgb(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo === dest) { + t1 = $.$get$linearSrgbToLinearRec2020(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ === dest) { + t1 = $.$get$linearSrgbToXyzD65(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB === dest) { + t1 = $.$get$linearSrgbToXyzD50(); + break $label0$0; + } + if (B.LmsColorSpace_Os3 === dest) { + t1 = $.$get$linearSrgbToLms(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix(dest); + break $label0$0; + } + return t1; + } + }; + A.XyzD50ColorSpace.prototype = { + get$isBoundedInternal() { + return false; + }, + convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, x, y, z, alpha, missingA, missingB, missingChroma, missingHue, missingLightness) { + var f0, f1, f2, lightness, a, b, t1, _this = this, _null = null; + if (B.LabColorSpace_2nT === dest || B.LchColorSpace_Bpv === dest) { + f0 = _this._convertComponentToLabF$1((x == null ? 0 : x) / 0.9642956764295677); + f1 = _this._convertComponentToLabF$1((y == null ? 0 : y) / 1); + f2 = _this._convertComponentToLabF$1((z == null ? 0 : z) / 0.8251046025104602); + lightness = missingLightness ? _null : 116 * f1 - 16; + a = 500 * (f0 - f1); + b = 200 * (f1 - f2); + if (dest === B.LabColorSpace_2nT) { + t1 = missingA ? _null : a; + t1 = A.SassColor$_forSpace(B.LabColorSpace_2nT, lightness, t1, missingB ? _null : b, alpha, _null); + } else + t1 = A.labToLch(B.LchColorSpace_Bpv, lightness, a, b, alpha, missingChroma, missingHue); + return t1; + } + return _this.super$ColorSpace$convertLinear(dest, x, y, z, alpha, missingA, missingB, missingChroma, missingHue, missingLightness); + }, + convert$5(dest, x, y, z, alpha) { + return this.convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, x, y, z, alpha, false, false, false, false, false); + }, + _convertComponentToLabF$1(component) { + return component > 0.008856451679035631 ? Math.pow(component, 0.3333333333333333) + 0 : (903.2962962962963 * component + 16) / 116; + }, + toLinear$1(channel) { + return channel; + }, + fromLinear$1(channel) { + return channel; + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.SrgbLinearColorSpace_kUj === dest || B.SrgbColorSpace_thf === dest || B.RgbColorSpace_i0P === dest) { + t1 = $.$get$xyzD50ToLinearSrgb(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf2 === dest) { + t1 = $.$get$xyzD50ToLinearA98Rgb(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz === dest) { + t1 = $.$get$xyzD50ToLinearProphotoRgb(); + break $label0$0; + } + if (B.DisplayP3ColorSpace_MmT === dest) { + t1 = $.$get$xyzD50ToLinearDisplayP3(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo === dest) { + t1 = $.$get$xyzD50ToLinearRec2020(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ === dest) { + t1 = $.$get$xyzD50ToXyzD65(); + break $label0$0; + } + if (B.LmsColorSpace_Os3 === dest) { + t1 = $.$get$xyzD50ToLms(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix(dest); + break $label0$0; + } + return t1; + } + }; + A.XyzD65ColorSpace.prototype = { + get$isBoundedInternal() { + return false; + }, + toLinear$1(channel) { + return channel; + }, + fromLinear$1(channel) { + return channel; + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.SrgbLinearColorSpace_kUj === dest || B.SrgbColorSpace_thf === dest || B.RgbColorSpace_i0P === dest) { + t1 = $.$get$xyzD65ToLinearSrgb(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf2 === dest) { + t1 = $.$get$xyzD65ToLinearA98Rgb(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz === dest) { + t1 = $.$get$xyzD65ToLinearProphotoRgb(); + break $label0$0; + } + if (B.DisplayP3ColorSpace_MmT === dest) { + t1 = $.$get$xyzD65ToLinearDisplayP3(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo === dest) { + t1 = $.$get$xyzD65ToLinearRec2020(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB === dest) { + t1 = $.$get$xyzD65ToXyzD50(); + break $label0$0; + } + if (B.LmsColorSpace_Os3 === dest) { + t1 = $.$get$xyzD65ToLms(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix(dest); + break $label0$0; + } + return t1; + } + }; + A.SassFunction.prototype = { + accept$1$1(visitor) { + var t1, t2; + if (!visitor._inspect) + A.throwExpression(A.SassScriptException$(this.toString$0(0) + " isn't a valid CSS value.", null)); + t1 = visitor._serialize$_buffer; + t1.write$1(0, "get-function("); + t2 = this.callable; + visitor._visitQuotedString$1(t2.get$name(t2)); + t1.writeCharCode$1(41); + return null; + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + assertFunction$1($name) { + return this; + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.SassFunction && this.callable.$eq(0, other.callable); + }, + get$hashCode(_) { + var t1 = this.callable; + return t1.get$hashCode(t1); + } + }; + A.SassList.prototype = { + get$separator(_) { + return this._separator; + }, + get$hasBrackets() { + return this._hasBrackets; + }, + get$isBlank() { + return !this._hasBrackets && B.JSArray_methods.every$1(this._list$_contents, new A.SassList_isBlank_closure()); + }, + get$asList() { + return this._list$_contents; + }, + get$lengthAsList() { + return this._list$_contents.length; + }, + SassList$3$brackets(contents, _separator, brackets) { + if (this._separator === B.ListSeparator_undecided_null_undecided && this._list$_contents.length > 1) + throw A.wrapException(A.ArgumentError$(string$.A_list, null)); + }, + toString$0(_) { + var t2, _this = this, + t1 = true; + if (!_this._hasBrackets) { + t2 = _this._list$_contents.length; + if (t2 !== 0) + t1 = t2 === 1 && _this._separator === B.ListSeparator_qVN; + } + if (t1) + return _this.super$Value$toString(0); + return "(" + _this.super$Value$toString(0) + ")"; + }, + accept$1$1(visitor) { + return visitor.visitList$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + assertMap$1($name) { + return this._list$_contents.length === 0 ? B.SassMap_Map_empty : this.super$Value$assertMap($name); + }, + tryMap$0() { + return this._list$_contents.length === 0 ? B.SassMap_Map_empty : null; + }, + $eq(_, other) { + var t1, _this = this; + if (other == null) + return false; + if (!(other instanceof A.SassList && other._separator === _this._separator && other._hasBrackets === _this._hasBrackets && B.C_ListEquality.equals$2(0, other._list$_contents, _this._list$_contents))) + t1 = _this._list$_contents.length === 0 && other instanceof A.SassMap && other.get$asList().length === 0; + else + t1 = true; + return t1; + }, + get$hashCode(_) { + return B.C_ListEquality0.hash$1(this._list$_contents); + } + }; + A.SassList_isBlank_closure.prototype = { + call$1(element) { + return element.get$isBlank(); + }, + $signature: 72 + }; + A.ListSeparator.prototype = { + _enumToString$0() { + return "ListSeparator." + this._name; + }, + toString$0(_) { + return this._list$_name; + } + }; + A.SassMap.prototype = { + get$separator(_) { + var t1 = this._map$_contents; + return t1.get$isEmpty(t1) ? B.ListSeparator_undecided_null_undecided : B.ListSeparator_qVN; + }, + get$asList() { + var t3, t4, t5, result, + t1 = type$.JSArray_Value, + t2 = A._setArrayType([], t1); + for (t3 = type$.Value, t4 = A.MapExtensions_get_pairs(this._map$_contents, t3, t3), t4 = t4.get$iterator(t4); t4.moveNext$0();) { + t5 = t4.get$current(t4); + result = A.List_List$from(A._setArrayType([t5._0, t5._1], t1), false, t3); + result.$flags = 3; + t2.push(new A.SassList(result, B.ListSeparator_qSL, false)); + } + return t2; + }, + get$lengthAsList() { + var t1 = this._map$_contents; + return t1.get$length(t1); + }, + accept$1$1(visitor) { + return visitor.visitMap$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + assertMap$1($name) { + return this; + }, + tryMap$0() { + return this; + }, + $eq(_, other) { + var t1; + if (other == null) + return false; + if (!(other instanceof A.SassMap && B.C_MapEquality.equals$2(0, other._map$_contents, this._map$_contents))) { + t1 = this._map$_contents; + t1 = t1.get$isEmpty(t1) && other instanceof A.SassList && other._list$_contents.length === 0; + } else + t1 = true; + return t1; + }, + get$hashCode(_) { + var t1 = this._map$_contents; + return t1.get$isEmpty(t1) ? B.C_ListEquality0.hash$1(B.List_empty8) : B.C_MapEquality.hash$1(t1); + } + }; + A.SassMixin.prototype = { + accept$1$1(visitor) { + var t1, t2; + if (!visitor._inspect) + A.throwExpression(A.SassScriptException$(this.toString$0(0) + " isn't a valid CSS value.", null)); + t1 = visitor._serialize$_buffer; + t1.write$1(0, "get-mixin("); + t2 = this.callable; + visitor._visitQuotedString$1(t2.get$name(t2)); + t1.writeCharCode$1(41); + return null; + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + assertMixin$1($name) { + return this; + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.SassMixin && this.callable.$eq(0, other.callable); + }, + get$hashCode(_) { + var t1 = this.callable; + return t1.get$hashCode(t1); + } + }; + A._SassNull.prototype = { + get$isTruthy() { + return false; + }, + get$isBlank() { + return true; + }, + get$realNull() { + return null; + }, + accept$1$1(visitor) { + if (visitor._inspect) + visitor._serialize$_buffer.write$1(0, "null"); + return null; + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + unaryNot$0() { + return B.SassBoolean_true; + } + }; + A.SassNumber.prototype = { + get$unitString() { + var _this = this; + return _this.get$hasUnits() ? _this._unitString$2(_this.get$numeratorUnits(_this), _this.get$denominatorUnits(_this)) : ""; + }, + accept$1$1(visitor) { + return visitor.visitNumber$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + withoutSlash$0() { + var _this = this; + return _this.asSlash == null ? _this : _this.withValue$1(_this._number$_value); + }, + assertNumber$1($name) { + return this; + }, + assertNumber$0() { + return this.assertNumber$1(null); + }, + assertInt$1($name) { + var _0_0 = A.fuzzyAsInt(this._number$_value); + if (_0_0 != null) + return _0_0; + throw A.wrapException(A.SassScriptException$(this.toString$0(0) + " is not an int.", $name)); + }, + assertInt$0() { + return this.assertInt$1(null); + }, + valueInRange$3(min, max, $name) { + var _this = this, + _0_0 = A.fuzzyCheckRange(_this._number$_value, min, max); + if (_0_0 != null) + return _0_0; + throw A.wrapException(A.SassScriptException$("Expected " + _this.toString$0(0) + " to be within " + min + _this.get$unitString() + " and " + max + _this.get$unitString() + ".", $name)); + }, + valueInRangeWithUnit$4(min, max, $name, unit) { + var _0_0 = A.fuzzyCheckRange(this._number$_value, min, max); + if (_0_0 != null) + return _0_0; + throw A.wrapException(A.SassScriptException$("Expected " + this.toString$0(0) + " to be within " + min + unit + " and " + max + unit + ".", $name)); + }, + hasCompatibleUnits$1(other) { + var _this = this; + if (_this.get$numeratorUnits(_this).length !== other.get$numeratorUnits(other).length) + return false; + if (_this.get$denominatorUnits(_this).length !== other.get$denominatorUnits(other).length) + return false; + return _this.isComparableTo$1(other); + }, + assertUnit$2(unit, $name) { + if (this.hasUnit$1(unit)) + return; + throw A.wrapException(A.SassScriptException$("Expected " + this.toString$0(0) + ' to have unit "' + unit + '".', $name)); + }, + assertNoUnits$1($name) { + if (!this.get$hasUnits()) + return; + throw A.wrapException(A.SassScriptException$("Expected " + this.toString$0(0) + " to have no units.", $name)); + }, + assertNoUnits$0() { + return this.assertNoUnits$1(null); + }, + convertValueToMatch$3(other, $name, otherName) { + return this._coerceOrConvertValue$6$coerceUnitless$name$other$otherName(other.get$numeratorUnits(other), other.get$denominatorUnits(other), false, $name, other, otherName); + }, + convertValueToMatch$1(other) { + return this.convertValueToMatch$3(other, null, null); + }, + coerce$3(newNumerators, newDenominators, $name) { + return A.SassNumber_SassNumber$withUnits(this.coerceValue$3(newNumerators, newDenominators, $name), newDenominators, newNumerators); + }, + coerce$2(newNumerators, newDenominators) { + return this.coerce$3(newNumerators, newDenominators, null); + }, + coerceValue$3(newNumerators, newDenominators, $name) { + return this._coerceOrConvertValue$4$coerceUnitless$name(newNumerators, newDenominators, true, $name); + }, + coerceValueToUnit$2(unit, $name) { + var t1 = type$.JSArray_String; + return this.coerceValue$3(A._setArrayType([unit], t1), A._setArrayType([], t1), $name); + }, + coerceValueToUnit$1(unit) { + return this.coerceValueToUnit$2(unit, null); + }, + coerceToMatch$3(other, $name, otherName) { + var t1 = this.coerceValueToMatch$3(other, $name, otherName), + t2 = other.get$numeratorUnits(other); + return A.SassNumber_SassNumber$withUnits(t1, other.get$denominatorUnits(other), t2); + }, + coerceValueToMatch$3(other, $name, otherName) { + return this._coerceOrConvertValue$6$coerceUnitless$name$other$otherName(other.get$numeratorUnits(other), other.get$denominatorUnits(other), true, $name, other, otherName); + }, + coerceValueToMatch$1(other) { + return this.coerceValueToMatch$3(other, null, null); + }, + _coerceOrConvertValue$6$coerceUnitless$name$other$otherName(newNumerators, newDenominators, coerceUnitless, $name, other, otherName) { + var otherHasUnits, t1, compatibilityException, oldNumerators, _i, oldDenominators, _this = this, _box_0 = {}; + if (B.C_ListEquality.equals$2(0, _this.get$numeratorUnits(_this), newNumerators) && B.C_ListEquality.equals$2(0, _this.get$denominatorUnits(_this), newDenominators)) + return _this._number$_value; + otherHasUnits = newNumerators.length !== 0 || newDenominators.length !== 0; + if (coerceUnitless) + t1 = !_this.get$hasUnits() || !otherHasUnits; + else + t1 = false; + if (t1) + return _this._number$_value; + compatibilityException = new A.SassNumber__coerceOrConvertValue_compatibilityException(_this, other, otherName, otherHasUnits, $name, newNumerators, newDenominators); + _box_0.value = _this._number$_value; + t1 = _this.get$numeratorUnits(_this); + oldNumerators = A._setArrayType(t1.slice(0), A._arrayInstanceType(t1)); + for (t1 = newNumerators.length, _i = 0; _i < newNumerators.length; newNumerators.length === t1 || (0, A.throwConcurrentModificationError)(newNumerators), ++_i) + A.removeFirstWhere(oldNumerators, new A.SassNumber__coerceOrConvertValue_closure(_box_0, newNumerators[_i]), new A.SassNumber__coerceOrConvertValue_closure0(compatibilityException)); + t1 = _this.get$denominatorUnits(_this); + oldDenominators = A._setArrayType(t1.slice(0), A._arrayInstanceType(t1)); + for (t1 = newDenominators.length, _i = 0; _i < newDenominators.length; newDenominators.length === t1 || (0, A.throwConcurrentModificationError)(newDenominators), ++_i) + A.removeFirstWhere(oldDenominators, new A.SassNumber__coerceOrConvertValue_closure1(_box_0, newDenominators[_i]), new A.SassNumber__coerceOrConvertValue_closure2(compatibilityException)); + if (oldNumerators.length !== 0 || oldDenominators.length !== 0) + throw A.wrapException(compatibilityException.call$0()); + return _box_0.value; + }, + _coerceOrConvertValue$4$coerceUnitless$name(newNumerators, newDenominators, coerceUnitless, $name) { + return this._coerceOrConvertValue$6$coerceUnitless$name$other$otherName(newNumerators, newDenominators, coerceUnitless, $name, null, null); + }, + isComparableTo$1(other) { + var exception; + if (!this.get$hasUnits() || !other.get$hasUnits()) + return true; + try { + this.greaterThan$1(other); + return true; + } catch (exception) { + if (A.unwrapException(exception) instanceof A.SassScriptException) + return false; + else + throw exception; + } + }, + greaterThan$1(other) { + if (other instanceof A.SassNumber) + return this._coerceUnits$2(other, A.number0__fuzzyGreaterThan$closure()) ? B.SassBoolean_true : B.SassBoolean_false; + throw A.wrapException(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " > " + other.toString$0(0) + '".', null)); + }, + greaterThanOrEquals$1(other) { + if (other instanceof A.SassNumber) + return this._coerceUnits$2(other, A.number0__fuzzyGreaterThanOrEquals$closure()) ? B.SassBoolean_true : B.SassBoolean_false; + throw A.wrapException(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " >= " + other.toString$0(0) + '".', null)); + }, + lessThan$1(other) { + if (other instanceof A.SassNumber) + return this._coerceUnits$2(other, A.number0__fuzzyLessThan$closure()) ? B.SassBoolean_true : B.SassBoolean_false; + throw A.wrapException(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " < " + other.toString$0(0) + '".', null)); + }, + lessThanOrEquals$1(other) { + if (other instanceof A.SassNumber) + return this._coerceUnits$2(other, A.number0__fuzzyLessThanOrEquals$closure()) ? B.SassBoolean_true : B.SassBoolean_false; + throw A.wrapException(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " <= " + other.toString$0(0) + '".', null)); + }, + modulo$1(other) { + if (other instanceof A.SassNumber) + return this.withValue$1(this._coerceUnits$2(other, A.number0__moduloLikeSass$closure())); + throw A.wrapException(A.SassScriptException$('Undefined operation "' + this.toString$0(0) + " % " + other.toString$0(0) + '".', null)); + }, + plus$1(other) { + var _this = this; + if (other instanceof A.SassNumber) + return _this.withValue$1(_this._coerceUnits$2(other, new A.SassNumber_plus_closure())); + if (!(other instanceof A.SassColor)) + return _this.super$Value$plus(other); + throw A.wrapException(A.SassScriptException$('Undefined operation "' + _this.toString$0(0) + " + " + other.toString$0(0) + '".', null)); + }, + minus$1(other) { + var _this = this; + if (other instanceof A.SassNumber) + return _this.withValue$1(_this._coerceUnits$2(other, new A.SassNumber_minus_closure())); + if (!(other instanceof A.SassColor)) + return _this.super$Value$minus(other); + throw A.wrapException(A.SassScriptException$('Undefined operation "' + _this.toString$0(0) + " - " + other.toString$0(0) + '".', null)); + }, + times$1(other) { + var _this = this; + if (other instanceof A.SassNumber) { + if (!other.get$hasUnits()) + return _this.withValue$1(_this._number$_value * other._number$_value); + return _this.multiplyUnits$3(_this._number$_value * other._number$_value, other.get$numeratorUnits(other), other.get$denominatorUnits(other)); + } + throw A.wrapException(A.SassScriptException$('Undefined operation "' + _this.toString$0(0) + " * " + other.toString$0(0) + '".', null)); + }, + dividedBy$1(other) { + var _this = this; + if (other instanceof A.SassNumber) { + if (!other.get$hasUnits()) + return _this.withValue$1(_this._number$_value / other._number$_value); + return _this.multiplyUnits$3(_this._number$_value / other._number$_value, other.get$denominatorUnits(other), other.get$numeratorUnits(other)); + } + return _this.super$Value$dividedBy(other); + }, + unaryPlus$0() { + return this; + }, + _coerceUnits$1$2(other, operation) { + var t1, exception; + try { + t1 = operation.call$2(this._number$_value, other.coerceValueToMatch$1(this)); + return t1; + } catch (exception) { + if (A.unwrapException(exception) instanceof A.SassScriptException) { + this.coerceValueToMatch$1(other); + throw exception; + } else + throw exception; + } + }, + _coerceUnits$2(other, operation) { + return this._coerceUnits$1$2(other, operation, type$.dynamic); + }, + multiplyUnits$3(value, otherNumerators, otherDenominators) { + var t1, _0_1, _0_6, _0_3, _0_9, _0_9_isSet, _0_7, _0_7_isSet, t2, _0_2, denominators_case_0, _0_11_isSet, _0_11, _0_13, _0_13_isSet, _0_10, numerators_case_0, t4, t3, t5, t6, t7, numerators_case_1, denominators_case_1, t0, newNumerators, mutableOtherDenominators, _i, numerator, mutableDenominatorUnits, _this = this, _null = null, _box_0 = {}; + _box_0.value = value; + t1 = [_this.get$numeratorUnits(_this), _this.get$denominatorUnits(_this), otherNumerators, otherDenominators]; + _0_1 = t1[0]; + _0_6 = _null; + _0_3 = _null; + _0_9 = _null; + _0_9_isSet = false; + _0_7 = _null; + _0_7_isSet = false; + t2 = false; + _0_2 = t1[1]; + _0_3 = t1[2]; + _0_6 = _0_3.length <= 0; + _0_7_isSet = _0_6; + if (_0_7_isSet) { + _0_7 = t1[3]; + _0_9 = _0_7.length <= 0; + t2 = _0_9; + } + _0_9_isSet = _0_7_isSet; + denominators_case_0 = _0_2; + _0_11_isSet = !t2; + _0_11 = _null; + _0_13 = _null; + if (_0_11_isSet) { + _0_11 = _0_1.length <= 0; + _0_13_isSet = _0_11; + _0_10 = _0_1; + if (_0_13_isSet) { + _0_13 = _0_2.length <= 0; + t2 = _0_13; + if (t2) { + if (_0_7_isSet) + denominators_case_0 = _0_7; + else { + _0_7 = t1[3]; + denominators_case_0 = _0_7; + _0_7_isSet = true; + } + numerators_case_0 = _0_3; + } else + numerators_case_0 = _0_1; + } else { + numerators_case_0 = _0_1; + t2 = false; + } + _0_1 = _0_10; + } else { + numerators_case_0 = _0_1; + _0_13_isSet = false; + t2 = true; + } + if (t2) { + t4 = denominators_case_0; + t3 = numerators_case_0; + } else { + t4 = _null; + t3 = t4; + } + if (!t2) { + t2 = _null; + t5 = _null; + if (_0_11_isSet) + t6 = _0_11; + else { + _0_11 = _0_1.length <= 0; + t6 = _0_11; + } + t7 = false; + if (t6) { + if (_0_9_isSet) + t2 = _0_9; + else { + if (_0_7_isSet) + t2 = _0_7; + else { + _0_7 = t1[3]; + t2 = _0_7; + _0_7_isSet = true; + } + _0_9 = t2.length <= 0; + t2 = _0_9; + } + numerators_case_1 = _0_3; + denominators_case_1 = _0_2; + } else { + numerators_case_1 = t2; + t2 = t7; + denominators_case_1 = t5; + } + if (!t2) { + t2 = false; + if (_0_13_isSet) + t5 = _0_13; + else { + _0_13 = _0_2.length <= 0; + t5 = _0_13; + } + if (t5) { + if (_0_6) + denominators_case_1 = _0_7_isSet ? _0_7 : t1[3]; + t1 = _0_6; + } else + t1 = t2; + numerators_case_1 = _0_1; + } else + t1 = true; + if (t1) { + t1 = !_this._areAnyConvertible$2(numerators_case_1, denominators_case_1); + if (t1) { + t3 = denominators_case_1; + t2 = numerators_case_1; + } else { + t2 = t3; + t3 = t4; + } + t0 = t3; + t3 = t1; + t1 = t2; + t2 = t0; + } else { + t2 = t4; + t1 = t3; + t3 = false; + } + } else { + t2 = t4; + t1 = t3; + t3 = true; + } + if (t3) + return A.SassNumber_SassNumber$withUnits(value, t2, t1); + newNumerators = A._setArrayType([], type$.JSArray_String); + mutableOtherDenominators = A._setArrayType(otherDenominators.slice(0), A._arrayInstanceType(otherDenominators)); + for (t1 = _this.get$numeratorUnits(_this), t2 = t1.length, _i = 0; _i < t2; ++_i) { + numerator = t1[_i]; + A.removeFirstWhere(mutableOtherDenominators, new A.SassNumber_multiplyUnits_closure(_box_0, numerator), new A.SassNumber_multiplyUnits_closure0(newNumerators, numerator)); + } + t1 = _this.get$denominatorUnits(_this); + mutableDenominatorUnits = A._setArrayType(t1.slice(0), A._arrayInstanceType(t1)); + for (t1 = otherNumerators.length, _i = 0; _i < t1; ++_i) { + numerator = otherNumerators[_i]; + A.removeFirstWhere(mutableDenominatorUnits, new A.SassNumber_multiplyUnits_closure1(_box_0, numerator), new A.SassNumber_multiplyUnits_closure2(newNumerators, numerator)); + } + t1 = _box_0.value; + B.JSArray_methods.addAll$1(mutableDenominatorUnits, mutableOtherDenominators); + return A.SassNumber_SassNumber$withUnits(t1, mutableDenominatorUnits, newNumerators); + }, + _areAnyConvertible$2(units1, units2) { + return B.JSArray_methods.any$1(units1, new A.SassNumber__areAnyConvertible_closure(units2)); + }, + _unitString$2(numerators, denominators) { + var _0_4, _0_7, _0_6, _0_5, t1, _0_9, _0_6_isSet, _0_5_isSet, _0_10, denominator, _null = null; + $label0$0: { + _0_4 = numerators.length <= 0; + _0_7 = _null; + _0_6 = _null; + _0_5 = _null; + if (_0_4) { + _0_6 = denominators.length; + t1 = _0_6; + _0_7 = t1 <= 0; + t1 = _0_7; + _0_5 = denominators; + } else + t1 = false; + if (t1) { + t1 = "no units"; + break $label0$0; + } + _0_9 = _null; + if (_0_4) { + _0_9 = _0_6 === 1; + t1 = _0_9; + _0_6_isSet = true; + _0_5_isSet = true; + } else { + _0_5_isSet = _0_4; + _0_6_isSet = _0_5_isSet; + t1 = false; + } + if (t1) { + _0_10 = (_0_5_isSet ? _0_5 : denominators)[0]; + denominator = _0_10; + t1 = denominator + "^-1"; + break $label0$0; + } + if (_0_4) { + t1 = "(" + B.JSArray_methods.join$1(denominators, "*") + ")^-1"; + break $label0$0; + } + if (_0_6_isSet) + t1 = _0_6; + else { + if (_0_5_isSet) + t1 = _0_5; + else { + t1 = denominators; + _0_5 = t1; + _0_5_isSet = true; + } + _0_6 = t1.length; + t1 = _0_6; + _0_6_isSet = true; + } + _0_7 = t1 <= 0; + t1 = _0_7; + if (t1) { + t1 = B.JSArray_methods.join$1(numerators, "*"); + break $label0$0; + } + if (_0_6_isSet) + t1 = _0_6; + else { + if (_0_5_isSet) + t1 = _0_5; + else { + t1 = denominators; + _0_5 = t1; + _0_5_isSet = true; + } + _0_6 = t1.length; + t1 = _0_6; + } + _0_9 = t1 === 1; + t1 = _0_9; + if (t1) { + _0_10 = (_0_5_isSet ? _0_5 : denominators)[0]; + denominator = _0_10; + t1 = B.JSArray_methods.join$1(numerators, "*") + "/" + denominator; + break $label0$0; + } + t1 = B.JSArray_methods.join$1(numerators, "*") + "/(" + B.JSArray_methods.join$1(denominators, "*") + ")"; + break $label0$0; + } + return t1; + }, + $eq(_, other) { + var _this = this; + if (other == null) + return false; + if (!(other instanceof A.SassNumber)) + return false; + if (_this.get$numeratorUnits(_this).length !== other.get$numeratorUnits(other).length || _this.get$denominatorUnits(_this).length !== other.get$denominatorUnits(other).length) + return false; + if (!_this.get$hasUnits()) + return A.fuzzyEquals(_this._number$_value, other._number$_value); + if (!B.C_ListEquality.equals$2(0, _this._canonicalizeUnitList$1(_this.get$numeratorUnits(_this)), _this._canonicalizeUnitList$1(other.get$numeratorUnits(other))) || !B.C_ListEquality.equals$2(0, _this._canonicalizeUnitList$1(_this.get$denominatorUnits(_this)), _this._canonicalizeUnitList$1(other.get$denominatorUnits(other)))) + return false; + return A.fuzzyEquals(_this._number$_value * _this._canonicalMultiplier$1(_this.get$numeratorUnits(_this)) / _this._canonicalMultiplier$1(_this.get$denominatorUnits(_this)), other._number$_value * _this._canonicalMultiplier$1(other.get$numeratorUnits(other)) / _this._canonicalMultiplier$1(other.get$denominatorUnits(other))); + }, + get$hashCode(_) { + var _this = this, + t1 = _this.hashCache; + return t1 == null ? _this.hashCache = A.fuzzyHashCode(_this._number$_value * _this._canonicalMultiplier$1(_this.get$numeratorUnits(_this)) / _this._canonicalMultiplier$1(_this.get$denominatorUnits(_this))) : t1; + }, + _canonicalizeUnitList$1(units) { + var type, + t1 = units.length; + if (t1 === 0) + return units; + if (t1 === 1) { + type = $.$get$_typesByUnit().$index(0, B.JSArray_methods.get$first(units)); + if (type == null) + t1 = units; + else { + t1 = B.Map_Sr65K.$index(0, type); + t1.toString; + t1 = A._setArrayType([B.JSArray_methods.get$first(t1)], type$.JSArray_String); + } + return t1; + } + t1 = A._arrayInstanceType(units)._eval$1("MappedListIterable<1,String>"); + t1 = A.List_List$of(new A.MappedListIterable(units, new A.SassNumber__canonicalizeUnitList_closure(), t1), true, t1._eval$1("ListIterable.E")); + B.JSArray_methods.sort$0(t1); + return t1; + }, + _canonicalMultiplier$1(units) { + return B.JSArray_methods.fold$2(units, 1, new A.SassNumber__canonicalMultiplier_closure(this)); + }, + canonicalMultiplierForUnit$1(unit) { + var t1, + innerMap = B.Map_NtHoP.$index(0, unit); + if (innerMap == null) + t1 = 1; + else { + t1 = innerMap.get$values(innerMap); + t1 = 1 / t1.get$first(t1); + } + return t1; + }, + unitSuggestion$2($name, unit) { + var t2, t3, result, _this = this, + t1 = _this.get$denominatorUnits(_this); + t1 = new A.MappedListIterable(t1, new A.SassNumber_unitSuggestion_closure(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,String>")).join$0(0); + t2 = _this.get$numeratorUnits(_this); + t2 = new A.MappedListIterable(t2, new A.SassNumber_unitSuggestion_closure0(), A._arrayInstanceType(t2)._eval$1("MappedListIterable<1,String>")).join$0(0); + t3 = unit == null ? "" : " * 1" + unit; + result = "$" + $name + t1 + t2 + t3; + return _this.get$numeratorUnits(_this).length === 0 ? result : "calc(" + result + ")"; + }, + unitSuggestion$1($name) { + return this.unitSuggestion$2($name, null); + } + }; + A.SassNumber__coerceOrConvertValue_compatibilityException.prototype = { + call$0() { + var t2, t3, message, t4, type, unit, _this = this, + t1 = _this.other; + if (t1 != null) { + t2 = _this.$this; + t3 = t2.toString$0(0) + " and"; + message = new A.StringBuffer(t3); + t4 = _this.otherName; + if (t4 != null) + t3 = message._contents = t3 + (" $" + t4 + ":"); + t1 = t3 + (" " + t1.toString$0(0) + " have incompatible units"); + message._contents = t1; + if (!t2.get$hasUnits() || !_this.otherHasUnits) + message._contents = t1 + " (one has units and the other doesn't)"; + t1 = message.toString$0(0) + "."; + t2 = _this.name; + return new A.SassScriptException(t2 == null ? t1 : "$" + t2 + ": " + t1); + } else if (!_this.otherHasUnits) { + t1 = "Expected " + _this.$this.toString$0(0) + " to have no units."; + t2 = _this.name; + return new A.SassScriptException(t2 == null ? t1 : "$" + t2 + ": " + t1); + } else { + t1 = _this.newNumerators; + if (t1.length === 1 && _this.newDenominators.length === 0) { + type = $.$get$_typesByUnit().$index(0, B.JSArray_methods.get$first(t1)); + if (type != null) { + t1 = _this.$this.toString$0(0); + t2 = B.JSArray_methods.contains$1(A._setArrayType([97, 101, 105, 111, 117], type$.JSArray_int), type.charCodeAt(0)) ? "an " + type : "a " + type; + t3 = B.Map_Sr65K.$index(0, type); + t3.toString; + t3 = "Expected " + t1 + " to have " + t2 + " unit (" + B.JSArray_methods.join$1(t3, ", ") + ")."; + t2 = _this.name; + return new A.SassScriptException(t2 == null ? t3 : "$" + t2 + ": " + t3); + } + } + t2 = _this.newDenominators; + unit = A.pluralize("unit", t1.length + t2.length, null); + t3 = _this.$this; + t2 = "Expected " + t3.toString$0(0) + " to have " + unit + " " + t3._unitString$2(t1, t2) + "."; + t1 = _this.name; + return new A.SassScriptException(t1 == null ? t2 : "$" + t1 + ": " + t2); + } + }, + $signature: 326 + }; + A.SassNumber__coerceOrConvertValue_closure.prototype = { + call$1(oldNumerator) { + var factor = A.conversionFactor(this.newNumerator, oldNumerator); + if (factor == null) + return false; + this._box_0.value *= factor; + return true; + }, + $signature: 5 + }; + A.SassNumber__coerceOrConvertValue_closure0.prototype = { + call$0() { + return A.throwExpression(this.compatibilityException.call$0()); + }, + $signature: 0 + }; + A.SassNumber__coerceOrConvertValue_closure1.prototype = { + call$1(oldDenominator) { + var factor = A.conversionFactor(this.newDenominator, oldDenominator); + if (factor == null) + return false; + this._box_0.value /= factor; + return true; + }, + $signature: 5 + }; + A.SassNumber__coerceOrConvertValue_closure2.prototype = { + call$0() { + return A.throwExpression(this.compatibilityException.call$0()); + }, + $signature: 0 + }; + A.SassNumber_plus_closure.prototype = { + call$2(num1, num2) { + return num1 + num2; + }, + $signature: 61 + }; + A.SassNumber_minus_closure.prototype = { + call$2(num1, num2) { + return num1 - num2; + }, + $signature: 61 + }; + A.SassNumber_multiplyUnits_closure.prototype = { + call$1(denominator) { + var factor = A.conversionFactor(this.numerator, denominator); + if (factor == null) + return false; + this._box_0.value /= factor; + return true; + }, + $signature: 5 + }; + A.SassNumber_multiplyUnits_closure0.prototype = { + call$0() { + return this.newNumerators.push(this.numerator); + }, + $signature: 0 + }; + A.SassNumber_multiplyUnits_closure1.prototype = { + call$1(denominator) { + var factor = A.conversionFactor(this.numerator, denominator); + if (factor == null) + return false; + this._box_0.value /= factor; + return true; + }, + $signature: 5 + }; + A.SassNumber_multiplyUnits_closure2.prototype = { + call$0() { + return this.newNumerators.push(this.numerator); + }, + $signature: 0 + }; + A.SassNumber__areAnyConvertible_closure.prototype = { + call$1(unit1) { + var t1, + _0_0 = B.Map_NtHoP.$index(0, unit1); + $label0$0: { + if (_0_0 != null) { + t1 = B.JSArray_methods.any$1(this.units2, _0_0.get$containsKey()); + break $label0$0; + } + t1 = B.JSArray_methods.contains$1(this.units2, unit1); + break $label0$0; + } + return t1; + }, + $signature: 5 + }; + A.SassNumber__canonicalizeUnitList_closure.prototype = { + call$1(unit) { + var t1, + type = $.$get$_typesByUnit().$index(0, unit); + if (type == null) + t1 = unit; + else { + t1 = B.Map_Sr65K.$index(0, type); + t1.toString; + t1 = B.JSArray_methods.get$first(t1); + } + return t1; + }, + $signature: 6 + }; + A.SassNumber__canonicalMultiplier_closure.prototype = { + call$2(multiplier, unit) { + return multiplier * this.$this.canonicalMultiplierForUnit$1(unit); + }, + $signature: 165 + }; + A.SassNumber_unitSuggestion_closure.prototype = { + call$1(unit) { + return " * 1" + unit; + }, + $signature: 6 + }; + A.SassNumber_unitSuggestion_closure0.prototype = { + call$1(unit) { + return " / 1" + unit; + }, + $signature: 6 + }; + A.ComplexSassNumber.prototype = { + get$numeratorUnits(_) { + return this._numeratorUnits; + }, + get$denominatorUnits(_) { + return this._denominatorUnits; + }, + get$hasUnits() { + return true; + }, + get$hasComplexUnits() { + return true; + }, + hasUnit$1(unit) { + return false; + }, + compatibleWithUnit$1(unit) { + return false; + }, + hasPossiblyCompatibleUnits$1(other) { + throw A.wrapException(A.UnimplementedError$(string$.Comple)); + }, + withValue$1(value) { + return new A.ComplexSassNumber(this._numeratorUnits, this._denominatorUnits, value, null); + }, + withSlash$2(numerator, denominator) { + return new A.ComplexSassNumber(this._numeratorUnits, this._denominatorUnits, this._number$_value, new A._Record_2(numerator, denominator)); + } + }; + A.SingleUnitSassNumber.prototype = { + get$numeratorUnits(_) { + return A.List_List$unmodifiable([this._unit], type$.String); + }, + get$denominatorUnits(_) { + return B.List_empty; + }, + get$hasUnits() { + return true; + }, + get$hasComplexUnits() { + return false; + }, + withValue$1(value) { + return new A.SingleUnitSassNumber(this._unit, value, null); + }, + withSlash$2(numerator, denominator) { + return new A.SingleUnitSassNumber(this._unit, this._number$_value, new A._Record_2(numerator, denominator)); + }, + hasUnit$1(unit) { + return unit === this._unit; + }, + hasCompatibleUnits$1(other) { + return other instanceof A.SingleUnitSassNumber && A.conversionFactor(this._unit, other._unit) != null; + }, + hasPossiblyCompatibleUnits$1(other) { + var t1, knownCompatibilities, otherUnit; + if (!(other instanceof A.SingleUnitSassNumber)) + return false; + t1 = $.$get$_knownCompatibilitiesByUnit(); + knownCompatibilities = t1.$index(0, this._unit.toLowerCase()); + if (knownCompatibilities == null) + return true; + otherUnit = other._unit.toLowerCase(); + return knownCompatibilities.contains$1(0, otherUnit) || !t1.containsKey$1(otherUnit); + }, + compatibleWithUnit$1(unit) { + return A.conversionFactor(this._unit, unit) != null; + }, + coerceToMatch$1(other) { + var t1 = other instanceof A.SingleUnitSassNumber ? this._coerceToUnit$1(other._unit) : null; + return t1 == null ? this.super$SassNumber$coerceToMatch(other, null, null) : t1; + }, + coerceValueToMatch$3(other, $name, otherName) { + var t1 = other instanceof A.SingleUnitSassNumber ? this._coerceValueToUnit$1(other._unit) : null; + return t1 == null ? this.super$SassNumber$coerceValueToMatch(other, $name, otherName) : t1; + }, + coerceValueToMatch$1(other) { + return this.coerceValueToMatch$3(other, null, null); + }, + convertValueToMatch$3(other, $name, otherName) { + var t1 = other instanceof A.SingleUnitSassNumber ? this._coerceValueToUnit$1(other._unit) : null; + return t1 == null ? this.super$SassNumber$convertValueToMatch(other, $name, otherName) : t1; + }, + convertValueToMatch$1(other) { + return this.convertValueToMatch$3(other, null, null); + }, + coerce$2(newNumerators, newDenominators) { + var t1 = newNumerators.length === 1 && newDenominators.length === 0 ? this._coerceToUnit$1(newNumerators[0]) : null; + return t1 == null ? this.super$SassNumber$coerce(newNumerators, newDenominators, null) : t1; + }, + coerceValue$3(newNumerators, newDenominators, $name) { + var t1 = newNumerators.length === 1 && newDenominators.length === 0 ? this._coerceValueToUnit$1(newNumerators[0]) : null; + return t1 == null ? this.super$SassNumber$coerceValue(newNumerators, newDenominators, $name) : t1; + }, + coerceValueToUnit$2(unit, $name) { + var t1 = this._coerceValueToUnit$1(unit); + return t1 == null ? this.super$SassNumber$coerceValueToUnit(unit, $name) : t1; + }, + coerceValueToUnit$1(unit) { + return this.coerceValueToUnit$2(unit, null); + }, + _coerceToUnit$1(unit) { + var t1 = this._unit; + if (t1 === unit) + return this; + return A.NullableExtension_andThen(A.conversionFactor(unit, t1), new A.SingleUnitSassNumber__coerceToUnit_closure(this, unit)); + }, + _coerceValueToUnit$1(unit) { + return A.NullableExtension_andThen(A.conversionFactor(unit, this._unit), new A.SingleUnitSassNumber__coerceValueToUnit_closure(this)); + }, + multiplyUnits$3(value, otherNumerators, otherDenominators) { + var mutableOtherDenominators, t1 = {}; + t1.value = value; + t1.newNumerators = otherNumerators; + mutableOtherDenominators = A._setArrayType(otherDenominators.slice(0), A._arrayInstanceType(otherDenominators)); + A.removeFirstWhere(mutableOtherDenominators, new A.SingleUnitSassNumber_multiplyUnits_closure(t1, this), new A.SingleUnitSassNumber_multiplyUnits_closure0(t1, this)); + return A.SassNumber_SassNumber$withUnits(t1.value, mutableOtherDenominators, t1.newNumerators); + }, + unaryMinus$0() { + return new A.SingleUnitSassNumber(this._unit, -this._number$_value, null); + }, + $eq(_, other) { + var factor; + if (other == null) + return false; + if (other instanceof A.SingleUnitSassNumber) { + factor = A.conversionFactor(other._unit, this._unit); + return factor != null && A.fuzzyEquals(this._number$_value * factor, other._number$_value); + } else + return false; + }, + get$hashCode(_) { + var _this = this, + t1 = _this.hashCache; + return t1 == null ? _this.hashCache = A.fuzzyHashCode(_this._number$_value * _this.canonicalMultiplierForUnit$1(_this._unit)) : t1; + } + }; + A.SingleUnitSassNumber__coerceToUnit_closure.prototype = { + call$1(factor) { + return new A.SingleUnitSassNumber(this.unit, this.$this._number$_value * factor, null); + }, + $signature: 337 + }; + A.SingleUnitSassNumber__coerceValueToUnit_closure.prototype = { + call$1(factor) { + return this.$this._number$_value * factor; + }, + $signature: 16 + }; + A.SingleUnitSassNumber_multiplyUnits_closure.prototype = { + call$1(denominator) { + var factor = A.conversionFactor(denominator, this.$this._unit); + if (factor == null) + return false; + this._box_0.value *= factor; + return true; + }, + $signature: 5 + }; + A.SingleUnitSassNumber_multiplyUnits_closure0.prototype = { + call$0() { + var t1 = A._setArrayType([this.$this._unit], type$.JSArray_String), + t2 = this._box_0; + B.JSArray_methods.addAll$1(t1, t2.newNumerators); + t2.newNumerators = t1; + }, + $signature: 0 + }; + A.UnitlessSassNumber.prototype = { + get$numeratorUnits(_) { + return B.List_empty; + }, + get$denominatorUnits(_) { + return B.List_empty; + }, + get$hasUnits() { + return false; + }, + get$hasComplexUnits() { + return false; + }, + withValue$1(value) { + return new A.UnitlessSassNumber(value, null); + }, + withSlash$2(numerator, denominator) { + return new A.UnitlessSassNumber(this._number$_value, new A._Record_2(numerator, denominator)); + }, + hasUnit$1(unit) { + return false; + }, + hasCompatibleUnits$1(other) { + return other instanceof A.UnitlessSassNumber; + }, + hasPossiblyCompatibleUnits$1(other) { + return other instanceof A.UnitlessSassNumber; + }, + compatibleWithUnit$1(unit) { + return true; + }, + coerceToMatch$1(other) { + return other.withValue$1(this._number$_value); + }, + coerceValueToMatch$3(other, $name, otherName) { + return this._number$_value; + }, + coerceValueToMatch$1(other) { + return this.coerceValueToMatch$3(other, null, null); + }, + convertValueToMatch$3(other, $name, otherName) { + return other.get$hasUnits() ? this.super$SassNumber$convertValueToMatch(other, $name, otherName) : this._number$_value; + }, + convertValueToMatch$1(other) { + return this.convertValueToMatch$3(other, null, null); + }, + coerce$2(newNumerators, newDenominators) { + return A.SassNumber_SassNumber$withUnits(this._number$_value, newDenominators, newNumerators); + }, + coerceValue$3(newNumerators, newDenominators, $name) { + return this._number$_value; + }, + coerceValueToUnit$2(unit, $name) { + return this._number$_value; + }, + coerceValueToUnit$1(unit) { + return this.coerceValueToUnit$2(unit, null); + }, + greaterThan$1(other) { + var t1, t2; + if (other instanceof A.SassNumber) { + t1 = this._number$_value; + t2 = other._number$_value; + return t1 > t2 && !A.fuzzyEquals(t1, t2) ? B.SassBoolean_true : B.SassBoolean_false; + } + return this.super$SassNumber$greaterThan(other); + }, + greaterThanOrEquals$1(other) { + var t1, t2; + if (other instanceof A.SassNumber) { + t1 = this._number$_value; + t2 = other._number$_value; + return t1 > t2 || A.fuzzyEquals(t1, t2) ? B.SassBoolean_true : B.SassBoolean_false; + } + return this.super$SassNumber$greaterThanOrEquals(other); + }, + lessThan$1(other) { + var t1, t2; + if (other instanceof A.SassNumber) { + t1 = this._number$_value; + t2 = other._number$_value; + return t1 < t2 && !A.fuzzyEquals(t1, t2) ? B.SassBoolean_true : B.SassBoolean_false; + } + return this.super$SassNumber$lessThan(other); + }, + lessThanOrEquals$1(other) { + var t1, t2; + if (other instanceof A.SassNumber) { + t1 = this._number$_value; + t2 = other._number$_value; + return t1 < t2 || A.fuzzyEquals(t1, t2) ? B.SassBoolean_true : B.SassBoolean_false; + } + return this.super$SassNumber$lessThanOrEquals(other); + }, + modulo$1(other) { + if (other instanceof A.SassNumber) + return other.withValue$1(A.moduloLikeSass(this._number$_value, other._number$_value)); + return this.super$SassNumber$modulo(other); + }, + plus$1(other) { + if (other instanceof A.SassNumber) + return other.withValue$1(this._number$_value + other._number$_value); + return this.super$SassNumber$plus(other); + }, + minus$1(other) { + if (other instanceof A.SassNumber) + return other.withValue$1(this._number$_value - other._number$_value); + return this.super$SassNumber$minus(other); + }, + times$1(other) { + if (other instanceof A.SassNumber) + return other.withValue$1(this._number$_value * other._number$_value); + return this.super$SassNumber$times(other); + }, + dividedBy$1(other) { + var t1, t2; + if (other instanceof A.SassNumber) { + t1 = this._number$_value / other._number$_value; + if (other.get$hasUnits()) { + t2 = other.get$denominatorUnits(other); + t2 = A.SassNumber_SassNumber$withUnits(t1, other.get$numeratorUnits(other), t2); + t1 = t2; + } else + t1 = new A.UnitlessSassNumber(t1, null); + return t1; + } + return this.super$SassNumber$dividedBy(other); + }, + unaryMinus$0() { + return new A.UnitlessSassNumber(-this._number$_value, null); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.UnitlessSassNumber && A.fuzzyEquals(this._number$_value, other._number$_value); + }, + get$hashCode(_) { + var t1 = this.hashCache; + return t1 == null ? this.hashCache = A.fuzzyHashCode(this._number$_value) : t1; + } + }; + A.SassString.prototype = { + get$_sassLength() { + var result, _this = this, + value = _this.__SassString__sassLength_FI; + if (value === $) { + result = new A.Runes(_this._string$_text).get$length(0); + _this.__SassString__sassLength_FI !== $ && A.throwUnnamedLateFieldADI(); + _this.__SassString__sassLength_FI = result; + value = result; + } + return value; + }, + get$isSpecialNumber() { + var t1, _2_0, t2, _0_0, _1_0; + if (this._hasQuotes) + return false; + t1 = this._string$_text; + if (t1.length < 6) + return false; + _2_0 = t1.charCodeAt(0); + $label0$0: { + t2 = false; + if (97 === _2_0 || 65 === _2_0) { + t1 = (t1.charCodeAt(1) | 32) === 116 && (t1.charCodeAt(2) | 32) === 116 && (t1.charCodeAt(3) | 32) === 114 && t1.charCodeAt(4) === 40; + break $label0$0; + } + if (99 === _2_0 || 67 === _2_0) { + _0_0 = t1.charCodeAt(1); + $label1$1: { + if (108 === _0_0 || 76 === _0_0) { + t1 = (t1.charCodeAt(2) | 32) === 97 && (t1.charCodeAt(3) | 32) === 109 && (t1.charCodeAt(4) | 32) === 112 && t1.charCodeAt(5) === 40; + break $label1$1; + } + if (97 === _0_0 || 65 === _0_0) { + t1 = (t1.charCodeAt(2) | 32) === 108 && (t1.charCodeAt(3) | 32) === 99 && t1.charCodeAt(4) === 40; + break $label1$1; + } + t1 = t2; + break $label1$1; + } + break $label0$0; + } + if (118 === _2_0 || 86 === _2_0) { + t1 = (t1.charCodeAt(1) | 32) === 97 && (t1.charCodeAt(2) | 32) === 114 && t1.charCodeAt(3) === 40; + break $label0$0; + } + if (101 === _2_0 || 69 === _2_0) { + t1 = (t1.charCodeAt(1) | 32) === 110 && (t1.charCodeAt(2) | 32) === 118 && t1.charCodeAt(3) === 40; + break $label0$0; + } + if (109 === _2_0 || 77 === _2_0) { + _1_0 = t1.charCodeAt(1); + $label2$2: { + if (97 === _1_0 || 65 === _1_0) { + t1 = (t1.charCodeAt(2) | 32) === 120 && t1.charCodeAt(3) === 40; + break $label2$2; + } + if (105 === _1_0 || 73 === _1_0) { + t1 = (t1.charCodeAt(2) | 32) === 110 && t1.charCodeAt(3) === 40; + break $label2$2; + } + t1 = t2; + break $label2$2; + } + break $label0$0; + } + t1 = t2; + break $label0$0; + } + return t1; + }, + get$isVar() { + if (this._hasQuotes) + return false; + var t1 = this._string$_text; + if (t1.length < 8) + return false; + return (t1.charCodeAt(0) | 32) === 118 && (t1.charCodeAt(1) | 32) === 97 && (t1.charCodeAt(2) | 32) === 114 && t1.charCodeAt(3) === 40; + }, + get$isBlank() { + return !this._hasQuotes && this._string$_text.length === 0; + }, + assertQuoted$1($name) { + if (this._hasQuotes) + return; + throw A.wrapException(A.SassScriptException$("Expected " + this.toString$0(0) + " to be a quoted string.", $name)); + }, + assertUnquoted$1($name) { + if (!this._hasQuotes) + return; + throw A.wrapException(A.SassScriptException$("Expected " + this.toString$0(0) + " to be an unquoted string.", $name)); + }, + assertUnquoted$0() { + return this.assertUnquoted$1(null); + }, + accept$1$1(visitor) { + var t1 = visitor._quote && this._hasQuotes, + t2 = this._string$_text; + if (t1) + visitor._visitQuotedString$1(t2); + else + visitor._visitUnquotedString$1(t2); + return null; + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + assertString$1($name) { + return this; + }, + plus$1(other) { + var t1 = this._string$_text, + t2 = this._hasQuotes; + return other instanceof A.SassString ? new A.SassString(t1 + other._string$_text, t2) : new A.SassString(t1 + A.serializeValue(other, false, true), t2); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.SassString && this._string$_text === other._string$_text; + }, + get$hashCode(_) { + var t1 = this._hashCache; + return t1 == null ? this._hashCache = B.JSString_methods.get$hashCode(this._string$_text) : t1; + } + }; + A.AnySelectorVisitor.prototype = { + visitComplexSelector$1(complex) { + return B.JSArray_methods.any$1(complex.components, new A.AnySelectorVisitor_visitComplexSelector_closure(this)); + }, + visitCompoundSelector$1(compound) { + return B.JSArray_methods.any$1(compound.components, new A.AnySelectorVisitor_visitCompoundSelector_closure(this)); + }, + visitPseudoSelector$1(pseudo) { + var selector = pseudo.selector; + return selector == null ? false : this.visitSelectorList$1(selector); + }, + visitSelectorList$1(list) { + return B.JSArray_methods.any$1(list.components, this.get$visitComplexSelector()); + }, + visitAttributeSelector$1(attribute) { + return false; + }, + visitClassSelector$1(klass) { + return false; + }, + visitIDSelector$1(id) { + return false; + }, + visitParentSelector$1($parent) { + return false; + }, + visitPlaceholderSelector$1(placeholder) { + return false; + }, + visitTypeSelector$1(type) { + return false; + }, + visitUniversalSelector$1(universal) { + return false; + } + }; + A.AnySelectorVisitor_visitComplexSelector_closure.prototype = { + call$1(component) { + return this.$this.visitCompoundSelector$1(component.selector); + }, + $signature: 53 + }; + A.AnySelectorVisitor_visitCompoundSelector_closure.prototype = { + call$1(simple) { + return simple.accept$1(this.$this); + }, + $signature: 13 + }; + A._EvaluateVisitor0.prototype = { + _EvaluateVisitor$6$functions$importCache$logger$nodeImporter$quietDeps$sourceMap0(functions, importCache, logger, nodeImporter, quietDeps, sourceMap) { + var t2, metaModule, t3, _i, module, $function, t4, _this = this, + _s20_ = "$name, $module: null", + _s9_ = "sass:meta", + _s7_ = "$module", + t1 = type$.JSArray_AsyncBuiltInCallable, + metaFunctions = A._setArrayType([A.BuiltInCallable$function("global-variable-exists", _s20_, new A._EvaluateVisitor_closure12(_this), _s9_), A.BuiltInCallable$function("variable-exists", "$name", new A._EvaluateVisitor_closure13(_this), _s9_), A.BuiltInCallable$function("function-exists", _s20_, new A._EvaluateVisitor_closure14(_this), _s9_), A.BuiltInCallable$function("mixin-exists", _s20_, new A._EvaluateVisitor_closure15(_this), _s9_), A.BuiltInCallable$function("content-exists", "", new A._EvaluateVisitor_closure16(_this), _s9_), A.BuiltInCallable$function("module-variables", _s7_, new A._EvaluateVisitor_closure17(_this), _s9_), A.BuiltInCallable$function("module-functions", _s7_, new A._EvaluateVisitor_closure18(_this), _s9_), A.BuiltInCallable$function("module-mixins", _s7_, new A._EvaluateVisitor_closure19(_this), _s9_), A.BuiltInCallable$function("get-function", "$name, $css: false, $module: null", new A._EvaluateVisitor_closure20(_this), _s9_), A.BuiltInCallable$function("get-mixin", _s20_, new A._EvaluateVisitor_closure21(_this), _s9_), new A.AsyncBuiltInCallable("call", A.ScssParser$("@function call($function, $args...) {", _s9_).parseParameterList$0(), new A._EvaluateVisitor_closure22(_this), false)], t1), + metaMixins = A._setArrayType([A.AsyncBuiltInCallable$mixin("load-css", "$url, $with: null", new A._EvaluateVisitor_closure23(_this), false, _s9_), A.AsyncBuiltInCallable$mixin("apply", "$mixin, $args...", new A._EvaluateVisitor_closure24(_this), true, _s9_)], t1); + t1 = type$.AsyncBuiltInCallable; + t2 = A.List_List$of($.$get$moduleFunctions(), true, t1); + B.JSArray_methods.addAll$1(t2, metaFunctions); + metaModule = A.BuiltInModule$("meta", t2, metaMixins, null, t1); + for (t1 = A.List_List$of($.$get$coreModules(), true, type$.BuiltInModule_AsyncCallable), t1.push(metaModule), t2 = t1.length, t3 = _this._async_evaluate$_builtInModules, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + module = t1[_i]; + t3.$indexSet(0, module.url, module); + } + t1 = type$.JSArray_AsyncCallable; + t2 = A._setArrayType([], t1); + B.JSArray_methods.addAll$1(t2, $.$get$globalFunctions()); + t1 = A._setArrayType([], t1); + for (_i = 0; _i < 11; ++_i) + t1.push(metaFunctions[_i].withDeprecationWarning$1("meta")); + B.JSArray_methods.addAll$1(t2, t1); + for (t1 = t2.length, t3 = _this._async_evaluate$_builtInFunctions, _i = 0; _i < t2.length; t2.length === t1 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + $function = t2[_i]; + t4 = $function.get$name($function); + t3.$indexSet(0, A.stringReplaceAllUnchecked(t4, "_", "-"), $function); + } + }, + run$2(_, importer, node) { + return this.run$body$_EvaluateVisitor(0, importer, node); + }, + run$body$_EvaluateVisitor(_, importer, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$self = this, error, stackTrace, t1, exception, $async$exception; + var $async$run$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$handler = 4; + t1 = type$.nullable_Object; + t1 = A.runZoned(new A._EvaluateVisitor_run_closure0($async$self, node, importer), A.LinkedHashMap_LinkedHashMap$_literal([B.Symbol__evaluationContext, new A._EvaluationContext0($async$self, node)], t1, t1), type$.FutureOr_Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet); + $async$goto = 7; + return A._asyncAwait(type$.Future_Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet._is(t1) ? t1 : A._Future$value(t1, type$.Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet), $async$run$2); + case 7: + // returning from await. + t1 = $async$result; + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + $async$handler = 2; + // goto after finally + $async$goto = 6; + break; + case 4: + // catch + $async$handler = 3; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (t1 instanceof A.SassException) { + error = t1; + stackTrace = A.getTraceFromException($async$exception); + A.throwWithTrace(error.withLoadedUrls$1($async$self._async_evaluate$_loadedUrls), error, stackTrace); + } else + throw $async$exception; + // goto after finally + $async$goto = 6; + break; + case 3: + // uncaught + // goto rethrow + $async$goto = 2; + break; + case 6: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$run$2, $async$completer); + }, + _async_evaluate$_assertInModule$1$2(value, $name) { + if (value != null) + return value; + throw A.wrapException(A.StateError$("Can't access " + $name + " outside of a module.")); + }, + _async_evaluate$_assertInModule$2(value, $name) { + return this._async_evaluate$_assertInModule$1$2(value, $name, type$.dynamic); + }, + _async_evaluate$_loadModule$7$baseUrl$configuration$namesInErrors(url, stackFrame, nodeWithSpan, callback, baseUrl, configuration, namesInErrors) { + return this._loadModule$body$_EvaluateVisitor(url, stackFrame, nodeWithSpan, callback, baseUrl, configuration, namesInErrors); + }, + _async_evaluate$_loadModule$5$configuration(url, stackFrame, nodeWithSpan, callback, configuration) { + return this._async_evaluate$_loadModule$7$baseUrl$configuration$namesInErrors(url, stackFrame, nodeWithSpan, callback, null, configuration, false); + }, + _async_evaluate$_loadModule$4(url, stackFrame, nodeWithSpan, callback) { + return this._async_evaluate$_loadModule$7$baseUrl$configuration$namesInErrors(url, stackFrame, nodeWithSpan, callback, null, null, false); + }, + _loadModule$body$_EvaluateVisitor(url, stackFrame, nodeWithSpan, callback, baseUrl, configuration, namesInErrors) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$returnValue, $async$self = this, t2, _0_0, t1; + var $async$_async_evaluate$_loadModule$7$baseUrl$configuration$namesInErrors = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + _0_0 = $async$self._async_evaluate$_builtInModules.$index(0, url); + t1 = {}; + t1.builtInModule = null; + $async$goto = _0_0 != null ? 3 : 4; + break; + case 3: + // then + t1.builtInModule = _0_0; + if (configuration instanceof A.ExplicitConfiguration) { + t1 = namesInErrors ? "Built-in module " + url.toString$0(0) + " can't be configured." : "Built-in modules can't be configured."; + t2 = configuration.nodeWithSpan; + throw A.wrapException($async$self._async_evaluate$_exception$2(t1, t2.get$span(t2))); + } + $async$goto = 5; + return A._asyncAwait($async$self._addExceptionSpanAsync$1$2(nodeWithSpan, new A._EvaluateVisitor__loadModule_closure1(t1, callback), type$.void), $async$_async_evaluate$_loadModule$7$baseUrl$configuration$namesInErrors); + case 5: + // returning from await. + // goto return + $async$goto = 1; + break; + case 4: + // join + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate$_withStackFrame$1$3(stackFrame, nodeWithSpan, new A._EvaluateVisitor__loadModule_closure2($async$self, url, nodeWithSpan, baseUrl, namesInErrors, configuration, callback), type$.Null), $async$_async_evaluate$_loadModule$7$baseUrl$configuration$namesInErrors); + case 6: + // returning from await. + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_loadModule$7$baseUrl$configuration$namesInErrors, $async$completer); + }, + _async_evaluate$_execute$5$configuration$namesInErrors$nodeWithSpan(importer, stylesheet, configuration, namesInErrors, nodeWithSpan) { + return this._execute$body$_EvaluateVisitor(importer, stylesheet, configuration, namesInErrors, nodeWithSpan); + }, + _async_evaluate$_execute$2(importer, stylesheet) { + return this._async_evaluate$_execute$5$configuration$namesInErrors$nodeWithSpan(importer, stylesheet, null, false, null); + }, + _execute$body$_EvaluateVisitor(importer, stylesheet, configuration, namesInErrors, nodeWithSpan) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Module_AsyncCallable), + $async$returnValue, $async$self = this, _0_0, currentConfiguration, t2, t3, message, existingSpan, configurationSpan, environment, css, preModuleComments, extensionStore, module, t1, url; + var $async$_async_evaluate$_execute$5$configuration$namesInErrors$nodeWithSpan = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = stylesheet.span; + url = t1.get$sourceUrl(t1); + t1 = $async$self._async_evaluate$_modules; + _0_0 = t1.$index(0, url); + if (_0_0 != null) { + t1 = configuration == null; + currentConfiguration = t1 ? $async$self._async_evaluate$_configuration : configuration; + t2 = $async$self._async_evaluate$_moduleConfigurations.$index(0, url); + t3 = t2.__originalConfiguration; + t2 = t3 == null ? t2 : t3; + t3 = currentConfiguration.__originalConfiguration; + if (t2 !== (t3 == null ? currentConfiguration : t3) && currentConfiguration instanceof A.ExplicitConfiguration) { + if (namesInErrors) { + t2 = $.$get$context(); + url.toString; + message = t2.prettyUri$1(url) + string$.x20was_a; + } else + message = string$.This_mw; + t2 = $async$self._async_evaluate$_moduleNodes.$index(0, url); + existingSpan = t2 == null ? null : t2.get$span(t2); + if (t1) { + t1 = currentConfiguration.nodeWithSpan; + configurationSpan = t1.get$span(t1); + } else + configurationSpan = null; + t1 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + if (existingSpan != null) + t1.$indexSet(0, existingSpan, "original load"); + if (configurationSpan != null) + t1.$indexSet(0, configurationSpan, "configuration"); + throw A.wrapException(t1.get$isEmpty(0) ? $async$self._async_evaluate$_exception$1(message) : $async$self._async_evaluate$_multiSpanException$3(message, "new load", t1)); + } + $async$returnValue = _0_0; + // goto return + $async$goto = 1; + break; + } + environment = A.AsyncEnvironment$(); + css = A._Cell$(); + preModuleComments = A._Cell$(); + extensionStore = A.ExtensionStore$(); + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_withEnvironment$1$2(environment, new A._EvaluateVisitor__execute_closure0($async$self, importer, stylesheet, extensionStore, configuration, css, preModuleComments), type$.Null), $async$_async_evaluate$_execute$5$configuration$namesInErrors$nodeWithSpan); + case 3: + // returning from await. + t2 = css._readLocal$0(); + t3 = preModuleComments._readLocal$0(); + module = environment.toModule$3(t2, t3 == null ? B.Map_empty8 : t3, extensionStore); + if (url != null) { + t1.$indexSet(0, url, module); + $async$self._async_evaluate$_moduleConfigurations.$indexSet(0, url, $async$self._async_evaluate$_configuration); + if (nodeWithSpan != null) + $async$self._async_evaluate$_moduleNodes.$indexSet(0, url, nodeWithSpan); + } + $async$returnValue = module; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_execute$5$configuration$namesInErrors$nodeWithSpan, $async$completer); + }, + _async_evaluate$_addOutOfOrderImports$0() { + var t1, t2, _this = this, _s5_ = "_root", + _s13_ = "_endOfImports", + _0_0 = _this._async_evaluate$_outOfOrderImports; + $label0$0: { + if (_0_0 == null) { + t1 = _this._async_evaluate$_assertInModule$2(_this._async_evaluate$__root, _s5_).children; + break $label0$0; + } + t1 = _this._async_evaluate$_assertInModule$2(_this._async_evaluate$__root, _s5_).children; + t1 = A.List_List$of(A.SubListIterable$(t1, 0, A.checkNotNullable(_this._async_evaluate$_assertInModule$2(_this._async_evaluate$__endOfImports, _s13_), "count", type$.int), t1.$ti._eval$1("ListBase.E")), true, type$.ModifiableCssNode); + B.JSArray_methods.addAll$1(t1, _0_0); + t2 = _this._async_evaluate$_assertInModule$2(_this._async_evaluate$__root, _s5_).children; + B.JSArray_methods.addAll$1(t1, A.SubListIterable$(t2, _this._async_evaluate$_assertInModule$2(_this._async_evaluate$__endOfImports, _s13_), null, t2.$ti._eval$1("ListBase.E"))); + break $label0$0; + } + return t1; + }, + _async_evaluate$_combineCss$2$clone(root, clone) { + var selectors, _0_0, t1, imports, css, sorted, t2; + if (!B.JSArray_methods.any$1(root.get$upstream(), new A._EvaluateVisitor__combineCss_closure1())) { + selectors = root.get$extensionStore().get$simpleSelectors(); + _0_0 = A.IterableExtension_get_firstOrNull(root.get$extensionStore().extensionsWhereTarget$1(new A._EvaluateVisitor__combineCss_closure2(selectors))); + if (_0_0 != null) + this._async_evaluate$_throwForUnsatisfiedExtension$1(_0_0); + return root.get$css(root); + } + t1 = type$.JSArray_CssNode; + imports = A._setArrayType([], t1); + css = A._setArrayType([], t1); + t1 = type$.Module_AsyncCallable; + sorted = A.ListQueue$(t1); + new A._EvaluateVisitor__combineCss_visitModule0(this, A.LinkedHashSet_LinkedHashSet$_empty(t1), clone, css, imports, sorted).call$1(root); + if (root.get$transitivelyContainsExtensions()) + this._async_evaluate$_extendModules$1(sorted); + t1 = B.JSArray_methods.$add(imports, css); + t2 = root.get$css(root); + return new A.CssStylesheet(new A.UnmodifiableListView(t1, type$.UnmodifiableListView_CssNode), t2.get$span(t2)); + }, + _async_evaluate$_combineCss$1(root) { + return this._async_evaluate$_combineCss$2$clone(root, false); + }, + _async_evaluate$_extendModules$1(sortedModules) { + var t1, t2, t3, originalSelectors, $self, t4, t5, _i, upstream, _0_0, + downstreamExtensionStores = A.LinkedHashMap_LinkedHashMap$_empty(type$.Uri, type$.List_ExtensionStore), + unsatisfiedExtensions = new A._LinkedIdentityHashSet(type$._LinkedIdentityHashSet_Extension); + for (t1 = A._ListQueueIterator$(sortedModules, sortedModules.$ti._precomputed1), t2 = t1.$ti._precomputed1; t1.moveNext$0();) { + t3 = t1._collection$_current; + if (t3 == null) + t3 = t2._as(t3); + originalSelectors = t3.get$extensionStore().get$simpleSelectors().toSet$0(0); + unsatisfiedExtensions.addAll$1(0, t3.get$extensionStore().extensionsWhereTarget$1(new A._EvaluateVisitor__extendModules_closure1(originalSelectors))); + $self = downstreamExtensionStores.$index(0, t3.get$url(t3)); + t4 = t3.get$extensionStore().get$addExtensions(); + if ($self != null) + t4.call$1($self); + t4 = t3.get$extensionStore(); + if (t4.get$isEmpty(t4)) + continue; + for (t4 = t3.get$upstream(), t5 = t4.length, _i = 0; _i < t4.length; t4.length === t5 || (0, A.throwConcurrentModificationError)(t4), ++_i) { + upstream = t4[_i]; + _0_0 = upstream.get$url(upstream); + if (_0_0 != null) + J.add$1$ax(downstreamExtensionStores.putIfAbsent$2(_0_0, new A._EvaluateVisitor__extendModules_closure2()), t3.get$extensionStore()); + } + unsatisfiedExtensions.removeAll$1(t3.get$extensionStore().extensionsWhereTarget$1(originalSelectors.get$contains(originalSelectors))); + } + if (unsatisfiedExtensions._collection$_length !== 0) + this._async_evaluate$_throwForUnsatisfiedExtension$1(unsatisfiedExtensions.get$first(0)); + }, + _async_evaluate$_throwForUnsatisfiedExtension$1(extension) { + throw A.wrapException(A.SassException$(string$.The_ta + extension.target.toString$0(0) + ' !optional" to avoid this error.', extension.span, null)); + }, + _async_evaluate$_indexAfterImports$1(statements) { + var t1, lastImport, i, _0_0; + for (t1 = J.getInterceptor$asx(statements), lastImport = -1, i = 0; i < t1.get$length(statements); ++i) { + $label0$0: { + _0_0 = t1.$index(statements, i); + if (_0_0 instanceof A.ModifiableCssImport) + break $label0$0; + if (_0_0 instanceof A.ModifiableCssComment) + continue; + break; + } + lastImport = i; + } + return lastImport + 1; + }, + visitStylesheet$1(_, node) { + return this.visitStylesheet$body$_EvaluateVisitor(0, node); + }, + visitStylesheet$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, t1, t2, warning, _i, $name, span; + var $async$visitStylesheet$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + for (t1 = node.parseTimeWarnings, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + warning = t1.__internal$_current; + if (warning == null) + warning = t2._as(warning); + $async$self._async_evaluate$_warn$3(warning._1, warning._2, warning._0); + } + t1 = node.children, t2 = t1.length, _i = 0; + case 3: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 5; + break; + } + $async$goto = 6; + return A._asyncAwait(t1[_i].accept$1($async$self), $async$visitStylesheet$1); + case 6: + // returning from await. + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + for (t1 = A.MapExtensions_get_pairs(node.globalVariables, type$.String, type$.FileSpan), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t2 = t1.get$current(t1); + $name = t2._0; + span = t2._1; + $async$self.visitVariableDeclaration$1(0, new A.VariableDeclaration(null, $name, new A.NullExpression(span), true, false, span)); + } + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitStylesheet$1, $async$completer); + }, + visitAtRootRule$1(_, node) { + return this.visitAtRootRule$body$_EvaluateVisitor(0, node); + }, + visitAtRootRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, _1_0, resolved, query, $parent, included, t1, _2_0, root, first, rest, innerCopy, outerCopy, _i, copy, _0_0; + var $async$visitAtRootRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + _0_0 = node.query; + $async$goto = _0_0 != null ? 3 : 5; + break; + case 3: + // then + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate$_performInterpolationWithMap$2$warnForColor(_0_0, true), $async$visitAtRootRule$1); + case 6: + // returning from await. + _1_0 = $async$result; + resolved = _1_0._0; + _1_0._1; + query = new A.AtRootQueryParser(A.SpanScanner$(resolved, null), null).parse$0(0); + // goto join + $async$goto = 4; + break; + case 5: + // else + query = B.AtRootQuery_bfj; + case 4: + // join + $parent = $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent"); + included = A._setArrayType([], type$.JSArray_ModifiableCssParentNode); + for (t1 = type$.CssStylesheet; !t1._is($parent); $parent = _2_0) { + if (!query.excludes$1($parent)) + included.push($parent); + _2_0 = $parent._parent; + if (_2_0 == null) + throw A.wrapException(A.StateError$(string$.CssNod)); + } + root = $async$self._async_evaluate$_trimIncluded$1(included); + $async$goto = root === $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent") ? 7 : 8; + break; + case 7: + // then + $async$goto = 9; + return A._asyncAwait($async$self._async_evaluate$_environment.scope$1$2$when(new A._EvaluateVisitor_visitAtRootRule_closure1($async$self, node), node.hasDeclarations, type$.Null), $async$visitAtRootRule$1); + case 9: + // returning from await. + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 8: + // join + if (included.length >= 1) { + first = included[0]; + rest = B.JSArray_methods.sublist$1(included, 1); + innerCopy = first.copyWithoutChildren$0(); + for (t1 = rest.length, outerCopy = innerCopy, _i = 0; _i < rest.length; rest.length === t1 || (0, A.throwConcurrentModificationError)(rest), ++_i, outerCopy = copy) { + copy = rest[_i].copyWithoutChildren$0(); + copy.addChild$1(outerCopy); + } + root.addChild$1(outerCopy); + } else + innerCopy = root; + $async$goto = 10; + return A._asyncAwait($async$self._async_evaluate$_scopeForAtRoot$4(node, innerCopy, query, included).call$1(new A._EvaluateVisitor_visitAtRootRule_closure2($async$self, node)), $async$visitAtRootRule$1); + case 10: + // returning from await. + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitAtRootRule$1, $async$completer); + }, + _async_evaluate$_trimIncluded$1(nodes) { + var $parent, t1, innermostContiguous, i, t2, _0_0, _1_0, root, _this = this, _null = null, _s5_ = "_root", + _s22_ = " to be an ancestor of "; + if (nodes.length === 0) + return _this._async_evaluate$_assertInModule$2(_this._async_evaluate$__root, _s5_); + $parent = _this._async_evaluate$_assertInModule$2(_this._async_evaluate$__parent, "__parent"); + for (t1 = nodes.length, innermostContiguous = _null, i = 0; i < t1; ++i, $parent = _1_0) { + for (; t2 = nodes[i], $parent !== t2; innermostContiguous = _null, $parent = _0_0) { + _0_0 = $parent._parent; + if (_0_0 == null) + throw A.wrapException(A.ArgumentError$("Expected " + t2.toString$0(0) + _s22_ + _this.toString$0(0) + ".", _null)); + } + if (innermostContiguous == null) + innermostContiguous = i; + _1_0 = $parent._parent; + if (_1_0 == null) + throw A.wrapException(A.ArgumentError$("Expected " + t2.toString$0(0) + _s22_ + _this.toString$0(0) + ".", _null)); + } + if ($parent !== _this._async_evaluate$_assertInModule$2(_this._async_evaluate$__root, _s5_)) + return _this._async_evaluate$_assertInModule$2(_this._async_evaluate$__root, _s5_); + innermostContiguous.toString; + root = nodes[innermostContiguous]; + B.JSArray_methods.removeRange$2(nodes, innermostContiguous, nodes.length); + return root; + }, + _async_evaluate$_scopeForAtRoot$4(node, newParent, query, included) { + var _this = this, + scope = new A._EvaluateVisitor__scopeForAtRoot_closure5(_this, newParent, node), + t1 = query._all || query._at_root_query$_rule; + if (t1 !== query.include) + scope = new A._EvaluateVisitor__scopeForAtRoot_closure6(_this, scope); + if (_this._async_evaluate$_mediaQueries != null && query.excludesName$1("media")) + scope = new A._EvaluateVisitor__scopeForAtRoot_closure7(_this, scope); + if (_this._async_evaluate$_inKeyframes && query.excludesName$1("keyframes")) + scope = new A._EvaluateVisitor__scopeForAtRoot_closure8(_this, scope); + return _this._async_evaluate$_inUnknownAtRule && !B.JSArray_methods.any$1(included, new A._EvaluateVisitor__scopeForAtRoot_closure9()) ? new A._EvaluateVisitor__scopeForAtRoot_closure10(_this, scope) : scope; + }, + visitContentBlock$1(_, node) { + return A.throwExpression(A.UnsupportedError$(string$.Evalua)); + }, + visitContentRule$1(_, node) { + return this.visitContentRule$body$_EvaluateVisitor(0, node); + }, + visitContentRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, $content; + var $async$visitContentRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $content = $async$self._async_evaluate$_environment._async_environment$_content; + if ($content == null) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_runUserDefinedCallable$1$4(node.$arguments, $content, node, new A._EvaluateVisitor_visitContentRule_closure0($async$self, $content), type$.Null), $async$visitContentRule$1); + case 3: + // returning from await. + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitContentRule$1, $async$completer); + }, + visitDebugRule$1(_, node) { + return this.visitDebugRule$body$_EvaluateVisitor(0, node); + }, + visitDebugRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, value, t1; + var $async$visitDebugRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait(node.expression.accept$1($async$self), $async$visitDebugRule$1); + case 3: + // returning from await. + value = $async$result; + t1 = value instanceof A.SassString ? value._string$_text : A.serializeValue(value, true, true); + $async$self._async_evaluate$_logger.debug$2(0, t1, node.span); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitDebugRule$1, $async$completer); + }, + visitDeclaration$1(_, node) { + return this.visitDeclaration$body$_EvaluateVisitor(0, node); + }, + visitDeclaration$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, siblings, interleavedRules, t1, t2, t3, t4, t5, t6, rule, rule0, $name, _1_0, _2_0, value, _3_0, oldDeclarationName; + var $async$visitDeclaration$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if (($async$self._async_evaluate$_atRootExcludingStyleRule ? null : $async$self._async_evaluate$_styleRuleIgnoringAtRoot) == null && !$async$self._async_evaluate$_inUnknownAtRule && !$async$self._async_evaluate$_inKeyframes) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Declarm, node.span)); + if ($async$self._async_evaluate$_declarationName != null && B.JSString_methods.startsWith$1(node.name.get$initialPlain(), "--")) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Declarw, node.span)); + siblings = $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent")._parent.children; + interleavedRules = A._setArrayType([], type$.JSArray_CssStyleRule); + if (siblings.get$last(siblings) !== $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent")) + t1 = !($async$self._async_evaluate$_quietDeps && $async$self._async_evaluate$_inDependency); + else + t1 = false; + if (t1) + for (t1 = A.SubListIterable$(siblings, siblings.indexOf$1(siblings, $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent")) + 1, null, siblings.$ti._eval$1("ListBase.E")), t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = node.span, t4 = type$.SourceSpan, t5 = type$.String, t2 = t2._eval$1("ListIterable.E"); t1.moveNext$0();) { + t6 = t1.__internal$_current; + rule = t6 == null ? t2._as(t6) : t6; + $label0$1: { + if (rule instanceof A.ModifiableCssComment) + continue; + t6 = rule instanceof A.ModifiableCssStyleRule; + rule0 = t6 ? rule : null; + if (t6) { + interleavedRules.push(rule0); + break $label0$1; + } + $async$self._async_evaluate$_warn$3(string$.Sassx27s, new A.MultiSpan(t3, "declaration", A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_literal([rule.get$span(rule), "nested rule"], t4, t5), t4, t5)), B.Deprecation_39u); + B.JSArray_methods.clear$0(interleavedRules); + break $label0$1; + } + } + t1 = node.name; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_interpolationToValue$2$warnForColor(t1, true), $async$visitDeclaration$1); + case 3: + // returning from await. + $name = $async$result; + _1_0 = $async$self._async_evaluate$_declarationName; + if (_1_0 != null) + $name = new A.CssValue(_1_0 + "-" + A.S($name.value), $name.span, type$.CssValue_String); + _2_0 = node.value; + $async$goto = _2_0 != null ? 4 : 5; + break; + case 4: + // then + $async$goto = 6; + return A._asyncAwait(_2_0.accept$1($async$self), $async$visitDeclaration$1); + case 6: + // returning from await. + value = $async$result; + if (!value.get$isBlank() || value.get$asList().length === 0) { + t2 = $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent"); + t3 = _2_0.get$span(_2_0); + t4 = node.span; + t1 = B.JSString_methods.startsWith$1(t1.get$initialPlain(), "--"); + t5 = interleavedRules.length === 0 ? null : $async$self._async_evaluate$_stackTrace$1(t4); + if ($async$self._async_evaluate$_sourceMap) { + t6 = A.NullableExtension_andThen(_2_0, $async$self.get$_async_evaluate$_expressionNode()); + t6 = t6 == null ? null : J.get$span$z(t6); + } else + t6 = null; + t2.addChild$1(A.ModifiableCssDeclaration$($name, new A.CssValue(value, t3, type$.CssValue_Value), t4, interleavedRules, t1, t5, t6)); + } else if (J.startsWith$1$s($name.value, "--")) + throw A.wrapException($async$self._async_evaluate$_exception$2("Custom property values may not be empty.", _2_0.get$span(_2_0))); + case 5: + // join + _3_0 = node.children; + t1 = {}; + t1.children = null; + $async$goto = _3_0 != null ? 7 : 8; + break; + case 7: + // then + t1.children = _3_0; + oldDeclarationName = $async$self._async_evaluate$_declarationName; + $async$self._async_evaluate$_declarationName = $name.value; + $async$goto = 9; + return A._asyncAwait($async$self._async_evaluate$_environment.scope$1$2$when(new A._EvaluateVisitor_visitDeclaration_closure0(t1, $async$self), node.hasDeclarations, type$.Null), $async$visitDeclaration$1); + case 9: + // returning from await. + $async$self._async_evaluate$_declarationName = oldDeclarationName; + case 8: + // join + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitDeclaration$1, $async$completer); + }, + visitEachRule$1(_, node) { + return this.visitEachRule$body$_EvaluateVisitor(0, node); + }, + visitEachRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, t1, list, nodeWithSpan, _0_0; + var $async$visitEachRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = node.list; + $async$goto = 3; + return A._asyncAwait(t1.accept$1($async$self), $async$visitEachRule$1); + case 3: + // returning from await. + list = $async$result; + nodeWithSpan = $async$self._async_evaluate$_expressionNode$1(t1); + _0_0 = node.variables; + $label0$0: { + t1 = {}; + t1.variable = null; + if (_0_0.length === 1) { + t1.variable = _0_0[0]; + t1 = new A._EvaluateVisitor_visitEachRule_closure2(t1, $async$self, nodeWithSpan); + break $label0$0; + } + t1 = {}; + t1.variables = null; + t1.variables = _0_0; + t1 = new A._EvaluateVisitor_visitEachRule_closure3(t1, $async$self, nodeWithSpan); + break $label0$0; + } + $async$returnValue = $async$self._async_evaluate$_environment.scope$1$2$semiGlobal(new A._EvaluateVisitor_visitEachRule_closure4($async$self, list, t1, node), true, type$.nullable_Value); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitEachRule$1, $async$completer); + }, + _async_evaluate$_setMultipleVariables$3(variables, value, nodeWithSpan) { + var i, + list = value.get$asList(), + t1 = variables.length, + minLength = Math.min(t1, list.length); + for (i = 0; i < minLength; ++i) + this._async_evaluate$_environment.setLocalVariable$3(variables[i], this._async_evaluate$_withoutSlash$2(list[i], nodeWithSpan), nodeWithSpan); + for (i = minLength; i < t1; ++i) + this._async_evaluate$_environment.setLocalVariable$3(variables[i], B.C__SassNull, nodeWithSpan); + }, + visitErrorRule$1(_, node) { + return this.visitErrorRule$body$_EvaluateVisitor(0, node); + }, + visitErrorRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$self = this, $async$temp1, $async$temp2; + var $async$visitErrorRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$temp1 = A; + $async$temp2 = J; + $async$goto = 2; + return A._asyncAwait(node.expression.accept$1($async$self), $async$visitErrorRule$1); + case 2: + // returning from await. + throw $async$temp1.wrapException($async$self._async_evaluate$_exception$2($async$temp2.toString$0$($async$result), node.span)); + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitErrorRule$1, $async$completer); + }, + visitExtendRule$1(_, node) { + return this.visitExtendRule$body$_EvaluateVisitor(0, node); + }, + visitExtendRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, t1, t2, t3, t4, t5, _i, complex, visitor, t6, t7, _0_0, targetText, targetMap, compound, styleRule; + var $async$visitExtendRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + styleRule = $async$self._async_evaluate$_atRootExcludingStyleRule ? null : $async$self._async_evaluate$_styleRuleIgnoringAtRoot; + if (styleRule == null || $async$self._async_evaluate$_declarationName != null) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.x40exten, node.span)); + for (t1 = styleRule.originalSelector.components, t2 = t1.length, t3 = node.span, t4 = type$.SourceSpan, t5 = type$.String, _i = 0; _i < t2; ++_i) { + complex = t1[_i]; + if (!complex.accept$1(B._IsBogusVisitor_true)) + continue; + visitor = A._SerializeVisitor$(null, true, null, null, true, false, null, true); + complex.accept$1(visitor); + t6 = B.JSString_methods.trim$0(visitor._serialize$_buffer.toString$0(0)); + t7 = complex.accept$1(B.C__IsUselessVisitor) ? "can't" : "shouldn't"; + $async$self._async_evaluate$_warn$3('The selector "' + t6 + '" is invalid CSS and ' + t7 + string$.x20be_an, new A.MultiSpan(A.SpanExtensions_trimRight(complex.span), "invalid selector", A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_literal([t3, "@extend rule"], t4, t5), t4, t5)), B.Deprecation_9hF); + } + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_performInterpolationWithMap$2$warnForColor(node.selector, true), $async$visitExtendRule$1); + case 3: + // returning from await. + _0_0 = $async$result; + targetText = _0_0._0; + targetMap = _0_0._1; + for (t1 = A.SelectorList_SelectorList$parse(A.trimAscii(targetText, true), false, targetMap, false).components, t2 = t1.length, t3 = styleRule._style_rule$_selector._box$_inner, _i = 0; _i < t2; ++_i) { + complex = t1[_i]; + compound = complex.get$singleCompound(); + if (compound == null) + throw A.wrapException(A.SassFormatException$("complex selectors may not be extended.", complex.span, null)); + t4 = compound.components; + t5 = t4.length === 1 ? B.JSArray_methods.get$first(t4) : null; + if (t5 == null) + throw A.wrapException(A.SassFormatException$(string$.compou + B.JSArray_methods.join$1(t4, ", ") + string$.x60_inst, compound.span, null)); + $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__extensionStore, "_extensionStore").addExtension$4(t3.value, t5, node, $async$self._async_evaluate$_mediaQueries); + } + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitExtendRule$1, $async$completer); + }, + visitAtRule$1(_, node) { + return this.visitAtRule$body$_EvaluateVisitor(0, node); + }, + visitAtRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, $name, t1, value, children, wasInKeyframes, wasInUnknownAtRule; + var $async$visitAtRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate$_declarationName != null) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.At_rul, node.span)); + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_interpolationToValue$1(node.name), $async$visitAtRule$1); + case 3: + // returning from await. + $name = $async$result; + t1 = A.NullableExtension_andThen(node.value, new A._EvaluateVisitor_visitAtRule_closure2($async$self)); + $async$goto = 4; + return A._asyncAwait(type$.Future_nullable_CssValue_String._is(t1) ? t1 : A._Future$value(t1, type$.nullable_CssValue_String), $async$visitAtRule$1); + case 4: + // returning from await. + value = $async$result; + children = node.children; + if (children == null) { + $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent").addChild$1(A.ModifiableCssAtRule$($name, node.span, true, value)); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + wasInKeyframes = $async$self._async_evaluate$_inKeyframes; + wasInUnknownAtRule = $async$self._async_evaluate$_inUnknownAtRule; + if (A.unvendor($name.value) === "keyframes") + $async$self._async_evaluate$_inKeyframes = true; + else + $async$self._async_evaluate$_inUnknownAtRule = true; + $async$goto = 5; + return A._asyncAwait($async$self._async_evaluate$_withParent$2$4$scopeWhen$through(A.ModifiableCssAtRule$($name, node.span, false, value), new A._EvaluateVisitor_visitAtRule_closure3($async$self, $name, children), node.hasDeclarations, new A._EvaluateVisitor_visitAtRule_closure4(), type$.ModifiableCssAtRule, type$.Null), $async$visitAtRule$1); + case 5: + // returning from await. + $async$self._async_evaluate$_inUnknownAtRule = wasInUnknownAtRule; + $async$self._async_evaluate$_inKeyframes = wasInKeyframes; + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitAtRule$1, $async$completer); + }, + visitForRule$1(_, node) { + return this.visitForRule$body$_EvaluateVisitor(0, node); + }, + visitForRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, t1, t2, t3, fromNumber, t4, toNumber, from, to, direction; + var $async$visitForRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = {}; + t2 = node.from; + t3 = type$.SassNumber; + $async$goto = 3; + return A._asyncAwait($async$self._addExceptionSpanAsync$1$2(t2, new A._EvaluateVisitor_visitForRule_closure4($async$self, node), t3), $async$visitForRule$1); + case 3: + // returning from await. + fromNumber = $async$result; + t4 = node.to; + $async$goto = 4; + return A._asyncAwait($async$self._addExceptionSpanAsync$1$2(t4, new A._EvaluateVisitor_visitForRule_closure5($async$self, node), t3), $async$visitForRule$1); + case 4: + // returning from await. + toNumber = $async$result; + from = $async$self._async_evaluate$_addExceptionSpan$2(t2, new A._EvaluateVisitor_visitForRule_closure6(fromNumber)); + to = t1.to = $async$self._async_evaluate$_addExceptionSpan$2(t4, new A._EvaluateVisitor_visitForRule_closure7(toNumber, fromNumber)); + direction = from > to ? -1 : 1; + if (from === (!node.isExclusive ? t1.to = to + direction : to)) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + $async$returnValue = $async$self._async_evaluate$_environment.scope$1$2$semiGlobal(new A._EvaluateVisitor_visitForRule_closure8(t1, $async$self, node, from, direction, fromNumber), true, type$.nullable_Value); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitForRule$1, $async$completer); + }, + visitForwardRule$1(_, node) { + return this.visitForwardRule$body$_EvaluateVisitor(0, node); + }, + visitForwardRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, newConfiguration, t4, _i, variable, $name, oldConfiguration, adjustedConfiguration, t1, t2, t3; + var $async$visitForwardRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + oldConfiguration = $async$self._async_evaluate$_configuration; + adjustedConfiguration = oldConfiguration.throughForward$1(node); + t1 = node.configuration; + t2 = t1.length; + t3 = node.url; + $async$goto = t2 !== 0 ? 3 : 5; + break; + case 3: + // then + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate$_addForwardConfiguration$2(adjustedConfiguration, node), $async$visitForwardRule$1); + case 6: + // returning from await. + newConfiguration = $async$result; + $async$goto = 7; + return A._asyncAwait($async$self._async_evaluate$_loadModule$5$configuration(t3, "@forward", node, new A._EvaluateVisitor_visitForwardRule_closure1($async$self, node), newConfiguration), $async$visitForwardRule$1); + case 7: + // returning from await. + t3 = type$.String; + t4 = A.LinkedHashSet_LinkedHashSet$_empty(t3); + for (_i = 0; _i < t2; ++_i) { + variable = t1[_i]; + if (!variable.isGuarded) + t4.add$1(0, variable.name); + } + $async$self._async_evaluate$_removeUsedConfiguration$3$except(adjustedConfiguration, newConfiguration, t4); + t3 = A.LinkedHashSet_LinkedHashSet$_empty(t3); + for (_i = 0; _i < t2; ++_i) + t3.add$1(0, t1[_i].name); + for (t1 = newConfiguration._configuration$_values, t2 = J.toList$0$ax(t1.get$keys(t1)), t4 = t2.length, _i = 0; _i < t2.length; t2.length === t4 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + $name = t2[_i]; + if (!t3.contains$1(0, $name)) + if (!t1.get$isEmpty(t1)) + t1.remove$1(0, $name); + } + $async$self._async_evaluate$_assertConfigurationIsEmpty$1(newConfiguration); + // goto join + $async$goto = 4; + break; + case 5: + // else + $async$self._async_evaluate$_configuration = adjustedConfiguration; + $async$goto = 8; + return A._asyncAwait($async$self._async_evaluate$_loadModule$4(t3, "@forward", node, new A._EvaluateVisitor_visitForwardRule_closure2($async$self, node)), $async$visitForwardRule$1); + case 8: + // returning from await. + $async$self._async_evaluate$_configuration = oldConfiguration; + case 4: + // join + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitForwardRule$1, $async$completer); + }, + _async_evaluate$_addForwardConfiguration$2(configuration, node) { + return this._addForwardConfiguration$body$_EvaluateVisitor(configuration, node); + }, + _addForwardConfiguration$body$_EvaluateVisitor(configuration, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Configuration), + $async$returnValue, $async$self = this, t2, t3, t4, t5, _i, variable, t6, _0_0, t7, oldValue, variableNodeWithSpan, t1, newValues, $async$temp1, $async$temp2, $async$temp3; + var $async$_async_evaluate$_addForwardConfiguration$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = configuration._configuration$_values; + newValues = A.LinkedHashMap_LinkedHashMap$of(new A.UnmodifiableMapView(t1, type$.UnmodifiableMapView_String_ConfiguredValue), type$.String, type$.ConfiguredValue); + t2 = node.configuration, t3 = t2.length, t4 = type$._Future_Value, t5 = type$.Future_Value, _i = 0; + case 3: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 5; + break; + } + variable = t2[_i]; + if (variable.isGuarded) { + t6 = variable.name; + _0_0 = t1.get$isEmpty(t1) ? null : t1.remove$1(0, t6); + if (_0_0 != null) { + t7 = !_0_0.value.$eq(0, B.C__SassNull); + oldValue = _0_0; + } else { + oldValue = null; + t7 = false; + } + if (t7) { + newValues.$indexSet(0, t6, oldValue); + // goto for update + $async$goto = 4; + break; + } + } + t6 = variable.expression; + variableNodeWithSpan = $async$self._async_evaluate$_expressionNode$1(t6); + t6 = t6.accept$1($async$self); + if (!t5._is(t6)) { + t7 = new A._Future($.Zone__current, t4); + t7._state = 8; + t7._resultOrListeners = t6; + t6 = t7; + } + $async$temp1 = newValues; + $async$temp2 = variable.name; + $async$temp3 = A; + $async$goto = 6; + return A._asyncAwait(t6, $async$_async_evaluate$_addForwardConfiguration$2); + case 6: + // returning from await. + $async$temp1.$indexSet(0, $async$temp2, new $async$temp3.ConfiguredValue($async$self._async_evaluate$_withoutSlash$2($async$result, variableNodeWithSpan), variable.span, variableNodeWithSpan)); + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + if (configuration instanceof A.ExplicitConfiguration || t1.get$isEmpty(t1)) { + $async$returnValue = new A.ExplicitConfiguration(node, newValues, null); + // goto return + $async$goto = 1; + break; + } else { + $async$returnValue = new A.Configuration(newValues, null); + // goto return + $async$goto = 1; + break; + } + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_addForwardConfiguration$2, $async$completer); + }, + _async_evaluate$_registerCommentsForModule$1(module) { + var _this = this, _s5_ = "_root", + t1 = _this._async_evaluate$__root; + if (t1 == null) + return; + if (_this._async_evaluate$_assertInModule$2(t1, _s5_).children.get$length(0) === 0 || !module.get$transitivelyContainsCss()) + return; + t1 = _this._async_evaluate$_preModuleComments; + if (t1 == null) + t1 = _this._async_evaluate$_preModuleComments = A.LinkedHashMap_LinkedHashMap$_empty(type$.Module_AsyncCallable, type$.List_CssComment); + J.addAll$1$ax(t1.putIfAbsent$2(module, new A._EvaluateVisitor__registerCommentsForModule_closure0()), new A.UnmodifiableListView(J.cast$1$0$ax(_this._async_evaluate$_assertInModule$2(_this._async_evaluate$__root, _s5_).children._collection$_source, type$.CssComment), type$.UnmodifiableListView_CssComment)); + _this._async_evaluate$_assertInModule$2(_this._async_evaluate$__root, _s5_).clearChildren$0(); + _this._async_evaluate$__endOfImports = 0; + }, + _async_evaluate$_removeUsedConfiguration$3$except(upstream, downstream, except) { + var t1, t2, t3, t4, _i, $name; + for (t1 = upstream._configuration$_values, t2 = J.toList$0$ax(t1.get$keys(t1)), t3 = t2.length, t4 = downstream._configuration$_values, _i = 0; _i < t2.length; t2.length === t3 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + $name = t2[_i]; + if (except.contains$1(0, $name)) + continue; + if (!t4.containsKey$1($name)) + if (!t1.get$isEmpty(t1)) + t1.remove$1(0, $name); + } + }, + _async_evaluate$_assertConfigurationIsEmpty$2$nameInError(configuration, nameInError) { + var t1, _0_0, $name, value; + if (!(configuration instanceof A.ExplicitConfiguration)) + return; + t1 = configuration._configuration$_values; + if (t1.get$isEmpty(t1)) + return; + t1 = A.MapExtensions_get_pairs(new A.UnmodifiableMapView(t1, type$.UnmodifiableMapView_String_ConfiguredValue), type$.String, type$.ConfiguredValue); + _0_0 = t1.get$first(t1); + $name = _0_0._0; + value = _0_0._1; + t1 = nameInError ? "$" + $name + string$.x20was_n : string$.This_v; + throw A.wrapException(this._async_evaluate$_exception$2(t1, value.configurationSpan)); + }, + _async_evaluate$_assertConfigurationIsEmpty$1(configuration) { + return this._async_evaluate$_assertConfigurationIsEmpty$2$nameInError(configuration, false); + }, + visitFunctionRule$1(_, node) { + return this.visitFunctionRule$body$_EvaluateVisitor(0, node); + }, + visitFunctionRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, t1, t2, t3, t4, index, t5; + var $async$visitFunctionRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self._async_evaluate$_environment; + t2 = t1.closure$0(); + t3 = $async$self._async_evaluate$_inDependency; + t4 = t1._async_environment$_functions; + index = t4.length - 1; + t5 = node.name; + t1._async_environment$_functionIndices.$indexSet(0, t5, index); + t4[index].$indexSet(0, t5, new A.UserDefinedCallable(node, t2, t3, type$.UserDefinedCallable_AsyncEnvironment)); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitFunctionRule$1, $async$completer); + }, + visitIfRule$1(_, node) { + return this.visitIfRule$body$_EvaluateVisitor(0, node); + }, + visitIfRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, t1, t2, _i, clauseToCheck, clause; + var $async$visitIfRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + clause = node.lastClause; + t1 = node.clauses, t2 = t1.length, _i = 0; + case 3: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 5; + break; + } + clauseToCheck = t1[_i]; + $async$goto = 6; + return A._asyncAwait(clauseToCheck.expression.accept$1($async$self), $async$visitIfRule$1); + case 6: + // returning from await. + if ($async$result.get$isTruthy()) { + clause = clauseToCheck; + // goto after for + $async$goto = 5; + break; + } + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + t1 = A.NullableExtension_andThen(clause, new A._EvaluateVisitor_visitIfRule_closure0($async$self)); + $async$goto = 7; + return A._asyncAwait(type$.Future_nullable_Value._is(t1) ? t1 : A._Future$value(t1, type$.nullable_Value), $async$visitIfRule$1); + case 7: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitIfRule$1, $async$completer); + }, + visitImportRule$1(_, node) { + return this.visitImportRule$body$_EvaluateVisitor(0, node); + }, + visitImportRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, t1, t2, t3, _i, $import; + var $async$visitImportRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = node.imports, t2 = t1.length, t3 = type$.StaticImport, _i = 0; + case 3: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 5; + break; + } + $import = t1[_i]; + $async$goto = $import instanceof A.DynamicImport ? 6 : 8; + break; + case 6: + // then + $async$goto = 9; + return A._asyncAwait($async$self._async_evaluate$_visitDynamicImport$1($import), $async$visitImportRule$1); + case 9: + // returning from await. + // goto join + $async$goto = 7; + break; + case 8: + // else + $async$goto = 10; + return A._asyncAwait($async$self._visitStaticImport$1(t3._as($import)), $async$visitImportRule$1); + case 10: + // returning from await. + case 7: + // join + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitImportRule$1, $async$completer); + }, + _async_evaluate$_visitDynamicImport$1($import) { + return this._async_evaluate$_withStackFrame$1$3("@import", $import, new A._EvaluateVisitor__visitDynamicImport_closure0(this, $import), type$.void); + }, + _async_evaluate$_loadStylesheet$4$baseUrl$forImport(url, span, baseUrl, forImport) { + return this._loadStylesheet$body$_EvaluateVisitor(url, span, baseUrl, forImport); + }, + _async_evaluate$_loadStylesheet$3$baseUrl(url, span, baseUrl) { + return this._async_evaluate$_loadStylesheet$4$baseUrl$forImport(url, span, baseUrl, false); + }, + _async_evaluate$_loadStylesheet$3$forImport(url, span, forImport) { + return this._async_evaluate$_loadStylesheet$4$baseUrl$forImport(url, span, null, forImport); + }, + _loadStylesheet$body$_EvaluateVisitor(url, span, baseUrl, forImport) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_3_Stylesheet_and_nullable_AsyncImporter_importer_and_bool_isDependency), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$next = [], $async$self = this, _0_0, importCache, _1_0, importer, canonicalUrl, originalUrl, isDependency, _2_0, stylesheet, error, stackTrace, error0, stackTrace0, t1, t2, exception, $async$exception; + var $async$_async_evaluate$_loadStylesheet$4$baseUrl$forImport = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + baseUrl = baseUrl; + $async$handler = 4; + $async$self._async_evaluate$_importSpan = span; + _0_0 = $async$self._async_evaluate$_importCache; + importCache = null; + $async$goto = _0_0 != null ? 7 : 8; + break; + case 7: + // then + importCache = _0_0; + if (baseUrl == null) { + t1 = $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__stylesheet, "_stylesheet").span; + baseUrl = t1.get$sourceUrl(t1); + } + $async$goto = 9; + return A._asyncAwait(J.canonicalize$4$baseImporter$baseUrl$forImport$x(importCache, A.Uri_parse(url), $async$self._async_evaluate$_importer, baseUrl, forImport), $async$_async_evaluate$_loadStylesheet$4$baseUrl$forImport); + case 9: + // returning from await. + _1_0 = $async$result; + importer = null; + canonicalUrl = null; + originalUrl = null; + $async$goto = type$.Record_3_nullable_Object_and_nullable_Object_and_nullable_Object_originalUrl._is(_1_0) ? 10 : 11; + break; + case 10: + // then + importer = _1_0._0; + canonicalUrl = _1_0._1; + originalUrl = _1_0._2; + if (canonicalUrl.get$scheme() === "") + A.WarnForDeprecation_warnForDeprecation($async$self._async_evaluate$_logger, B.Deprecation_746, "Importer " + A.S(importer) + " canonicalized " + url + " to " + A.S(canonicalUrl) + string$.x2e_Rela, null, null); + $async$self._async_evaluate$_loadedUrls.add$1(0, canonicalUrl); + isDependency = $async$self._async_evaluate$_inDependency || !J.$eq$(importer, $async$self._async_evaluate$_importer); + $async$goto = 12; + return A._asyncAwait(importCache.importCanonical$3$originalUrl(importer, canonicalUrl, originalUrl), $async$_async_evaluate$_loadStylesheet$4$baseUrl$forImport); + case 12: + // returning from await. + _2_0 = $async$result; + stylesheet = null; + if (_2_0 != null) { + stylesheet = _2_0; + t1 = stylesheet; + t2 = importer; + $async$returnValue = new A._Record_3_importer_isDependency(t1, t2, isDependency); + $async$next = [1]; + // goto finally + $async$goto = 5; + break; + } + case 11: + // join + case 8: + // join + t1 = B.JSString_methods.startsWith$1(url, "package:"); + if (t1) + throw A.wrapException(string$.x22packa); + else + throw A.wrapException("Can't find stylesheet to import."); + $async$next.push(6); + // goto finally + $async$goto = 5; + break; + case 4: + // catch + $async$handler = 3; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (t1 instanceof A.SassException) + throw $async$exception; + else if (t1 instanceof A.ArgumentError) { + error = t1; + stackTrace = A.getTraceFromException($async$exception); + A.throwWithTrace($async$self._async_evaluate$_exception$1(J.toString$0$(error)), error, stackTrace); + } else { + error0 = t1; + stackTrace0 = A.getTraceFromException($async$exception); + A.throwWithTrace($async$self._async_evaluate$_exception$1($async$self._async_evaluate$_getErrorMessage$1(error0)), error0, stackTrace0); + } + $async$next.push(6); + // goto finally + $async$goto = 5; + break; + case 3: + // uncaught + $async$next = [2]; + case 5: + // finally + $async$handler = 2; + $async$self._async_evaluate$_importSpan = null; + // goto the next finally handler + $async$goto = $async$next.pop(); + break; + case 6: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_loadStylesheet$4$baseUrl$forImport, $async$completer); + }, + _visitStaticImport$1($import) { + return this._visitStaticImport$body$_EvaluateVisitor($import); + }, + _visitStaticImport$body$_EvaluateVisitor($import) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1, t2, node, $async$temp1, $async$temp2; + var $async$_visitStaticImport$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 2; + return A._asyncAwait($async$self._async_evaluate$_interpolationToValue$1($import.url), $async$_visitStaticImport$1); + case 2: + // returning from await. + t1 = $async$result; + t2 = A.NullableExtension_andThen($import.modifiers, $async$self.get$_async_evaluate$_interpolationToValue()); + $async$temp1 = A; + $async$temp2 = t1; + $async$goto = 3; + return A._asyncAwait(type$.Future_nullable_CssValue_String._is(t2) ? t2 : A._Future$value(t2, type$.nullable_CssValue_String), $async$_visitStaticImport$1); + case 3: + // returning from await. + node = new $async$temp1.ModifiableCssImport($async$temp2, $async$result, $import.span); + if ($async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent") !== $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__root, "_root")) + $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent").addChild$1(node); + else if ($async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__endOfImports, "_endOfImports") === J.get$length$asx($async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__root, "_root").children._collection$_source)) { + $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__root, "_root").addChild$1(node); + $async$self._async_evaluate$__endOfImports = $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__endOfImports, "_endOfImports") + 1; + } else { + t1 = $async$self._async_evaluate$_outOfOrderImports; + (t1 == null ? $async$self._async_evaluate$_outOfOrderImports = A._setArrayType([], type$.JSArray_ModifiableCssImport) : t1).push(node); + } + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$_visitStaticImport$1, $async$completer); + }, + _async_evaluate$_applyMixin$5(mixin, contentCallable, $arguments, nodeWithSpan, nodeWithSpanWithoutContent) { + return this._applyMixin$body$_EvaluateVisitor(mixin, contentCallable, $arguments, nodeWithSpan, nodeWithSpanWithoutContent); + }, + _applyMixin$body$_EvaluateVisitor(mixin, contentCallable, $arguments, nodeWithSpan, nodeWithSpanWithoutContent) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1, _0_0, t2, _1_8; + var $async$_async_evaluate$_applyMixin$5 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if (mixin == null) + throw A.wrapException($async$self._async_evaluate$_exception$2("Undefined mixin.", nodeWithSpan.get$span(nodeWithSpan))); + t1 = type$.AsyncBuiltInCallable._is(mixin); + $async$goto = t1 && !mixin.get$acceptsContent() && contentCallable != null ? 3 : 4; + break; + case 3: + // then + $async$goto = 5; + return A._asyncAwait($async$self._async_evaluate$_evaluateArguments$1($arguments), $async$_async_evaluate$_applyMixin$5); + case 5: + // returning from await. + t1 = $async$result._values; + _0_0 = mixin.callbackFor$2(J.get$length$asx(t1[2]), new A.MapKeySet(t1[0], type$.MapKeySet_String)); + throw A.wrapException(A.MultiSpanSassRuntimeException$("Mixin doesn't accept a content block.", nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent), "invocation", A.LinkedHashMap_LinkedHashMap$_literal([_0_0._0.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), $async$self._async_evaluate$_stackTrace$1(nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent)), null)); + case 4: + // join + $async$goto = t1 ? 6 : 7; + break; + case 6: + // then + $async$goto = 8; + return A._asyncAwait($async$self._async_evaluate$_environment.withContent$2(contentCallable, new A._EvaluateVisitor__applyMixin_closure1($async$self, $arguments, mixin, nodeWithSpanWithoutContent)), $async$_async_evaluate$_applyMixin$5); + case 8: + // returning from await. + // goto break $label0$0 + $async$goto = 2; + break; + case 7: + // join + t1 = type$.UserDefinedCallable_AsyncEnvironment._is(mixin); + t2 = false; + if (t1) { + _1_8 = mixin.declaration; + if (_1_8 instanceof A.MixinRule) + t2 = !type$.MixinRule._as(_1_8).get$hasContent() && contentCallable != null; + } + if (t2) + throw A.wrapException(A.MultiSpanSassRuntimeException$("Mixin doesn't accept a content block.", nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent), "invocation", A.LinkedHashMap_LinkedHashMap$_literal([mixin.declaration.parameters.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), $async$self._async_evaluate$_stackTrace$1(nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent)), null)); + $async$goto = t1 ? 9 : 10; + break; + case 9: + // then + $async$goto = 11; + return A._asyncAwait($async$self._async_evaluate$_runUserDefinedCallable$1$4($arguments, mixin, nodeWithSpanWithoutContent, new A._EvaluateVisitor__applyMixin_closure2($async$self, contentCallable, mixin, nodeWithSpanWithoutContent), type$.Null), $async$_async_evaluate$_applyMixin$5); + case 11: + // returning from await. + // goto break $label0$0 + $async$goto = 2; + break; + case 10: + // join + throw A.wrapException(A.UnsupportedError$("Unknown callable type " + mixin.toString$0(0) + ".")); + case 2: + // break $label0$0 + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_applyMixin$5, $async$completer); + }, + visitIncludeRule$1(_, node) { + return this.visitIncludeRule$body$_EvaluateVisitor(0, node); + }, + visitIncludeRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, mixin; + var $async$visitIncludeRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + mixin = $async$self._async_evaluate$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitIncludeRule_closure2($async$self, node)); + if (B.JSString_methods.startsWith$1(node.originalName, "--") && mixin instanceof A.UserDefinedCallable && !B.JSString_methods.startsWith$1(mixin.declaration.originalName, "--")) + $async$self._async_evaluate$_warn$3(string$.Sassx20_m, node.get$nameSpan(), B.Deprecation_Kg6); + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_applyMixin$5(mixin, A.NullableExtension_andThen(node.content, new A._EvaluateVisitor_visitIncludeRule_closure3($async$self)), node.$arguments, node, new A._FakeAstNode(new A._EvaluateVisitor_visitIncludeRule_closure4(node))), $async$visitIncludeRule$1); + case 3: + // returning from await. + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitIncludeRule$1, $async$completer); + }, + visitMixinRule$1(_, node) { + return this.visitMixinRule$body$_EvaluateVisitor(0, node); + }, + visitMixinRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, t1, t2, t3, t4, index, t5; + var $async$visitMixinRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self._async_evaluate$_environment; + t2 = t1.closure$0(); + t3 = $async$self._async_evaluate$_inDependency; + t4 = t1._async_environment$_mixins; + index = t4.length - 1; + t5 = node.name; + t1._async_environment$_mixinIndices.$indexSet(0, t5, index); + t4[index].$indexSet(0, t5, new A.UserDefinedCallable(node, t2, t3, type$.UserDefinedCallable_AsyncEnvironment)); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitMixinRule$1, $async$completer); + }, + visitLoudComment$1(_, node) { + return this.visitLoudComment$body$_EvaluateVisitor(0, node); + }, + visitLoudComment$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, t1, text; + var $async$visitLoudComment$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate$_inFunction) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + if ($async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent") === $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__root, "_root") && $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__endOfImports, "_endOfImports") === J.get$length$asx($async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__root, "_root").children._collection$_source)) + $async$self._async_evaluate$__endOfImports = $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__endOfImports, "_endOfImports") + 1; + t1 = node.text; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_performInterpolation$1(t1), $async$visitLoudComment$1); + case 3: + // returning from await. + text = $async$result; + if (!B.JSString_methods.endsWith$1(text, "*/")) + text += " */"; + $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent").addChild$1(new A.ModifiableCssComment(text, t1.span)); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitLoudComment$1, $async$completer); + }, + visitMediaRule$1(_, node) { + return this.visitMediaRule$body$_EvaluateVisitor(0, node); + }, + visitMediaRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, queries, mergedQueries, t1, mergedSources, t2, t3; + var $async$visitMediaRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate$_declarationName != null) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Media_, node.span)); + $async$goto = 3; + return A._asyncAwait($async$self._visitMediaQueries$1(node.query), $async$visitMediaRule$1); + case 3: + // returning from await. + queries = $async$result; + mergedQueries = A.NullableExtension_andThen($async$self._async_evaluate$_mediaQueries, new A._EvaluateVisitor_visitMediaRule_closure2($async$self, queries)); + t1 = mergedQueries == null; + if (!t1 && J.get$isEmpty$asx(mergedQueries)) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + if (t1) + mergedSources = B.Set_empty1; + else { + t2 = $async$self._async_evaluate$_mediaQuerySources; + t2.toString; + t2 = A.LinkedHashSet_LinkedHashSet$of(t2, type$.CssMediaQuery); + t3 = $async$self._async_evaluate$_mediaQueries; + t3.toString; + t2.addAll$1(0, t3); + t2.addAll$1(0, queries); + mergedSources = t2; + } + t1 = t1 ? queries : mergedQueries; + $async$goto = 4; + return A._asyncAwait($async$self._async_evaluate$_withParent$2$4$scopeWhen$through(A.ModifiableCssMediaRule$(t1, node.span), new A._EvaluateVisitor_visitMediaRule_closure3($async$self, mergedQueries, queries, mergedSources, node), node.hasDeclarations, new A._EvaluateVisitor_visitMediaRule_closure4(mergedSources), type$.ModifiableCssMediaRule, type$.Null), $async$visitMediaRule$1); + case 4: + // returning from await. + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitMediaRule$1, $async$completer); + }, + _visitMediaQueries$1(interpolation) { + return this._visitMediaQueries$body$_EvaluateVisitor(interpolation); + }, + _visitMediaQueries$body$_EvaluateVisitor(interpolation) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.List_CssMediaQuery), + $async$returnValue, $async$self = this, _0_0, resolved, map; + var $async$_visitMediaQueries$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_performInterpolationWithMap$2$warnForColor(interpolation, true), $async$_visitMediaQueries$1); + case 3: + // returning from await. + _0_0 = $async$result; + resolved = _0_0._0; + map = _0_0._1; + $async$returnValue = new A.MediaQueryParser(A.SpanScanner$(resolved, null), map).parse$0(0); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_visitMediaQueries$1, $async$completer); + }, + _async_evaluate$_mergeMediaQueries$2(queries1, queries2) { + var t1, t2, t3, t4, _0_0, t5, result, + queries = A._setArrayType([], type$.JSArray_CssMediaQuery); + for (t1 = J.get$iterator$ax(queries1), t2 = J.getInterceptor$ax(queries2); t1.moveNext$0();) { + t3 = t1.get$current(t1); + for (t4 = t2.get$iterator(queries2); t4.moveNext$0();) { + _0_0 = t3.merge$1(t4.get$current(t4)); + if (B._SingletonCssMediaQueryMergeResult_0 === _0_0) + continue; + if (B._SingletonCssMediaQueryMergeResult_1 === _0_0) + return null; + t5 = _0_0 instanceof A.MediaQuerySuccessfulMergeResult; + result = t5 ? _0_0 : null; + if (t5) + queries.push(result.query); + } + } + return queries; + }, + visitReturnRule$1(_, node) { + return this.visitReturnRule$body$_EvaluateVisitor(0, node); + }, + visitReturnRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue, $async$self = this, t1, t2; + var $async$visitReturnRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = node.expression; + t2 = t1.accept$1($async$self); + $async$goto = 3; + return A._asyncAwait(type$.Future_Value._is(t2) ? t2 : A._Future$value(t2, type$.Value), $async$visitReturnRule$1); + case 3: + // returning from await. + $async$returnValue = $async$self._async_evaluate$_withoutSlash$2($async$result, t1); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitReturnRule$1, $async$completer); + }, + visitSilentComment$1(_, node) { + return this.visitSilentComment$body$_EvaluateVisitor(0, node); + }, + visitSilentComment$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue; + var $async$visitSilentComment$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitSilentComment$1, $async$completer); + }, + visitStyleRule$1(_, node) { + return this.visitStyleRule$body$_EvaluateVisitor(0, node); + }, + visitStyleRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, t1, _0_0, selectorText, selectorMap, parsedSelector, nest, t2, _i, _1_0, first, t3, rule, oldAtRootExcludingStyleRule; + var $async$visitStyleRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate$_declarationName != null) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Style_n, node.span)); + else if ($async$self._async_evaluate$_inKeyframes && $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent") instanceof A.ModifiableCssKeyframeBlock) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Style_k, node.span)); + t1 = node.selector; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_performInterpolationWithMap$2$warnForColor(t1, true), $async$visitStyleRule$1); + case 3: + // returning from await. + _0_0 = $async$result; + selectorText = _0_0._0; + selectorMap = _0_0._1; + $async$goto = $async$self._async_evaluate$_inKeyframes ? 4 : 5; + break; + case 4: + // then + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate$_withParent$2$4$scopeWhen$through(A.ModifiableCssKeyframeBlock$(new A.CssValue(A.List_List$unmodifiable(new A.KeyframeSelectorParser(A.SpanScanner$(selectorText, null), selectorMap).parse$0(0), type$.String), t1.span, type$.CssValue_List_String), node.span), new A._EvaluateVisitor_visitStyleRule_closure3($async$self, node), node.hasDeclarations, new A._EvaluateVisitor_visitStyleRule_closure4(), type$.ModifiableCssKeyframeBlock, type$.Null), $async$visitStyleRule$1); + case 6: + // returning from await. + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 5: + // join + parsedSelector = A.SelectorList_SelectorList$parse(selectorText, true, selectorMap, $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__stylesheet, "_stylesheet").plainCss); + t1 = $async$self._async_evaluate$_atRootExcludingStyleRule ? null : $async$self._async_evaluate$_styleRuleIgnoringAtRoot; + t1 = t1 == null ? null : t1.fromPlainCss; + nest = t1 !== true; + if (nest) { + if ($async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__stylesheet, "_stylesheet").plainCss) + for (t1 = parsedSelector.components, t2 = t1.length, _i = 0; _i < t2; ++_i) { + _1_0 = t1[_i].leadingCombinators; + if (_1_0.length >= 1) { + first = _1_0[0]; + t3 = $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__stylesheet, "_stylesheet").plainCss; + } else { + first = null; + t3 = false; + } + if (t3) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Top_lel, first.span)); + } + t1 = $async$self._async_evaluate$_styleRuleIgnoringAtRoot; + t1 = t1 == null ? null : t1.originalSelector; + parsedSelector = parsedSelector.nestWithin$3$implicitParent$preserveParentSelectors(t1, !$async$self._async_evaluate$_atRootExcludingStyleRule, $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__stylesheet, "_stylesheet").plainCss); + } + rule = A.ModifiableCssStyleRule$($async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__extensionStore, "_extensionStore").addSelector$2(parsedSelector, $async$self._async_evaluate$_mediaQueries), node.span, $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__stylesheet, "_stylesheet").plainCss, parsedSelector); + oldAtRootExcludingStyleRule = $async$self._async_evaluate$_atRootExcludingStyleRule; + t1 = $async$self._async_evaluate$_atRootExcludingStyleRule = false; + t2 = nest ? new A._EvaluateVisitor_visitStyleRule_closure5() : null; + $async$goto = 7; + return A._asyncAwait($async$self._async_evaluate$_withParent$2$4$scopeWhen$through(rule, new A._EvaluateVisitor_visitStyleRule_closure6($async$self, rule, node), node.hasDeclarations, t2, type$.ModifiableCssStyleRule, type$.Null), $async$visitStyleRule$1); + case 7: + // returning from await. + $async$self._async_evaluate$_atRootExcludingStyleRule = oldAtRootExcludingStyleRule; + $async$self._async_evaluate$_warnForBogusCombinators$1(rule); + if (($async$self._async_evaluate$_atRootExcludingStyleRule ? null : $async$self._async_evaluate$_styleRuleIgnoringAtRoot) == null) { + t1 = $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent").children; + t1 = !t1.get$isEmpty(t1); + } + if (t1) { + t1 = $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent").children; + t1.get$last(t1).isGroupEnd = true; + } + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitStyleRule$1, $async$completer); + }, + _async_evaluate$_warnForBogusCombinators$1(rule) { + var t1, t2, t3, t4, t5, _i, complex, visitor, t6, t7, t8, t9, _this = this, _null = null; + if (!rule.accept$1(B._IsInvisibleVisitor_false_false)) + for (t1 = rule._style_rule$_selector._box$_inner.value.components, t2 = t1.length, t3 = type$.SourceSpan, t4 = type$.String, t5 = rule.children, _i = 0; _i < t2; ++_i) { + complex = t1[_i]; + if (!complex.accept$1(B._IsBogusVisitor_true)) + continue; + if (complex.accept$1(B.C__IsUselessVisitor)) { + visitor = A._SerializeVisitor$(_null, true, _null, _null, true, false, _null, true); + complex.accept$1(visitor); + _this._async_evaluate$_warn$3('The selector "' + B.JSString_methods.trim$0(visitor._serialize$_buffer.toString$0(0)) + string$.x22x20is_ix20, A.SpanExtensions_trimRight(complex.span), B.Deprecation_9hF); + } else if (complex.leadingCombinators.length !== 0) { + if (!_this._async_evaluate$_assertInModule$2(_this._async_evaluate$__stylesheet, "_stylesheet").plainCss) { + visitor = A._SerializeVisitor$(_null, true, _null, _null, true, false, _null, true); + complex.accept$1(visitor); + _this._async_evaluate$_warn$3('The selector "' + B.JSString_methods.trim$0(visitor._serialize$_buffer.toString$0(0)) + string$.x22x20is_ix0a, A.SpanExtensions_trimRight(complex.span), B.Deprecation_9hF); + } + } else { + visitor = A._SerializeVisitor$(_null, true, _null, _null, true, false, _null, true); + complex.accept$1(visitor); + t6 = B.JSString_methods.trim$0(visitor._serialize$_buffer.toString$0(0)); + t7 = complex.accept$1(B._IsBogusVisitor_false) ? string$.x20It_wi : ""; + t8 = A.SpanExtensions_trimRight(complex.span); + if (t5.get$length(0) === 0) + A.throwExpression(A.IterableElementError_noElement()); + t9 = J.get$span$z(t5.$index(0, 0)); + _this._async_evaluate$_warn$3('The selector "' + t6 + string$.x22x20is_o + t7 + string$.x0aThis_, new A.MultiSpan(t8, "invalid selector", A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_literal([t9, "this is not a style rule" + (t5.every$1(t5, new A._EvaluateVisitor__warnForBogusCombinators_closure0()) ? "\n(try converting to a //-style comment)" : "")], t3, t4), t3, t4)), B.Deprecation_9hF); + } + } + }, + visitSupportsRule$1(_, node) { + return this.visitSupportsRule$body$_EvaluateVisitor(0, node); + }, + visitSupportsRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, t1, $async$temp1, $async$temp2; + var $async$visitSupportsRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate$_declarationName != null) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Suppor, node.span)); + t1 = node.condition; + $async$temp1 = A; + $async$temp2 = A; + $async$goto = 4; + return A._asyncAwait($async$self._async_evaluate$_visitSupportsCondition$1(t1), $async$visitSupportsRule$1); + case 4: + // returning from await. + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_withParent$2$4$scopeWhen$through($async$temp1.ModifiableCssSupportsRule$(new $async$temp2.CssValue($async$result, t1.get$span(t1), type$.CssValue_String), node.span), new A._EvaluateVisitor_visitSupportsRule_closure1($async$self, node), node.hasDeclarations, new A._EvaluateVisitor_visitSupportsRule_closure2(), type$.ModifiableCssSupportsRule, type$.Null), $async$visitSupportsRule$1); + case 3: + // returning from await. + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitSupportsRule$1, $async$completer); + }, + _async_evaluate$_visitSupportsCondition$1(condition) { + return this._visitSupportsCondition$body$_EvaluateVisitor(condition); + }, + _visitSupportsCondition$body$_EvaluateVisitor(condition) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.String), + $async$returnValue, $async$self = this, t1, $async$temp1, $async$temp2; + var $async$_async_evaluate$_visitSupportsCondition$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = condition instanceof A.SupportsOperation ? 4 : 5; + break; + case 4: + // then + t1 = condition.operator; + $async$temp1 = A; + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate$_parenthesize$2(condition.left, t1), $async$_async_evaluate$_visitSupportsCondition$1); + case 6: + // returning from await. + $async$temp1 = $async$temp1.S($async$result) + " " + t1 + " "; + $async$temp2 = A; + $async$goto = 7; + return A._asyncAwait($async$self._async_evaluate$_parenthesize$2(condition.right, t1), $async$_async_evaluate$_visitSupportsCondition$1); + case 7: + // returning from await. + t1 = $async$temp1 + $async$temp2.S($async$result); + // goto break $label0$0 + $async$goto = 3; + break; + case 5: + // join + $async$goto = condition instanceof A.SupportsNegation ? 8 : 9; + break; + case 8: + // then + $async$temp1 = A; + $async$goto = 10; + return A._asyncAwait($async$self._async_evaluate$_parenthesize$1(condition.condition), $async$_async_evaluate$_visitSupportsCondition$1); + case 10: + // returning from await. + t1 = "not " + $async$temp1.S($async$result); + // goto break $label0$0 + $async$goto = 3; + break; + case 9: + // join + $async$goto = condition instanceof A.SupportsInterpolation ? 11 : 12; + break; + case 11: + // then + $async$goto = 13; + return A._asyncAwait($async$self._evaluateToCss$2$quote(condition.expression, false), $async$_async_evaluate$_visitSupportsCondition$1); + case 13: + // returning from await. + t1 = $async$result; + // goto break $label0$0 + $async$goto = 3; + break; + case 12: + // join + t1 = {}; + t1.declaration = null; + $async$goto = condition instanceof A.SupportsDeclaration ? 14 : 15; + break; + case 14: + // then + t1.declaration = condition; + $async$goto = 16; + return A._asyncAwait($async$self._async_evaluate$_withSupportsDeclaration$1$1(new A._EvaluateVisitor__visitSupportsCondition_closure0(t1, $async$self), type$.String), $async$_async_evaluate$_visitSupportsCondition$1); + case 16: + // returning from await. + t1 = $async$result; + // goto break $label0$0 + $async$goto = 3; + break; + case 15: + // join + $async$goto = condition instanceof A.SupportsFunction ? 17 : 18; + break; + case 17: + // then + $async$temp1 = A; + $async$goto = 19; + return A._asyncAwait($async$self._async_evaluate$_performInterpolation$1(condition.name), $async$_async_evaluate$_visitSupportsCondition$1); + case 19: + // returning from await. + $async$temp1 = $async$temp1.S($async$result) + "("; + $async$temp2 = A; + $async$goto = 20; + return A._asyncAwait($async$self._async_evaluate$_performInterpolation$1(condition.$arguments), $async$_async_evaluate$_visitSupportsCondition$1); + case 20: + // returning from await. + t1 = $async$temp1 + $async$temp2.S($async$result) + ")"; + // goto break $label0$0 + $async$goto = 3; + break; + case 18: + // join + $async$goto = condition instanceof A.SupportsAnything ? 21 : 22; + break; + case 21: + // then + $async$temp1 = A; + $async$goto = 23; + return A._asyncAwait($async$self._async_evaluate$_performInterpolation$1(condition.contents), $async$_async_evaluate$_visitSupportsCondition$1); + case 23: + // returning from await. + t1 = "(" + $async$temp1.S($async$result) + ")"; + // goto break $label0$0 + $async$goto = 3; + break; + case 22: + // join + t1 = A.throwExpression(A.ArgumentError$("Unknown supports condition type " + A.getRuntimeTypeOfDartObject(condition).toString$0(0) + ".", null)); + case 3: + // break $label0$0 + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_visitSupportsCondition$1, $async$completer); + }, + _async_evaluate$_withSupportsDeclaration$1$1(callback, $T) { + return this._withSupportsDeclaration$body$_EvaluateVisitor(callback, $T, $T); + }, + _withSupportsDeclaration$body$_EvaluateVisitor(callback, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$next = [], $async$self = this, t1, oldInSupportsDeclaration; + var $async$_async_evaluate$_withSupportsDeclaration$1$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + oldInSupportsDeclaration = $async$self._async_evaluate$_inSupportsDeclaration; + $async$self._async_evaluate$_inSupportsDeclaration = true; + $async$handler = 3; + t1 = callback.call$0(); + $async$goto = 6; + return A._asyncAwait($T._eval$1("Future<0>")._is(t1) ? t1 : A._Future$value(t1, $T), $async$_async_evaluate$_withSupportsDeclaration$1$1); + case 6: + // returning from await. + t1 = $async$result; + $async$returnValue = t1; + $async$next = [1]; + // goto finally + $async$goto = 4; + break; + $async$next.push(5); + // goto finally + $async$goto = 4; + break; + case 3: + // uncaught + $async$next = [2]; + case 4: + // finally + $async$handler = 2; + $async$self._async_evaluate$_inSupportsDeclaration = oldInSupportsDeclaration; + // goto the next finally handler + $async$goto = $async$next.pop(); + break; + case 5: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_withSupportsDeclaration$1$1, $async$completer); + }, + _async_evaluate$_parenthesize$2(condition, operator) { + return this._parenthesize$body$_EvaluateVisitor(condition, operator); + }, + _async_evaluate$_parenthesize$1(condition) { + return this._async_evaluate$_parenthesize$2(condition, null); + }, + _parenthesize$body$_EvaluateVisitor(condition, operator) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.String), + $async$returnValue, $async$self = this, t1, $async$temp1; + var $async$_async_evaluate$_parenthesize$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if (!(condition instanceof A.SupportsNegation)) + if (condition instanceof A.SupportsOperation) + t1 = operator == null || operator !== condition.operator; + else + t1 = false; + else + t1 = true; + $async$goto = t1 ? 3 : 4; + break; + case 3: + // then + $async$temp1 = A; + $async$goto = 5; + return A._asyncAwait($async$self._async_evaluate$_visitSupportsCondition$1(condition), $async$_async_evaluate$_parenthesize$2); + case 5: + // returning from await. + $async$returnValue = "(" + $async$temp1.S($async$result) + ")"; + // goto return + $async$goto = 1; + break; + case 4: + // join + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate$_visitSupportsCondition$1(condition), $async$_async_evaluate$_parenthesize$2); + case 6: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_parenthesize$2, $async$completer); + }, + visitVariableDeclaration$1(_, node) { + return this.visitVariableDeclaration$body$_EvaluateVisitor(0, node); + }, + visitVariableDeclaration$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, t1, _0_0, t2, value, $async$temp1, $async$temp2, $async$temp3; + var $async$visitVariableDeclaration$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if (node.isGuarded) { + if (node.namespace == null && $async$self._async_evaluate$_environment._async_environment$_variables.length === 1) { + t1 = $async$self._async_evaluate$_configuration._configuration$_values; + _0_0 = t1.get$isEmpty(t1) ? null : t1.remove$1(0, node.name); + t1 = {}; + t1.override = null; + if (_0_0 != null) { + t1.override = _0_0; + t2 = !_0_0.value.$eq(0, B.C__SassNull); + } else + t2 = false; + if (t2) { + $async$self._async_evaluate$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitVariableDeclaration_closure2(t1, $async$self, node)); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + } + value = $async$self._async_evaluate$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitVariableDeclaration_closure3($async$self, node)); + if (value != null && !value.$eq(0, B.C__SassNull)) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + } + if (node.isGlobal && !$async$self._async_evaluate$_environment.globalVariableExists$1(node.name)) { + t1 = $async$self._async_evaluate$_environment._async_environment$_variables.length === 1 ? string$.As_of_S : string$.As_of_R + A.declarationName(node.span) + ": null` at the stylesheet root."; + $async$self._async_evaluate$_warn$3(t1, node.span, B.Deprecation_Rg0); + } + t1 = node.expression; + t2 = t1.accept$1($async$self); + $async$temp1 = node; + $async$temp2 = A; + $async$temp3 = node; + $async$goto = 3; + return A._asyncAwait(type$.Future_Value._is(t2) ? t2 : A._Future$value(t2, type$.Value), $async$visitVariableDeclaration$1); + case 3: + // returning from await. + $async$self._async_evaluate$_addExceptionSpan$2($async$temp1, new $async$temp2._EvaluateVisitor_visitVariableDeclaration_closure4($async$self, $async$temp3, $async$self._async_evaluate$_withoutSlash$2($async$result, t1))); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitVariableDeclaration$1, $async$completer); + }, + visitUseRule$1(_, node) { + return this.visitUseRule$body$_EvaluateVisitor(0, node); + }, + visitUseRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, values, t3, t4, _i, variable, t5, variableNodeWithSpan, t6, configuration, t1, t2, $async$temp1, $async$temp2, $async$temp3; + var $async$visitUseRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = node.configuration; + t2 = t1.length; + $async$goto = t2 !== 0 ? 3 : 5; + break; + case 3: + // then + values = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.ConfiguredValue); + t3 = type$._Future_Value, t4 = type$.Future_Value, _i = 0; + case 6: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 8; + break; + } + variable = t1[_i]; + t5 = variable.expression; + variableNodeWithSpan = $async$self._async_evaluate$_expressionNode$1(t5); + t5 = t5.accept$1($async$self); + if (!t4._is(t5)) { + t6 = new A._Future($.Zone__current, t3); + t6._state = 8; + t6._resultOrListeners = t5; + t5 = t6; + } + $async$temp1 = values; + $async$temp2 = variable.name; + $async$temp3 = A; + $async$goto = 9; + return A._asyncAwait(t5, $async$visitUseRule$1); + case 9: + // returning from await. + $async$temp1.$indexSet(0, $async$temp2, new $async$temp3.ConfiguredValue($async$self._async_evaluate$_withoutSlash$2($async$result, variableNodeWithSpan), variable.span, variableNodeWithSpan)); + case 7: + // for update + ++_i; + // goto for condition + $async$goto = 6; + break; + case 8: + // after for + configuration = new A.ExplicitConfiguration(node, values, null); + // goto join + $async$goto = 4; + break; + case 5: + // else + configuration = B.Configuration_Map_empty_null; + case 4: + // join + $async$goto = 10; + return A._asyncAwait($async$self._async_evaluate$_loadModule$5$configuration(node.url, "@use", node, new A._EvaluateVisitor_visitUseRule_closure0($async$self, node), configuration), $async$visitUseRule$1); + case 10: + // returning from await. + $async$self._async_evaluate$_assertConfigurationIsEmpty$1(configuration); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitUseRule$1, $async$completer); + }, + visitWarnRule$1(_, node) { + return this.visitWarnRule$body$_EvaluateVisitor(0, node); + }, + visitWarnRule$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, value, t1, t2; + var $async$visitWarnRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._addExceptionSpanAsync$1$2(node, new A._EvaluateVisitor_visitWarnRule_closure0($async$self, node), type$.Value), $async$visitWarnRule$1); + case 3: + // returning from await. + value = $async$result; + t1 = value instanceof A.SassString ? value._string$_text : $async$self._async_evaluate$_serialize$2(value, node.expression); + t2 = $async$self._async_evaluate$_stackTrace$1(node.span); + $async$self._async_evaluate$_logger.internalWarn$4$deprecation$span$trace(t1, null, null, t2); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitWarnRule$1, $async$completer); + }, + visitWhileRule$1(_, node) { + return this._async_evaluate$_environment.scope$1$3$semiGlobal$when(new A._EvaluateVisitor_visitWhileRule_closure0(this, node), true, node.hasDeclarations, type$.nullable_Value); + }, + visitBinaryOperationExpression$1(_, node) { + var t1, _this = this; + if (_this._async_evaluate$_assertInModule$2(_this._async_evaluate$__stylesheet, "_stylesheet").plainCss) { + t1 = node.operator; + t1 = t1 !== B.BinaryOperator_Kyq && t1 !== B.BinaryOperator_Mh5; + } else + t1 = false; + if (t1) + throw A.wrapException(_this._async_evaluate$_exception$2("Operators aren't allowed in plain CSS.", node.get$operatorSpan())); + return _this._addExceptionSpanAsync$1$2(node, new A._EvaluateVisitor_visitBinaryOperationExpression_closure0(_this, node), type$.Value); + }, + _async_evaluate$_slash$3(left, right, node) { + var t2, _1_1, + result = left.dividedBy$1(right), + _1_2_isSet = left instanceof A.SassNumber, + _1_2 = null, right0 = null, + t1 = false; + if (_1_2_isSet) { + t2 = type$.SassNumber; + t2._as(left); + if (right instanceof A.SassNumber) { + t2._as(right); + t1 = node.allowsSlash && this._async_evaluate$_operandAllowsSlash$1(node.left) && this._async_evaluate$_operandAllowsSlash$1(node.right); + right0 = right; + _1_2 = right0; + } else + _1_2 = right; + _1_1 = left; + } else { + _1_1 = left; + left = null; + } + if (t1) + return type$.SassNumber._as(result).withSlash$2(left, right0); + if (_1_1 instanceof A.SassNumber) + t1 = (_1_2_isSet ? _1_2 : right) instanceof A.SassNumber; + else + t1 = false; + if (t1) { + this._async_evaluate$_warn$3(string$.Using__o + A.S(new A._EvaluateVisitor__slash_recommendation0().call$1(node)) + " or " + A.expressionToCalc(node).toString$0(0) + string$.x0a_Morex20, node.get$span(0), B.Deprecation_BvP); + return result; + } + return result; + }, + _async_evaluate$_operandAllowsSlash$1(node) { + var t1; + if (node instanceof A.FunctionExpression) + if (node.namespace == null) { + t1 = node.name; + t1 = B.Set_Pr3yj.contains$1(0, t1.toLowerCase()) && this._async_evaluate$_environment.getFunction$1(t1) == null; + } else + t1 = false; + else + t1 = true; + return t1; + }, + visitValueExpression$1(_, node) { + return this.visitValueExpression$body$_EvaluateVisitor(0, node); + }, + visitValueExpression$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue; + var $async$visitValueExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$returnValue = node.value; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitValueExpression$1, $async$completer); + }, + visitVariableExpression$1(_, node) { + return this.visitVariableExpression$body$_EvaluateVisitor(0, node); + }, + visitVariableExpression$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue, $async$self = this, result; + var $async$visitVariableExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + result = $async$self._async_evaluate$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitVariableExpression_closure0($async$self, node)); + if (result != null) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + throw A.wrapException($async$self._async_evaluate$_exception$2("Undefined variable.", node.span)); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitVariableExpression$1, $async$completer); + }, + visitUnaryOperationExpression$1(_, node) { + return this.visitUnaryOperationExpression$body$_EvaluateVisitor(0, node); + }, + visitUnaryOperationExpression$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue, $async$self = this, $async$temp1, $async$temp2, $async$temp3; + var $async$visitUnaryOperationExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$temp1 = node; + $async$temp2 = A; + $async$temp3 = node; + $async$goto = 3; + return A._asyncAwait(node.operand.accept$1($async$self), $async$visitUnaryOperationExpression$1); + case 3: + // returning from await. + $async$returnValue = $async$self._async_evaluate$_addExceptionSpan$2($async$temp1, new $async$temp2._EvaluateVisitor_visitUnaryOperationExpression_closure0($async$temp3, $async$result)); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitUnaryOperationExpression$1, $async$completer); + }, + visitBooleanExpression$1(_, node) { + return this.visitBooleanExpression$body$_EvaluateVisitor(0, node); + }, + visitBooleanExpression$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassBoolean), + $async$returnValue; + var $async$visitBooleanExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$returnValue = node.value ? B.SassBoolean_true : B.SassBoolean_false; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitBooleanExpression$1, $async$completer); + }, + visitIfExpression$1(_, node) { + return this.visitIfExpression$body$_EvaluateVisitor(0, node); + }, + visitIfExpression$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue, $async$self = this, condition, t1, ifTrue, ifFalse, result, _0_0, positional, named; + var $async$visitIfExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_evaluateMacroArguments$1(node), $async$visitIfExpression$1); + case 3: + // returning from await. + _0_0 = $async$result; + positional = _0_0._0; + named = _0_0._1; + $async$self._async_evaluate$_verifyArguments$4(J.get$length$asx(positional), named, $.$get$IfExpression_declaration(), node); + condition = A.ListExtensions_elementAtOrNull(positional, 0); + if (condition == null) { + t1 = named.$index(0, "condition"); + t1.toString; + condition = t1; + } + ifTrue = A.ListExtensions_elementAtOrNull(positional, 1); + if (ifTrue == null) { + t1 = named.$index(0, "if-true"); + t1.toString; + ifTrue = t1; + } + ifFalse = A.ListExtensions_elementAtOrNull(positional, 2); + if (ifFalse == null) { + t1 = named.$index(0, "if-false"); + t1.toString; + ifFalse = t1; + } + $async$goto = 4; + return A._asyncAwait(condition.accept$1($async$self), $async$visitIfExpression$1); + case 4: + // returning from await. + result = $async$result.get$isTruthy() ? ifTrue : ifFalse; + t1 = result.accept$1($async$self); + $async$goto = 5; + return A._asyncAwait(type$.Future_Value._is(t1) ? t1 : A._Future$value(t1, type$.Value), $async$visitIfExpression$1); + case 5: + // returning from await. + $async$returnValue = $async$self._async_evaluate$_withoutSlash$2($async$result, $async$self._async_evaluate$_expressionNode$1(result)); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitIfExpression$1, $async$completer); + }, + visitNullExpression$1(_, node) { + return this.visitNullExpression$body$_EvaluateVisitor(0, node); + }, + visitNullExpression$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue; + var $async$visitNullExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$returnValue = B.C__SassNull; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitNullExpression$1, $async$completer); + }, + visitNumberExpression$1(_, node) { + return this.visitNumberExpression$body$_EvaluateVisitor(0, node); + }, + visitNumberExpression$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassNumber), + $async$returnValue; + var $async$visitNumberExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$returnValue = A.SassNumber_SassNumber(node.value, node.unit); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitNumberExpression$1, $async$completer); + }, + visitParenthesizedExpression$1(_, node) { + var _this = this; + return _this._async_evaluate$_assertInModule$2(_this._async_evaluate$__stylesheet, "_stylesheet").plainCss ? A.throwExpression(_this._async_evaluate$_exception$2("Parentheses aren't allowed in plain CSS.", node.span)) : node.expression.accept$1(_this); + }, + visitColorExpression$1(_, node) { + return this.visitColorExpression$body$_EvaluateVisitor(0, node); + }, + visitColorExpression$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassColor), + $async$returnValue; + var $async$visitColorExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$returnValue = node.value; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitColorExpression$1, $async$completer); + }, + visitListExpression$1(_, node) { + return this.visitListExpression$body$_EvaluateVisitor(0, node); + }, + visitListExpression$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassList), + $async$returnValue, $async$self = this, $async$temp1; + var $async$visitListExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$temp1 = A; + $async$goto = 3; + return A._asyncAwait(A.mapAsync(node.contents, new A._EvaluateVisitor_visitListExpression_closure0($async$self), type$.Expression, type$.Value), $async$visitListExpression$1); + case 3: + // returning from await. + $async$returnValue = $async$temp1.SassList$($async$result, node.separator, node.hasBrackets); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitListExpression$1, $async$completer); + }, + visitMapExpression$1(_, node) { + return this.visitMapExpression$body$_EvaluateVisitor(0, node); + }, + visitMapExpression$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassMap), + $async$returnValue, $async$self = this, t2, t3, _i, t4, key, keyValue, valueValue, oldValueSpan, t1, map, keyNodes; + var $async$visitMapExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = type$.Value; + map = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + keyNodes = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.AstNode); + t2 = node.pairs, t3 = t2.length, _i = 0; + case 3: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 5; + break; + } + t4 = t2[_i]; + key = t4._0; + $async$goto = 6; + return A._asyncAwait(key.accept$1($async$self), $async$visitMapExpression$1); + case 6: + // returning from await. + keyValue = $async$result; + $async$goto = 7; + return A._asyncAwait(t4._1.accept$1($async$self), $async$visitMapExpression$1); + case 7: + // returning from await. + valueValue = $async$result; + if (map.containsKey$1(keyValue)) { + t1 = keyNodes.$index(0, keyValue); + oldValueSpan = t1 == null ? null : t1.get$span(t1); + t1 = key.get$span(key); + t2 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + if (oldValueSpan != null) + t2.$indexSet(0, oldValueSpan, "first key"); + throw A.wrapException(A.MultiSpanSassRuntimeException$("Duplicate key.", t1, "second key", t2, $async$self._async_evaluate$_stackTrace$1(key.get$span(key)), null)); + } + map.$indexSet(0, keyValue, valueValue); + keyNodes.$indexSet(0, keyValue, key); + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $async$returnValue = new A.SassMap(A.ConstantMap_ConstantMap$from(map, t1, t1)); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitMapExpression$1, $async$completer); + }, + visitFunctionExpression$1(_, node) { + return this.visitFunctionExpression$body$_EvaluateVisitor(0, node); + }, + visitFunctionExpression$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue, $async$self = this, t2, _0_0, t3, t4, $name, oldInFunction, result, t1, $function; + var $async$visitFunctionExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = {}; + $function = $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__stylesheet, "_stylesheet").plainCss ? null : $async$self._async_evaluate$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitFunctionExpression_closure2($async$self, node)); + t1.$function = $function; + $async$goto = $function == null ? 3 : 5; + break; + case 3: + // then + if (node.namespace != null) + throw A.wrapException($async$self._async_evaluate$_exception$2("Undefined function.", node.span)); + t2 = node.name; + _0_0 = t2.toLowerCase(); + t3 = false; + if ("min" === _0_0 || "max" === _0_0 || "round" === _0_0 || "abs" === _0_0) { + t3 = node.$arguments; + t4 = t3.named; + t3 = t4.get$isEmpty(t4) && t3.rest == null && B.JSArray_methods.every$1(t3.positional, new A._EvaluateVisitor_visitFunctionExpression_closure3()); + $name = _0_0; + } else + $name = null; + $async$goto = t3 ? 6 : 7; + break; + case 6: + // then + $async$goto = 8; + return A._asyncAwait($async$self._async_evaluate$_visitCalculation$2$inLegacySassFunction(node, $name), $async$visitFunctionExpression$1); + case 8: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + case 7: + // join + $async$goto = "calc" === _0_0 || "clamp" === _0_0 || "hypot" === _0_0 || "sin" === _0_0 || "cos" === _0_0 || "tan" === _0_0 || "asin" === _0_0 || "acos" === _0_0 || "atan" === _0_0 || "sqrt" === _0_0 || "exp" === _0_0 || "sign" === _0_0 || "mod" === _0_0 || "rem" === _0_0 || "atan2" === _0_0 || "pow" === _0_0 || "log" === _0_0 || "calc-size" === _0_0 ? 9 : 10; + break; + case 9: + // then + $async$goto = 11; + return A._asyncAwait($async$self._async_evaluate$_visitCalculation$1(node), $async$visitFunctionExpression$1); + case 11: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + case 10: + // join + $function = $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__stylesheet, "_stylesheet").plainCss ? null : $async$self._async_evaluate$_builtInFunctions.$index(0, t2); + t2 = t1.$function = $function == null ? new A.PlainCssCallable(node.originalName) : $function; + // goto join + $async$goto = 4; + break; + case 5: + // else + t2 = $function; + case 4: + // join + if (B.JSString_methods.startsWith$1(node.originalName, "--") && t2 instanceof A.UserDefinedCallable && !B.JSString_methods.startsWith$1(t2.declaration.originalName, "--")) + $async$self._async_evaluate$_warn$3(string$.Sassx20_f_, node.get$nameSpan(), B.Deprecation_Kg6); + oldInFunction = $async$self._async_evaluate$_inFunction; + $async$self._async_evaluate$_inFunction = true; + $async$goto = 12; + return A._asyncAwait($async$self._async_evaluate$_addErrorSpan$1$2(node, new A._EvaluateVisitor_visitFunctionExpression_closure4(t1, $async$self, node), type$.Value), $async$visitFunctionExpression$1); + case 12: + // returning from await. + result = $async$result; + $async$self._async_evaluate$_inFunction = oldInFunction; + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitFunctionExpression$1, $async$completer); + }, + _async_evaluate$_visitCalculation$2$inLegacySassFunction(node, inLegacySassFunction) { + return this._visitCalculation$body$_EvaluateVisitor(node, inLegacySassFunction); + }, + _async_evaluate$_visitCalculation$1(node) { + return this._async_evaluate$_visitCalculation$2$inLegacySassFunction(node, null); + }, + _visitCalculation$body$_EvaluateVisitor(node, inLegacySassFunction) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue, $async$next = [], $async$self = this, $arguments, oldCallableNode, t1, _0_0, error, stackTrace, t4, _i, exception, t2, t3, $async$temp1; + var $async$_async_evaluate$_visitCalculation$2$inLegacySassFunction = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t2 = node.$arguments; + t3 = t2.named; + if (t3.get$isNotEmpty(t3)) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Keywor, node.span)); + else if (t2.rest != null) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Rest_a, node.span)); + $async$self._async_evaluate$_checkCalculationArguments$1(node); + t3 = A._setArrayType([], type$.JSArray_Object); + t2 = t2.positional, t4 = t2.length, _i = 0; + case 3: + // for condition + if (!(_i < t4)) { + // goto after for + $async$goto = 5; + break; + } + $async$temp1 = t3; + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate$_visitCalculationExpression$2$inLegacySassFunction(t2[_i], inLegacySassFunction), $async$_async_evaluate$_visitCalculation$2$inLegacySassFunction); + case 6: + // returning from await. + $async$temp1.push($async$result); + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $arguments = t3; + if ($async$self._async_evaluate$_inSupportsDeclaration) { + $async$returnValue = new A.SassCalculation(node.name, A.List_List$unmodifiable($arguments, type$.Object)); + // goto return + $async$goto = 1; + break; + } + oldCallableNode = $async$self._async_evaluate$_callableNode; + $async$self._async_evaluate$_callableNode = node; + try { + t1 = null; + t3 = node.name; + _0_0 = t3.toLowerCase(); + $label0$0: { + if ("calc" === _0_0) { + t1 = A.SassCalculation_calc(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("sqrt" === _0_0) { + t1 = A.SassCalculation__singleArgument("sqrt", J.$index$asx($arguments, 0), A.number0__sqrt$closure(), true); + break $label0$0; + } + if ("sin" === _0_0) { + t1 = A.SassCalculation__singleArgument("sin", J.$index$asx($arguments, 0), A.number0__sin$closure(), false); + break $label0$0; + } + if ("cos" === _0_0) { + t1 = A.SassCalculation__singleArgument("cos", J.$index$asx($arguments, 0), A.number0__cos$closure(), false); + break $label0$0; + } + if ("tan" === _0_0) { + t1 = A.SassCalculation__singleArgument("tan", J.$index$asx($arguments, 0), A.number0__tan$closure(), false); + break $label0$0; + } + if ("asin" === _0_0) { + t1 = A.SassCalculation__singleArgument("asin", J.$index$asx($arguments, 0), A.number0__asin$closure(), true); + break $label0$0; + } + if ("acos" === _0_0) { + t1 = A.SassCalculation__singleArgument("acos", J.$index$asx($arguments, 0), A.number0__acos$closure(), true); + break $label0$0; + } + if ("atan" === _0_0) { + t1 = A.SassCalculation__singleArgument("atan", J.$index$asx($arguments, 0), A.number0__atan$closure(), true); + break $label0$0; + } + if ("abs" === _0_0) { + t1 = A.SassCalculation_abs(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("exp" === _0_0) { + t1 = A.SassCalculation_exp(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("sign" === _0_0) { + t1 = A.SassCalculation_sign(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("min" === _0_0) { + t1 = A.SassCalculation_min($arguments); + break $label0$0; + } + if ("max" === _0_0) { + t1 = A.SassCalculation_max($arguments); + break $label0$0; + } + if ("hypot" === _0_0) { + t1 = A.SassCalculation_hypot($arguments); + break $label0$0; + } + if ("pow" === _0_0) { + t1 = A.SassCalculation_pow(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("atan2" === _0_0) { + t1 = A.SassCalculation_atan2(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("log" === _0_0) { + t1 = A.SassCalculation_log(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("mod" === _0_0) { + t1 = A.SassCalculation_mod(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("rem" === _0_0) { + t1 = A.SassCalculation_rem(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("round" === _0_0) { + t1 = A.SassCalculation_roundInternal(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1), A.ListExtensions_elementAtOrNull($arguments, 2), inLegacySassFunction, node.span, new A._EvaluateVisitor__visitCalculation_closure0($async$self, node)); + break $label0$0; + } + if ("clamp" === _0_0) { + t1 = A.SassCalculation_clamp(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1), A.ListExtensions_elementAtOrNull($arguments, 2)); + break $label0$0; + } + if ("calc-size" === _0_0) { + t1 = A.SassCalculation_calcSize(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + t3 = A.UnsupportedError$('Unknown calculation name "' + t3 + '".'); + t1 = A.throwExpression(t3); + } + t1 = t1; + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassScriptException) { + error = t1; + stackTrace = A.getTraceFromException(exception); + if (B.JSString_methods.contains$1(error.message, "compatible")) + $async$self._async_evaluate$_verifyCompatibleNumbers$2($arguments, t2); + A.throwWithTrace($async$self._async_evaluate$_exception$2(error.message, node.span), error, stackTrace); + } else + throw exception; + } finally { + $async$self._async_evaluate$_callableNode = oldCallableNode; + } + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_visitCalculation$2$inLegacySassFunction, $async$completer); + }, + _async_evaluate$_checkCalculationArguments$1(node) { + var t1, _0_0, + check = new A._EvaluateVisitor__checkCalculationArguments_check0(this, node); + $label0$0: { + t1 = node.name; + _0_0 = t1.toLowerCase(); + if ("calc" === _0_0 || "sqrt" === _0_0 || "sin" === _0_0 || "cos" === _0_0 || "tan" === _0_0 || "asin" === _0_0 || "acos" === _0_0 || "atan" === _0_0 || "abs" === _0_0 || "exp" === _0_0 || "sign" === _0_0) { + check.call$1(1); + break $label0$0; + } + if ("min" === _0_0 || "max" === _0_0 || "hypot" === _0_0) { + check.call$0(); + break $label0$0; + } + if ("pow" === _0_0 || "atan2" === _0_0 || "log" === _0_0 || "mod" === _0_0 || "rem" === _0_0 || "calc-size" === _0_0) { + check.call$1(2); + break $label0$0; + } + if ("round" === _0_0 || "clamp" === _0_0) { + check.call$1(3); + break $label0$0; + } + throw A.wrapException(A.UnsupportedError$('Unknown calculation name "' + t1 + '".')); + } + }, + _async_evaluate$_verifyCompatibleNumbers$2(args, nodesWithSpans) { + var i, t1, _0_0, arg, t2, number1, j, number2, t3, t4, t5, t6; + for (i = 0; t1 = args.length, i < t1; ++i) { + _0_0 = args[i]; + if (_0_0 instanceof A.SassNumber) { + t1 = _0_0.get$hasComplexUnits(); + arg = _0_0; + } else { + arg = null; + t1 = false; + } + if (t1) { + t1 = A.S(arg); + t2 = nodesWithSpans[i]; + throw A.wrapException(this._async_evaluate$_exception$2("Number " + t1 + " isn't compatible with CSS calculations.", t2.get$span(t2))); + } + } + for (i = 0; i < t1 - 1; ++i) { + number1 = args[i]; + if (!(number1 instanceof A.SassNumber)) + continue; + for (j = i + 1; t1 = args.length, j < t1; ++j) { + number2 = args[j]; + if (!(number2 instanceof A.SassNumber)) + continue; + if (number1.hasPossiblyCompatibleUnits$1(number2)) + continue; + t1 = number1.toString$0(0); + t2 = number2.toString$0(0); + t3 = nodesWithSpans[i]; + t3 = t3.get$span(t3); + t4 = number1.toString$0(0); + t5 = nodesWithSpans[j]; + t5 = A.LinkedHashMap_LinkedHashMap$_literal([t5.get$span(t5), number2.toString$0(0)], type$.FileSpan, type$.String); + t6 = nodesWithSpans[i]; + throw A.wrapException(A.MultiSpanSassRuntimeException$(t1 + " and " + t2 + " are incompatible.", t3, t4, t5, this._async_evaluate$_stackTrace$1(t6.get$span(t6)), null)); + } + } + }, + _async_evaluate$_visitCalculationExpression$2$inLegacySassFunction(node, inLegacySassFunction) { + return this._visitCalculationExpression$body$_EvaluateVisitor(node, inLegacySassFunction); + }, + _visitCalculationExpression$body$_EvaluateVisitor(node, inLegacySassFunction) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Object), + $async$returnValue, $async$self = this, result, t2, _0_0, _box_0, _1_0, t3, _i, i, t1, inner, $async$temp1; + var $async$_async_evaluate$_visitCalculationExpression$2$inLegacySassFunction = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = node instanceof A.ParenthesizedExpression; + inner = t1 ? node.expression : null; + $async$goto = t1 ? 3 : 4; + break; + case 3: + // then + $async$goto = 5; + return A._asyncAwait($async$self._async_evaluate$_visitCalculationExpression$2$inLegacySassFunction(inner, inLegacySassFunction), $async$_async_evaluate$_visitCalculationExpression$2$inLegacySassFunction); + case 5: + // returning from await. + result = $async$result; + $async$returnValue = result instanceof A.SassString ? new A.SassString("(" + result._string$_text + ")", false) : result; + // goto return + $async$goto = 1; + break; + case 4: + // join + $async$goto = node instanceof A.StringExpression && node.accept$1(B.C_IsCalculationSafeVisitor) ? 6 : 7; + break; + case 6: + // then + t1 = node.text; + t2 = t1.get$asPlain(); + _0_0 = t2 == null ? null : t2.toLowerCase(); + if ("pi" === _0_0) { + t1 = A.SassNumber_SassNumber(3.141592653589793, null); + // goto break $label0$0 + $async$goto = 8; + break; + } + if ("e" === _0_0) { + t1 = A.SassNumber_SassNumber(2.718281828459045, null); + // goto break $label0$0 + $async$goto = 8; + break; + } + if ("infinity" === _0_0) { + t1 = A.SassNumber_SassNumber(1 / 0, null); + // goto break $label0$0 + $async$goto = 8; + break; + } + if ("-infinity" === _0_0) { + t1 = A.SassNumber_SassNumber(-1 / 0, null); + // goto break $label0$0 + $async$goto = 8; + break; + } + if ("nan" === _0_0) { + t1 = A.SassNumber_SassNumber(0 / 0, null); + // goto break $label0$0 + $async$goto = 8; + break; + } + $async$temp1 = A; + $async$goto = 9; + return A._asyncAwait($async$self._async_evaluate$_performInterpolation$1(t1), $async$_async_evaluate$_visitCalculationExpression$2$inLegacySassFunction); + case 9: + // returning from await. + t1 = new $async$temp1.SassString($async$result, false); + // goto break $label0$0 + $async$goto = 8; + break; + case 8: + // break $label0$0 + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + case 7: + // join + _box_0 = {}; + _box_0.right = _box_0.left = _box_0.operator = null; + t1 = node instanceof A.BinaryOperationExpression; + if (t1) { + _box_0.operator = node.operator; + _box_0.left = node.left; + _box_0.right = node.right; + } + $async$goto = t1 ? 10 : 11; + break; + case 10: + // then + $async$self._async_evaluate$_checkWhitespaceAroundCalculationOperator$1(node); + $async$goto = 12; + return A._asyncAwait($async$self._addExceptionSpanAsync$1$2(node, new A._EvaluateVisitor__visitCalculationExpression_closure0(_box_0, $async$self, node, inLegacySassFunction), type$.Object), $async$_async_evaluate$_visitCalculationExpression$2$inLegacySassFunction); + case 12: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + case 11: + // join + $async$goto = node instanceof A.NumberExpression || node instanceof A.VariableExpression || node instanceof A.FunctionExpression || node instanceof A.IfExpression ? 13 : 14; + break; + case 13: + // then + $async$goto = 15; + return A._asyncAwait(node.accept$1($async$self), $async$_async_evaluate$_visitCalculationExpression$2$inLegacySassFunction); + case 15: + // returning from await. + _1_0 = $async$result; + $label1$1: { + if (_1_0 instanceof A.SassNumber) { + t1 = _1_0; + break $label1$1; + } + if (_1_0 instanceof A.SassCalculation) { + t1 = _1_0; + break $label1$1; + } + if (_1_0 instanceof A.SassString) { + t1 = !_1_0._hasQuotes; + result = _1_0; + } else { + result = null; + t1 = false; + } + if (t1) { + t1 = result; + break $label1$1; + } + t1 = A.throwExpression($async$self._async_evaluate$_exception$2("Value " + _1_0.toString$0(0) + " can't be used in a calculation.", node.get$span(node))); + } + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + case 14: + // join + $async$goto = node instanceof A.ListExpression && !node.hasBrackets && B.ListSeparator_qSL === node.separator && node.contents.length >= 2 ? 16 : 17; + break; + case 16: + // then + t1 = A._setArrayType([], type$.JSArray_Object); + t2 = node.contents, t3 = t2.length, _i = 0; + case 18: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 20; + break; + } + $async$temp1 = t1; + $async$goto = 21; + return A._asyncAwait($async$self._async_evaluate$_visitCalculationExpression$2$inLegacySassFunction(t2[_i], inLegacySassFunction), $async$_async_evaluate$_visitCalculationExpression$2$inLegacySassFunction); + case 21: + // returning from await. + $async$temp1.push($async$result); + case 19: + // for update + ++_i; + // goto for condition + $async$goto = 18; + break; + case 20: + // after for + $async$self._async_evaluate$_checkAdjacentCalculationValues$2(t1, node); + for (i = 0; i < t1.length; ++i) { + t3 = t1[i]; + if (t3 instanceof A.CalculationOperation && t2[i] instanceof A.ParenthesizedExpression) + t1[i] = new A.SassString("(" + A.S(t3) + ")", false); + } + $async$returnValue = new A.SassString(B.JSArray_methods.join$1(t1, " "), false); + // goto return + $async$goto = 1; + break; + case 17: + // join + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.This_e, node.get$span(node))); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_visitCalculationExpression$2$inLegacySassFunction, $async$completer); + }, + _async_evaluate$_checkWhitespaceAroundCalculationOperator$1(node) { + var t2, t3, t4, textBetweenOperands, first, last, + t1 = node.operator; + if (t1 !== B.BinaryOperator_Swh && t1 !== B.BinaryOperator_QG1) + return; + t1 = node.left; + t2 = t1.get$span(t1); + t2 = t2.get$file(t2); + t3 = node.right; + t4 = t3.get$span(t3); + if (t2 !== t4.get$file(t4)) + return; + t2 = t1.get$span(t1); + t2 = t2.get$end(t2); + t4 = t3.get$span(t3); + if (t2.offset >= t4.get$start(t4).offset) + return; + t2 = t1.get$span(t1); + t2 = t2.get$file(t2); + t1 = t1.get$span(t1); + t1 = t1.get$end(t1); + t3 = t3.get$span(t3); + textBetweenOperands = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t2._decodedChars, t1.offset, t3.get$start(t3).offset), 0, null); + first = textBetweenOperands.charCodeAt(0); + last = textBetweenOperands.charCodeAt(textBetweenOperands.length - 1); + if (first === 32 || first === 9 || first === 10 || first === 13 || first === 12 || first === 47) + t1 = !(last === 32 || last === 9 || last === 10 || last === 13 || last === 12 || last === 47); + else + t1 = true; + if (t1) + throw A.wrapException(this._async_evaluate$_exception$2(string$.x22x2b__an, node.get$operatorSpan())); + }, + _async_evaluate$_binaryOperatorToCalculationOperator$2(operator, node) { + var t1; + $label0$0: { + if (B.BinaryOperator_Swh === operator) { + t1 = B.CalculationOperator_F7i; + break $label0$0; + } + if (B.BinaryOperator_QG1 === operator) { + t1 = B.CalculationOperator_oum; + break $label0$0; + } + if (B.BinaryOperator_tht === operator) { + t1 = B.CalculationOperator_kkN; + break $label0$0; + } + if (B.BinaryOperator_Mh5 === operator) { + t1 = B.CalculationOperator_bo5; + break $label0$0; + } + t1 = A.throwExpression(this._async_evaluate$_exception$2(string$.This_o, node.get$operatorSpan())); + } + return t1; + }, + _async_evaluate$_checkAdjacentCalculationValues$2(elements, node) { + var t1, i, t2, previous, current, previousNode, currentNode, _0_2; + for (t1 = elements.length, i = 1; i < t1; ++i) { + t2 = i - 1; + previous = elements[t2]; + current = elements[i]; + if (previous instanceof A.SassString || current instanceof A.SassString) + continue; + t1 = node.contents; + previousNode = t1[t2]; + currentNode = t1[i]; + if (currentNode instanceof A.UnaryOperationExpression) { + _0_2 = currentNode.operator; + if (B.UnaryOperator_UCP !== _0_2) + t1 = B.UnaryOperator_Rbl === _0_2; + else + t1 = true; + } else + t1 = false; + if (!t1) + t1 = currentNode instanceof A.NumberExpression && currentNode.value < 0; + else + t1 = true; + if (t1) + throw A.wrapException(this._async_evaluate$_exception$2(string$.x22x2b__an, A.FileSpanExtension_subspan(currentNode.get$span(currentNode), 0, 1))); + else + throw A.wrapException(this._async_evaluate$_exception$2("Missing math operator.", previousNode.get$span(previousNode).expand$1(0, currentNode.get$span(currentNode)))); + } + }, + visitInterpolatedFunctionExpression$1(_, node) { + return this.visitInterpolatedFunctionExpression$body$_EvaluateVisitor(0, node); + }, + visitInterpolatedFunctionExpression$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue, $async$self = this, result, t1, oldInFunction; + var $async$visitInterpolatedFunctionExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_performInterpolation$1(node.name), $async$visitInterpolatedFunctionExpression$1); + case 3: + // returning from await. + t1 = $async$result; + oldInFunction = $async$self._async_evaluate$_inFunction; + $async$self._async_evaluate$_inFunction = true; + $async$goto = 4; + return A._asyncAwait($async$self._async_evaluate$_addErrorSpan$1$2(node, new A._EvaluateVisitor_visitInterpolatedFunctionExpression_closure0($async$self, node, new A.PlainCssCallable(t1)), type$.Value), $async$visitInterpolatedFunctionExpression$1); + case 4: + // returning from await. + result = $async$result; + $async$self._async_evaluate$_inFunction = oldInFunction; + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitInterpolatedFunctionExpression$1, $async$completer); + }, + _async_evaluate$_runUserDefinedCallable$1$4($arguments, callable, nodeWithSpan, run, $V) { + return this._runUserDefinedCallable$body$_EvaluateVisitor($arguments, callable, nodeWithSpan, run, $V, $V); + }, + _runUserDefinedCallable$body$_EvaluateVisitor($arguments, callable, nodeWithSpan, run, $V, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$self = this, oldCallable, oldInDependency, result, evaluated, $name; + var $async$_async_evaluate$_runUserDefinedCallable$1$4 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_evaluateArguments$1($arguments), $async$_async_evaluate$_runUserDefinedCallable$1$4); + case 3: + // returning from await. + evaluated = $async$result; + $name = callable.declaration.name; + if ($name !== "@content") + $name += "()"; + oldCallable = $async$self._async_evaluate$_currentCallable; + oldInDependency = $async$self._async_evaluate$_inDependency; + $async$self._async_evaluate$_currentCallable = callable; + $async$self._async_evaluate$_inDependency = callable.inDependency; + $async$goto = 4; + return A._asyncAwait($async$self._async_evaluate$_withStackFrame$1$3($name, nodeWithSpan, new A._EvaluateVisitor__runUserDefinedCallable_closure0($async$self, callable, evaluated, nodeWithSpan, run, $V), $V), $async$_async_evaluate$_runUserDefinedCallable$1$4); + case 4: + // returning from await. + result = $async$result; + $async$self._async_evaluate$_currentCallable = oldCallable; + $async$self._async_evaluate$_inDependency = oldInDependency; + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_runUserDefinedCallable$1$4, $async$completer); + }, + _async_evaluate$_runFunctionCallable$3($arguments, callable, nodeWithSpan) { + return this._runFunctionCallable$body$_EvaluateVisitor($arguments, callable, nodeWithSpan); + }, + _runFunctionCallable$body$_EvaluateVisitor($arguments, callable, nodeWithSpan) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$self = this, buffer, first, argument, restArg, rest, error, t1, t2, _i, t3, t4, exception, $async$exception, $async$temp1; + var $async$_async_evaluate$_runFunctionCallable$3 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = type$.AsyncBuiltInCallable._is(callable) ? 3 : 5; + break; + case 3: + // then + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate$_runBuiltInCallable$3($arguments, callable, nodeWithSpan), $async$_async_evaluate$_runFunctionCallable$3); + case 6: + // returning from await. + $async$returnValue = $async$self._async_evaluate$_withoutSlash$2($async$result, nodeWithSpan); + // goto return + $async$goto = 1; + break; + // goto join + $async$goto = 4; + break; + case 5: + // else + $async$goto = type$.UserDefinedCallable_AsyncEnvironment._is(callable) ? 7 : 9; + break; + case 7: + // then + $async$goto = 10; + return A._asyncAwait($async$self._async_evaluate$_runUserDefinedCallable$1$4($arguments, callable, nodeWithSpan, new A._EvaluateVisitor__runFunctionCallable_closure0($async$self, callable), type$.Value), $async$_async_evaluate$_runFunctionCallable$3); + case 10: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + // goto join + $async$goto = 8; + break; + case 9: + // else + $async$goto = callable instanceof A.PlainCssCallable ? 11 : 13; + break; + case 11: + // then + t1 = $arguments.named; + if (t1.get$isNotEmpty(t1) || $arguments.keywordRest != null) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Plain_, nodeWithSpan.get$span(nodeWithSpan))); + buffer = new A.StringBuffer(callable.name + "("); + $async$handler = 15; + first = true; + t1 = $arguments.positional, t2 = t1.length, _i = 0; + case 18: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 20; + break; + } + argument = t1[_i]; + if (first) + first = false; + else + buffer._contents += ", "; + t3 = buffer; + $async$temp1 = A; + $async$goto = 21; + return A._asyncAwait($async$self._evaluateToCss$1(argument), $async$_async_evaluate$_runFunctionCallable$3); + case 21: + // returning from await. + t4 = $async$temp1.S($async$result); + t3._contents += t4; + case 19: + // for update + ++_i; + // goto for condition + $async$goto = 18; + break; + case 20: + // after for + restArg = $arguments.rest; + $async$goto = restArg != null ? 22 : 23; + break; + case 22: + // then + $async$goto = 24; + return A._asyncAwait(restArg.accept$1($async$self), $async$_async_evaluate$_runFunctionCallable$3); + case 24: + // returning from await. + rest = $async$result; + if (!first) + buffer._contents += ", "; + t1 = buffer; + t2 = $async$self._async_evaluate$_serialize$2(rest, restArg); + t1._contents += t2; + case 23: + // join + $async$handler = 2; + // goto after finally + $async$goto = 17; + break; + case 15: + // catch + $async$handler = 14; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (type$.SassRuntimeException._is(t1)) { + error = t1; + if (!B.JSString_methods.endsWith$1(error._span_exception$_message, "isn't a valid CSS value.")) + throw $async$exception; + throw A.wrapException(A.MultiSpanSassRuntimeException$(error._span_exception$_message, J.get$span$z(error), "value", A.LinkedHashMap_LinkedHashMap$_literal([nodeWithSpan.get$span(nodeWithSpan), "unknown function treated as plain CSS"], type$.FileSpan, type$.String), J.get$trace$z(error), null)); + } else + throw $async$exception; + // goto after finally + $async$goto = 17; + break; + case 14: + // uncaught + // goto rethrow + $async$goto = 2; + break; + case 17: + // after finally + t1 = buffer; + t2 = A.Primitives_stringFromCharCode(41); + t1._contents += t2; + t2 = buffer._contents; + $async$returnValue = new A.SassString(t2.charCodeAt(0) == 0 ? t2 : t2, false); + // goto return + $async$goto = 1; + break; + // goto join + $async$goto = 12; + break; + case 13: + // else + throw A.wrapException(A.ArgumentError$("Unknown callable type " + J.get$runtimeType$(callable).toString$0(0) + ".", null)); + case 12: + // join + case 8: + // join + case 4: + // join + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_runFunctionCallable$3, $async$completer); + }, + _async_evaluate$_runBuiltInCallable$3($arguments, callable, nodeWithSpan) { + return this._runBuiltInCallable$body$_EvaluateVisitor($arguments, callable, nodeWithSpan); + }, + _runBuiltInCallable$body$_EvaluateVisitor($arguments, callable, nodeWithSpan) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$self = this, result, error, stackTrace, namedSet, _0_0, parameters, i, t1, t2, t3, parameter, t4, t5, t6, t7, rest, argumentList, exception, _box_0, evaluated, oldCallableNode, $async$exception; + var $async$_async_evaluate$_runBuiltInCallable$3 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + _box_0 = {}; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_evaluateArguments$1($arguments), $async$_async_evaluate$_runBuiltInCallable$3); + case 3: + // returning from await. + evaluated = $async$result; + oldCallableNode = $async$self._async_evaluate$_callableNode; + $async$self._async_evaluate$_callableNode = nodeWithSpan; + namedSet = new A.MapKeySet(evaluated._values[0], type$.MapKeySet_String); + _box_0.callback = _box_0.overload = null; + _0_0 = callable.callbackFor$2(J.get$length$asx(evaluated._values[2]), namedSet); + _box_0.overload = _0_0._0; + _box_0.callback = _0_0._1; + $async$self._async_evaluate$_addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__runBuiltInCallable_closure2(_box_0, evaluated, namedSet)); + parameters = _box_0.overload.parameters; + i = J.get$length$asx(evaluated._values[2]), t1 = parameters.length, t2 = type$._Future_Value, t3 = type$.Future_Value; + case 4: + // for condition + if (!(i < t1)) { + // goto after for + $async$goto = 6; + break; + } + parameter = parameters[i]; + t4 = evaluated._values[2]; + t5 = evaluated._values[0].remove$1(0, parameter.name); + $async$goto = t5 == null ? 7 : 8; + break; + case 7: + // then + t5 = parameter.defaultValue; + t6 = t5.accept$1($async$self); + if (!t3._is(t6)) { + t7 = new A._Future($.Zone__current, t2); + t7._state = 8; + t7._resultOrListeners = t6; + t6 = t7; + } + $async$goto = 9; + return A._asyncAwait(t6, $async$_async_evaluate$_runBuiltInCallable$3); + case 9: + // returning from await. + t5 = $async$self._async_evaluate$_withoutSlash$2($async$result, t5); + case 8: + // join + J.add$1$ax(t4, t5); + case 5: + // for update + ++i; + // goto for condition + $async$goto = 4; + break; + case 6: + // after for + if (_box_0.overload.restParameter != null) { + if (J.get$length$asx(evaluated._values[2]) > t1) { + rest = J.sublist$1$ax(evaluated._values[2], t1); + J.removeRange$2$ax(evaluated._values[2], t1, J.get$length$asx(evaluated._values[2])); + } else + rest = B.List_empty8; + t1 = evaluated._values[0]; + argumentList = A.SassArgumentList$(rest, t1, evaluated._values[4] === B.ListSeparator_undecided_null_undecided ? B.ListSeparator_qVN : evaluated._values[4]); + J.add$1$ax(evaluated._values[2], argumentList); + } else + argumentList = null; + result = null; + $async$handler = 11; + $async$goto = 14; + return A._asyncAwait($async$self._addExceptionSpanAsync$1$2(nodeWithSpan, new A._EvaluateVisitor__runBuiltInCallable_closure3(_box_0, evaluated), type$.Value), $async$_async_evaluate$_runBuiltInCallable$3); + case 14: + // returning from await. + result = $async$result; + $async$handler = 2; + // goto after finally + $async$goto = 13; + break; + case 11: + // catch + $async$handler = 10; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (t1 instanceof A.SassException) + throw $async$exception; + else { + error = t1; + stackTrace = A.getTraceFromException($async$exception); + A.throwWithTrace($async$self._async_evaluate$_exception$2($async$self._async_evaluate$_getErrorMessage$1(error), nodeWithSpan.get$span(nodeWithSpan)), error, stackTrace); + } + // goto after finally + $async$goto = 13; + break; + case 10: + // uncaught + // goto rethrow + $async$goto = 2; + break; + case 13: + // after finally + $async$self._async_evaluate$_callableNode = oldCallableNode; + if (argumentList == null) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + t1 = evaluated._values[0]; + if (t1.get$isEmpty(t1)) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + if (argumentList._wereKeywordsAccessed) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + t1 = evaluated._values[0]; + t1 = A.pluralize("parameter", J.get$length$asx(t1.get$keys(t1)), null); + t2 = evaluated._values[0]; + throw A.wrapException(A.MultiSpanSassRuntimeException$("No " + t1 + " named " + A.toSentence(J.map$1$1$ax(t2.get$keys(t2), new A._EvaluateVisitor__runBuiltInCallable_closure4(), type$.Object), "or") + ".", nodeWithSpan.get$span(nodeWithSpan), "invocation", A.LinkedHashMap_LinkedHashMap$_literal([_box_0.overload.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), $async$self._async_evaluate$_stackTrace$1(nodeWithSpan.get$span(nodeWithSpan)), null)); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_runBuiltInCallable$3, $async$completer); + }, + _async_evaluate$_evaluateArguments$1($arguments) { + return this._evaluateArguments$body$_EvaluateVisitor($arguments); + }, + _evaluateArguments$body$_EvaluateVisitor($arguments) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_5_Map_String_Value_named_and_Map_String_AstNode_namedNodes_and_List_Value_positional_and_List_AstNode_positionalNodes_and_ListSeparator_separator), + $async$returnValue, $async$self = this, t1, t2, t3, t4, _i, expression, nodeForSpan, t5, t6, named, namedNodes, $name, value, t7, restArgs, rest, restNodeForSpan, separator, keywordRestArgs, keywordRest, keywordRestNodeForSpan, positional, positionalNodes, $async$temp1, $async$temp2; + var $async$_async_evaluate$_evaluateArguments$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + positional = A._setArrayType([], type$.JSArray_Value); + positionalNodes = A._setArrayType([], type$.JSArray_AstNode); + t1 = $arguments.positional, t2 = t1.length, t3 = type$._Future_Value, t4 = type$.Future_Value, _i = 0; + case 3: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 5; + break; + } + expression = t1[_i]; + nodeForSpan = $async$self._async_evaluate$_expressionNode$1(expression); + t5 = expression.accept$1($async$self); + if (!t4._is(t5)) { + t6 = new A._Future($.Zone__current, t3); + t6._state = 8; + t6._resultOrListeners = t5; + t5 = t6; + } + $async$temp1 = positional; + $async$goto = 6; + return A._asyncAwait(t5, $async$_async_evaluate$_evaluateArguments$1); + case 6: + // returning from await. + $async$temp1.push($async$self._async_evaluate$_withoutSlash$2($async$result, nodeForSpan)); + positionalNodes.push(nodeForSpan); + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + t1 = type$.String; + named = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Value); + t2 = type$.AstNode; + namedNodes = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + t5 = A.MapExtensions_get_pairs($arguments.named, t1, type$.Expression), t5 = t5.get$iterator(t5); + case 7: + // for condition + if (!t5.moveNext$0()) { + // goto after for + $async$goto = 8; + break; + } + t6 = t5.get$current(t5); + $name = t6._0; + value = t6._1; + nodeForSpan = $async$self._async_evaluate$_expressionNode$1(value); + t6 = value.accept$1($async$self); + if (!t4._is(t6)) { + t7 = new A._Future($.Zone__current, t3); + t7._state = 8; + t7._resultOrListeners = t6; + t6 = t7; + } + $async$temp1 = named; + $async$temp2 = $name; + $async$goto = 9; + return A._asyncAwait(t6, $async$_async_evaluate$_evaluateArguments$1); + case 9: + // returning from await. + $async$temp1.$indexSet(0, $async$temp2, $async$self._async_evaluate$_withoutSlash$2($async$result, nodeForSpan)); + namedNodes.$indexSet(0, $name, nodeForSpan); + // goto for condition + $async$goto = 7; + break; + case 8: + // after for + restArgs = $arguments.rest; + if (restArgs == null) { + $async$returnValue = new A._Record_5_named_namedNodes_positional_positionalNodes_separator([named, namedNodes, positional, positionalNodes, B.ListSeparator_undecided_null_undecided]); + // goto return + $async$goto = 1; + break; + } + $async$goto = 10; + return A._asyncAwait(restArgs.accept$1($async$self), $async$_async_evaluate$_evaluateArguments$1); + case 10: + // returning from await. + rest = $async$result; + restNodeForSpan = $async$self._async_evaluate$_expressionNode$1(restArgs); + if (rest instanceof A.SassMap) { + $async$self._async_evaluate$_addRestMap$4(named, rest, restArgs, new A._EvaluateVisitor__evaluateArguments_closure3()); + t3 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t4 = rest._map$_contents, t4 = J.get$iterator$ax(t4.get$keys(t4)), t5 = type$.SassString; t4.moveNext$0();) + t3.$indexSet(0, t5._as(t4.get$current(t4))._string$_text, restNodeForSpan); + namedNodes.addAll$1(0, t3); + separator = B.ListSeparator_undecided_null_undecided; + } else if (rest instanceof A.SassList) { + t3 = rest._list$_contents; + B.JSArray_methods.addAll$1(positional, new A.MappedListIterable(t3, new A._EvaluateVisitor__evaluateArguments_closure4($async$self, restNodeForSpan), A._arrayInstanceType(t3)._eval$1("MappedListIterable<1,Value>"))); + B.JSArray_methods.addAll$1(positionalNodes, A.List_List$filled(t3.length, restNodeForSpan, false, t2)); + separator = rest._separator; + if (rest instanceof A.SassArgumentList) { + rest._wereKeywordsAccessed = true; + rest._keywords.forEach$1(0, new A._EvaluateVisitor__evaluateArguments_closure5($async$self, named, restNodeForSpan, namedNodes)); + } + } else { + positional.push($async$self._async_evaluate$_withoutSlash$2(rest, restNodeForSpan)); + positionalNodes.push(restNodeForSpan); + separator = B.ListSeparator_undecided_null_undecided; + } + keywordRestArgs = $arguments.keywordRest; + if (keywordRestArgs == null) { + $async$returnValue = new A._Record_5_named_namedNodes_positional_positionalNodes_separator([named, namedNodes, positional, positionalNodes, separator]); + // goto return + $async$goto = 1; + break; + } + $async$goto = 11; + return A._asyncAwait(keywordRestArgs.accept$1($async$self), $async$_async_evaluate$_evaluateArguments$1); + case 11: + // returning from await. + keywordRest = $async$result; + keywordRestNodeForSpan = $async$self._async_evaluate$_expressionNode$1(keywordRestArgs); + if (keywordRest instanceof A.SassMap) { + $async$self._async_evaluate$_addRestMap$4(named, keywordRest, keywordRestArgs, new A._EvaluateVisitor__evaluateArguments_closure6()); + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t2 = keywordRest._map$_contents, t2 = J.get$iterator$ax(t2.get$keys(t2)), t3 = type$.SassString; t2.moveNext$0();) + t1.$indexSet(0, t3._as(t2.get$current(t2))._string$_text, keywordRestNodeForSpan); + namedNodes.addAll$1(0, t1); + $async$returnValue = new A._Record_5_named_namedNodes_positional_positionalNodes_separator([named, namedNodes, positional, positionalNodes, separator]); + // goto return + $async$goto = 1; + break; + } else + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Variabs + keywordRest.toString$0(0) + ").", keywordRestArgs.get$span(keywordRestArgs))); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_evaluateArguments$1, $async$completer); + }, + _async_evaluate$_evaluateMacroArguments$1(invocation) { + return this._evaluateMacroArguments$body$_EvaluateVisitor(invocation); + }, + _evaluateMacroArguments$body$_EvaluateVisitor(invocation) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_2_List_Expression_and_Map_String_Expression), + $async$returnValue, $async$self = this, t2, positional, named, rest, restNodeForSpan, keywordRestArgs_, keywordRest, keywordRestNodeForSpan, t1, restArgs_; + var $async$_async_evaluate$_evaluateMacroArguments$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = invocation.$arguments; + restArgs_ = t1.rest; + if (restArgs_ == null) { + $async$returnValue = new A._Record_2(t1.positional, t1.named); + // goto return + $async$goto = 1; + break; + } + t2 = t1.positional; + positional = A._setArrayType(t2.slice(0), A._arrayInstanceType(t2)); + named = A.LinkedHashMap_LinkedHashMap$of(t1.named, type$.String, type$.Expression); + $async$goto = 3; + return A._asyncAwait(restArgs_.accept$1($async$self), $async$_async_evaluate$_evaluateMacroArguments$1); + case 3: + // returning from await. + rest = $async$result; + restNodeForSpan = $async$self._async_evaluate$_expressionNode$1(restArgs_); + if (rest instanceof A.SassMap) + $async$self._async_evaluate$_addRestMap$4(named, rest, invocation, new A._EvaluateVisitor__evaluateMacroArguments_closure3(restArgs_)); + else if (rest instanceof A.SassList) { + t2 = rest._list$_contents; + B.JSArray_methods.addAll$1(positional, new A.MappedListIterable(t2, new A._EvaluateVisitor__evaluateMacroArguments_closure4($async$self, restNodeForSpan, restArgs_), A._arrayInstanceType(t2)._eval$1("MappedListIterable<1,Expression>"))); + if (rest instanceof A.SassArgumentList) { + rest._wereKeywordsAccessed = true; + rest._keywords.forEach$1(0, new A._EvaluateVisitor__evaluateMacroArguments_closure5($async$self, named, restNodeForSpan, restArgs_)); + } + } else + positional.push(new A.ValueExpression($async$self._async_evaluate$_withoutSlash$2(rest, restNodeForSpan), restArgs_.get$span(restArgs_))); + keywordRestArgs_ = t1.keywordRest; + if (keywordRestArgs_ == null) { + $async$returnValue = new A._Record_2(positional, named); + // goto return + $async$goto = 1; + break; + } + $async$goto = 4; + return A._asyncAwait(keywordRestArgs_.accept$1($async$self), $async$_async_evaluate$_evaluateMacroArguments$1); + case 4: + // returning from await. + keywordRest = $async$result; + keywordRestNodeForSpan = $async$self._async_evaluate$_expressionNode$1(keywordRestArgs_); + if (keywordRest instanceof A.SassMap) { + $async$self._async_evaluate$_addRestMap$4(named, keywordRest, invocation, new A._EvaluateVisitor__evaluateMacroArguments_closure6($async$self, keywordRestNodeForSpan, keywordRestArgs_)); + $async$returnValue = new A._Record_2(positional, named); + // goto return + $async$goto = 1; + break; + } else + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Variabs + keywordRest.toString$0(0) + ").", keywordRestArgs_.get$span(keywordRestArgs_))); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_evaluateMacroArguments$1, $async$completer); + }, + _async_evaluate$_addRestMap$1$4(values, map, nodeWithSpan, convert) { + map._map$_contents.forEach$1(0, new A._EvaluateVisitor__addRestMap_closure0(this, values, convert, this._async_evaluate$_expressionNode$1(nodeWithSpan), map, nodeWithSpan)); + }, + _async_evaluate$_addRestMap$4(values, map, nodeWithSpan, convert) { + return this._async_evaluate$_addRestMap$1$4(values, map, nodeWithSpan, convert, type$.dynamic); + }, + _async_evaluate$_verifyArguments$4(positional, named, parameters, nodeWithSpan) { + return this._async_evaluate$_addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__verifyArguments_closure0(parameters, positional, named)); + }, + visitSelectorExpression$1(_, node) { + return this.visitSelectorExpression$body$_EvaluateVisitor(0, node); + }, + visitSelectorExpression$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue, $async$self = this, t1; + var $async$visitSelectorExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self._async_evaluate$_styleRuleIgnoringAtRoot; + t1 = t1 == null ? null : t1.originalSelector.get$asSassList(); + $async$returnValue = t1 == null ? B.C__SassNull : t1; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitSelectorExpression$1, $async$completer); + }, + visitStringExpression$1(_, node) { + return this.visitStringExpression$body$_EvaluateVisitor(0, node); + }, + visitStringExpression$body$_EvaluateVisitor(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassString), + $async$returnValue, $async$self = this, t1, t2, t3, _i, value, t4, _0_0, text, oldInSupportsDeclaration; + var $async$visitStringExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + oldInSupportsDeclaration = $async$self._async_evaluate$_inSupportsDeclaration; + $async$self._async_evaluate$_inSupportsDeclaration = false; + t1 = A._setArrayType([], type$.JSArray_String); + t2 = node.text.contents, t3 = t2.length, _i = 0; + case 3: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 5; + break; + } + value = t2[_i]; + if (typeof value == "string") { + t4 = value; + // goto break $label0$0 + $async$goto = 6; + break; + } + $async$goto = value instanceof A.Expression ? 7 : 8; + break; + case 7: + // then + $async$goto = 9; + return A._asyncAwait(value.accept$1($async$self), $async$visitStringExpression$1); + case 9: + // returning from await. + _0_0 = $async$result; + $label1$1: { + if (_0_0 instanceof A.SassString) { + text = _0_0._string$_text; + t4 = text; + break $label1$1; + } + t4 = $async$self._async_evaluate$_serialize$3$quote(_0_0, value, false); + break $label1$1; + } + // goto break $label0$0 + $async$goto = 6; + break; + case 8: + // join + t4 = A.throwExpression(A.UnsupportedError$("Unknown interpolation value " + A.S(value))); + case 6: + // break $label0$0 + t1.push(t4); + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + t1 = B.JSArray_methods.join$0(t1); + $async$self._async_evaluate$_inSupportsDeclaration = oldInSupportsDeclaration; + $async$returnValue = new A.SassString(t1, node.hasQuotes); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitStringExpression$1, $async$completer); + }, + visitSupportsExpression$1(_, expression) { + return this.visitSupportsExpression$body$_EvaluateVisitor(0, expression); + }, + visitSupportsExpression$body$_EvaluateVisitor(_, expression) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassString), + $async$returnValue, $async$self = this, $async$temp1; + var $async$visitSupportsExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$temp1 = A; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_visitSupportsCondition$1(expression.condition), $async$visitSupportsExpression$1); + case 3: + // returning from await. + $async$returnValue = new $async$temp1.SassString($async$result, false); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitSupportsExpression$1, $async$completer); + }, + visitCssAtRule$1(node) { + return this.visitCssAtRule$body$_EvaluateVisitor(node); + }, + visitCssAtRule$body$_EvaluateVisitor(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$returnValue, $async$self = this, wasInKeyframes, wasInUnknownAtRule, t1; + var $async$visitCssAtRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate$_declarationName != null) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.At_rul, node.span)); + if (node.isChildless) { + $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent").addChild$1(A.ModifiableCssAtRule$(node.name, node.span, true, node.value)); + // goto return + $async$goto = 1; + break; + } + wasInKeyframes = $async$self._async_evaluate$_inKeyframes; + wasInUnknownAtRule = $async$self._async_evaluate$_inUnknownAtRule; + t1 = node.name; + if (A.unvendor(t1.value) === "keyframes") + $async$self._async_evaluate$_inKeyframes = true; + else + $async$self._async_evaluate$_inUnknownAtRule = true; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_withParent$2$4$scopeWhen$through(A.ModifiableCssAtRule$(t1, node.span, false, node.value), new A._EvaluateVisitor_visitCssAtRule_closure1($async$self, node), false, new A._EvaluateVisitor_visitCssAtRule_closure2(), type$.ModifiableCssAtRule, type$.Null), $async$visitCssAtRule$1); + case 3: + // returning from await. + $async$self._async_evaluate$_inUnknownAtRule = wasInUnknownAtRule; + $async$self._async_evaluate$_inKeyframes = wasInKeyframes; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssAtRule$1, $async$completer); + }, + visitCssComment$1(node) { + return this.visitCssComment$body$_EvaluateVisitor(node); + }, + visitCssComment$body$_EvaluateVisitor(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this; + var $async$visitCssComment$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent") === $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__root, "_root") && $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__endOfImports, "_endOfImports") === J.get$length$asx($async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__root, "_root").children._collection$_source)) + $async$self._async_evaluate$__endOfImports = $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__endOfImports, "_endOfImports") + 1; + $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent").addChild$1(new A.ModifiableCssComment(node.text, node.span)); + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssComment$1, $async$completer); + }, + visitCssDeclaration$1(node) { + return this.visitCssDeclaration$body$_EvaluateVisitor(node); + }, + visitCssDeclaration$body$_EvaluateVisitor(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this; + var $async$visitCssDeclaration$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent").addChild$1(A.ModifiableCssDeclaration$(node.name, node.value, node.span, null, node.parsedAsCustomProperty, null, node.valueSpanForMap)); + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssDeclaration$1, $async$completer); + }, + visitCssImport$1(node) { + return this.visitCssImport$body$_EvaluateVisitor(node); + }, + visitCssImport$body$_EvaluateVisitor(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1, modifiableNode; + var $async$visitCssImport$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + modifiableNode = new A.ModifiableCssImport(node.url, node.modifiers, node.span); + if ($async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent") !== $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__root, "_root")) + $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent").addChild$1(modifiableNode); + else if ($async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__endOfImports, "_endOfImports") === J.get$length$asx($async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__root, "_root").children._collection$_source)) { + $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__root, "_root").addChild$1(modifiableNode); + $async$self._async_evaluate$__endOfImports = $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__endOfImports, "_endOfImports") + 1; + } else { + t1 = $async$self._async_evaluate$_outOfOrderImports; + (t1 == null ? $async$self._async_evaluate$_outOfOrderImports = A._setArrayType([], type$.JSArray_ModifiableCssImport) : t1).push(modifiableNode); + } + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssImport$1, $async$completer); + }, + visitCssKeyframeBlock$1(node) { + return this.visitCssKeyframeBlock$body$_EvaluateVisitor(node); + }, + visitCssKeyframeBlock$body$_EvaluateVisitor(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this; + var $async$visitCssKeyframeBlock$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 2; + return A._asyncAwait($async$self._async_evaluate$_withParent$2$4$scopeWhen$through(A.ModifiableCssKeyframeBlock$(node.selector, node.span), new A._EvaluateVisitor_visitCssKeyframeBlock_closure1($async$self, node), false, new A._EvaluateVisitor_visitCssKeyframeBlock_closure2(), type$.ModifiableCssKeyframeBlock, type$.Null), $async$visitCssKeyframeBlock$1); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssKeyframeBlock$1, $async$completer); + }, + visitCssMediaRule$1(node) { + return this.visitCssMediaRule$body$_EvaluateVisitor(node); + }, + visitCssMediaRule$body$_EvaluateVisitor(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$returnValue, $async$self = this, mergedQueries, t1, mergedSources, t2, t3; + var $async$visitCssMediaRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate$_declarationName != null) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Media_, node.span)); + mergedQueries = A.NullableExtension_andThen($async$self._async_evaluate$_mediaQueries, new A._EvaluateVisitor_visitCssMediaRule_closure2($async$self, node)); + t1 = mergedQueries == null; + if (!t1 && J.get$isEmpty$asx(mergedQueries)) { + // goto return + $async$goto = 1; + break; + } + if (t1) + mergedSources = B.Set_empty1; + else { + t2 = $async$self._async_evaluate$_mediaQuerySources; + t2.toString; + t2 = A.LinkedHashSet_LinkedHashSet$of(t2, type$.CssMediaQuery); + t3 = $async$self._async_evaluate$_mediaQueries; + t3.toString; + t2.addAll$1(0, t3); + t2.addAll$1(0, node.queries); + mergedSources = t2; + } + t1 = t1 ? node.queries : mergedQueries; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_withParent$2$4$scopeWhen$through(A.ModifiableCssMediaRule$(t1, node.span), new A._EvaluateVisitor_visitCssMediaRule_closure3($async$self, mergedQueries, node, mergedSources), false, new A._EvaluateVisitor_visitCssMediaRule_closure4(mergedSources), type$.ModifiableCssMediaRule, type$.Null), $async$visitCssMediaRule$1); + case 3: + // returning from await. + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssMediaRule$1, $async$completer); + }, + visitCssStyleRule$1(node) { + return this.visitCssStyleRule$body$_EvaluateVisitor(node); + }, + visitCssStyleRule$body$_EvaluateVisitor(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1, styleRule, t2, nest, t3, originalSelector, rule, oldAtRootExcludingStyleRule, _0_1, lastChild; + var $async$visitCssStyleRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate$_declarationName != null) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Style_n, node.span)); + else if ($async$self._async_evaluate$_inKeyframes && $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent") instanceof A.ModifiableCssKeyframeBlock) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Style_k, node.span)); + t1 = $async$self._async_evaluate$_atRootExcludingStyleRule; + styleRule = t1 ? null : $async$self._async_evaluate$_styleRuleIgnoringAtRoot; + t2 = t1 ? null : $async$self._async_evaluate$_styleRuleIgnoringAtRoot; + t2 = t2 == null ? null : t2.fromPlainCss; + nest = t2 !== true; + t2 = node._style_rule$_selector._box$_inner; + if (nest) { + t2 = t2.value; + t3 = styleRule == null ? null : styleRule.originalSelector; + originalSelector = t2.nestWithin$3$implicitParent$preserveParentSelectors(t3, !t1, node.fromPlainCss); + } else + originalSelector = t2.value; + rule = A.ModifiableCssStyleRule$($async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__extensionStore, "_extensionStore").addSelector$2(originalSelector, $async$self._async_evaluate$_mediaQueries), node.span, node.fromPlainCss, originalSelector); + oldAtRootExcludingStyleRule = $async$self._async_evaluate$_atRootExcludingStyleRule; + $async$self._async_evaluate$_atRootExcludingStyleRule = false; + t1 = nest ? new A._EvaluateVisitor_visitCssStyleRule_closure1() : null; + $async$goto = 2; + return A._asyncAwait($async$self._async_evaluate$_withParent$2$4$scopeWhen$through(rule, new A._EvaluateVisitor_visitCssStyleRule_closure2($async$self, rule, node), false, t1, type$.ModifiableCssStyleRule, type$.Null), $async$visitCssStyleRule$1); + case 2: + // returning from await. + $async$self._async_evaluate$_atRootExcludingStyleRule = oldAtRootExcludingStyleRule; + t1 = $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent").children._collection$_source; + t2 = J.getInterceptor$asx(t1); + _0_1 = t2.get$length(t1); + if (_0_1 >= 1) { + lastChild = t2.elementAt$1(t1, _0_1 - 1); + t1 = styleRule == null; + } else { + lastChild = null; + t1 = false; + } + if (t1) + lastChild.isGroupEnd = true; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssStyleRule$1, $async$completer); + }, + visitCssStylesheet$1(node) { + return this.visitCssStylesheet$body$_EvaluateVisitor(node); + }, + visitCssStylesheet$body$_EvaluateVisitor(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1; + var $async$visitCssStylesheet$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = J.get$iterator$ax(node.get$children(node)); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + $async$goto = 4; + return A._asyncAwait(t1.get$current(t1).accept$1($async$self), $async$visitCssStylesheet$1); + case 4: + // returning from await. + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssStylesheet$1, $async$completer); + }, + visitCssSupportsRule$1(node) { + return this.visitCssSupportsRule$body$_EvaluateVisitor(node); + }, + visitCssSupportsRule$body$_EvaluateVisitor(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this; + var $async$visitCssSupportsRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate$_declarationName != null) + throw A.wrapException($async$self._async_evaluate$_exception$2(string$.Suppor, node.span)); + $async$goto = 2; + return A._asyncAwait($async$self._async_evaluate$_withParent$2$4$scopeWhen$through(A.ModifiableCssSupportsRule$(node.condition, node.span), new A._EvaluateVisitor_visitCssSupportsRule_closure1($async$self, node), false, new A._EvaluateVisitor_visitCssSupportsRule_closure2(), type$.ModifiableCssSupportsRule, type$.Null), $async$visitCssSupportsRule$1); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssSupportsRule$1, $async$completer); + }, + _async_evaluate$_handleReturn$1$2(list, callback) { + return this._handleReturn$body$_EvaluateVisitor(list, callback); + }, + _async_evaluate$_handleReturn$2(list, callback) { + return this._async_evaluate$_handleReturn$1$2(list, callback, type$.dynamic); + }, + _handleReturn$body$_EvaluateVisitor(list, callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, t1, _i, _0_0; + var $async$_async_evaluate$_handleReturn$1$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = list.length, _i = 0; + case 3: + // for condition + if (!(_i < list.length)) { + // goto after for + $async$goto = 5; + break; + } + $async$goto = 6; + return A._asyncAwait(callback.call$1(list[_i]), $async$_async_evaluate$_handleReturn$1$2); + case 6: + // returning from await. + _0_0 = $async$result; + if (_0_0 != null) { + $async$returnValue = _0_0; + // goto return + $async$goto = 1; + break; + } + case 4: + // for update + list.length === t1 || (0, A.throwConcurrentModificationError)(list), ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_handleReturn$1$2, $async$completer); + }, + _async_evaluate$_withEnvironment$1$2(environment, callback, $T) { + return this._withEnvironment$body$_EvaluateVisitor(environment, callback, $T, $T); + }, + _withEnvironment$body$_EvaluateVisitor(environment, callback, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$self = this, result, oldEnvironment; + var $async$_async_evaluate$_withEnvironment$1$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + oldEnvironment = $async$self._async_evaluate$_environment; + $async$self._async_evaluate$_environment = environment; + $async$goto = 3; + return A._asyncAwait(callback.call$0(), $async$_async_evaluate$_withEnvironment$1$2); + case 3: + // returning from await. + result = $async$result; + $async$self._async_evaluate$_environment = oldEnvironment; + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_withEnvironment$1$2, $async$completer); + }, + _async_evaluate$_interpolationToValue$3$trim$warnForColor(interpolation, trim, warnForColor) { + return this._interpolationToValue$body$_EvaluateVisitor(interpolation, trim, warnForColor); + }, + _async_evaluate$_interpolationToValue$1(interpolation) { + return this._async_evaluate$_interpolationToValue$3$trim$warnForColor(interpolation, false, false); + }, + _async_evaluate$_interpolationToValue$2$warnForColor(interpolation, warnForColor) { + return this._async_evaluate$_interpolationToValue$3$trim$warnForColor(interpolation, false, warnForColor); + }, + _interpolationToValue$body$_EvaluateVisitor(interpolation, trim, warnForColor) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.CssValue_String), + $async$returnValue, $async$self = this, result, t1; + var $async$_async_evaluate$_interpolationToValue$3$trim$warnForColor = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_performInterpolation$2$warnForColor(interpolation, warnForColor), $async$_async_evaluate$_interpolationToValue$3$trim$warnForColor); + case 3: + // returning from await. + result = $async$result; + t1 = trim ? A.trimAscii(result, true) : result; + $async$returnValue = new A.CssValue(t1, interpolation.span, type$.CssValue_String); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_interpolationToValue$3$trim$warnForColor, $async$completer); + }, + _async_evaluate$_performInterpolation$2$warnForColor(interpolation, warnForColor) { + return this._performInterpolation$body$_EvaluateVisitor(interpolation, warnForColor); + }, + _async_evaluate$_performInterpolation$1(interpolation) { + return this._async_evaluate$_performInterpolation$2$warnForColor(interpolation, false); + }, + _performInterpolation$body$_EvaluateVisitor(interpolation, warnForColor) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.String), + $async$returnValue, $async$self = this; + var $async$_async_evaluate$_performInterpolation$2$warnForColor = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_performInterpolationHelper$3$sourceMap$warnForColor(interpolation, false, warnForColor), $async$_async_evaluate$_performInterpolation$2$warnForColor); + case 3: + // returning from await. + $async$returnValue = $async$result._0; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_performInterpolation$2$warnForColor, $async$completer); + }, + _async_evaluate$_performInterpolationWithMap$2$warnForColor(interpolation, warnForColor) { + return this._performInterpolationWithMap$body$_EvaluateVisitor(interpolation, true); + }, + _performInterpolationWithMap$body$_EvaluateVisitor(interpolation, warnForColor) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_2_String_and_InterpolationMap), + $async$returnValue, $async$self = this, _0_0, result, map; + var $async$_async_evaluate$_performInterpolationWithMap$2$warnForColor = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_performInterpolationHelper$3$sourceMap$warnForColor(interpolation, true, true), $async$_async_evaluate$_performInterpolationWithMap$2$warnForColor); + case 3: + // returning from await. + _0_0 = $async$result; + result = _0_0._0; + map = _0_0._1; + map.toString; + $async$returnValue = new A._Record_2(result, map); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_performInterpolationWithMap$2$warnForColor, $async$completer); + }, + _async_evaluate$_performInterpolationHelper$3$sourceMap$warnForColor(interpolation, sourceMap, warnForColor) { + return this._performInterpolationHelper$body$_EvaluateVisitor(interpolation, sourceMap, warnForColor); + }, + _performInterpolationHelper$body$_EvaluateVisitor(interpolation, sourceMap, warnForColor) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_2_String_and_nullable_InterpolationMap), + $async$returnValue, $async$self = this, t1, t2, t3, t4, t5, t6, first, _i, t7, value, result, result0, t8, targetLocations, oldInSupportsDeclaration; + var $async$_async_evaluate$_performInterpolationHelper$3$sourceMap$warnForColor = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + targetLocations = sourceMap ? A._setArrayType([], type$.JSArray_SourceLocation) : null; + oldInSupportsDeclaration = $async$self._async_evaluate$_inSupportsDeclaration; + $async$self._async_evaluate$_inSupportsDeclaration = false; + t1 = interpolation.contents, t2 = t1.length, t3 = type$.Expression, t4 = targetLocations == null, t5 = interpolation.span, t6 = type$.Object, first = true, _i = 0, t7 = ""; + case 3: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 5; + break; + } + value = t1[_i]; + if (!first) + if (!t4) + targetLocations.push(A.SourceLocation$(t7.length, null, null, null)); + if (typeof value == "string") { + t7 += value; + // goto for update + $async$goto = 4; + break; + } + t3._as(value); + $async$goto = 6; + return A._asyncAwait(value.accept$1($async$self), $async$_async_evaluate$_performInterpolationHelper$3$sourceMap$warnForColor); + case 6: + // returning from await. + result = $async$result; + if (warnForColor && $.$get$namesByColor().containsKey$1(result)) { + result0 = A.List_List$from([""], false, t6); + result0.$flags = 3; + t8 = $.$get$namesByColor(); + $async$self._async_evaluate$_warn$2(string$.You_pr + A.S(t8.$index(0, result)) + string$.x20in_in + result.toString$0(0) + string$.x2c_whicw + A.S(t8.$index(0, result)) + string$.x22x29__If + new A.BinaryOperationExpression(B.BinaryOperator_Swh, new A.StringExpression(new A.Interpolation(result0, B.List_null, t5), true), value, false).toString$0(0) + "'.", value.get$span(value)); + } + t7 += $async$self._async_evaluate$_serialize$3$quote(result, value, false); + case 4: + // for update + ++_i, first = false; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $async$self._async_evaluate$_inSupportsDeclaration = oldInSupportsDeclaration; + $async$returnValue = new A._Record_2(t7.charCodeAt(0) == 0 ? t7 : t7, A.NullableExtension_andThen(targetLocations, new A._EvaluateVisitor__performInterpolationHelper_closure0(interpolation))); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_performInterpolationHelper$3$sourceMap$warnForColor, $async$completer); + }, + _evaluateToCss$2$quote(expression, quote) { + return this._evaluateToCss$body$_EvaluateVisitor(expression, quote); + }, + _evaluateToCss$1(expression) { + return this._evaluateToCss$2$quote(expression, true); + }, + _evaluateToCss$body$_EvaluateVisitor(expression, quote) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.String), + $async$returnValue, $async$self = this, t1; + var $async$_evaluateToCss$2$quote = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = expression.accept$1($async$self); + $async$goto = 3; + return A._asyncAwait(type$.Future_Value._is(t1) ? t1 : A._Future$value(t1, type$.Value), $async$_evaluateToCss$2$quote); + case 3: + // returning from await. + $async$returnValue = $async$self._async_evaluate$_serialize$3$quote($async$result, expression, quote); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_evaluateToCss$2$quote, $async$completer); + }, + _async_evaluate$_serialize$3$quote(value, nodeWithSpan, quote) { + return this._async_evaluate$_addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__serialize_closure0(value, quote)); + }, + _async_evaluate$_serialize$2(value, nodeWithSpan) { + return this._async_evaluate$_serialize$3$quote(value, nodeWithSpan, true); + }, + _async_evaluate$_expressionNode$1(expression) { + var t1; + if (expression instanceof A.VariableExpression) { + t1 = this._async_evaluate$_addExceptionSpan$2(expression, new A._EvaluateVisitor__expressionNode_closure0(this, expression)); + return t1 == null ? expression : t1; + } else + return expression; + }, + _async_evaluate$_withParent$2$4$scopeWhen$through(node, callback, scopeWhen, through, $S, $T) { + return this._withParent$body$_EvaluateVisitor(node, callback, scopeWhen, through, $S, $T, $T); + }, + _async_evaluate$_withParent$2$2(node, callback, $S, $T) { + return this._async_evaluate$_withParent$2$4$scopeWhen$through(node, callback, true, null, $S, $T); + }, + _async_evaluate$_withParent$2$3$scopeWhen(node, callback, scopeWhen, $S, $T) { + return this._async_evaluate$_withParent$2$4$scopeWhen$through(node, callback, scopeWhen, null, $S, $T); + }, + _withParent$body$_EvaluateVisitor(node, callback, scopeWhen, through, $S, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$self = this, oldParent, result; + var $async$_async_evaluate$_withParent$2$4$scopeWhen$through = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$self._async_evaluate$_addChild$2$through(node, through); + oldParent = $async$self._async_evaluate$_assertInModule$2($async$self._async_evaluate$__parent, "__parent"); + $async$self._async_evaluate$__parent = node; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate$_environment.scope$1$2$when(callback, scopeWhen, $T), $async$_async_evaluate$_withParent$2$4$scopeWhen$through); + case 3: + // returning from await. + result = $async$result; + $async$self._async_evaluate$__parent = oldParent; + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_withParent$2$4$scopeWhen$through, $async$completer); + }, + _async_evaluate$_addChild$2$through(node, through) { + var _0_0, grandparent, t1, + $parent = this._async_evaluate$_assertInModule$2(this._async_evaluate$__parent, "__parent"); + if (through != null) { + for (; through.call$1($parent); $parent = _0_0) { + _0_0 = $parent._parent; + if (_0_0 == null) + throw A.wrapException(A.ArgumentError$(string$.throug + node.toString$0(0) + ".", null)); + } + if ($parent.get$hasFollowingSibling()) { + grandparent = $parent._parent; + t1 = grandparent.children; + if ($parent.equalsIgnoringChildren$1(t1.get$last(t1))) + $parent = type$.ModifiableCssParentNode._as(t1.get$last(t1)); + else { + $parent = $parent.copyWithoutChildren$0(); + grandparent.addChild$1($parent); + } + } + } + $parent.addChild$1(node); + }, + _async_evaluate$_addChild$1(node) { + return this._async_evaluate$_addChild$2$through(node, null); + }, + _async_evaluate$_withStyleRule$1$2(rule, callback, $T) { + return this._withStyleRule$body$_EvaluateVisitor(rule, callback, $T, $T); + }, + _withStyleRule$body$_EvaluateVisitor(rule, callback, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$self = this, result, oldRule; + var $async$_async_evaluate$_withStyleRule$1$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + oldRule = $async$self._async_evaluate$_styleRuleIgnoringAtRoot; + $async$self._async_evaluate$_styleRuleIgnoringAtRoot = rule; + $async$goto = 3; + return A._asyncAwait(callback.call$0(), $async$_async_evaluate$_withStyleRule$1$2); + case 3: + // returning from await. + result = $async$result; + $async$self._async_evaluate$_styleRuleIgnoringAtRoot = oldRule; + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_withStyleRule$1$2, $async$completer); + }, + _async_evaluate$_withMediaQueries$1$3(queries, sources, callback, $T) { + return this._withMediaQueries$body$_EvaluateVisitor(queries, sources, callback, $T, $T); + }, + _withMediaQueries$body$_EvaluateVisitor(queries, sources, callback, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$self = this, result, oldMediaQueries, oldSources; + var $async$_async_evaluate$_withMediaQueries$1$3 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + oldMediaQueries = $async$self._async_evaluate$_mediaQueries; + oldSources = $async$self._async_evaluate$_mediaQuerySources; + $async$self._async_evaluate$_mediaQueries = queries; + $async$self._async_evaluate$_mediaQuerySources = sources; + $async$goto = 3; + return A._asyncAwait(callback.call$0(), $async$_async_evaluate$_withMediaQueries$1$3); + case 3: + // returning from await. + result = $async$result; + $async$self._async_evaluate$_mediaQueries = oldMediaQueries; + $async$self._async_evaluate$_mediaQuerySources = oldSources; + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_withMediaQueries$1$3, $async$completer); + }, + _async_evaluate$_withStackFrame$1$3(member, nodeWithSpan, callback, $T) { + return this._withStackFrame$body$_EvaluateVisitor(member, nodeWithSpan, callback, $T, $T); + }, + _withStackFrame$body$_EvaluateVisitor(member, nodeWithSpan, callback, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$self = this, oldMember, result, t1; + var $async$_async_evaluate$_withStackFrame$1$3 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self._async_evaluate$_stack; + t1.push(new A._Record_2($async$self._async_evaluate$_member, nodeWithSpan)); + oldMember = $async$self._async_evaluate$_member; + $async$self._async_evaluate$_member = member; + $async$goto = 3; + return A._asyncAwait(callback.call$0(), $async$_async_evaluate$_withStackFrame$1$3); + case 3: + // returning from await. + result = $async$result; + $async$self._async_evaluate$_member = oldMember; + t1.pop(); + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_withStackFrame$1$3, $async$completer); + }, + _async_evaluate$_withoutSlash$2(value, nodeForSpan) { + var t1; + if (value instanceof A.SassNumber) + t1 = value.asSlash != null; + else + t1 = false; + if (t1) + this._async_evaluate$_warn$3(string$.Using__i + A.S(new A._EvaluateVisitor__withoutSlash_recommendation0().call$1(value)) + string$.x0a_Morex20, nodeForSpan.get$span(nodeForSpan), B.Deprecation_BvP); + return value.withoutSlash$0(); + }, + _async_evaluate$_stackFrame$2(member, span) { + return A.frameForSpan(span, member, A.NullableExtension_andThen(span.get$sourceUrl(span), new A._EvaluateVisitor__stackFrame_closure0(this))); + }, + _async_evaluate$_stackTrace$1(span) { + var t2, t3, _i, t4, nodeWithSpan, _this = this, + t1 = A._setArrayType([], type$.JSArray_Frame); + for (t2 = _this._async_evaluate$_stack, t3 = t2.length, _i = 0; _i < t2.length; t2.length === t3 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + t4 = t2[_i]; + nodeWithSpan = t4._1; + t1.push(_this._async_evaluate$_stackFrame$2(t4._0, nodeWithSpan.get$span(nodeWithSpan))); + } + if (span != null) + t1.push(_this._async_evaluate$_stackFrame$2(_this._async_evaluate$_member, span)); + return A.Trace$(new A.ReversedListIterable(t1, type$.ReversedListIterable_Frame), null); + }, + _async_evaluate$_stackTrace$0() { + return this._async_evaluate$_stackTrace$1(null); + }, + _async_evaluate$_warn$3(message, span, deprecation) { + var trace, t1, _this = this; + if (_this._async_evaluate$_quietDeps && _this._async_evaluate$_inDependency) + return; + if (!_this._async_evaluate$_warningsEmitted.add$1(0, new A._Record_2(message, span))) + return; + trace = _this._async_evaluate$_stackTrace$1(span); + t1 = _this._async_evaluate$_logger; + if (deprecation == null) + t1.internalWarn$4$deprecation$span$trace(message, null, span, trace); + else + A.WarnForDeprecation_warnForDeprecation(t1, deprecation, message, span, trace); + }, + _async_evaluate$_warn$2(message, span) { + return this._async_evaluate$_warn$3(message, span, null); + }, + _async_evaluate$_exception$2(message, span) { + var t1, t2; + if (span == null) { + t1 = B.JSArray_methods.get$last(this._async_evaluate$_stack)._1; + t1 = t1.get$span(t1); + } else + t1 = span; + t2 = this._async_evaluate$_stackTrace$1(span); + return new A.SassRuntimeException(t2, B.Set_empty, message, t1); + }, + _async_evaluate$_exception$1(message) { + return this._async_evaluate$_exception$2(message, null); + }, + _async_evaluate$_multiSpanException$3(message, primaryLabel, secondaryLabels) { + var t1 = B.JSArray_methods.get$last(this._async_evaluate$_stack)._1; + return A.MultiSpanSassRuntimeException$(message, t1.get$span(t1), primaryLabel, secondaryLabels, this._async_evaluate$_stackTrace$0(), null); + }, + _async_evaluate$_addExceptionSpan$1$2(nodeWithSpan, callback) { + var error, stackTrace, t1, exception, + addStackFrame = true; + try { + t1 = callback.call$0(); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassScriptException) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = error.withSpan$1(nodeWithSpan.get$span(nodeWithSpan)); + A.throwWithTrace(t1.withTrace$1(this._async_evaluate$_stackTrace$1(addStackFrame ? nodeWithSpan.get$span(nodeWithSpan) : null)), error, stackTrace); + } else + throw exception; + } + }, + _async_evaluate$_addExceptionSpan$2(nodeWithSpan, callback) { + return this._async_evaluate$_addExceptionSpan$1$2(nodeWithSpan, callback, type$.dynamic); + }, + _addExceptionSpanAsync$1$3$addStackFrame(nodeWithSpan, callback, addStackFrame, $T) { + return this._addExceptionSpanAsync$body$_EvaluateVisitor(nodeWithSpan, callback, addStackFrame, $T, $T); + }, + _addExceptionSpanAsync$1$2(nodeWithSpan, callback, $T) { + return this._addExceptionSpanAsync$1$3$addStackFrame(nodeWithSpan, callback, true, $T); + }, + _addExceptionSpanAsync$body$_EvaluateVisitor(nodeWithSpan, callback, addStackFrame, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$self = this, error, stackTrace, t1, exception, $async$exception; + var $async$_addExceptionSpanAsync$1$3$addStackFrame = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$handler = 4; + t1 = callback.call$0(); + $async$goto = 7; + return A._asyncAwait($T._eval$1("Future<0>")._is(t1) ? t1 : A._Future$value(t1, $T), $async$_addExceptionSpanAsync$1$3$addStackFrame); + case 7: + // returning from await. + t1 = $async$result; + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + $async$handler = 2; + // goto after finally + $async$goto = 6; + break; + case 4: + // catch + $async$handler = 3; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (t1 instanceof A.SassScriptException) { + error = t1; + stackTrace = A.getTraceFromException($async$exception); + t1 = error.withSpan$1(nodeWithSpan.get$span(nodeWithSpan)); + A.throwWithTrace(t1.withTrace$1($async$self._async_evaluate$_stackTrace$1(addStackFrame ? nodeWithSpan.get$span(nodeWithSpan) : null)), error, stackTrace); + } else + throw $async$exception; + // goto after finally + $async$goto = 6; + break; + case 3: + // uncaught + // goto rethrow + $async$goto = 2; + break; + case 6: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$_addExceptionSpanAsync$1$3$addStackFrame, $async$completer); + }, + _async_evaluate$_addExceptionTrace$1$1(callback, $T) { + return this._addExceptionTrace$body$_EvaluateVisitor(callback, $T, $T); + }, + _addExceptionTrace$body$_EvaluateVisitor(callback, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$self = this, error, stackTrace, t1, exception, t2, $async$exception; + var $async$_async_evaluate$_addExceptionTrace$1$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$handler = 4; + t1 = callback.call$0(); + $async$goto = 7; + return A._asyncAwait($T._eval$1("Future<0>")._is(t1) ? t1 : A._Future$value(t1, $T), $async$_async_evaluate$_addExceptionTrace$1$1); + case 7: + // returning from await. + t1 = $async$result; + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + $async$handler = 2; + // goto after finally + $async$goto = 6; + break; + case 4: + // catch + $async$handler = 3; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (type$.SassRuntimeException._is(t1)) + throw $async$exception; + else if (t1 instanceof A.SassException) { + error = t1; + stackTrace = A.getTraceFromException($async$exception); + t1 = error; + t2 = J.getInterceptor$z(t1); + A.throwWithTrace(error.withTrace$1($async$self._async_evaluate$_stackTrace$1(A.SourceSpanException.prototype.get$span.call(t2, t1))), error, stackTrace); + } else + throw $async$exception; + // goto after finally + $async$goto = 6; + break; + case 3: + // uncaught + // goto rethrow + $async$goto = 2; + break; + case 6: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_addExceptionTrace$1$1, $async$completer); + }, + _async_evaluate$_addErrorSpan$1$2(nodeWithSpan, callback, $T) { + return this._addErrorSpan$body$_EvaluateVisitor(nodeWithSpan, callback, $T, $T); + }, + _addErrorSpan$body$_EvaluateVisitor(nodeWithSpan, callback, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$self = this, error, stackTrace, t1, exception, t2, t3, $async$exception; + var $async$_async_evaluate$_addErrorSpan$1$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$handler = 4; + $async$goto = 7; + return A._asyncAwait(callback.call$0(), $async$_async_evaluate$_addErrorSpan$1$2); + case 7: + // returning from await. + t1 = $async$result; + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + $async$handler = 2; + // goto after finally + $async$goto = 6; + break; + case 4: + // catch + $async$handler = 3; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (type$.SassRuntimeException._is(t1)) { + error = t1; + stackTrace = A.getTraceFromException($async$exception); + if (!B.JSString_methods.startsWith$1(J.get$span$z(error).get$text(), "@error")) + throw $async$exception; + t1 = error._span_exception$_message; + t2 = nodeWithSpan.get$span(nodeWithSpan); + t3 = $async$self._async_evaluate$_stackTrace$0(); + A.throwWithTrace(new A.SassRuntimeException(t3, B.Set_empty, t1, t2), error, stackTrace); + } else + throw $async$exception; + // goto after finally + $async$goto = 6; + break; + case 3: + // uncaught + // goto rethrow + $async$goto = 2; + break; + case 6: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate$_addErrorSpan$1$2, $async$completer); + }, + _async_evaluate$_getErrorMessage$1(error) { + var t1, exception; + if (type$.Error._is(error)) + return error.toString$0(0); + try { + t1 = A._asString(J.get$message$x(error)); + return t1; + } catch (exception) { + t1 = J.toString$0$(error); + return t1; + } + } + }; + A._EvaluateVisitor_closure12.prototype = { + call$1($arguments) { + var module, t2, + t1 = J.getInterceptor$asx($arguments), + variable = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this._async_evaluate$_environment; + t2 = A.stringReplaceAllUnchecked(variable._string$_text, "_", "-"); + return t1.globalVariableExists$2$namespace(t2, module == null ? null : module._string$_text) ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._EvaluateVisitor_closure13.prototype = { + call$1($arguments) { + var variable = J.$index$asx($arguments, 0).assertString$1("name"), + t1 = this.$this._async_evaluate$_environment; + return t1.getVariable$1(A.stringReplaceAllUnchecked(variable._string$_text, "_", "-")) != null ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._EvaluateVisitor_closure14.prototype = { + call$1($arguments) { + var module, t2, t3, t4, + t1 = J.getInterceptor$asx($arguments), + variable = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this; + t2 = t1._async_evaluate$_environment; + t3 = variable._string$_text; + t4 = A.stringReplaceAllUnchecked(t3, "_", "-"); + return t2.getFunction$2$namespace(t4, module == null ? null : module._string$_text) != null || t1._async_evaluate$_builtInFunctions.containsKey$1(t3) ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._EvaluateVisitor_closure15.prototype = { + call$1($arguments) { + var module, t2, + t1 = J.getInterceptor$asx($arguments), + variable = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this._async_evaluate$_environment; + t2 = A.stringReplaceAllUnchecked(variable._string$_text, "_", "-"); + return t1.getMixin$2$namespace(t2, module == null ? null : module._string$_text) != null ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._EvaluateVisitor_closure16.prototype = { + call$1($arguments) { + var t1 = this.$this._async_evaluate$_environment; + if (!t1._async_environment$_inMixin) + throw A.wrapException(A.SassScriptException$(string$.conten, null)); + return t1._async_environment$_content != null ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._EvaluateVisitor_closure17.prototype = { + call$1($arguments) { + var t2, t3, t4, + t1 = J.$index$asx($arguments, 0).assertString$1("module")._string$_text, + module = this.$this._async_evaluate$_environment._async_environment$_modules.$index(0, t1); + if (module == null) + throw A.wrapException('There is no module with namespace "' + t1 + '".'); + t1 = type$.Value; + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t3 = A.MapExtensions_get_pairs(module.get$variables(), type$.String, t1), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t2.$indexSet(0, new A.SassString(t4._0, true), t4._1); + } + return new A.SassMap(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 38 + }; + A._EvaluateVisitor_closure18.prototype = { + call$1($arguments) { + var t2, t3, t4, + t1 = J.$index$asx($arguments, 0).assertString$1("module")._string$_text, + module = this.$this._async_evaluate$_environment._async_environment$_modules.$index(0, t1); + if (module == null) + throw A.wrapException('There is no module with namespace "' + t1 + '".'); + t1 = type$.Value; + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t3 = A.MapExtensions_get_pairs(module.get$functions(module), type$.String, type$.AsyncCallable), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t2.$indexSet(0, new A.SassString(t4._0, true), new A.SassFunction(t4._1)); + } + return new A.SassMap(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 38 + }; + A._EvaluateVisitor_closure19.prototype = { + call$1($arguments) { + var t2, t3, t4, + t1 = J.$index$asx($arguments, 0).assertString$1("module")._string$_text, + module = this.$this._async_evaluate$_environment._async_environment$_modules.$index(0, t1); + if (module == null) + throw A.wrapException('There is no module with namespace "' + t1 + '".'); + t1 = type$.Value; + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t3 = A.MapExtensions_get_pairs(module.get$mixins(), type$.String, type$.AsyncCallable), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t2.$indexSet(0, new A.SassString(t4._0, true), new A.SassMixin(t4._1)); + } + return new A.SassMap(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 38 + }; + A._EvaluateVisitor_closure20.prototype = { + call$1($arguments) { + var module, t2, callable, + t1 = J.getInterceptor$asx($arguments), + $name = t1.$index($arguments, 0).assertString$1("name"), + css = t1.$index($arguments, 1).get$isTruthy(); + t1 = t1.$index($arguments, 2).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + if (css) { + if (module != null) + throw A.wrapException(string$.x24css_a); + return new A.SassFunction(new A.PlainCssCallable($name._string$_text)); + } + t1 = this.$this; + t2 = t1._async_evaluate$_callableNode; + t2.toString; + callable = t1._async_evaluate$_addExceptionSpan$2(t2, new A._EvaluateVisitor__closure6(t1, $name, module)); + if (callable == null) + throw A.wrapException("Function not found: " + $name.toString$0(0)); + return new A.SassFunction(callable); + }, + $signature: 167 + }; + A._EvaluateVisitor__closure6.prototype = { + call$0() { + var local, + normalizedName = A.stringReplaceAllUnchecked(this.name._string$_text, "_", "-"), + t1 = this.module, + namespace = t1 == null ? null : t1._string$_text; + t1 = this.$this; + local = t1._async_evaluate$_environment.getFunction$2$namespace(normalizedName, namespace); + if (local != null || namespace != null) + return local; + return t1._async_evaluate$_builtInFunctions.$index(0, normalizedName); + }, + $signature: 100 + }; + A._EvaluateVisitor_closure21.prototype = { + call$1($arguments) { + var module, t2, callable, + t1 = J.getInterceptor$asx($arguments), + $name = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this; + t2 = t1._async_evaluate$_callableNode; + t2.toString; + callable = t1._async_evaluate$_addExceptionSpan$2(t2, new A._EvaluateVisitor__closure5(t1, $name, module)); + if (callable == null) + throw A.wrapException("Mixin not found: " + $name.toString$0(0)); + return new A.SassMixin(callable); + }, + $signature: 168 + }; + A._EvaluateVisitor__closure5.prototype = { + call$0() { + var t1 = this.$this._async_evaluate$_environment, + t2 = A.stringReplaceAllUnchecked(this.name._string$_text, "_", "-"), + t3 = this.module; + return t1.getMixin$2$namespace(t2, t3 == null ? null : t3._string$_text); + }, + $signature: 100 + }; + A._EvaluateVisitor_closure22.prototype = { + call$1($arguments) { + return this.$call$body$_EvaluateVisitor_closure1($arguments); + }, + $call$body$_EvaluateVisitor_closure1($arguments) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue, $async$self = this, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, invocation, callableNode, t1, $function, args; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = J.getInterceptor$asx($arguments); + $function = t1.$index($arguments, 0); + args = type$.SassArgumentList._as(t1.$index($arguments, 1)); + t1 = $async$self.$this; + t2 = t1._async_evaluate$_callableNode; + t2.toString; + t3 = A._setArrayType([], type$.JSArray_Expression); + t4 = type$.String; + t5 = type$.Expression; + t6 = t2.get$span(t2); + t7 = t2.get$span(t2); + args._wereKeywordsAccessed = true; + t8 = args._keywords; + if (t8.get$isEmpty(t8)) + t2 = null; + else { + t9 = type$.Value; + t10 = A.LinkedHashMap_LinkedHashMap$_empty(t9, t9); + args._wereKeywordsAccessed = true; + t8 = A.MapExtensions_get_pairs(t8, t4, t9); + t8 = t8.get$iterator(t8); + for (; t8.moveNext$0();) { + t11 = t8.get$current(t8); + t10.$indexSet(0, new A.SassString(t11._0, false), t11._1); + } + t2 = new A.ValueExpression(new A.SassMap(A.ConstantMap_ConstantMap$from(t10, t9, t9)), t2.get$span(t2)); + } + invocation = new A.ArgumentList(A.List_List$unmodifiable(t3, t5), A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_empty(t4, t5), t4, t5), new A.ValueExpression(args, t7), t2, t6); + $async$goto = $function instanceof A.SassString ? 3 : 4; + break; + case 3: + // then + A.warnForDeprecation(string$.Passina + $function.toString$0(0) + "))", B.Deprecation_dAn); + callableNode = t1._async_evaluate$_callableNode; + t2 = $function._string$_text; + t3 = callableNode.get$span(callableNode); + t1 = t1.visitFunctionExpression$1(0, new A.FunctionExpression(null, A.stringReplaceAllUnchecked(t2, "_", "-"), t2, invocation, t3)); + $async$goto = 5; + return A._asyncAwait(type$.Future_Value._is(t1) ? t1 : A._Future$value(t1, type$.Value), $async$call$1); + case 5: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + case 4: + // join + t2 = $function.assertFunction$1("function"); + t3 = t1._async_evaluate$_callableNode; + t3.toString; + $async$goto = 6; + return A._asyncAwait(t1._async_evaluate$_runFunctionCallable$3(invocation, t2.callable, t3), $async$call$1); + case 6: + // returning from await. + t3 = $async$result; + $async$returnValue = t3; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 187 + }; + A._EvaluateVisitor_closure23.prototype = { + call$1($arguments) { + return this.$call$body$_EvaluateVisitor_closure0($arguments); + }, + $call$body$_EvaluateVisitor_closure0($arguments) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, withMap, t2, values, configuration, t3, t1, url; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = J.getInterceptor$asx($arguments); + url = A.Uri_parse(t1.$index($arguments, 0).assertString$1("url")._string$_text); + t1 = t1.$index($arguments, 1).get$realNull(); + withMap = t1 == null ? null : t1.assertMap$1("with")._map$_contents; + t1 = $async$self.$this; + t2 = t1._async_evaluate$_callableNode; + t2.toString; + if (withMap != null) { + values = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.ConfiguredValue); + withMap.forEach$1(0, new A._EvaluateVisitor__closure3(values, t2.get$span(t2), t2)); + configuration = new A.ExplicitConfiguration(t2, values, null); + } else + configuration = B.Configuration_Map_empty_null; + t3 = t2.get$span(t2); + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate$_loadModule$7$baseUrl$configuration$namesInErrors(url, "load-css()", t2, new A._EvaluateVisitor__closure4(t1), t3.get$sourceUrl(t3), configuration, true), $async$call$1); + case 2: + // returning from await. + t1._async_evaluate$_assertConfigurationIsEmpty$2$nameInError(configuration, true); + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 169 + }; + A._EvaluateVisitor__closure3.prototype = { + call$2(variable, value) { + var t1 = variable.assertString$1("with key"), + $name = A.stringReplaceAllUnchecked(t1._string$_text, "_", "-"); + t1 = this.values; + if (t1.containsKey$1($name)) + throw A.wrapException("The variable $" + $name + " was configured twice."); + t1.$indexSet(0, $name, new A.ConfiguredValue(value, this.span, this.callableNode)); + }, + $signature: 101 + }; + A._EvaluateVisitor__closure4.prototype = { + call$2(module, _) { + var t1 = this.$this; + return t1._async_evaluate$_combineCss$2$clone(module, true).accept$1(t1); + }, + $signature: 360 + }; + A._EvaluateVisitor_closure24.prototype = { + call$1($arguments) { + return this.$call$body$_EvaluateVisitor_closure($arguments); + }, + $call$body$_EvaluateVisitor_closure($arguments) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, callableNode, t2, t3, t4, t5, t1, mixin, args; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = J.getInterceptor$asx($arguments); + mixin = t1.$index($arguments, 0); + args = type$.SassArgumentList._as(t1.$index($arguments, 1)); + t1 = $async$self.$this; + callableNode = t1._async_evaluate$_callableNode; + t2 = callableNode.get$span(callableNode); + t3 = callableNode.get$span(callableNode); + t4 = type$.Expression; + t5 = A.List_List$unmodifiable(B.List_empty9, t4); + t4 = A.ConstantMap_ConstantMap$from(B.Map_empty5, type$.String, t4); + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate$_applyMixin$5(mixin.assertMixin$1("mixin").callable, t1._async_evaluate$_environment._async_environment$_content, new A.ArgumentList(t5, t4, new A.ValueExpression(args, t3), null, t2), callableNode, callableNode), $async$call$1); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 169 + }; + A._EvaluateVisitor_run_closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet), + $async$returnValue, $async$self = this, module, t1, t2, _0_0, url; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node; + t2 = t1.span; + _0_0 = t2.get$sourceUrl(t2); + url = null; + if (_0_0 != null) { + url = _0_0; + t2 = $async$self.$this; + t2._async_evaluate$_activeModules.$indexSet(0, url, null); + t2._async_evaluate$_loadedUrls.add$1(0, url); + } + t2 = $async$self.$this; + $async$goto = 3; + return A._asyncAwait(t2._async_evaluate$_addExceptionTrace$1$1(new A._EvaluateVisitor_run__closure0(t2, $async$self.importer, t1), type$.Module_AsyncCallable), $async$call$0); + case 3: + // returning from await. + module = $async$result; + $async$returnValue = new A._Record_2_loadedUrls_stylesheet(t2._async_evaluate$_loadedUrls, t2._async_evaluate$_combineCss$1(module)); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 361 + }; + A._EvaluateVisitor_run__closure0.prototype = { + call$0() { + return this.$this._async_evaluate$_execute$2(this.importer, this.node); + }, + $signature: 367 + }; + A._EvaluateVisitor__loadModule_closure1.prototype = { + call$0() { + return this.callback.call$2(this._box_0.builtInModule, false); + }, + $signature: 0 + }; + A._EvaluateVisitor__loadModule_closure2.prototype = { + call$0() { + return this.$call$body$_EvaluateVisitor__loadModule_closure(); + }, + $call$body$_EvaluateVisitor__loadModule_closure() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$handler = 1, $async$errorStack = [], $async$next = [], $async$self = this, canonicalUrl, oldInDependency, isDependency, t4, message, t1, stylesheet, importer, t2, t3, _1_0, $async$temp1; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = {}; + stylesheet = null; + importer = null; + t2 = $async$self.$this; + t3 = $async$self.nodeWithSpan; + $async$goto = 2; + return A._asyncAwait(t2._async_evaluate$_loadStylesheet$3$baseUrl($async$self.url.toString$0(0), t3.get$span(t3), $async$self.baseUrl), $async$call$0); + case 2: + // returning from await. + _1_0 = $async$result; + stylesheet = _1_0._0; + importer = _1_0._1; + isDependency = _1_0._2; + t4 = stylesheet.span; + canonicalUrl = t4.get$sourceUrl(t4); + if (canonicalUrl != null) { + t4 = t2._async_evaluate$_activeModules; + if (t4.containsKey$1(canonicalUrl)) { + if ($async$self.namesInErrors) { + t1 = canonicalUrl; + t3 = $.$get$context(); + t1.toString; + message = "Module loop: " + t3.prettyUri$1(t1) + " is already being loaded."; + } else + message = string$.Modulel; + t1 = A.NullableExtension_andThen(t4.$index(0, canonicalUrl), new A._EvaluateVisitor__loadModule__closure1(t2, message)); + throw A.wrapException(t1 == null ? t2._async_evaluate$_exception$1(message) : t1); + } else + t4.$indexSet(0, canonicalUrl, t3); + } + t4 = t2._async_evaluate$_modules.containsKey$1(canonicalUrl); + oldInDependency = t2._async_evaluate$_inDependency; + t2._async_evaluate$_inDependency = isDependency; + t1.module = null; + $async$handler = 3; + $async$temp1 = t1; + $async$goto = 6; + return A._asyncAwait(t2._async_evaluate$_execute$5$configuration$namesInErrors$nodeWithSpan(importer, stylesheet, $async$self.configuration, $async$self.namesInErrors, t3), $async$call$0); + case 6: + // returning from await. + $async$temp1.module = $async$result; + $async$next.push(5); + // goto finally + $async$goto = 4; + break; + case 3: + // uncaught + $async$next = [1]; + case 4: + // finally + $async$handler = 1; + t2._async_evaluate$_activeModules.remove$1(0, canonicalUrl); + t2._async_evaluate$_inDependency = oldInDependency; + // goto the next finally handler + $async$goto = $async$next.pop(); + break; + case 5: + // after finally + $async$goto = 7; + return A._asyncAwait(t2._addExceptionSpanAsync$1$3$addStackFrame(t3, new A._EvaluateVisitor__loadModule__closure2(t1, $async$self.callback, !t4), false, type$.void), $async$call$0); + case 7: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + case 1: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor__loadModule__closure1.prototype = { + call$1(previousLoad) { + return this.$this._async_evaluate$_multiSpanException$3(this.message, "new load", A.LinkedHashMap_LinkedHashMap$_literal([previousLoad.get$span(previousLoad), "original load"], type$.FileSpan, type$.String)); + }, + $signature: 85 + }; + A._EvaluateVisitor__loadModule__closure2.prototype = { + call$0() { + return this.callback.call$2(this._box_1.module, this.firstLoad); + }, + $signature: 0 + }; + A._EvaluateVisitor__execute_closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t3, t4, t5, t6, t1, oldImporter, oldStylesheet, oldRoot, oldPreModuleComments, oldParent, oldEndOfImports, oldOutOfOrderImports, oldExtensionStore, t2, oldStyleRule, oldMediaQueries, oldDeclarationName, oldInUnknownAtRule, oldInKeyframes, oldConfiguration; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + oldImporter = t1._async_evaluate$_importer; + oldStylesheet = t1._async_evaluate$__stylesheet; + oldRoot = t1._async_evaluate$__root; + oldPreModuleComments = t1._async_evaluate$_preModuleComments; + oldParent = t1._async_evaluate$__parent; + oldEndOfImports = t1._async_evaluate$__endOfImports; + oldOutOfOrderImports = t1._async_evaluate$_outOfOrderImports; + oldExtensionStore = t1._async_evaluate$__extensionStore; + t2 = t1._async_evaluate$_atRootExcludingStyleRule; + oldStyleRule = t2 ? null : t1._async_evaluate$_styleRuleIgnoringAtRoot; + oldMediaQueries = t1._async_evaluate$_mediaQueries; + oldDeclarationName = t1._async_evaluate$_declarationName; + oldInUnknownAtRule = t1._async_evaluate$_inUnknownAtRule; + oldInKeyframes = t1._async_evaluate$_inKeyframes; + oldConfiguration = t1._async_evaluate$_configuration; + t1._async_evaluate$_importer = $async$self.importer; + t3 = t1._async_evaluate$__stylesheet = $async$self.stylesheet; + t4 = t3.span; + t5 = t1._async_evaluate$__parent = t1._async_evaluate$__root = A.ModifiableCssStylesheet$(t4); + t1._async_evaluate$__endOfImports = 0; + t1._async_evaluate$_outOfOrderImports = null; + t1._async_evaluate$__extensionStore = $async$self.extensionStore; + t1._async_evaluate$_declarationName = t1._async_evaluate$_mediaQueries = t1._async_evaluate$_styleRuleIgnoringAtRoot = null; + t1._async_evaluate$_inKeyframes = t1._async_evaluate$_atRootExcludingStyleRule = t1._async_evaluate$_inUnknownAtRule = false; + t6 = $async$self.configuration; + if (t6 != null) + t1._async_evaluate$_configuration = t6; + $async$goto = 2; + return A._asyncAwait(t1.visitStylesheet$1(0, t3), $async$call$0); + case 2: + // returning from await. + t3 = t1._async_evaluate$_outOfOrderImports == null ? t5 : new A.CssStylesheet(new A.UnmodifiableListView(t1._async_evaluate$_addOutOfOrderImports$0(), type$.UnmodifiableListView_CssNode), t4); + $async$self.css.__late_helper$_value = t3; + $async$self.preModuleComments.__late_helper$_value = t1._async_evaluate$_preModuleComments; + t1._async_evaluate$_importer = oldImporter; + t1._async_evaluate$__stylesheet = oldStylesheet; + t1._async_evaluate$__root = oldRoot; + t1._async_evaluate$_preModuleComments = oldPreModuleComments; + t1._async_evaluate$__parent = oldParent; + t1._async_evaluate$__endOfImports = oldEndOfImports; + t1._async_evaluate$_outOfOrderImports = oldOutOfOrderImports; + t1._async_evaluate$__extensionStore = oldExtensionStore; + t1._async_evaluate$_styleRuleIgnoringAtRoot = oldStyleRule; + t1._async_evaluate$_mediaQueries = oldMediaQueries; + t1._async_evaluate$_declarationName = oldDeclarationName; + t1._async_evaluate$_inUnknownAtRule = oldInUnknownAtRule; + t1._async_evaluate$_atRootExcludingStyleRule = t2; + t1._async_evaluate$_inKeyframes = oldInKeyframes; + t1._async_evaluate$_configuration = oldConfiguration; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor__combineCss_closure1.prototype = { + call$1(module) { + return module.get$transitivelyContainsCss(); + }, + $signature: 130 + }; + A._EvaluateVisitor__combineCss_closure2.prototype = { + call$1(target) { + return !this.selectors.contains$1(0, target); + }, + $signature: 13 + }; + A._EvaluateVisitor__combineCss_visitModule0.prototype = { + call$1(module) { + var t1, t2, t3, t4, _i, upstream, _1_0, statements, index, _this = this; + if (!_this.seen.add$1(0, module)) + return; + if (_this.clone) + module = module.cloneCss$0(); + for (t1 = module.get$upstream(), t2 = t1.length, t3 = _this.css, t4 = _this.imports, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + upstream = t1[_i]; + if (upstream.get$transitivelyContainsCss()) { + _1_0 = module.get$preModuleComments().$index(0, upstream); + if (_1_0 != null) + B.JSArray_methods.addAll$1(t3.length === 0 ? t4 : t3, _1_0); + _this.call$1(upstream); + } + } + _this.sorted.addFirst$1(module); + t1 = module.get$css(module); + statements = t1.get$children(t1); + index = _this.$this._async_evaluate$_indexAfterImports$1(statements); + t1 = J.getInterceptor$ax(statements); + B.JSArray_methods.addAll$1(t4, t1.getRange$2(statements, 0, index)); + B.JSArray_methods.addAll$1(t3, t1.getRange$2(statements, index, t1.get$length(statements))); + }, + $signature: 389 + }; + A._EvaluateVisitor__extendModules_closure1.prototype = { + call$1(target) { + return !this.originalSelectors.contains$1(0, target); + }, + $signature: 13 + }; + A._EvaluateVisitor__extendModules_closure2.prototype = { + call$0() { + return A._setArrayType([], type$.JSArray_ExtensionStore); + }, + $signature: 141 + }; + A._EvaluateVisitor_visitAtRootRule_closure1.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitAtRootRule_closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 32 + }; + A._EvaluateVisitor__scopeForAtRoot_closure5.prototype = { + call$1(callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, oldParent; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + oldParent = t1._async_evaluate$_assertInModule$2(t1._async_evaluate$__parent, "__parent"); + t1._async_evaluate$__parent = $async$self.newParent; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate$_environment.scope$1$2$when(callback, $async$self.node.hasDeclarations, type$.void), $async$call$1); + case 2: + // returning from await. + t1._async_evaluate$__parent = oldParent; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 40 + }; + A._EvaluateVisitor__scopeForAtRoot_closure6.prototype = { + call$1(callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, oldAtRootExcludingStyleRule; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + oldAtRootExcludingStyleRule = t1._async_evaluate$_atRootExcludingStyleRule; + t1._async_evaluate$_atRootExcludingStyleRule = true; + $async$goto = 2; + return A._asyncAwait($async$self.innerScope.call$1(callback), $async$call$1); + case 2: + // returning from await. + t1._async_evaluate$_atRootExcludingStyleRule = oldAtRootExcludingStyleRule; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 40 + }; + A._EvaluateVisitor__scopeForAtRoot_closure7.prototype = { + call$1(callback) { + return this.$this._async_evaluate$_withMediaQueries$1$3(null, null, new A._EvaluateVisitor__scopeForAtRoot__closure0(this.innerScope, callback), type$.Null); + }, + $signature: 40 + }; + A._EvaluateVisitor__scopeForAtRoot__closure0.prototype = { + call$0() { + return this.innerScope.call$1(this.callback); + }, + $signature: 2 + }; + A._EvaluateVisitor__scopeForAtRoot_closure8.prototype = { + call$1(callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, wasInKeyframes; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + wasInKeyframes = t1._async_evaluate$_inKeyframes; + t1._async_evaluate$_inKeyframes = false; + $async$goto = 2; + return A._asyncAwait($async$self.innerScope.call$1(callback), $async$call$1); + case 2: + // returning from await. + t1._async_evaluate$_inKeyframes = wasInKeyframes; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 40 + }; + A._EvaluateVisitor__scopeForAtRoot_closure9.prototype = { + call$1($parent) { + return $parent instanceof A.ModifiableCssAtRule; + }, + $signature: 172 + }; + A._EvaluateVisitor__scopeForAtRoot_closure10.prototype = { + call$1(callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, wasInUnknownAtRule; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + wasInUnknownAtRule = t1._async_evaluate$_inUnknownAtRule; + t1._async_evaluate$_inUnknownAtRule = false; + $async$goto = 2; + return A._asyncAwait($async$self.innerScope.call$1(callback), $async$call$1); + case 2: + // returning from await. + t1._async_evaluate$_inUnknownAtRule = wasInUnknownAtRule; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 40 + }; + A._EvaluateVisitor_visitContentRule_closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$returnValue, $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.content.declaration.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 3: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 5; + break; + } + $async$goto = 6; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 6: + // returning from await. + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitDeclaration_closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self._box_0.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitEachRule_closure2.prototype = { + call$1(value) { + var t1 = this.$this, + t2 = this.nodeWithSpan; + return t1._async_evaluate$_environment.setLocalVariable$3(this._box_0.variable, t1._async_evaluate$_withoutSlash$2(value, t2), t2); + }, + $signature: 62 + }; + A._EvaluateVisitor_visitEachRule_closure3.prototype = { + call$1(value) { + return this.$this._async_evaluate$_setMultipleVariables$3(this._box_1.variables, value, this.nodeWithSpan); + }, + $signature: 62 + }; + A._EvaluateVisitor_visitEachRule_closure4.prototype = { + call$0() { + var _this = this, + t1 = _this.$this; + return t1._async_evaluate$_handleReturn$2(_this.list.get$asList(), new A._EvaluateVisitor_visitEachRule__closure0(t1, _this.setVariables, _this.node)); + }, + $signature: 68 + }; + A._EvaluateVisitor_visitEachRule__closure0.prototype = { + call$1(element) { + var t1; + this.setVariables.call$1(element); + t1 = this.$this; + return t1._async_evaluate$_handleReturn$2(this.node.children, new A._EvaluateVisitor_visitEachRule___closure0(t1)); + }, + $signature: 674 + }; + A._EvaluateVisitor_visitEachRule___closure0.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 93 + }; + A._EvaluateVisitor_visitAtRule_closure2.prototype = { + call$1(value) { + return this.$this._async_evaluate$_interpolationToValue$3$trim$warnForColor(value, true, true); + }, + $signature: 424 + }; + A._EvaluateVisitor_visitAtRule_closure3.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t2, t3, _i, t1, styleRule; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + styleRule = t1._async_evaluate$_atRootExcludingStyleRule ? null : t1._async_evaluate$_styleRuleIgnoringAtRoot; + $async$goto = styleRule == null || t1._async_evaluate$_inKeyframes || J.$eq$($async$self.name.value, "font-face") ? 2 : 4; + break; + case 2: + // then + t2 = $async$self.children, t3 = t2.length, _i = 0; + case 5: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 7; + break; + } + $async$goto = 8; + return A._asyncAwait(t2[_i].accept$1(t1), $async$call$0); + case 8: + // returning from await. + case 6: + // for update + ++_i; + // goto for condition + $async$goto = 5; + break; + case 7: + // after for + // goto join + $async$goto = 3; + break; + case 4: + // else + $async$goto = 9; + return A._asyncAwait(t1._async_evaluate$_withParent$2$3$scopeWhen(A.ModifiableCssStyleRule$(styleRule._style_rule$_selector, styleRule.span, false, styleRule.originalSelector), new A._EvaluateVisitor_visitAtRule__closure0(t1, $async$self.children), false, type$.ModifiableCssStyleRule, type$.Null), $async$call$0); + case 9: + // returning from await. + case 3: + // join + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitAtRule__closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitAtRule_closure4.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitForRule_closure4.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassNumber), + $async$returnValue, $async$self = this; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self.node.from.accept$1($async$self.$this), $async$call$0); + case 3: + // returning from await. + $async$returnValue = $async$result.assertNumber$0(); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 176 + }; + A._EvaluateVisitor_visitForRule_closure5.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassNumber), + $async$returnValue, $async$self = this; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self.node.to.accept$1($async$self.$this), $async$call$0); + case 3: + // returning from await. + $async$returnValue = $async$result.assertNumber$0(); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 176 + }; + A._EvaluateVisitor_visitForRule_closure6.prototype = { + call$0() { + return this.fromNumber.assertInt$0(); + }, + $signature: 10 + }; + A._EvaluateVisitor_visitForRule_closure7.prototype = { + call$0() { + var t1 = this.fromNumber; + return this.toNumber.coerce$2(t1.get$numeratorUnits(t1), t1.get$denominatorUnits(t1)).assertInt$0(); + }, + $signature: 10 + }; + A._EvaluateVisitor_visitForRule_closure8.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, i, t3, t4, t5, t6, t7, t8, _0_0, t1, t2, nodeWithSpan; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + t2 = $async$self.node; + nodeWithSpan = t1._async_evaluate$_expressionNode$1(t2.from); + i = $async$self.from, t3 = $async$self._box_0, t4 = $async$self.direction, t5 = t2.variable, t6 = $async$self.fromNumber, t2 = t2.children; + case 3: + // for condition + if (!(i !== t3.to)) { + // goto after for + $async$goto = 5; + break; + } + t7 = t1._async_evaluate$_environment; + t8 = t6.get$numeratorUnits(t6); + t7.setLocalVariable$3(t5, A.SassNumber_SassNumber$withUnits(i, t6.get$denominatorUnits(t6), t8), nodeWithSpan); + $async$goto = 6; + return A._asyncAwait(t1._async_evaluate$_handleReturn$2(t2, new A._EvaluateVisitor_visitForRule__closure0(t1)), $async$call$0); + case 6: + // returning from await. + _0_0 = $async$result; + if (_0_0 != null) { + $async$returnValue = _0_0; + // goto return + $async$goto = 1; + break; + } + case 4: + // for update + i += t4; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 68 + }; + A._EvaluateVisitor_visitForRule__closure0.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 93 + }; + A._EvaluateVisitor_visitForwardRule_closure1.prototype = { + call$2(module, firstLoad) { + if (firstLoad) + this.$this._async_evaluate$_registerCommentsForModule$1(module); + this.$this._async_evaluate$_environment.forwardModule$2(module, this.node); + }, + $signature: 119 + }; + A._EvaluateVisitor_visitForwardRule_closure2.prototype = { + call$2(module, firstLoad) { + if (firstLoad) + this.$this._async_evaluate$_registerCommentsForModule$1(module); + this.$this._async_evaluate$_environment.forwardModule$2(module, this.node); + }, + $signature: 119 + }; + A._EvaluateVisitor__registerCommentsForModule_closure0.prototype = { + call$0() { + return A._setArrayType([], type$.JSArray_CssComment); + }, + $signature: 177 + }; + A._EvaluateVisitor_visitIfRule_closure0.prototype = { + call$1(clause) { + var t1 = this.$this; + return t1._async_evaluate$_environment.scope$1$3$semiGlobal$when(new A._EvaluateVisitor_visitIfRule__closure0(t1, clause), true, clause.hasDeclarations, type$.nullable_Value); + }, + $signature: 447 + }; + A._EvaluateVisitor_visitIfRule__closure0.prototype = { + call$0() { + var t1 = this.$this; + return t1._async_evaluate$_handleReturn$2(this.clause.children, new A._EvaluateVisitor_visitIfRule___closure0(t1)); + }, + $signature: 68 + }; + A._EvaluateVisitor_visitIfRule___closure0.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 93 + }; + A._EvaluateVisitor__visitDynamicImport_closure0.prototype = { + call$0() { + return this.$call$body$_EvaluateVisitor__visitDynamicImport_closure(); + }, + $call$body$_EvaluateVisitor__visitDynamicImport_closure() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$returnValue, $async$self = this, t1, t2, _0_0, stylesheet, importer, isDependency, t3, url, oldImporter, oldStylesheet, oldInDependency, loadsUserDefinedModules, children, t4, t5, t6, t7, t8, t9, t10, environment, module, visitor, _box_0; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + _box_0 = {}; + _box_0.isDependency = _box_0.importer = _box_0.stylesheet = null; + t1 = $async$self.$this; + t2 = $async$self.$import; + $async$goto = 3; + return A._asyncAwait(t1._async_evaluate$_loadStylesheet$3$forImport(t2.urlString, t2.span, true), $async$call$0); + case 3: + // returning from await. + _0_0 = $async$result; + stylesheet = _box_0.stylesheet = _0_0._0; + importer = _0_0._1; + _box_0.importer = importer; + isDependency = _0_0._2; + _box_0.isDependency = isDependency; + t3 = stylesheet.span; + url = t3.get$sourceUrl(t3); + if (url != null) { + t3 = t1._async_evaluate$_activeModules; + if (t3.containsKey$1(url)) { + t2 = A.NullableExtension_andThen(t3.$index(0, url), new A._EvaluateVisitor__visitDynamicImport__closure3(t1)); + throw A.wrapException(t2 == null ? t1._async_evaluate$_exception$1("This file is already being loaded.") : t2); + } + t3.$indexSet(0, url, t2); + } + t2 = stylesheet._uses; + t3 = type$.UnmodifiableListView_UseRule; + $async$goto = new A.UnmodifiableListView(t2, t3).get$length(0) === 0 && new A.UnmodifiableListView(stylesheet._forwards, type$.UnmodifiableListView_ForwardRule).get$length(0) === 0 ? 4 : 5; + break; + case 4: + // then + oldImporter = t1._async_evaluate$_importer; + oldStylesheet = t1._async_evaluate$_assertInModule$2(t1._async_evaluate$__stylesheet, "_stylesheet"); + oldInDependency = t1._async_evaluate$_inDependency; + t1._async_evaluate$_importer = importer; + t1._async_evaluate$__stylesheet = stylesheet; + t1._async_evaluate$_inDependency = isDependency; + $async$goto = 6; + return A._asyncAwait(t1.visitStylesheet$1(0, stylesheet), $async$call$0); + case 6: + // returning from await. + t1._async_evaluate$_importer = oldImporter; + t1._async_evaluate$__stylesheet = oldStylesheet; + t1._async_evaluate$_inDependency = oldInDependency; + t1._async_evaluate$_activeModules.remove$1(0, url); + // goto return + $async$goto = 1; + break; + case 5: + // join + t2 = new A.UnmodifiableListView(t2, t3); + if (!t2.any$1(t2, new A._EvaluateVisitor__visitDynamicImport__closure4())) { + t2 = new A.UnmodifiableListView(stylesheet._forwards, type$.UnmodifiableListView_ForwardRule); + loadsUserDefinedModules = t2.any$1(t2, new A._EvaluateVisitor__visitDynamicImport__closure5()); + } else + loadsUserDefinedModules = true; + children = A._Cell$(); + t2 = t1._async_evaluate$_environment; + t3 = type$.String; + t4 = type$.Module_AsyncCallable; + t5 = type$.AstNode; + t6 = A._setArrayType([], type$.JSArray_Module_AsyncCallable); + t7 = t2._async_environment$_variables; + t7 = A._setArrayType(t7.slice(0), A._arrayInstanceType(t7)); + t8 = t2._async_environment$_variableNodes; + t8 = A._setArrayType(t8.slice(0), A._arrayInstanceType(t8)); + t9 = t2._async_environment$_functions; + t9 = A._setArrayType(t9.slice(0), A._arrayInstanceType(t9)); + t10 = t2._async_environment$_mixins; + t10 = A._setArrayType(t10.slice(0), A._arrayInstanceType(t10)); + environment = A.AsyncEnvironment$_(A.LinkedHashMap_LinkedHashMap$_empty(t3, t4), A.LinkedHashMap_LinkedHashMap$_empty(t3, t5), A.LinkedHashMap_LinkedHashMap$_empty(t4, t5), t2._async_environment$_importedModules, null, null, t6, t7, t8, t9, t10, t2._async_environment$_content); + $async$goto = 7; + return A._asyncAwait(t1._async_evaluate$_withEnvironment$1$2(environment, new A._EvaluateVisitor__visitDynamicImport__closure6(_box_0, t1, loadsUserDefinedModules, environment, children), type$.Null), $async$call$0); + case 7: + // returning from await. + module = environment.toDummyModule$0(); + t1._async_evaluate$_environment.importForwards$1(module); + $async$goto = loadsUserDefinedModules ? 8 : 9; + break; + case 8: + // then + $async$goto = module.transitivelyContainsCss ? 10 : 11; + break; + case 10: + // then + $async$goto = 12; + return A._asyncAwait(t1._async_evaluate$_combineCss$2$clone(module, module.transitivelyContainsExtensions).accept$1(t1), $async$call$0); + case 12: + // returning from await. + case 11: + // join + visitor = new A._ImportedCssVisitor0(t1); + for (t2 = J.get$iterator$ax(children._readLocal$0()); t2.moveNext$0();) + t2.get$current(t2).accept$1(visitor); + case 9: + // join + t1._async_evaluate$_activeModules.remove$1(0, url); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 32 + }; + A._EvaluateVisitor__visitDynamicImport__closure3.prototype = { + call$1(previousLoad) { + return this.$this._async_evaluate$_multiSpanException$3("This file is already being loaded.", "new load", A.LinkedHashMap_LinkedHashMap$_literal([previousLoad.get$span(previousLoad), "original load"], type$.FileSpan, type$.String)); + }, + $signature: 85 + }; + A._EvaluateVisitor__visitDynamicImport__closure4.prototype = { + call$1(rule) { + return rule.url.get$scheme() !== "sass"; + }, + $signature: 178 + }; + A._EvaluateVisitor__visitDynamicImport__closure5.prototype = { + call$1(rule) { + return rule.url.get$scheme() !== "sass"; + }, + $signature: 179 + }; + A._EvaluateVisitor__visitDynamicImport__closure6.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t3, t4, t1, oldImporter, oldStylesheet, oldRoot, oldParent, oldEndOfImports, oldOutOfOrderImports, oldConfiguration, oldInDependency, t2; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + oldImporter = t1._async_evaluate$_importer; + oldStylesheet = t1._async_evaluate$_assertInModule$2(t1._async_evaluate$__stylesheet, "_stylesheet"); + oldRoot = t1._async_evaluate$_assertInModule$2(t1._async_evaluate$__root, "_root"); + oldParent = t1._async_evaluate$_assertInModule$2(t1._async_evaluate$__parent, "__parent"); + oldEndOfImports = t1._async_evaluate$_assertInModule$2(t1._async_evaluate$__endOfImports, "_endOfImports"); + oldOutOfOrderImports = t1._async_evaluate$_outOfOrderImports; + oldConfiguration = t1._async_evaluate$_configuration; + oldInDependency = t1._async_evaluate$_inDependency; + t2 = $async$self._box_0; + t1._async_evaluate$_importer = t2.importer; + t3 = t2.stylesheet; + t1._async_evaluate$__stylesheet = t3; + t4 = $async$self.loadsUserDefinedModules; + if (t4) { + t3 = A.ModifiableCssStylesheet$(t3.span); + t1._async_evaluate$__root = t3; + t1._async_evaluate$__parent = t1._async_evaluate$_assertInModule$2(t3, "_root"); + t1._async_evaluate$__endOfImports = 0; + t1._async_evaluate$_outOfOrderImports = null; + } + t1._async_evaluate$_inDependency = t2.isDependency; + t3 = new A.UnmodifiableListView(t2.stylesheet._forwards, type$.UnmodifiableListView_ForwardRule); + if (!t3.get$isEmpty(t3)) + t1._async_evaluate$_configuration = $async$self.environment.toImplicitConfiguration$0(); + $async$goto = 2; + return A._asyncAwait(t1.visitStylesheet$1(0, t2.stylesheet), $async$call$0); + case 2: + // returning from await. + t2 = t4 ? t1._async_evaluate$_addOutOfOrderImports$0() : A._setArrayType([], type$.JSArray_ModifiableCssNode); + $async$self.children.__late_helper$_value = t2; + t1._async_evaluate$_importer = oldImporter; + t1._async_evaluate$__stylesheet = oldStylesheet; + if (t4) { + t1._async_evaluate$__root = oldRoot; + t1._async_evaluate$__parent = oldParent; + t1._async_evaluate$__endOfImports = oldEndOfImports; + t1._async_evaluate$_outOfOrderImports = oldOutOfOrderImports; + } + t1._async_evaluate$_configuration = oldConfiguration; + t1._async_evaluate$_inDependency = oldInDependency; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor__applyMixin_closure1.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate$_environment.asMixin$1(new A._EvaluateVisitor__applyMixin__closure2(t1, $async$self.$arguments, $async$self.mixin, $async$self.nodeWithSpanWithoutContent)), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 32 + }; + A._EvaluateVisitor__applyMixin__closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 2; + return A._asyncAwait($async$self.$this._async_evaluate$_runBuiltInCallable$3($async$self.$arguments, $async$self.mixin, $async$self.nodeWithSpanWithoutContent), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 32 + }; + A._EvaluateVisitor__applyMixin_closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate$_environment.withContent$2($async$self.contentCallable, new A._EvaluateVisitor__applyMixin__closure1(t1, $async$self.mixin, $async$self.nodeWithSpanWithoutContent)), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor__applyMixin__closure1.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate$_environment.asMixin$1(new A._EvaluateVisitor__applyMixin___closure0(t1, $async$self.mixin, $async$self.nodeWithSpanWithoutContent)), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 32 + }; + A._EvaluateVisitor__applyMixin___closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1, t2, t3, t4, t5, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.mixin.declaration.children, t2 = t1.length, t3 = $async$self.$this, t4 = $async$self.nodeWithSpanWithoutContent, t5 = type$.nullable_Value, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t3._async_evaluate$_addErrorSpan$1$2(t4, new A._EvaluateVisitor__applyMixin____closure0(t3, t1[_i]), t5), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 32 + }; + A._EvaluateVisitor__applyMixin____closure0.prototype = { + call$0() { + return this.statement.accept$1(this.$this); + }, + $signature: 68 + }; + A._EvaluateVisitor_visitIncludeRule_closure2.prototype = { + call$0() { + var t1 = this.node; + return this.$this._async_evaluate$_environment.getMixin$2$namespace(t1.name, t1.namespace); + }, + $signature: 100 + }; + A._EvaluateVisitor_visitIncludeRule_closure3.prototype = { + call$1($content) { + var t1 = this.$this; + return new A.UserDefinedCallable($content, t1._async_evaluate$_environment.closure$0(), t1._async_evaluate$_inDependency, type$.UserDefinedCallable_AsyncEnvironment); + }, + $signature: 456 + }; + A._EvaluateVisitor_visitIncludeRule_closure4.prototype = { + call$0() { + return this.node.get$spanWithoutContent(); + }, + $signature: 29 + }; + A._EvaluateVisitor_visitMediaRule_closure2.prototype = { + call$1(mediaQueries) { + return this.$this._async_evaluate$_mergeMediaQueries$2(mediaQueries, this.queries); + }, + $signature: 96 + }; + A._EvaluateVisitor_visitMediaRule_closure3.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + t2 = $async$self.mergedQueries; + if (t2 == null) + t2 = $async$self.queries; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate$_withMediaQueries$1$3(t2, $async$self.mergedSources, new A._EvaluateVisitor_visitMediaRule__closure0(t1, $async$self.node), type$.Null), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitMediaRule__closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t2, t3, _i, t1, _0_0; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + _0_0 = t1._async_evaluate$_atRootExcludingStyleRule ? null : t1._async_evaluate$_styleRuleIgnoringAtRoot; + $async$goto = _0_0 != null ? 2 : 4; + break; + case 2: + // then + $async$goto = 5; + return A._asyncAwait(t1._async_evaluate$_withParent$2$3$scopeWhen(A.ModifiableCssStyleRule$(_0_0._style_rule$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitMediaRule___closure0(t1, $async$self.node), false, type$.ModifiableCssStyleRule, type$.Null), $async$call$0); + case 5: + // returning from await. + // goto join + $async$goto = 3; + break; + case 4: + // else + t2 = $async$self.node.children, t3 = t2.length, _i = 0; + case 6: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 8; + break; + } + $async$goto = 9; + return A._asyncAwait(t2[_i].accept$1(t1), $async$call$0); + case 9: + // returning from await. + case 7: + // for update + ++_i; + // goto for condition + $async$goto = 6; + break; + case 8: + // after for + case 3: + // join + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitMediaRule___closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitMediaRule_closure4.prototype = { + call$1(node) { + var t1; + if (!(node instanceof A.ModifiableCssStyleRule)) { + t1 = this.mergedSources; + t1 = t1.get$isNotEmpty(t1) && node instanceof A.ModifiableCssMediaRule && B.JSArray_methods.every$1(node.queries, t1.get$contains(t1)); + } else + t1 = true; + return t1; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitStyleRule_closure3.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitStyleRule_closure4.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitStyleRule_closure6.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate$_withStyleRule$1$2($async$self.rule, new A._EvaluateVisitor_visitStyleRule__closure0(t1, $async$self.node), type$.Null), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitStyleRule__closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitStyleRule_closure5.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor__warnForBogusCombinators_closure0.prototype = { + call$1(child) { + return child instanceof A.ModifiableCssComment; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitSupportsRule_closure1.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t2, t3, _i, t1, _0_0; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + _0_0 = t1._async_evaluate$_atRootExcludingStyleRule ? null : t1._async_evaluate$_styleRuleIgnoringAtRoot; + $async$goto = _0_0 != null ? 2 : 4; + break; + case 2: + // then + $async$goto = 5; + return A._asyncAwait(t1._async_evaluate$_withParent$2$2(A.ModifiableCssStyleRule$(_0_0._style_rule$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitSupportsRule__closure0(t1, $async$self.node), type$.ModifiableCssStyleRule, type$.Null), $async$call$0); + case 5: + // returning from await. + // goto join + $async$goto = 3; + break; + case 4: + // else + t2 = $async$self.node.children, t3 = t2.length, _i = 0; + case 6: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 8; + break; + } + $async$goto = 9; + return A._asyncAwait(t2[_i].accept$1(t1), $async$call$0); + case 9: + // returning from await. + case 7: + // for update + ++_i; + // goto for condition + $async$goto = 6; + break; + case 8: + // after for + case 3: + // join + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitSupportsRule__closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitSupportsRule_closure2.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor__visitSupportsCondition_closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.String), + $async$returnValue, $async$self = this, t1, t2, t3, t4, $async$temp1, $async$temp2; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + t2 = $async$self._box_0; + $async$temp1 = A; + $async$goto = 3; + return A._asyncAwait(t1._evaluateToCss$1(t2.declaration.name), $async$call$0); + case 3: + // returning from await. + t3 = $async$temp1.S($async$result); + t4 = t2.declaration.get$isCustomProperty() ? "" : " "; + $async$temp1 = "(" + t3 + ":" + t4; + $async$temp2 = A; + $async$goto = 4; + return A._asyncAwait(t1._evaluateToCss$1(t2.declaration.value), $async$call$0); + case 4: + // returning from await. + $async$returnValue = $async$temp1 + $async$temp2.S($async$result) + ")"; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 181 + }; + A._EvaluateVisitor_visitVariableDeclaration_closure2.prototype = { + call$0() { + var t1 = this.$this._async_evaluate$_environment, + t2 = this._box_0.override; + t1.setVariable$4$global(this.node.name, t2.value, t2.assignmentNode, true); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitVariableDeclaration_closure3.prototype = { + call$0() { + var t1 = this.node; + return this.$this._async_evaluate$_environment.getVariable$2$namespace(t1.name, t1.namespace); + }, + $signature: 41 + }; + A._EvaluateVisitor_visitVariableDeclaration_closure4.prototype = { + call$0() { + var t1 = this.$this, + t2 = this.node; + t1._async_evaluate$_environment.setVariable$5$global$namespace(t2.name, this.value, t1._async_evaluate$_expressionNode$1(t2.expression), t2.isGlobal, t2.namespace); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitUseRule_closure0.prototype = { + call$2(module, firstLoad) { + var t1, t2, t3, _0_0, t4, t5, span; + if (firstLoad) + this.$this._async_evaluate$_registerCommentsForModule$1(module); + t1 = this.$this._async_evaluate$_environment; + t2 = this.node; + t3 = t2.namespace; + if (t3 == null) { + t1._async_environment$_globalModules.$indexSet(0, module, t2); + t1._async_environment$_allModules.push(module); + _0_0 = A.IterableExtension_firstWhereOrNull(J.get$keys$z(B.JSArray_methods.get$first(t1._async_environment$_variables)), module.get$variables().get$containsKey()); + if (_0_0 != null) + A.throwExpression(A.SassScriptException$(string$.This_ma + _0_0 + '".', null)); + } else { + t4 = t1._async_environment$_modules; + if (t4.containsKey$1(t3)) { + t5 = t1._async_environment$_namespaceNodes.$index(0, t3); + span = t5 == null ? null : t5.span; + t5 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + if (span != null) + t5.$indexSet(0, span, "original @use"); + A.throwExpression(A.MultiSpanSassScriptException$(string$.There_ + t3 + '".', "new @use", t5)); + } + t4.$indexSet(0, t3, module); + t1._async_environment$_namespaceNodes.$indexSet(0, t3, t2); + t1._async_environment$_allModules.push(module); + } + }, + $signature: 119 + }; + A._EvaluateVisitor_visitWarnRule_closure0.prototype = { + call$0() { + return this.node.expression.accept$1(this.$this); + }, + $signature: 67 + }; + A._EvaluateVisitor_visitWhileRule_closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value), + $async$returnValue, $async$self = this, t1, t2, t3, _0_0; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node, t2 = t1.condition, t3 = $async$self.$this, t1 = t1.children; + case 3: + // for condition + $async$goto = 5; + return A._asyncAwait(t2.accept$1(t3), $async$call$0); + case 5: + // returning from await. + if (!$async$result.get$isTruthy()) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 6; + return A._asyncAwait(t3._async_evaluate$_handleReturn$2(t1, new A._EvaluateVisitor_visitWhileRule__closure0(t3)), $async$call$0); + case 6: + // returning from await. + _0_0 = $async$result; + if (_0_0 != null) { + $async$returnValue = _0_0; + // goto return + $async$goto = 1; + break; + } + // goto for condition + $async$goto = 3; + break; + case 4: + // after for + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 68 + }; + A._EvaluateVisitor_visitWhileRule__closure0.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 93 + }; + A._EvaluateVisitor_visitBinaryOperationExpression_closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue, $async$self = this, t3, t1, t2, left, $async$temp1, $async$temp2; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node; + t2 = $async$self.$this; + $async$goto = 3; + return A._asyncAwait(t1.left.accept$1(t2), $async$call$0); + case 3: + // returning from await. + left = $async$result; + case 4: + // switch + switch (t1.operator) { + case B.BinaryOperator_Kyq: + // goto case + $async$goto = 6; + break; + case B.BinaryOperator_tKu: + // goto case + $async$goto = 7; + break; + case B.BinaryOperator_uke: + // goto case + $async$goto = 8; + break; + case B.BinaryOperator_r84: + // goto case + $async$goto = 9; + break; + case B.BinaryOperator_qGq: + // goto case + $async$goto = 10; + break; + case B.BinaryOperator_o8O: + // goto case + $async$goto = 11; + break; + case B.BinaryOperator_JiR: + // goto case + $async$goto = 12; + break; + case B.BinaryOperator_qHy: + // goto case + $async$goto = 13; + break; + case B.BinaryOperator_FPG: + // goto case + $async$goto = 14; + break; + case B.BinaryOperator_Swh: + // goto case + $async$goto = 15; + break; + case B.BinaryOperator_QG1: + // goto case + $async$goto = 16; + break; + case B.BinaryOperator_tht: + // goto case + $async$goto = 17; + break; + case B.BinaryOperator_Mh5: + // goto case + $async$goto = 18; + break; + case B.BinaryOperator_s7T: + // goto case + $async$goto = 19; + break; + default: + // goto default + $async$goto = 20; + break; + } + break; + case 6: + // case + t1 = t1.right.accept$1(t2); + $async$goto = 21; + return A._asyncAwait(type$.Future_Value._is(t1) ? t1 : A._Future$value(t1, type$.Value), $async$call$0); + case 21: + // returning from await. + t1 = $async$result; + t1 = new A.SassString(A.serializeValue(left, false, true) + "=" + A.serializeValue(t1, false, true), false); + // goto after switch + $async$goto = 5; + break; + case 7: + // case + $async$goto = left.get$isTruthy() ? 22 : 24; + break; + case 22: + // then + t1 = left; + // goto join + $async$goto = 23; + break; + case 24: + // else + t1 = t1.right.accept$1(t2); + $async$goto = 25; + return A._asyncAwait(type$.Future_Value._is(t1) ? t1 : A._Future$value(t1, type$.Value), $async$call$0); + case 25: + // returning from await. + t1 = $async$result; + case 23: + // join + // goto after switch + $async$goto = 5; + break; + case 8: + // case + $async$goto = left.get$isTruthy() ? 26 : 28; + break; + case 26: + // then + t1 = t1.right.accept$1(t2); + $async$goto = 29; + return A._asyncAwait(type$.Future_Value._is(t1) ? t1 : A._Future$value(t1, type$.Value), $async$call$0); + case 29: + // returning from await. + t1 = $async$result; + // goto join + $async$goto = 27; + break; + case 28: + // else + t1 = left; + case 27: + // join + // goto after switch + $async$goto = 5; + break; + case 9: + // case + $async$temp1 = left; + $async$goto = 30; + return A._asyncAwait(t1.right.accept$1(t2), $async$call$0); + case 30: + // returning from await. + t1 = $async$temp1.$eq(0, $async$result) ? B.SassBoolean_true : B.SassBoolean_false; + // goto after switch + $async$goto = 5; + break; + case 10: + // case + $async$temp1 = left; + $async$goto = 31; + return A._asyncAwait(t1.right.accept$1(t2), $async$call$0); + case 31: + // returning from await. + t1 = !$async$temp1.$eq(0, $async$result) ? B.SassBoolean_true : B.SassBoolean_false; + // goto after switch + $async$goto = 5; + break; + case 11: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 32; + return A._asyncAwait(type$.Future_Value._is(t1) ? t1 : A._Future$value(t1, type$.Value), $async$call$0); + case 32: + // returning from await. + t1 = $async$temp1.greaterThan$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 12: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 33; + return A._asyncAwait(type$.Future_Value._is(t1) ? t1 : A._Future$value(t1, type$.Value), $async$call$0); + case 33: + // returning from await. + t1 = $async$temp1.greaterThanOrEquals$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 13: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 34; + return A._asyncAwait(type$.Future_Value._is(t1) ? t1 : A._Future$value(t1, type$.Value), $async$call$0); + case 34: + // returning from await. + t1 = $async$temp1.lessThan$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 14: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 35; + return A._asyncAwait(type$.Future_Value._is(t1) ? t1 : A._Future$value(t1, type$.Value), $async$call$0); + case 35: + // returning from await. + t1 = $async$temp1.lessThanOrEquals$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 15: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 36; + return A._asyncAwait(type$.Future_Value._is(t1) ? t1 : A._Future$value(t1, type$.Value), $async$call$0); + case 36: + // returning from await. + t1 = $async$temp1.plus$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 16: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 37; + return A._asyncAwait(type$.Future_Value._is(t1) ? t1 : A._Future$value(t1, type$.Value), $async$call$0); + case 37: + // returning from await. + t1 = $async$temp1.minus$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 17: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 38; + return A._asyncAwait(type$.Future_Value._is(t1) ? t1 : A._Future$value(t1, type$.Value), $async$call$0); + case 38: + // returning from await. + t1 = $async$temp1.times$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 18: + // case + t3 = t1.right.accept$1(t2); + $async$temp1 = t2; + $async$temp2 = left; + $async$goto = 39; + return A._asyncAwait(type$.Future_Value._is(t3) ? t3 : A._Future$value(t3, type$.Value), $async$call$0); + case 39: + // returning from await. + t1 = $async$temp1._async_evaluate$_slash$3($async$temp2, $async$result, t1); + // goto after switch + $async$goto = 5; + break; + case 19: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 40; + return A._asyncAwait(type$.Future_Value._is(t1) ? t1 : A._Future$value(t1, type$.Value), $async$call$0); + case 40: + // returning from await. + t1 = $async$temp1.modulo$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 20: + // default + t1 = null; + case 5: + // after switch + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 67 + }; + A._EvaluateVisitor__slash_recommendation0.prototype = { + call$1(expression) { + var t1; + $label0$0: { + if (expression instanceof A.BinaryOperationExpression && B.BinaryOperator_Mh5 === expression.operator) { + t1 = "math.div(" + A.S(this.call$1(expression.left)) + ", " + A.S(this.call$1(expression.right)) + ")"; + break $label0$0; + } + if (expression instanceof A.ParenthesizedExpression) { + t1 = expression.expression.toString$0(0); + break $label0$0; + } + t1 = expression.toString$0(0); + break $label0$0; + } + return t1; + }, + $signature: 133 + }; + A._EvaluateVisitor_visitVariableExpression_closure0.prototype = { + call$0() { + var t1 = this.node; + return this.$this._async_evaluate$_environment.getVariable$2$namespace(t1.name, t1.namespace); + }, + $signature: 41 + }; + A._EvaluateVisitor_visitUnaryOperationExpression_closure0.prototype = { + call$0() { + var t1, _this = this; + switch (_this.node.operator) { + case B.UnaryOperator_Rbl: + t1 = _this.operand.unaryPlus$0(); + break; + case B.UnaryOperator_UCP: + t1 = _this.operand.unaryMinus$0(); + break; + case B.UnaryOperator_lZV: + t1 = new A.SassString("/" + A.serializeValue(_this.operand, false, true), false); + break; + case B.UnaryOperator_not_not_not: + t1 = _this.operand.unaryNot$0(); + break; + default: + t1 = null; + } + return t1; + }, + $signature: 33 + }; + A._EvaluateVisitor_visitListExpression_closure0.prototype = { + call$1(expression) { + return expression.accept$1(this.$this); + }, + $signature: 486 + }; + A._EvaluateVisitor_visitFunctionExpression_closure2.prototype = { + call$0() { + var t1 = this.node; + return this.$this._async_evaluate$_environment.getFunction$2$namespace(t1.name, t1.namespace); + }, + $signature: 100 + }; + A._EvaluateVisitor_visitFunctionExpression_closure3.prototype = { + call$1(argument) { + return argument.accept$1(B.C_IsCalculationSafeVisitor); + }, + $signature: 118 + }; + A._EvaluateVisitor_visitFunctionExpression_closure4.prototype = { + call$0() { + var t1 = this.node; + return this.$this._async_evaluate$_runFunctionCallable$3(t1.$arguments, this._box_0.$function, t1); + }, + $signature: 67 + }; + A._EvaluateVisitor__visitCalculation_closure0.prototype = { + call$2(message, deprecation) { + return this.$this._async_evaluate$_warn$3(message, this.node.span, deprecation); + }, + call$1(message) { + return this.call$2(message, null); + }, + $signature: 105 + }; + A._EvaluateVisitor__checkCalculationArguments_check0.prototype = { + call$1(maxArgs) { + var t1 = this.node, + t2 = t1.$arguments.positional.length; + if (t2 === 0) + throw A.wrapException(this.$this._async_evaluate$_exception$2("Missing argument.", t1.span)); + else if (maxArgs != null && t2 > maxArgs) + throw A.wrapException(this.$this._async_evaluate$_exception$2("Only " + A.S(maxArgs) + " " + A.pluralize("argument", maxArgs, null) + " allowed, but " + t2 + " " + A.pluralize("was", t2, "were") + " passed.", t1.span)); + }, + call$0() { + return this.call$1(null); + }, + $signature: 106 + }; + A._EvaluateVisitor__visitCalculationExpression_closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Object), + $async$returnValue, $async$self = this, t1, t2, t3, t4, $async$temp1, $async$temp2, $async$temp3; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + t2 = $async$self._box_0; + t3 = $async$self.node; + t4 = $async$self.inLegacySassFunction; + $async$temp1 = A; + $async$temp2 = t1._async_evaluate$_binaryOperatorToCalculationOperator$2(t2.operator, t3); + $async$goto = 3; + return A._asyncAwait(t1._async_evaluate$_visitCalculationExpression$2$inLegacySassFunction(t2.left, t4), $async$call$0); + case 3: + // returning from await. + $async$temp3 = $async$result; + $async$goto = 4; + return A._asyncAwait(t1._async_evaluate$_visitCalculationExpression$2$inLegacySassFunction(t2.right, t4), $async$call$0); + case 4: + // returning from await. + $async$returnValue = $async$temp1.SassCalculation_operateInternal($async$temp2, $async$temp3, $async$result, t4, !t1._async_evaluate$_inSupportsDeclaration, new A._EvaluateVisitor__visitCalculationExpression__closure0(t1, t3)); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 183 + }; + A._EvaluateVisitor__visitCalculationExpression__closure0.prototype = { + call$2(message, deprecation) { + return this.$this._async_evaluate$_warn$3(message, this.node.get$span(0), deprecation); + }, + call$1(message) { + return this.call$2(message, null); + }, + $signature: 105 + }; + A._EvaluateVisitor_visitInterpolatedFunctionExpression_closure0.prototype = { + call$0() { + var t1 = this.node; + return this.$this._async_evaluate$_runFunctionCallable$3(t1.$arguments, this.$function, t1); + }, + $signature: 67 + }; + A._EvaluateVisitor__runUserDefinedCallable_closure0.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this.callable, + t3 = _this.V; + return t1._async_evaluate$_withEnvironment$1$2(t2.environment.closure$0(), new A._EvaluateVisitor__runUserDefinedCallable__closure0(t1, _this.evaluated, t2, _this.nodeWithSpan, _this.run, t3), t3); + }, + $signature() { + return this.V._eval$1("Future<0>()"); + } + }; + A._EvaluateVisitor__runUserDefinedCallable__closure0.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this.V; + return t1._async_evaluate$_environment.scope$1$1(new A._EvaluateVisitor__runUserDefinedCallable___closure0(t1, _this.evaluated, _this.callable, _this.nodeWithSpan, _this.run, t2), t2); + }, + $signature() { + return this.V._eval$1("Future<0>()"); + } + }; + A._EvaluateVisitor__runUserDefinedCallable___closure0.prototype = { + call$0() { + return this.$call$body$_EvaluateVisitor__runUserDefinedCallable___closure(this.V); + }, + $call$body$_EvaluateVisitor__runUserDefinedCallable___closure($async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$self = this, parameters, t5, minLength, i, parameter, t6, value, t7, t8, restParameter, rest, argumentList, result, parameterWord, t1, t2, t3, t4, $async$temp1; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + t2 = $async$self.evaluated._values; + t3 = $async$self.callable.declaration.parameters; + t4 = $async$self.nodeWithSpan; + t1._async_evaluate$_verifyArguments$4(J.get$length$asx(t2[2]), t2[0], t3, t4); + parameters = t3.parameters; + t5 = parameters.length; + minLength = Math.min(J.get$length$asx(t2[2]), t5); + for (i = 0; i < minLength; ++i) + t1._async_evaluate$_environment.setLocalVariable$3(parameters[i].name, J.$index$asx(t2[2], i), J.$index$asx(t2[3], i)); + i = J.get$length$asx(t2[2]); + case 3: + // for condition + if (!(i < t5)) { + // goto after for + $async$goto = 5; + break; + } + parameter = parameters[i]; + t6 = parameter.name; + value = t2[0].remove$1(0, t6); + $async$goto = value == null ? 6 : 7; + break; + case 6: + // then + t7 = parameter.defaultValue; + $async$temp1 = t1; + $async$goto = 8; + return A._asyncAwait(t7.accept$1(t1), $async$call$0); + case 8: + // returning from await. + value = $async$temp1._async_evaluate$_withoutSlash$2($async$result, t1._async_evaluate$_expressionNode$1(t7)); + case 7: + // join + t7 = t1._async_evaluate$_environment; + t8 = t2[1].$index(0, t6); + if (t8 == null) { + t8 = parameter.defaultValue; + t8.toString; + t8 = t1._async_evaluate$_expressionNode$1(t8); + } + t7.setLocalVariable$3(t6, value, t8); + case 4: + // for update + ++i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + restParameter = t3.restParameter; + if (restParameter != null) { + rest = J.get$length$asx(t2[2]) > t5 ? J.sublist$1$ax(t2[2], t5) : B.List_empty8; + t5 = t2[0]; + t6 = t2[4]; + argumentList = A.SassArgumentList$(rest, t5, t6 === B.ListSeparator_undecided_null_undecided ? B.ListSeparator_qVN : t6); + t1._async_evaluate$_environment.setLocalVariable$3(restParameter, argumentList, t4); + } else + argumentList = null; + $async$goto = 9; + return A._asyncAwait($async$self.run.call$0(), $async$call$0); + case 9: + // returning from await. + result = $async$result; + if (argumentList == null) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + t5 = t2[0]; + if (t5.get$isEmpty(t5)) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + if (argumentList._wereKeywordsAccessed) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + t5 = t2[0]; + parameterWord = A.pluralize("parameter", J.get$length$asx(t5.get$keys(t5)), null); + t2 = t2[0]; + throw A.wrapException(A.MultiSpanSassRuntimeException$("No " + parameterWord + " named " + A.toSentence(J.map$1$1$ax(t2.get$keys(t2), new A._EvaluateVisitor__runUserDefinedCallable____closure0(), type$.Object), "or") + ".", t4.get$span(t4), "invocation", A.LinkedHashMap_LinkedHashMap$_literal([t3.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), t1._async_evaluate$_stackTrace$1(t4.get$span(t4)), null)); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature() { + return this.V._eval$1("Future<0>()"); + } + }; + A._EvaluateVisitor__runUserDefinedCallable____closure0.prototype = { + call$1($name) { + return "$" + $name; + }, + $signature: 6 + }; + A._EvaluateVisitor__runFunctionCallable_closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value), + $async$returnValue, $async$self = this, t1, t2, t3, t4, _i, $returnValue; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.callable.declaration, t2 = t1.children, t3 = t2.length, t4 = $async$self.$this, _i = 0; + case 3: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 5; + break; + } + $async$goto = 6; + return A._asyncAwait(t2[_i].accept$1(t4), $async$call$0); + case 6: + // returning from await. + $returnValue = $async$result; + if ($returnValue instanceof A.Value) { + $async$returnValue = $returnValue; + // goto return + $async$goto = 1; + break; + } + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + throw A.wrapException(t4._async_evaluate$_exception$2("Function finished without @return.", t1.span)); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 67 + }; + A._EvaluateVisitor__runBuiltInCallable_closure2.prototype = { + call$0() { + return this._box_0.overload.verify$2(J.get$length$asx(this.evaluated._values[2]), this.namedSet); + }, + $signature: 0 + }; + A._EvaluateVisitor__runBuiltInCallable_closure3.prototype = { + call$0() { + return this._box_0.callback.call$1(this.evaluated._values[2]); + }, + $signature: 524 + }; + A._EvaluateVisitor__runBuiltInCallable_closure4.prototype = { + call$1($name) { + return "$" + $name; + }, + $signature: 6 + }; + A._EvaluateVisitor__evaluateArguments_closure3.prototype = { + call$1(value) { + return value; + }, + $signature: 42 + }; + A._EvaluateVisitor__evaluateArguments_closure4.prototype = { + call$1(value) { + return this.$this._async_evaluate$_withoutSlash$2(value, this.restNodeForSpan); + }, + $signature: 42 + }; + A._EvaluateVisitor__evaluateArguments_closure5.prototype = { + call$2(key, value) { + var _this = this, + t1 = _this.restNodeForSpan; + _this.named.$indexSet(0, key, _this.$this._async_evaluate$_withoutSlash$2(value, t1)); + _this.namedNodes.$indexSet(0, key, t1); + }, + $signature: 107 + }; + A._EvaluateVisitor__evaluateArguments_closure6.prototype = { + call$1(value) { + return value; + }, + $signature: 42 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure3.prototype = { + call$1(value) { + var t1 = this.restArgs; + return new A.ValueExpression(value, t1.get$span(t1)); + }, + $signature: 64 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure4.prototype = { + call$1(value) { + var t1 = this.restArgs; + return new A.ValueExpression(this.$this._async_evaluate$_withoutSlash$2(value, this.restNodeForSpan), t1.get$span(t1)); + }, + $signature: 64 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure5.prototype = { + call$2(key, value) { + var _this = this, + t1 = _this.restArgs; + _this.named.$indexSet(0, key, new A.ValueExpression(_this.$this._async_evaluate$_withoutSlash$2(value, _this.restNodeForSpan), t1.get$span(t1))); + }, + $signature: 107 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure6.prototype = { + call$1(value) { + var t1 = this.keywordRestArgs; + return new A.ValueExpression(this.$this._async_evaluate$_withoutSlash$2(value, this.keywordRestNodeForSpan), t1.get$span(t1)); + }, + $signature: 64 + }; + A._EvaluateVisitor__addRestMap_closure0.prototype = { + call$2(key, value) { + var t2, _this = this, + t1 = _this.$this; + if (key instanceof A.SassString) + _this.values.$indexSet(0, key._string$_text, _this.convert.call$1(t1._async_evaluate$_withoutSlash$2(value, _this.expressionNode))); + else { + t2 = _this.nodeWithSpan; + throw A.wrapException(t1._async_evaluate$_exception$2(string$.Variab_ + key.toString$0(0) + " is not a string in " + _this.map.toString$0(0) + ".", t2.get$span(t2))); + } + }, + $signature: 101 + }; + A._EvaluateVisitor__verifyArguments_closure0.prototype = { + call$0() { + return this.parameters.verify$2(this.positional, new A.MapKeySet(this.named, type$.MapKeySet_String)); + }, + $signature: 0 + }; + A._EvaluateVisitor_visitCssAtRule_closure1.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, t4; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = $async$self.$this, t2 = t2._eval$1("ListBase.E"); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + t4 = t1.__internal$_current; + $async$goto = 4; + return A._asyncAwait((t4 == null ? t2._as(t4) : t4).accept$1(t3), $async$call$0); + case 4: + // returning from await. + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssAtRule_closure2.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitCssKeyframeBlock_closure1.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, t4; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = $async$self.$this, t2 = t2._eval$1("ListBase.E"); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + t4 = t1.__internal$_current; + $async$goto = 4; + return A._asyncAwait((t4 == null ? t2._as(t4) : t4).accept$1(t3), $async$call$0); + case 4: + // returning from await. + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssKeyframeBlock_closure2.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitCssMediaRule_closure2.prototype = { + call$1(mediaQueries) { + return this.$this._async_evaluate$_mergeMediaQueries$2(mediaQueries, this.node.queries); + }, + $signature: 96 + }; + A._EvaluateVisitor_visitCssMediaRule_closure3.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + t2 = $async$self.mergedQueries; + if (t2 == null) + t2 = $async$self.node.queries; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate$_withMediaQueries$1$3(t2, $async$self.mergedSources, new A._EvaluateVisitor_visitCssMediaRule__closure0(t1, $async$self.node), type$.Null), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssMediaRule__closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t2, t3, t4, t1, _0_0; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + _0_0 = t1._async_evaluate$_atRootExcludingStyleRule ? null : t1._async_evaluate$_styleRuleIgnoringAtRoot; + $async$goto = _0_0 != null ? 2 : 4; + break; + case 2: + // then + $async$goto = 5; + return A._asyncAwait(t1._async_evaluate$_withParent$2$3$scopeWhen(A.ModifiableCssStyleRule$(_0_0._style_rule$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitCssMediaRule___closure0(t1, $async$self.node), false, type$.ModifiableCssStyleRule, type$.Null), $async$call$0); + case 5: + // returning from await. + // goto join + $async$goto = 3; + break; + case 4: + // else + t2 = $async$self.node.children, t3 = t2.$ti, t2 = new A.ListIterator(t2, t2.get$length(0), t3._eval$1("ListIterator")), t3 = t3._eval$1("ListBase.E"); + case 6: + // for condition + if (!t2.moveNext$0()) { + // goto after for + $async$goto = 7; + break; + } + t4 = t2.__internal$_current; + $async$goto = 8; + return A._asyncAwait((t4 == null ? t3._as(t4) : t4).accept$1(t1), $async$call$0); + case 8: + // returning from await. + // goto for condition + $async$goto = 6; + break; + case 7: + // after for + case 3: + // join + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssMediaRule___closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, t4; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = $async$self.$this, t2 = t2._eval$1("ListBase.E"); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + t4 = t1.__internal$_current; + $async$goto = 4; + return A._asyncAwait((t4 == null ? t2._as(t4) : t4).accept$1(t3), $async$call$0); + case 4: + // returning from await. + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssMediaRule_closure4.prototype = { + call$1(node) { + var t1; + if (!(node instanceof A.ModifiableCssStyleRule)) { + t1 = this.mergedSources; + t1 = t1.get$isNotEmpty(t1) && node instanceof A.ModifiableCssMediaRule && B.JSArray_methods.every$1(node.queries, t1.get$contains(t1)); + } else + t1 = true; + return t1; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitCssStyleRule_closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate$_withStyleRule$1$2($async$self.rule, new A._EvaluateVisitor_visitCssStyleRule__closure0(t1, $async$self.node), type$.Null), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssStyleRule__closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, t4; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = $async$self.$this, t2 = t2._eval$1("ListBase.E"); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + t4 = t1.__internal$_current; + $async$goto = 4; + return A._asyncAwait((t4 == null ? t2._as(t4) : t4).accept$1(t3), $async$call$0); + case 4: + // returning from await. + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssStyleRule_closure1.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitCssSupportsRule_closure1.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t2, t3, t4, t1, _0_0; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + _0_0 = t1._async_evaluate$_atRootExcludingStyleRule ? null : t1._async_evaluate$_styleRuleIgnoringAtRoot; + $async$goto = _0_0 != null ? 2 : 4; + break; + case 2: + // then + $async$goto = 5; + return A._asyncAwait(t1._async_evaluate$_withParent$2$2(A.ModifiableCssStyleRule$(_0_0._style_rule$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitCssSupportsRule__closure0(t1, $async$self.node), type$.ModifiableCssStyleRule, type$.Null), $async$call$0); + case 5: + // returning from await. + // goto join + $async$goto = 3; + break; + case 4: + // else + t2 = $async$self.node.children, t3 = t2.$ti, t2 = new A.ListIterator(t2, t2.get$length(0), t3._eval$1("ListIterator")), t3 = t3._eval$1("ListBase.E"); + case 6: + // for condition + if (!t2.moveNext$0()) { + // goto after for + $async$goto = 7; + break; + } + t4 = t2.__internal$_current; + $async$goto = 8; + return A._asyncAwait((t4 == null ? t3._as(t4) : t4).accept$1(t1), $async$call$0); + case 8: + // returning from await. + // goto for condition + $async$goto = 6; + break; + case 7: + // after for + case 3: + // join + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssSupportsRule__closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, t4; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = $async$self.$this, t2 = t2._eval$1("ListBase.E"); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + t4 = t1.__internal$_current; + $async$goto = 4; + return A._asyncAwait((t4 == null ? t2._as(t4) : t4).accept$1(t3), $async$call$0); + case 4: + // returning from await. + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssSupportsRule_closure2.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor__performInterpolationHelper_closure0.prototype = { + call$1(targetLocations) { + return A.InterpolationMap$(this.interpolation, targetLocations); + }, + $signature: 184 + }; + A._EvaluateVisitor__serialize_closure0.prototype = { + call$0() { + return A.serializeValue(this.value, false, this.quote); + }, + $signature: 26 + }; + A._EvaluateVisitor__expressionNode_closure0.prototype = { + call$0() { + var t1 = this.expression; + return this.$this._async_evaluate$_environment.getVariableNode$2$namespace(t1.name, t1.namespace); + }, + $signature: 142 + }; + A._EvaluateVisitor__withoutSlash_recommendation0.prototype = { + call$1(number) { + var before, after, t1, + _1_0 = number.asSlash; + $label0$0: { + if (type$.Record_2_nullable_Object_and_nullable_Object._is(_1_0)) { + before = _1_0._0; + after = _1_0._1; + t1 = "math.div(" + A.S(this.call$1(before)) + ", " + A.S(this.call$1(after)) + ")"; + break $label0$0; + } + t1 = A.serializeValue(number, true, true); + break $label0$0; + } + return t1; + }, + $signature: 186 + }; + A._EvaluateVisitor__stackFrame_closure0.prototype = { + call$1(url) { + var t1 = this.$this._async_evaluate$_importCache; + t1 = t1 == null ? null : t1.humanize$1(url); + return t1 == null ? url : t1; + }, + $signature: 50 + }; + A._ImportedCssVisitor0.prototype = { + visitCssAtRule$1(node) { + var t1 = node.isChildless ? null : new A._ImportedCssVisitor_visitCssAtRule_closure0(); + this._async_evaluate$_visitor._async_evaluate$_addChild$2$through(node, t1); + }, + visitCssComment$1(node) { + return this._async_evaluate$_visitor._async_evaluate$_addChild$1(node); + }, + visitCssDeclaration$1(node) { + }, + visitCssImport$1(node) { + var t2, + _s13_ = "_endOfImports", + t1 = this._async_evaluate$_visitor; + if (t1._async_evaluate$_assertInModule$2(t1._async_evaluate$__parent, "__parent") !== t1._async_evaluate$_assertInModule$2(t1._async_evaluate$__root, "_root")) + t1._async_evaluate$_addChild$1(node); + else if (t1._async_evaluate$_assertInModule$2(t1._async_evaluate$__endOfImports, _s13_) === J.get$length$asx(t1._async_evaluate$_assertInModule$2(t1._async_evaluate$__root, "_root").children._collection$_source)) { + t1._async_evaluate$_addChild$1(node); + t1._async_evaluate$__endOfImports = t1._async_evaluate$_assertInModule$2(t1._async_evaluate$__endOfImports, _s13_) + 1; + } else { + t2 = t1._async_evaluate$_outOfOrderImports; + (t2 == null ? t1._async_evaluate$_outOfOrderImports = A._setArrayType([], type$.JSArray_ModifiableCssImport) : t2).push(node); + } + }, + visitCssKeyframeBlock$1(node) { + }, + visitCssMediaRule$1(node) { + var t1 = this._async_evaluate$_visitor, + mediaQueries = t1._async_evaluate$_mediaQueries; + t1._async_evaluate$_addChild$2$through(node, new A._ImportedCssVisitor_visitCssMediaRule_closure0(mediaQueries == null || t1._async_evaluate$_mergeMediaQueries$2(mediaQueries, node.queries) != null)); + }, + visitCssStyleRule$1(node) { + return this._async_evaluate$_visitor._async_evaluate$_addChild$2$through(node, new A._ImportedCssVisitor_visitCssStyleRule_closure0()); + }, + visitCssStylesheet$1(node) { + var t1, t2, t3; + for (t1 = node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t3 = t1.__internal$_current; + (t3 == null ? t2._as(t3) : t3).accept$1(this); + } + }, + visitCssSupportsRule$1(node) { + return this._async_evaluate$_visitor._async_evaluate$_addChild$2$through(node, new A._ImportedCssVisitor_visitCssSupportsRule_closure0()); + } + }; + A._ImportedCssVisitor_visitCssAtRule_closure0.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._ImportedCssVisitor_visitCssMediaRule_closure0.prototype = { + call$1(node) { + var t1; + if (!(node instanceof A.ModifiableCssStyleRule)) + t1 = this.hasBeenMerged && node instanceof A.ModifiableCssMediaRule; + else + t1 = true; + return t1; + }, + $signature: 8 + }; + A._ImportedCssVisitor_visitCssStyleRule_closure0.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._ImportedCssVisitor_visitCssSupportsRule_closure0.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluationContext0.prototype = { + get$currentCallableSpan() { + var _0_0 = this._async_evaluate$_visitor._async_evaluate$_callableNode; + if (_0_0 != null) + return _0_0.get$span(_0_0); + throw A.wrapException(A.StateError$(string$.No_Sasc)); + }, + warn$2(_, message, deprecation) { + var t1 = this._async_evaluate$_visitor, + t2 = t1._async_evaluate$_importSpan; + if (t2 == null) { + t2 = t1._async_evaluate$_callableNode; + t2 = t2 == null ? null : t2.get$span(t2); + } + t1._async_evaluate$_warn$3(message, t2 == null ? this._async_evaluate$_defaultWarnNodeWithSpan.span : t2, deprecation); + }, + $isEvaluationContext: 1 + }; + A._CloneCssVisitor.prototype = { + visitCssAtRule$1(node) { + var t1 = node.isChildless, + rule = A.ModifiableCssAtRule$(node.name, node.span, t1, node.value); + return t1 ? rule : this._visitChildren$2(rule, node); + }, + visitCssComment$1(node) { + return new A.ModifiableCssComment(node.text, node.span); + }, + visitCssDeclaration$1(node) { + return A.ModifiableCssDeclaration$(node.name, node.value, node.span, null, node.parsedAsCustomProperty, null, node.valueSpanForMap); + }, + visitCssImport$1(node) { + return new A.ModifiableCssImport(node.url, node.modifiers, node.span); + }, + visitCssKeyframeBlock$1(node) { + return this._visitChildren$2(A.ModifiableCssKeyframeBlock$(node.selector, node.span), node); + }, + visitCssMediaRule$1(node) { + return this._visitChildren$2(A.ModifiableCssMediaRule$(node.queries, node.span), node); + }, + visitCssStyleRule$1(node) { + var _0_0 = this._oldToNewSelectors.$index(0, node._style_rule$_selector._box$_inner.value); + if (_0_0 != null) + return this._visitChildren$2(A.ModifiableCssStyleRule$(_0_0, node.span, false, node.originalSelector), node); + else + throw A.wrapException(A.StateError$(string$.The_Ex)); + }, + visitCssStylesheet$1(node) { + return this._visitChildren$2(A.ModifiableCssStylesheet$(node.get$span(node)), node); + }, + visitCssSupportsRule$1(node) { + return this._visitChildren$2(A.ModifiableCssSupportsRule$(node.condition, node.span), node); + }, + _visitChildren$1$2(newParent, oldParent) { + var t1, t2, newChild; + for (t1 = J.get$iterator$ax(oldParent.get$children(oldParent)); t1.moveNext$0();) { + t2 = t1.get$current(t1); + newChild = t2.accept$1(this); + newChild.isGroupEnd = t2.get$isGroupEnd(); + newParent.addChild$1(newChild); + } + return newParent; + }, + _visitChildren$2(newParent, oldParent) { + return this._visitChildren$1$2(newParent, oldParent, type$.ModifiableCssParentNode); + } + }; + A.Evaluator.prototype = {}; + A._EvaluateVisitor.prototype = { + _EvaluateVisitor$6$functions$importCache$logger$nodeImporter$quietDeps$sourceMap(functions, importCache, logger, nodeImporter, quietDeps, sourceMap) { + var t2, metaModule, t3, _i, module, $function, t4, _this = this, + _s20_ = "$name, $module: null", + _s9_ = "sass:meta", + _s7_ = "$module", + t1 = type$.JSArray_BuiltInCallable, + metaFunctions = A._setArrayType([A.BuiltInCallable$function("global-variable-exists", _s20_, new A._EvaluateVisitor_closure(_this), _s9_), A.BuiltInCallable$function("variable-exists", "$name", new A._EvaluateVisitor_closure0(_this), _s9_), A.BuiltInCallable$function("function-exists", _s20_, new A._EvaluateVisitor_closure1(_this), _s9_), A.BuiltInCallable$function("mixin-exists", _s20_, new A._EvaluateVisitor_closure2(_this), _s9_), A.BuiltInCallable$function("content-exists", "", new A._EvaluateVisitor_closure3(_this), _s9_), A.BuiltInCallable$function("module-variables", _s7_, new A._EvaluateVisitor_closure4(_this), _s9_), A.BuiltInCallable$function("module-functions", _s7_, new A._EvaluateVisitor_closure5(_this), _s9_), A.BuiltInCallable$function("module-mixins", _s7_, new A._EvaluateVisitor_closure6(_this), _s9_), A.BuiltInCallable$function("get-function", "$name, $css: false, $module: null", new A._EvaluateVisitor_closure7(_this), _s9_), A.BuiltInCallable$function("get-mixin", _s20_, new A._EvaluateVisitor_closure8(_this), _s9_), A.BuiltInCallable$function("call", "$function, $args...", new A._EvaluateVisitor_closure9(_this), _s9_)], t1), + metaMixins = A._setArrayType([A.BuiltInCallable$mixin("load-css", "$url, $with: null", new A._EvaluateVisitor_closure10(_this), false, _s9_), A.BuiltInCallable$mixin("apply", "$mixin, $args...", new A._EvaluateVisitor_closure11(_this), true, _s9_)], t1); + t1 = type$.BuiltInCallable; + t2 = A.List_List$of($.$get$moduleFunctions(), true, t1); + B.JSArray_methods.addAll$1(t2, metaFunctions); + metaModule = A.BuiltInModule$("meta", t2, metaMixins, null, t1); + for (t1 = A.List_List$of($.$get$coreModules(), true, type$.BuiltInModule_Callable), t1.push(metaModule), t2 = t1.length, t3 = _this._builtInModules, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + module = t1[_i]; + t3.$indexSet(0, module.url, module); + } + t1 = type$.JSArray_Callable; + t2 = A._setArrayType([], t1); + B.JSArray_methods.addAll$1(t2, $.$get$globalFunctions()); + t1 = A._setArrayType([], t1); + for (_i = 0; _i < 11; ++_i) + t1.push(metaFunctions[_i].withDeprecationWarning$1("meta")); + B.JSArray_methods.addAll$1(t2, t1); + for (t1 = t2.length, t3 = _this._builtInFunctions, _i = 0; _i < t2.length; t2.length === t1 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + $function = t2[_i]; + t4 = $function.get$name($function); + t3.$indexSet(0, A.stringReplaceAllUnchecked(t4, "_", "-"), $function); + } + }, + run$2(_, importer, node) { + var error, stackTrace, t1, exception; + try { + t1 = type$.nullable_Object; + t1 = A.runZoned(new A._EvaluateVisitor_run_closure(this, node, importer), A.LinkedHashMap_LinkedHashMap$_literal([B.Symbol__evaluationContext, new A._EvaluationContext(this, node)], t1, t1), type$.Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException) { + error = t1; + stackTrace = A.getTraceFromException(exception); + A.throwWithTrace(error.withLoadedUrls$1(this._loadedUrls), error, stackTrace); + } else + throw exception; + } + }, + runExpression$2(importer, expression) { + var t1 = type$.nullable_Object; + return A.runZoned(new A._EvaluateVisitor_runExpression_closure(this, importer, expression), A.LinkedHashMap_LinkedHashMap$_literal([B.Symbol__evaluationContext, new A._EvaluationContext(this, expression)], t1, t1), type$.Value); + }, + runStatement$2(importer, statement) { + var t1 = type$.nullable_Object; + return A.runZoned(new A._EvaluateVisitor_runStatement_closure(this, importer, statement), A.LinkedHashMap_LinkedHashMap$_literal([B.Symbol__evaluationContext, new A._EvaluationContext(this, statement)], t1, t1), type$.void); + }, + _assertInModule$1$2(value, $name) { + if (value != null) + return value; + throw A.wrapException(A.StateError$("Can't access " + $name + " outside of a module.")); + }, + _assertInModule$2(value, $name) { + return this._assertInModule$1$2(value, $name, type$.dynamic); + }, + _withFakeStylesheet$1$3(importer, nodeWithSpan, callback) { + var t1, _this = this, + oldImporter = _this._importer; + _this._importer = importer; + _this.__stylesheet = A.Stylesheet$(B.List_empty13, nodeWithSpan.get$span(nodeWithSpan)); + try { + t1 = callback.call$0(); + return t1; + } finally { + _this._importer = oldImporter; + _this.__stylesheet = null; + } + }, + _withFakeStylesheet$3(importer, nodeWithSpan, callback) { + return this._withFakeStylesheet$1$3(importer, nodeWithSpan, callback, type$.dynamic); + }, + _loadModule$7$baseUrl$configuration$namesInErrors(url, stackFrame, nodeWithSpan, callback, baseUrl, configuration, namesInErrors) { + var t2, _this = this, + _0_0 = _this._builtInModules.$index(0, url), + t1 = {}; + t1.builtInModule = null; + if (_0_0 != null) { + t1.builtInModule = _0_0; + if (configuration instanceof A.ExplicitConfiguration) { + t1 = namesInErrors ? "Built-in module " + url.toString$0(0) + " can't be configured." : "Built-in modules can't be configured."; + t2 = configuration.nodeWithSpan; + throw A.wrapException(_this._evaluate$_exception$2(t1, t2.get$span(t2))); + } + _this._addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__loadModule_closure(t1, callback)); + return; + } + _this._withStackFrame$3(stackFrame, nodeWithSpan, new A._EvaluateVisitor__loadModule_closure0(_this, url, nodeWithSpan, baseUrl, namesInErrors, configuration, callback)); + }, + _loadModule$5$configuration(url, stackFrame, nodeWithSpan, callback, configuration) { + return this._loadModule$7$baseUrl$configuration$namesInErrors(url, stackFrame, nodeWithSpan, callback, null, configuration, false); + }, + _loadModule$4(url, stackFrame, nodeWithSpan, callback) { + return this._loadModule$7$baseUrl$configuration$namesInErrors(url, stackFrame, nodeWithSpan, callback, null, null, false); + }, + _execute$5$configuration$namesInErrors$nodeWithSpan(importer, stylesheet, configuration, namesInErrors, nodeWithSpan) { + var _0_0, currentConfiguration, t2, t3, message, existingSpan, configurationSpan, environment, css, preModuleComments, extensionStore, module, _this = this, + t1 = stylesheet.span, + url = t1.get$sourceUrl(t1); + t1 = _this._modules; + _0_0 = t1.$index(0, url); + if (_0_0 != null) { + t1 = configuration == null; + currentConfiguration = t1 ? _this._configuration : configuration; + t2 = _this._moduleConfigurations.$index(0, url); + t3 = t2.__originalConfiguration; + t2 = t3 == null ? t2 : t3; + t3 = currentConfiguration.__originalConfiguration; + if (t2 !== (t3 == null ? currentConfiguration : t3) && currentConfiguration instanceof A.ExplicitConfiguration) { + if (namesInErrors) { + t2 = $.$get$context(); + url.toString; + message = t2.prettyUri$1(url) + string$.x20was_a; + } else + message = string$.This_mw; + t2 = _this._moduleNodes.$index(0, url); + existingSpan = t2 == null ? null : t2.get$span(t2); + if (t1) { + t1 = currentConfiguration.nodeWithSpan; + configurationSpan = t1.get$span(t1); + } else + configurationSpan = null; + t1 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + if (existingSpan != null) + t1.$indexSet(0, existingSpan, "original load"); + if (configurationSpan != null) + t1.$indexSet(0, configurationSpan, "configuration"); + throw A.wrapException(t1.get$isEmpty(0) ? _this._evaluate$_exception$1(message) : _this._multiSpanException$3(message, "new load", t1)); + } + return _0_0; + } + environment = A.Environment$(); + css = A._Cell$(); + preModuleComments = A._Cell$(); + extensionStore = A.ExtensionStore$(); + _this._withEnvironment$2(environment, new A._EvaluateVisitor__execute_closure(_this, importer, stylesheet, extensionStore, configuration, css, preModuleComments)); + t2 = css._readLocal$0(); + t3 = preModuleComments._readLocal$0(); + module = environment.toModule$3(t2, t3 == null ? B.Map_empty0 : t3, extensionStore); + if (url != null) { + t1.$indexSet(0, url, module); + _this._moduleConfigurations.$indexSet(0, url, _this._configuration); + if (nodeWithSpan != null) + _this._moduleNodes.$indexSet(0, url, nodeWithSpan); + } + return module; + }, + _execute$2(importer, stylesheet) { + return this._execute$5$configuration$namesInErrors$nodeWithSpan(importer, stylesheet, null, false, null); + }, + _addOutOfOrderImports$0() { + var t1, t2, _this = this, _s5_ = "_root", + _s13_ = "_endOfImports", + _0_0 = _this._outOfOrderImports; + $label0$0: { + if (_0_0 == null) { + t1 = _this._assertInModule$2(_this.__root, _s5_).children; + break $label0$0; + } + t1 = _this._assertInModule$2(_this.__root, _s5_).children; + t1 = A.List_List$of(A.SubListIterable$(t1, 0, A.checkNotNullable(_this._assertInModule$2(_this.__endOfImports, _s13_), "count", type$.int), t1.$ti._eval$1("ListBase.E")), true, type$.ModifiableCssNode); + B.JSArray_methods.addAll$1(t1, _0_0); + t2 = _this._assertInModule$2(_this.__root, _s5_).children; + B.JSArray_methods.addAll$1(t1, A.SubListIterable$(t2, _this._assertInModule$2(_this.__endOfImports, _s13_), null, t2.$ti._eval$1("ListBase.E"))); + break $label0$0; + } + return t1; + }, + _combineCss$2$clone(root, clone) { + var selectors, _0_0, t1, imports, css, sorted, t2; + if (!B.JSArray_methods.any$1(root.get$upstream(), new A._EvaluateVisitor__combineCss_closure())) { + selectors = root.get$extensionStore().get$simpleSelectors(); + _0_0 = A.IterableExtension_get_firstOrNull(root.get$extensionStore().extensionsWhereTarget$1(new A._EvaluateVisitor__combineCss_closure0(selectors))); + if (_0_0 != null) + this._throwForUnsatisfiedExtension$1(_0_0); + return root.get$css(root); + } + t1 = type$.JSArray_CssNode; + imports = A._setArrayType([], t1); + css = A._setArrayType([], t1); + t1 = type$.Module_Callable; + sorted = A.ListQueue$(t1); + new A._EvaluateVisitor__combineCss_visitModule(this, A.LinkedHashSet_LinkedHashSet$_empty(t1), clone, css, imports, sorted).call$1(root); + if (root.get$transitivelyContainsExtensions()) + this._extendModules$1(sorted); + t1 = B.JSArray_methods.$add(imports, css); + t2 = root.get$css(root); + return new A.CssStylesheet(new A.UnmodifiableListView(t1, type$.UnmodifiableListView_CssNode), t2.get$span(t2)); + }, + _combineCss$1(root) { + return this._combineCss$2$clone(root, false); + }, + _extendModules$1(sortedModules) { + var t1, t2, t3, originalSelectors, $self, t4, t5, _i, upstream, _0_0, + downstreamExtensionStores = A.LinkedHashMap_LinkedHashMap$_empty(type$.Uri, type$.List_ExtensionStore), + unsatisfiedExtensions = new A._LinkedIdentityHashSet(type$._LinkedIdentityHashSet_Extension); + for (t1 = A._ListQueueIterator$(sortedModules, sortedModules.$ti._precomputed1), t2 = t1.$ti._precomputed1; t1.moveNext$0();) { + t3 = t1._collection$_current; + if (t3 == null) + t3 = t2._as(t3); + originalSelectors = t3.get$extensionStore().get$simpleSelectors().toSet$0(0); + unsatisfiedExtensions.addAll$1(0, t3.get$extensionStore().extensionsWhereTarget$1(new A._EvaluateVisitor__extendModules_closure(originalSelectors))); + $self = downstreamExtensionStores.$index(0, t3.get$url(t3)); + t4 = t3.get$extensionStore().get$addExtensions(); + if ($self != null) + t4.call$1($self); + t4 = t3.get$extensionStore(); + if (t4.get$isEmpty(t4)) + continue; + for (t4 = t3.get$upstream(), t5 = t4.length, _i = 0; _i < t4.length; t4.length === t5 || (0, A.throwConcurrentModificationError)(t4), ++_i) { + upstream = t4[_i]; + _0_0 = upstream.get$url(upstream); + if (_0_0 != null) + J.add$1$ax(downstreamExtensionStores.putIfAbsent$2(_0_0, new A._EvaluateVisitor__extendModules_closure0()), t3.get$extensionStore()); + } + unsatisfiedExtensions.removeAll$1(t3.get$extensionStore().extensionsWhereTarget$1(originalSelectors.get$contains(originalSelectors))); + } + if (unsatisfiedExtensions._collection$_length !== 0) + this._throwForUnsatisfiedExtension$1(unsatisfiedExtensions.get$first(0)); + }, + _throwForUnsatisfiedExtension$1(extension) { + throw A.wrapException(A.SassException$(string$.The_ta + extension.target.toString$0(0) + ' !optional" to avoid this error.', extension.span, null)); + }, + _indexAfterImports$1(statements) { + var t1, lastImport, i, _0_0; + for (t1 = J.getInterceptor$asx(statements), lastImport = -1, i = 0; i < t1.get$length(statements); ++i) { + $label0$0: { + _0_0 = t1.$index(statements, i); + if (_0_0 instanceof A.ModifiableCssImport) + break $label0$0; + if (_0_0 instanceof A.ModifiableCssComment) + continue; + break; + } + lastImport = i; + } + return lastImport + 1; + }, + visitStylesheet$1(_, node) { + var t1, t2, warning, _i, $name, span; + for (t1 = node.parseTimeWarnings, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + warning = t1.__internal$_current; + if (warning == null) + warning = t2._as(warning); + this._warn$3(warning._1, warning._2, warning._0); + } + for (t1 = node.children, t2 = t1.length, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(this); + for (t1 = A.MapExtensions_get_pairs(node.globalVariables, type$.String, type$.FileSpan), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t2 = t1.get$current(t1); + $name = t2._0; + span = t2._1; + this.visitVariableDeclaration$1(0, new A.VariableDeclaration(null, $name, new A.NullExpression(span), true, false, span)); + } + return null; + }, + visitAtRootRule$1(_, node) { + var t1, _2_0, root, first, rest, innerCopy, outerCopy, _i, copy, _this = this, _null = null, + _s8_ = "__parent", + _0_0 = node.query, + query = _0_0 != null ? new A.AtRootQueryParser(A.SpanScanner$(_this._performInterpolationWithMap$2$warnForColor(_0_0, true)._0, _null), _null).parse$0(0) : B.AtRootQuery_bfj, + $parent = _this._assertInModule$2(_this.__parent, _s8_), + included = A._setArrayType([], type$.JSArray_ModifiableCssParentNode); + for (t1 = type$.CssStylesheet; !t1._is($parent); $parent = _2_0) { + if (!query.excludes$1($parent)) + included.push($parent); + _2_0 = $parent._parent; + if (_2_0 == null) + throw A.wrapException(A.StateError$(string$.CssNod)); + } + root = _this._trimIncluded$1(included); + if (root === _this._assertInModule$2(_this.__parent, _s8_)) { + _this._environment.scope$1$2$when(new A._EvaluateVisitor_visitAtRootRule_closure(_this, node), node.hasDeclarations, type$.Null); + return _null; + } + if (included.length >= 1) { + first = included[0]; + rest = B.JSArray_methods.sublist$1(included, 1); + innerCopy = first.copyWithoutChildren$0(); + for (t1 = rest.length, outerCopy = innerCopy, _i = 0; _i < rest.length; rest.length === t1 || (0, A.throwConcurrentModificationError)(rest), ++_i, outerCopy = copy) { + copy = rest[_i].copyWithoutChildren$0(); + copy.addChild$1(outerCopy); + } + root.addChild$1(outerCopy); + } else + innerCopy = root; + _this._scopeForAtRoot$4(node, innerCopy, query, included).call$1(new A._EvaluateVisitor_visitAtRootRule_closure0(_this, node)); + return _null; + }, + _trimIncluded$1(nodes) { + var $parent, t1, innermostContiguous, i, t2, _0_0, _1_0, root, _this = this, _null = null, _s5_ = "_root", + _s22_ = " to be an ancestor of "; + if (nodes.length === 0) + return _this._assertInModule$2(_this.__root, _s5_); + $parent = _this._assertInModule$2(_this.__parent, "__parent"); + for (t1 = nodes.length, innermostContiguous = _null, i = 0; i < t1; ++i, $parent = _1_0) { + for (; t2 = nodes[i], $parent !== t2; innermostContiguous = _null, $parent = _0_0) { + _0_0 = $parent._parent; + if (_0_0 == null) + throw A.wrapException(A.ArgumentError$("Expected " + t2.toString$0(0) + _s22_ + _this.toString$0(0) + ".", _null)); + } + if (innermostContiguous == null) + innermostContiguous = i; + _1_0 = $parent._parent; + if (_1_0 == null) + throw A.wrapException(A.ArgumentError$("Expected " + t2.toString$0(0) + _s22_ + _this.toString$0(0) + ".", _null)); + } + if ($parent !== _this._assertInModule$2(_this.__root, _s5_)) + return _this._assertInModule$2(_this.__root, _s5_); + innermostContiguous.toString; + root = nodes[innermostContiguous]; + B.JSArray_methods.removeRange$2(nodes, innermostContiguous, nodes.length); + return root; + }, + _scopeForAtRoot$4(node, newParent, query, included) { + var _this = this, + scope = new A._EvaluateVisitor__scopeForAtRoot_closure(_this, newParent, node), + t1 = query._all || query._at_root_query$_rule; + if (t1 !== query.include) + scope = new A._EvaluateVisitor__scopeForAtRoot_closure0(_this, scope); + if (_this._mediaQueries != null && query.excludesName$1("media")) + scope = new A._EvaluateVisitor__scopeForAtRoot_closure1(_this, scope); + if (_this._inKeyframes && query.excludesName$1("keyframes")) + scope = new A._EvaluateVisitor__scopeForAtRoot_closure2(_this, scope); + return _this._inUnknownAtRule && !B.JSArray_methods.any$1(included, new A._EvaluateVisitor__scopeForAtRoot_closure3()) ? new A._EvaluateVisitor__scopeForAtRoot_closure4(_this, scope) : scope; + }, + visitContentBlock$1(_, node) { + return A.throwExpression(A.UnsupportedError$(string$.Evalua)); + }, + visitContentRule$1(_, node) { + var $content = this._environment._content; + if ($content == null) + return null; + this._runUserDefinedCallable$1$4(node.$arguments, $content, node, new A._EvaluateVisitor_visitContentRule_closure(this, $content), type$.Null); + return null; + }, + visitDebugRule$1(_, node) { + var value = node.expression.accept$1(this), + t1 = value instanceof A.SassString ? value._string$_text : A.serializeValue(value, true, true); + this._logger.debug$2(0, t1, node.span); + return null; + }, + visitDeclaration$1(_, node) { + var siblings, interleavedRules, t1, t2, t3, t4, t5, t6, rule, rule0, $name, _1_0, _2_0, value, _3_0, oldDeclarationName, _this = this, _null = null, + _s8_ = "__parent"; + if ((_this._atRootExcludingStyleRule ? _null : _this._styleRuleIgnoringAtRoot) == null && !_this._inUnknownAtRule && !_this._inKeyframes) + throw A.wrapException(_this._evaluate$_exception$2(string$.Declarm, node.span)); + if (_this._declarationName != null && B.JSString_methods.startsWith$1(node.name.get$initialPlain(), "--")) + throw A.wrapException(_this._evaluate$_exception$2(string$.Declarw, node.span)); + siblings = _this._assertInModule$2(_this.__parent, _s8_)._parent.children; + interleavedRules = A._setArrayType([], type$.JSArray_CssStyleRule); + if (siblings.get$last(siblings) !== _this._assertInModule$2(_this.__parent, _s8_)) + t1 = !(_this._quietDeps && _this._inDependency); + else + t1 = false; + if (t1) + for (t1 = A.SubListIterable$(siblings, siblings.indexOf$1(siblings, _this._assertInModule$2(_this.__parent, _s8_)) + 1, _null, siblings.$ti._eval$1("ListBase.E")), t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = node.span, t4 = type$.SourceSpan, t5 = type$.String, t2 = t2._eval$1("ListIterable.E"); t1.moveNext$0();) { + t6 = t1.__internal$_current; + rule = t6 == null ? t2._as(t6) : t6; + $label0$1: { + if (rule instanceof A.ModifiableCssComment) + continue; + t6 = rule instanceof A.ModifiableCssStyleRule; + rule0 = t6 ? rule : _null; + if (t6) { + interleavedRules.push(rule0); + break $label0$1; + } + _this._warn$3(string$.Sassx27s, new A.MultiSpan(t3, "declaration", A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_literal([rule.get$span(rule), "nested rule"], t4, t5), t4, t5)), B.Deprecation_39u); + B.JSArray_methods.clear$0(interleavedRules); + break $label0$1; + } + } + t1 = node.name; + $name = _this._interpolationToValue$2$warnForColor(t1, true); + _1_0 = _this._declarationName; + if (_1_0 != null) + $name = new A.CssValue(_1_0 + "-" + A.S($name.value), $name.span, type$.CssValue_String); + _2_0 = node.value; + if (_2_0 != null) { + value = _2_0.accept$1(_this); + if (!value.get$isBlank() || value.get$asList().length === 0) { + t2 = _this._assertInModule$2(_this.__parent, _s8_); + t3 = _2_0.get$span(_2_0); + t4 = node.span; + t1 = B.JSString_methods.startsWith$1(t1.get$initialPlain(), "--"); + t5 = interleavedRules.length === 0 ? _null : _this._evaluate$_stackTrace$1(t4); + if (_this._sourceMap) { + t6 = A.NullableExtension_andThen(_2_0, _this.get$_expressionNode()); + t6 = t6 == null ? _null : J.get$span$z(t6); + } else + t6 = _null; + t2.addChild$1(A.ModifiableCssDeclaration$($name, new A.CssValue(value, t3, type$.CssValue_Value), t4, interleavedRules, t1, t5, t6)); + } else if (J.startsWith$1$s($name.value, "--")) + throw A.wrapException(_this._evaluate$_exception$2("Custom property values may not be empty.", _2_0.get$span(_2_0))); + } + _3_0 = node.children; + t1 = {}; + t1.children = null; + if (_3_0 != null) { + t1.children = _3_0; + oldDeclarationName = _this._declarationName; + _this._declarationName = $name.value; + _this._environment.scope$1$2$when(new A._EvaluateVisitor_visitDeclaration_closure(t1, _this), node.hasDeclarations, type$.Null); + _this._declarationName = oldDeclarationName; + } + return _null; + }, + visitEachRule$1(_, node) { + var _this = this, + t1 = node.list, + list = t1.accept$1(_this), + nodeWithSpan = _this._expressionNode$1(t1), + _0_0 = node.variables; + $label0$0: { + t1 = {}; + t1.variable = null; + if (_0_0.length === 1) { + t1.variable = _0_0[0]; + t1 = new A._EvaluateVisitor_visitEachRule_closure(t1, _this, nodeWithSpan); + break $label0$0; + } + t1 = {}; + t1.variables = null; + t1.variables = _0_0; + t1 = new A._EvaluateVisitor_visitEachRule_closure0(t1, _this, nodeWithSpan); + break $label0$0; + } + return _this._environment.scope$1$2$semiGlobal(new A._EvaluateVisitor_visitEachRule_closure1(_this, list, t1, node), true, type$.nullable_Value); + }, + _setMultipleVariables$3(variables, value, nodeWithSpan) { + var i, + list = value.get$asList(), + t1 = variables.length, + minLength = Math.min(t1, list.length); + for (i = 0; i < minLength; ++i) + this._environment.setLocalVariable$3(variables[i], this._withoutSlash$2(list[i], nodeWithSpan), nodeWithSpan); + for (i = minLength; i < t1; ++i) + this._environment.setLocalVariable$3(variables[i], B.C__SassNull, nodeWithSpan); + }, + visitErrorRule$1(_, node) { + throw A.wrapException(this._evaluate$_exception$2(node.expression.accept$1(this).toString$0(0), node.span)); + }, + visitExtendRule$1(_, node) { + var t1, t2, t3, t4, t5, _i, complex, visitor, t6, t7, _0_0, compound, _this = this, _null = null, + styleRule = _this._atRootExcludingStyleRule ? _null : _this._styleRuleIgnoringAtRoot; + if (styleRule == null || _this._declarationName != null) + throw A.wrapException(_this._evaluate$_exception$2(string$.x40exten, node.span)); + for (t1 = styleRule.originalSelector.components, t2 = t1.length, t3 = node.span, t4 = type$.SourceSpan, t5 = type$.String, _i = 0; _i < t2; ++_i) { + complex = t1[_i]; + if (!complex.accept$1(B._IsBogusVisitor_true)) + continue; + visitor = A._SerializeVisitor$(_null, true, _null, _null, true, false, _null, true); + complex.accept$1(visitor); + t6 = B.JSString_methods.trim$0(visitor._serialize$_buffer.toString$0(0)); + t7 = complex.accept$1(B.C__IsUselessVisitor) ? "can't" : "shouldn't"; + _this._warn$3('The selector "' + t6 + '" is invalid CSS and ' + t7 + string$.x20be_an, new A.MultiSpan(A.SpanExtensions_trimRight(complex.span), "invalid selector", A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_literal([t3, "@extend rule"], t4, t5), t4, t5)), B.Deprecation_9hF); + } + _0_0 = _this._performInterpolationWithMap$2$warnForColor(node.selector, true); + for (t1 = A.SelectorList_SelectorList$parse(A.trimAscii(_0_0._0, true), false, _0_0._1, false).components, t2 = t1.length, t3 = styleRule._style_rule$_selector._box$_inner, _i = 0; _i < t2; ++_i) { + complex = t1[_i]; + compound = complex.get$singleCompound(); + if (compound == null) + throw A.wrapException(A.SassFormatException$("complex selectors may not be extended.", complex.span, _null)); + t4 = compound.components; + t5 = t4.length === 1 ? B.JSArray_methods.get$first(t4) : _null; + if (t5 == null) + throw A.wrapException(A.SassFormatException$(string$.compou + B.JSArray_methods.join$1(t4, ", ") + string$.x60_inst, compound.span, _null)); + _this._assertInModule$2(_this.__extensionStore, "_extensionStore").addExtension$4(t3.value, t5, node, _this._mediaQueries); + } + return _null; + }, + visitAtRule$1(_, node) { + var $name, value, children, wasInKeyframes, wasInUnknownAtRule, _this = this; + if (_this._declarationName != null) + throw A.wrapException(_this._evaluate$_exception$2(string$.At_rul, node.span)); + $name = _this._interpolationToValue$1(node.name); + value = A.NullableExtension_andThen(node.value, new A._EvaluateVisitor_visitAtRule_closure(_this)); + children = node.children; + if (children == null) { + _this._assertInModule$2(_this.__parent, "__parent").addChild$1(A.ModifiableCssAtRule$($name, node.span, true, value)); + return null; + } + wasInKeyframes = _this._inKeyframes; + wasInUnknownAtRule = _this._inUnknownAtRule; + if (A.unvendor($name.value) === "keyframes") + _this._inKeyframes = true; + else + _this._inUnknownAtRule = true; + _this._withParent$2$4$scopeWhen$through(A.ModifiableCssAtRule$($name, node.span, false, value), new A._EvaluateVisitor_visitAtRule_closure0(_this, $name, children), node.hasDeclarations, new A._EvaluateVisitor_visitAtRule_closure1(), type$.ModifiableCssAtRule, type$.Null); + _this._inUnknownAtRule = wasInUnknownAtRule; + _this._inKeyframes = wasInKeyframes; + return null; + }, + visitForRule$1(_, node) { + var _this = this, t1 = {}, + t2 = node.from, + fromNumber = _this._addExceptionSpan$2(t2, new A._EvaluateVisitor_visitForRule_closure(_this, node)), + t3 = node.to, + toNumber = _this._addExceptionSpan$2(t3, new A._EvaluateVisitor_visitForRule_closure0(_this, node)), + from = _this._addExceptionSpan$2(t2, new A._EvaluateVisitor_visitForRule_closure1(fromNumber)), + to = t1.to = _this._addExceptionSpan$2(t3, new A._EvaluateVisitor_visitForRule_closure2(toNumber, fromNumber)), + direction = from > to ? -1 : 1; + if (from === (!node.isExclusive ? t1.to = to + direction : to)) + return null; + return _this._environment.scope$1$2$semiGlobal(new A._EvaluateVisitor_visitForRule_closure3(t1, _this, node, from, direction, fromNumber), true, type$.nullable_Value); + }, + visitForwardRule$1(_, node) { + var newConfiguration, t4, _i, variable, $name, _this = this, + _s8_ = "@forward", + oldConfiguration = _this._configuration, + adjustedConfiguration = oldConfiguration.throughForward$1(node), + t1 = node.configuration, + t2 = t1.length, + t3 = node.url; + if (t2 !== 0) { + newConfiguration = _this._addForwardConfiguration$2(adjustedConfiguration, node); + _this._loadModule$5$configuration(t3, _s8_, node, new A._EvaluateVisitor_visitForwardRule_closure(_this, node), newConfiguration); + t3 = type$.String; + t4 = A.LinkedHashSet_LinkedHashSet$_empty(t3); + for (_i = 0; _i < t2; ++_i) { + variable = t1[_i]; + if (!variable.isGuarded) + t4.add$1(0, variable.name); + } + _this._removeUsedConfiguration$3$except(adjustedConfiguration, newConfiguration, t4); + t3 = A.LinkedHashSet_LinkedHashSet$_empty(t3); + for (_i = 0; _i < t2; ++_i) + t3.add$1(0, t1[_i].name); + for (t1 = newConfiguration._configuration$_values, t2 = J.toList$0$ax(t1.get$keys(t1)), t4 = t2.length, _i = 0; _i < t2.length; t2.length === t4 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + $name = t2[_i]; + if (!t3.contains$1(0, $name)) + if (!t1.get$isEmpty(t1)) + t1.remove$1(0, $name); + } + _this._assertConfigurationIsEmpty$1(newConfiguration); + } else { + _this._configuration = adjustedConfiguration; + _this._loadModule$4(t3, _s8_, node, new A._EvaluateVisitor_visitForwardRule_closure0(_this, node)); + _this._configuration = oldConfiguration; + } + return null; + }, + _addForwardConfiguration$2(configuration, node) { + var t2, t3, _i, variable, t4, _0_0, t5, oldValue, variableNodeWithSpan, _null = null, + t1 = configuration._configuration$_values, + newValues = A.LinkedHashMap_LinkedHashMap$of(new A.UnmodifiableMapView(t1, type$.UnmodifiableMapView_String_ConfiguredValue), type$.String, type$.ConfiguredValue); + for (t2 = node.configuration, t3 = t2.length, _i = 0; _i < t3; ++_i) { + variable = t2[_i]; + if (variable.isGuarded) { + t4 = variable.name; + _0_0 = t1.get$isEmpty(t1) ? _null : t1.remove$1(0, t4); + if (_0_0 != null) { + t5 = !_0_0.value.$eq(0, B.C__SassNull); + oldValue = _0_0; + } else { + oldValue = _null; + t5 = false; + } + if (t5) { + newValues.$indexSet(0, t4, oldValue); + continue; + } + } + t4 = variable.expression; + variableNodeWithSpan = this._expressionNode$1(t4); + newValues.$indexSet(0, variable.name, new A.ConfiguredValue(this._withoutSlash$2(t4.accept$1(this), variableNodeWithSpan), variable.span, variableNodeWithSpan)); + } + if (configuration instanceof A.ExplicitConfiguration || t1.get$isEmpty(t1)) + return new A.ExplicitConfiguration(node, newValues, _null); + else + return new A.Configuration(newValues, _null); + }, + _registerCommentsForModule$1(module) { + var _this = this, _s5_ = "_root", + t1 = _this.__root; + if (t1 == null) + return; + if (_this._assertInModule$2(t1, _s5_).children.get$length(0) === 0 || !module.get$transitivelyContainsCss()) + return; + t1 = _this._preModuleComments; + if (t1 == null) + t1 = _this._preModuleComments = A.LinkedHashMap_LinkedHashMap$_empty(type$.Module_Callable, type$.List_CssComment); + J.addAll$1$ax(t1.putIfAbsent$2(module, new A._EvaluateVisitor__registerCommentsForModule_closure()), new A.UnmodifiableListView(J.cast$1$0$ax(_this._assertInModule$2(_this.__root, _s5_).children._collection$_source, type$.CssComment), type$.UnmodifiableListView_CssComment)); + _this._assertInModule$2(_this.__root, _s5_).clearChildren$0(); + _this.__endOfImports = 0; + }, + _removeUsedConfiguration$3$except(upstream, downstream, except) { + var t1, t2, t3, t4, _i, $name; + for (t1 = upstream._configuration$_values, t2 = J.toList$0$ax(t1.get$keys(t1)), t3 = t2.length, t4 = downstream._configuration$_values, _i = 0; _i < t2.length; t2.length === t3 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + $name = t2[_i]; + if (except.contains$1(0, $name)) + continue; + if (!t4.containsKey$1($name)) + if (!t1.get$isEmpty(t1)) + t1.remove$1(0, $name); + } + }, + _assertConfigurationIsEmpty$2$nameInError(configuration, nameInError) { + var t1, _0_0, $name, value; + if (!(configuration instanceof A.ExplicitConfiguration)) + return; + t1 = configuration._configuration$_values; + if (t1.get$isEmpty(t1)) + return; + t1 = A.MapExtensions_get_pairs(new A.UnmodifiableMapView(t1, type$.UnmodifiableMapView_String_ConfiguredValue), type$.String, type$.ConfiguredValue); + _0_0 = t1.get$first(t1); + $name = _0_0._0; + value = _0_0._1; + t1 = nameInError ? "$" + $name + string$.x20was_n : string$.This_v; + throw A.wrapException(this._evaluate$_exception$2(t1, value.configurationSpan)); + }, + _assertConfigurationIsEmpty$1(configuration) { + return this._assertConfigurationIsEmpty$2$nameInError(configuration, false); + }, + visitFunctionRule$1(_, node) { + var t1 = this._environment, + t2 = t1.closure$0(), + t3 = this._inDependency, + t4 = t1._functions, + index = t4.length - 1, + t5 = node.name; + t1._functionIndices.$indexSet(0, t5, index); + t4[index].$indexSet(0, t5, new A.UserDefinedCallable(node, t2, t3, type$.UserDefinedCallable_Environment)); + return null; + }, + visitIfRule$1(_, node) { + var t1, t2, _i, clauseToCheck, + clause = node.lastClause; + for (t1 = node.clauses, t2 = t1.length, _i = 0; _i < t2; ++_i) { + clauseToCheck = t1[_i]; + if (clauseToCheck.expression.accept$1(this).get$isTruthy()) { + clause = clauseToCheck; + break; + } + } + return A.NullableExtension_andThen(clause, new A._EvaluateVisitor_visitIfRule_closure(this)); + }, + visitImportRule$1(_, node) { + var t1, t2, t3, t4, t5, t6, _i, $import, t7, _0_0, $self, t8, _this = this, + _s8_ = "__parent", + _s5_ = "_root", + _s13_ = "_endOfImports"; + for (t1 = node.imports, t2 = t1.length, t3 = type$.CssValue_String, t4 = _this.get$_interpolationToValue(), t5 = type$.StaticImport, t6 = type$.JSArray_ModifiableCssImport, _i = 0; _i < t2; ++_i) { + $import = t1[_i]; + if ($import instanceof A.DynamicImport) + _this._visitDynamicImport$1($import); + else { + t5._as($import); + t7 = $import.url; + _0_0 = _this._performInterpolationHelper$3$sourceMap$warnForColor(t7, false, false); + $self = $import.modifiers; + t8 = $self == null ? null : t4.call$1($self); + node = new A.ModifiableCssImport(new A.CssValue(_0_0._0, t7.span, t3), t8, $import.span); + if (_this._assertInModule$2(_this.__parent, _s8_) !== _this._assertInModule$2(_this.__root, _s5_)) + _this._assertInModule$2(_this.__parent, _s8_).addChild$1(node); + else if (_this._assertInModule$2(_this.__endOfImports, _s13_) === J.get$length$asx(_this._assertInModule$2(_this.__root, _s5_).children._collection$_source)) { + t7 = _this._assertInModule$2(_this.__root, _s5_); + node._parent = t7; + t7 = t7._children; + node._indexInParent = t7.length; + t7.push(node); + _this.__endOfImports = _this._assertInModule$2(_this.__endOfImports, _s13_) + 1; + } else { + t7 = _this._outOfOrderImports; + (t7 == null ? _this._outOfOrderImports = A._setArrayType([], t6) : t7).push(node); + } + } + } + return null; + }, + _visitDynamicImport$1($import) { + return this._withStackFrame$3("@import", $import, new A._EvaluateVisitor__visitDynamicImport_closure(this, $import)); + }, + _loadStylesheet$4$baseUrl$forImport(url, span, baseUrl, forImport) { + var _0_0, importCache, _1_0, importer, canonicalUrl, originalUrl, isDependency, _2_0, stylesheet, error, stackTrace, error0, stackTrace0, t1, t2, exception, _this = this; + baseUrl = baseUrl; + try { + _this._importSpan = span; + _0_0 = _this._evaluate$_importCache; + importCache = null; + if (_0_0 != null) { + importCache = _0_0; + if (baseUrl == null) { + t1 = _this._assertInModule$2(_this.__stylesheet, "_stylesheet").span; + baseUrl = t1.get$sourceUrl(t1); + } + _1_0 = J.canonicalize$4$baseImporter$baseUrl$forImport$x(importCache, A.Uri_parse(url), _this._importer, baseUrl, forImport); + importer = null; + canonicalUrl = null; + originalUrl = null; + if (type$.Record_3_nullable_Object_and_nullable_Object_and_nullable_Object_originalUrl._is(_1_0)) { + importer = _1_0._0; + canonicalUrl = _1_0._1; + originalUrl = _1_0._2; + if (canonicalUrl.get$scheme() === "") + A.WarnForDeprecation_warnForDeprecation(_this._logger, B.Deprecation_746, "Importer " + A.S(importer) + " canonicalized " + url + " to " + A.S(canonicalUrl) + string$.x2e_Rela, null, null); + _this._loadedUrls.add$1(0, canonicalUrl); + isDependency = _this._inDependency || !J.$eq$(importer, _this._importer); + _2_0 = importCache.importCanonical$3$originalUrl(importer, canonicalUrl, originalUrl); + stylesheet = null; + if (_2_0 != null) { + stylesheet = _2_0; + t1 = stylesheet; + t2 = importer; + return new A._Record_3_importer_isDependency(t1, t2, isDependency); + } + } + } + t1 = B.JSString_methods.startsWith$1(url, "package:"); + if (t1) + throw A.wrapException(string$.x22packa); + else + throw A.wrapException("Can't find stylesheet to import."); + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException) + throw exception; + else if (t1 instanceof A.ArgumentError) { + error = t1; + stackTrace = A.getTraceFromException(exception); + A.throwWithTrace(_this._evaluate$_exception$1(J.toString$0$(error)), error, stackTrace); + } else { + error0 = t1; + stackTrace0 = A.getTraceFromException(exception); + A.throwWithTrace(_this._evaluate$_exception$1(_this._getErrorMessage$1(error0)), error0, stackTrace0); + } + } finally { + _this._importSpan = null; + } + }, + _loadStylesheet$3$baseUrl(url, span, baseUrl) { + return this._loadStylesheet$4$baseUrl$forImport(url, span, baseUrl, false); + }, + _loadStylesheet$3$forImport(url, span, forImport) { + return this._loadStylesheet$4$baseUrl$forImport(url, span, null, forImport); + }, + _applyMixin$5(mixin, contentCallable, $arguments, nodeWithSpan, nodeWithSpanWithoutContent) { + var t1, _0_0, t2, _1_8, _this = this, + _s37_ = "Mixin doesn't accept a content block.", + _s10_ = "invocation"; + $label0$0: { + if (mixin == null) + throw A.wrapException(_this._evaluate$_exception$2("Undefined mixin.", nodeWithSpan.get$span(nodeWithSpan))); + t1 = mixin instanceof A.BuiltInCallable; + if (t1 && !mixin.acceptsContent && contentCallable != null) { + t1 = _this._evaluateArguments$1($arguments)._values; + _0_0 = mixin.callbackFor$2(t1[2].length, new A.MapKeySet(t1[0], type$.MapKeySet_String)); + throw A.wrapException(A.MultiSpanSassRuntimeException$(_s37_, nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent), _s10_, A.LinkedHashMap_LinkedHashMap$_literal([_0_0._0.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), _this._evaluate$_stackTrace$1(nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent)), null)); + } + if (t1) { + _this._environment.withContent$2(contentCallable, new A._EvaluateVisitor__applyMixin_closure(_this, $arguments, mixin, nodeWithSpanWithoutContent)); + break $label0$0; + } + t1 = type$.UserDefinedCallable_Environment._is(mixin); + t2 = false; + if (t1) { + _1_8 = mixin.declaration; + if (_1_8 instanceof A.MixinRule) + t2 = !type$.MixinRule._as(_1_8).get$hasContent() && contentCallable != null; + } + if (t2) + throw A.wrapException(A.MultiSpanSassRuntimeException$(_s37_, nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent), _s10_, A.LinkedHashMap_LinkedHashMap$_literal([mixin.declaration.parameters.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), _this._evaluate$_stackTrace$1(nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent)), null)); + if (t1) { + _this._runUserDefinedCallable$1$4($arguments, mixin, nodeWithSpanWithoutContent, new A._EvaluateVisitor__applyMixin_closure0(_this, contentCallable, mixin, nodeWithSpanWithoutContent), type$.Null); + break $label0$0; + } + throw A.wrapException(A.UnsupportedError$("Unknown callable type " + mixin.toString$0(0) + ".")); + } + }, + visitIncludeRule$1(_, node) { + var _this = this, + mixin = _this._addExceptionSpan$2(node, new A._EvaluateVisitor_visitIncludeRule_closure(_this, node)); + if (B.JSString_methods.startsWith$1(node.originalName, "--") && mixin instanceof A.UserDefinedCallable && !B.JSString_methods.startsWith$1(mixin.declaration.originalName, "--")) + _this._warn$3(string$.Sassx20_m, node.get$nameSpan(), B.Deprecation_Kg6); + _this._applyMixin$5(mixin, A.NullableExtension_andThen(node.content, new A._EvaluateVisitor_visitIncludeRule_closure0(_this)), node.$arguments, node, new A._FakeAstNode(new A._EvaluateVisitor_visitIncludeRule_closure1(node))); + return null; + }, + visitMixinRule$1(_, node) { + var t1 = this._environment, + t2 = t1.closure$0(), + t3 = this._inDependency, + t4 = t1._mixins, + index = t4.length - 1, + t5 = node.name; + t1._mixinIndices.$indexSet(0, t5, index); + t4[index].$indexSet(0, t5, new A.UserDefinedCallable(node, t2, t3, type$.UserDefinedCallable_Environment)); + return null; + }, + visitLoudComment$1(_, node) { + var t1, text, _this = this, + _s8_ = "__parent", + _s13_ = "_endOfImports"; + if (_this._inFunction) + return null; + if (_this._assertInModule$2(_this.__parent, _s8_) === _this._assertInModule$2(_this.__root, "_root") && _this._assertInModule$2(_this.__endOfImports, _s13_) === J.get$length$asx(_this._assertInModule$2(_this.__root, "_root").children._collection$_source)) + _this.__endOfImports = _this._assertInModule$2(_this.__endOfImports, _s13_) + 1; + t1 = node.text; + text = _this._performInterpolation$1(t1); + if (!B.JSString_methods.endsWith$1(text, "*/")) + text += " */"; + _this._assertInModule$2(_this.__parent, _s8_).addChild$1(new A.ModifiableCssComment(text, t1.span)); + return null; + }, + visitMediaRule$1(_, node) { + var _0_0, queries, mergedQueries, t1, mergedSources, t2, t3, _this = this; + if (_this._declarationName != null) + throw A.wrapException(_this._evaluate$_exception$2(string$.Media_, node.span)); + _0_0 = _this._performInterpolationWithMap$2$warnForColor(node.query, true); + queries = new A.MediaQueryParser(A.SpanScanner$(_0_0._0, null), _0_0._1).parse$0(0); + mergedQueries = A.NullableExtension_andThen(_this._mediaQueries, new A._EvaluateVisitor_visitMediaRule_closure(_this, queries)); + t1 = mergedQueries == null; + if (!t1 && J.get$isEmpty$asx(mergedQueries)) + return null; + if (t1) + mergedSources = B.Set_empty1; + else { + t2 = _this._mediaQuerySources; + t2.toString; + t2 = A.LinkedHashSet_LinkedHashSet$of(t2, type$.CssMediaQuery); + t3 = _this._mediaQueries; + t3.toString; + t2.addAll$1(0, t3); + t2.addAll$1(0, queries); + mergedSources = t2; + } + t1 = t1 ? queries : mergedQueries; + _this._withParent$2$4$scopeWhen$through(A.ModifiableCssMediaRule$(t1, node.span), new A._EvaluateVisitor_visitMediaRule_closure0(_this, mergedQueries, queries, mergedSources, node), node.hasDeclarations, new A._EvaluateVisitor_visitMediaRule_closure1(mergedSources), type$.ModifiableCssMediaRule, type$.Null); + return null; + }, + _mergeMediaQueries$2(queries1, queries2) { + var t1, t2, t3, t4, _0_0, t5, result, + queries = A._setArrayType([], type$.JSArray_CssMediaQuery); + for (t1 = J.get$iterator$ax(queries1), t2 = J.getInterceptor$ax(queries2); t1.moveNext$0();) { + t3 = t1.get$current(t1); + for (t4 = t2.get$iterator(queries2); t4.moveNext$0();) { + _0_0 = t3.merge$1(t4.get$current(t4)); + if (B._SingletonCssMediaQueryMergeResult_0 === _0_0) + continue; + if (B._SingletonCssMediaQueryMergeResult_1 === _0_0) + return null; + t5 = _0_0 instanceof A.MediaQuerySuccessfulMergeResult; + result = t5 ? _0_0 : null; + if (t5) + queries.push(result.query); + } + } + return queries; + }, + visitReturnRule$1(_, node) { + var t1 = node.expression; + return this._withoutSlash$2(t1.accept$1(this), t1); + }, + visitSilentComment$1(_, node) { + return null; + }, + visitStyleRule$1(_, node) { + var t1, _0_0, selectorText, selectorMap, parsedSelector, nest, t2, _i, _1_0, first, t3, rule, oldAtRootExcludingStyleRule, _this = this, _null = null, + _s8_ = "__parent", + _s11_ = "_stylesheet"; + if (_this._declarationName != null) + throw A.wrapException(_this._evaluate$_exception$2(string$.Style_n, node.span)); + else if (_this._inKeyframes && _this._assertInModule$2(_this.__parent, _s8_) instanceof A.ModifiableCssKeyframeBlock) + throw A.wrapException(_this._evaluate$_exception$2(string$.Style_k, node.span)); + t1 = node.selector; + _0_0 = _this._performInterpolationWithMap$2$warnForColor(t1, true); + selectorText = _0_0._0; + selectorMap = _0_0._1; + if (_this._inKeyframes) { + _this._withParent$2$4$scopeWhen$through(A.ModifiableCssKeyframeBlock$(new A.CssValue(A.List_List$unmodifiable(new A.KeyframeSelectorParser(A.SpanScanner$(selectorText, _null), selectorMap).parse$0(0), type$.String), t1.span, type$.CssValue_List_String), node.span), new A._EvaluateVisitor_visitStyleRule_closure(_this, node), node.hasDeclarations, new A._EvaluateVisitor_visitStyleRule_closure0(), type$.ModifiableCssKeyframeBlock, type$.Null); + return _null; + } + parsedSelector = A.SelectorList_SelectorList$parse(selectorText, true, selectorMap, _this._assertInModule$2(_this.__stylesheet, _s11_).plainCss); + t1 = _this._atRootExcludingStyleRule ? _null : _this._styleRuleIgnoringAtRoot; + t1 = t1 == null ? _null : t1.fromPlainCss; + nest = t1 !== true; + if (nest) { + if (_this._assertInModule$2(_this.__stylesheet, _s11_).plainCss) + for (t1 = parsedSelector.components, t2 = t1.length, _i = 0; _i < t2; ++_i) { + _1_0 = t1[_i].leadingCombinators; + if (_1_0.length >= 1) { + first = _1_0[0]; + t3 = _this._assertInModule$2(_this.__stylesheet, _s11_).plainCss; + } else { + first = _null; + t3 = false; + } + if (t3) + throw A.wrapException(_this._evaluate$_exception$2(string$.Top_lel, first.span)); + } + t1 = _this._styleRuleIgnoringAtRoot; + t1 = t1 == null ? _null : t1.originalSelector; + parsedSelector = parsedSelector.nestWithin$3$implicitParent$preserveParentSelectors(t1, !_this._atRootExcludingStyleRule, _this._assertInModule$2(_this.__stylesheet, _s11_).plainCss); + } + rule = A.ModifiableCssStyleRule$(_this._assertInModule$2(_this.__extensionStore, "_extensionStore").addSelector$2(parsedSelector, _this._mediaQueries), node.span, _this._assertInModule$2(_this.__stylesheet, _s11_).plainCss, parsedSelector); + oldAtRootExcludingStyleRule = _this._atRootExcludingStyleRule; + t1 = _this._atRootExcludingStyleRule = false; + t2 = nest ? new A._EvaluateVisitor_visitStyleRule_closure1() : _null; + _this._withParent$2$4$scopeWhen$through(rule, new A._EvaluateVisitor_visitStyleRule_closure2(_this, rule, node), node.hasDeclarations, t2, type$.ModifiableCssStyleRule, type$.Null); + _this._atRootExcludingStyleRule = oldAtRootExcludingStyleRule; + _this._warnForBogusCombinators$1(rule); + if ((_this._atRootExcludingStyleRule ? _null : _this._styleRuleIgnoringAtRoot) == null) { + t1 = _this._assertInModule$2(_this.__parent, _s8_).children; + t1 = !t1.get$isEmpty(t1); + } + if (t1) { + t1 = _this._assertInModule$2(_this.__parent, _s8_).children; + t1.get$last(t1).isGroupEnd = true; + } + return _null; + }, + _warnForBogusCombinators$1(rule) { + var t1, t2, t3, t4, t5, _i, complex, visitor, t6, t7, t8, t9, _this = this, _null = null; + if (!rule.accept$1(B._IsInvisibleVisitor_false_false)) + for (t1 = rule._style_rule$_selector._box$_inner.value.components, t2 = t1.length, t3 = type$.SourceSpan, t4 = type$.String, t5 = rule.children, _i = 0; _i < t2; ++_i) { + complex = t1[_i]; + if (!complex.accept$1(B._IsBogusVisitor_true)) + continue; + if (complex.accept$1(B.C__IsUselessVisitor)) { + visitor = A._SerializeVisitor$(_null, true, _null, _null, true, false, _null, true); + complex.accept$1(visitor); + _this._warn$3('The selector "' + B.JSString_methods.trim$0(visitor._serialize$_buffer.toString$0(0)) + string$.x22x20is_ix20, A.SpanExtensions_trimRight(complex.span), B.Deprecation_9hF); + } else if (complex.leadingCombinators.length !== 0) { + if (!_this._assertInModule$2(_this.__stylesheet, "_stylesheet").plainCss) { + visitor = A._SerializeVisitor$(_null, true, _null, _null, true, false, _null, true); + complex.accept$1(visitor); + _this._warn$3('The selector "' + B.JSString_methods.trim$0(visitor._serialize$_buffer.toString$0(0)) + string$.x22x20is_ix0a, A.SpanExtensions_trimRight(complex.span), B.Deprecation_9hF); + } + } else { + visitor = A._SerializeVisitor$(_null, true, _null, _null, true, false, _null, true); + complex.accept$1(visitor); + t6 = B.JSString_methods.trim$0(visitor._serialize$_buffer.toString$0(0)); + t7 = complex.accept$1(B._IsBogusVisitor_false) ? string$.x20It_wi : ""; + t8 = A.SpanExtensions_trimRight(complex.span); + if (t5.get$length(0) === 0) + A.throwExpression(A.IterableElementError_noElement()); + t9 = J.get$span$z(t5.$index(0, 0)); + _this._warn$3('The selector "' + t6 + string$.x22x20is_o + t7 + string$.x0aThis_, new A.MultiSpan(t8, "invalid selector", A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_literal([t9, "this is not a style rule" + (t5.every$1(t5, new A._EvaluateVisitor__warnForBogusCombinators_closure()) ? "\n(try converting to a //-style comment)" : "")], t3, t4), t3, t4)), B.Deprecation_9hF); + } + } + }, + visitSupportsRule$1(_, node) { + var t1, _this = this; + if (_this._declarationName != null) + throw A.wrapException(_this._evaluate$_exception$2(string$.Suppor, node.span)); + t1 = node.condition; + _this._withParent$2$4$scopeWhen$through(A.ModifiableCssSupportsRule$(new A.CssValue(_this._visitSupportsCondition$1(t1), t1.get$span(t1), type$.CssValue_String), node.span), new A._EvaluateVisitor_visitSupportsRule_closure(_this, node), node.hasDeclarations, new A._EvaluateVisitor_visitSupportsRule_closure0(), type$.ModifiableCssSupportsRule, type$.Null); + return null; + }, + _visitSupportsCondition$1(condition) { + var t1, _this = this; + $label0$0: { + if (condition instanceof A.SupportsOperation) { + t1 = condition.operator; + t1 = _this._evaluate$_parenthesize$2(condition.left, t1) + " " + t1 + " " + _this._evaluate$_parenthesize$2(condition.right, t1); + break $label0$0; + } + if (condition instanceof A.SupportsNegation) { + t1 = "not " + _this._evaluate$_parenthesize$1(condition.condition); + break $label0$0; + } + if (condition instanceof A.SupportsInterpolation) { + t1 = condition.expression; + t1 = _this._evaluate$_serialize$3$quote(t1.accept$1(_this), t1, false); + break $label0$0; + } + t1 = {}; + t1.declaration = null; + if (condition instanceof A.SupportsDeclaration) { + t1.declaration = condition; + t1 = _this._withSupportsDeclaration$1(new A._EvaluateVisitor__visitSupportsCondition_closure(t1, _this)); + break $label0$0; + } + if (condition instanceof A.SupportsFunction) { + t1 = _this._performInterpolation$1(condition.name) + "(" + _this._performInterpolation$1(condition.$arguments) + ")"; + break $label0$0; + } + if (condition instanceof A.SupportsAnything) { + t1 = "(" + _this._performInterpolation$1(condition.contents) + ")"; + break $label0$0; + } + t1 = A.throwExpression(A.ArgumentError$("Unknown supports condition type " + A.getRuntimeTypeOfDartObject(condition).toString$0(0) + ".", null)); + } + return t1; + }, + _withSupportsDeclaration$1$1(callback) { + var t1, + oldInSupportsDeclaration = this._inSupportsDeclaration; + this._inSupportsDeclaration = true; + try { + t1 = callback.call$0(); + return t1; + } finally { + this._inSupportsDeclaration = oldInSupportsDeclaration; + } + }, + _withSupportsDeclaration$1(callback) { + return this._withSupportsDeclaration$1$1(callback, type$.dynamic); + }, + _evaluate$_parenthesize$2(condition, operator) { + var t1; + if (!(condition instanceof A.SupportsNegation)) + if (condition instanceof A.SupportsOperation) + t1 = operator == null || operator !== condition.operator; + else + t1 = false; + else + t1 = true; + if (t1) + return "(" + this._visitSupportsCondition$1(condition) + ")"; + return this._visitSupportsCondition$1(condition); + }, + _evaluate$_parenthesize$1(condition) { + return this._evaluate$_parenthesize$2(condition, null); + }, + visitVariableDeclaration$1(_, node) { + var t1, _0_0, t2, value, _this = this, _null = null; + if (node.isGuarded) { + if (node.namespace == null && _this._environment._variables.length === 1) { + t1 = _this._configuration._configuration$_values; + _0_0 = t1.get$isEmpty(t1) ? _null : t1.remove$1(0, node.name); + t1 = {}; + t1.override = null; + if (_0_0 != null) { + t1.override = _0_0; + t2 = !_0_0.value.$eq(0, B.C__SassNull); + } else + t2 = false; + if (t2) { + _this._addExceptionSpan$2(node, new A._EvaluateVisitor_visitVariableDeclaration_closure(t1, _this, node)); + return _null; + } + } + value = _this._addExceptionSpan$2(node, new A._EvaluateVisitor_visitVariableDeclaration_closure0(_this, node)); + if (value != null && !value.$eq(0, B.C__SassNull)) + return _null; + } + if (node.isGlobal && !_this._environment.globalVariableExists$1(node.name)) { + t1 = _this._environment._variables.length === 1 ? string$.As_of_S : string$.As_of_R + A.declarationName(node.span) + ": null` at the stylesheet root."; + _this._warn$3(t1, node.span, B.Deprecation_Rg0); + } + t1 = node.expression; + _this._addExceptionSpan$2(node, new A._EvaluateVisitor_visitVariableDeclaration_closure1(_this, node, _this._withoutSlash$2(t1.accept$1(_this), t1))); + return _null; + }, + visitUseRule$1(_, node) { + var values, _i, variable, t3, variableNodeWithSpan, configuration, _this = this, + t1 = node.configuration, + t2 = t1.length; + if (t2 !== 0) { + values = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.ConfiguredValue); + for (_i = 0; _i < t2; ++_i) { + variable = t1[_i]; + t3 = variable.expression; + variableNodeWithSpan = _this._expressionNode$1(t3); + values.$indexSet(0, variable.name, new A.ConfiguredValue(_this._withoutSlash$2(t3.accept$1(_this), variableNodeWithSpan), variable.span, variableNodeWithSpan)); + } + configuration = new A.ExplicitConfiguration(node, values, null); + } else + configuration = B.Configuration_Map_empty_null; + _this._loadModule$5$configuration(node.url, "@use", node, new A._EvaluateVisitor_visitUseRule_closure(_this, node), configuration); + _this._assertConfigurationIsEmpty$1(configuration); + return null; + }, + visitWarnRule$1(_, node) { + var _this = this, + value = _this._addExceptionSpan$2(node, new A._EvaluateVisitor_visitWarnRule_closure(_this, node)), + t1 = value instanceof A.SassString ? value._string$_text : _this._evaluate$_serialize$2(value, node.expression), + t2 = _this._evaluate$_stackTrace$1(node.span); + _this._logger.internalWarn$4$deprecation$span$trace(t1, null, null, t2); + return null; + }, + visitWhileRule$1(_, node) { + return this._environment.scope$1$3$semiGlobal$when(new A._EvaluateVisitor_visitWhileRule_closure(this, node), true, node.hasDeclarations, type$.nullable_Value); + }, + visitBinaryOperationExpression$1(_, node) { + var t1, _this = this; + if (_this._assertInModule$2(_this.__stylesheet, "_stylesheet").plainCss) { + t1 = node.operator; + t1 = t1 !== B.BinaryOperator_Kyq && t1 !== B.BinaryOperator_Mh5; + } else + t1 = false; + if (t1) + throw A.wrapException(_this._evaluate$_exception$2("Operators aren't allowed in plain CSS.", node.get$operatorSpan())); + return _this._addExceptionSpan$2(node, new A._EvaluateVisitor_visitBinaryOperationExpression_closure(_this, node)); + }, + _slash$3(left, right, node) { + var t2, _1_1, + result = left.dividedBy$1(right), + _1_2_isSet = left instanceof A.SassNumber, + _1_2 = null, right0 = null, + t1 = false; + if (_1_2_isSet) { + t2 = type$.SassNumber; + t2._as(left); + if (right instanceof A.SassNumber) { + t2._as(right); + t1 = node.allowsSlash && this._operandAllowsSlash$1(node.left) && this._operandAllowsSlash$1(node.right); + right0 = right; + _1_2 = right0; + } else + _1_2 = right; + _1_1 = left; + } else { + _1_1 = left; + left = null; + } + if (t1) + return type$.SassNumber._as(result).withSlash$2(left, right0); + if (_1_1 instanceof A.SassNumber) + t1 = (_1_2_isSet ? _1_2 : right) instanceof A.SassNumber; + else + t1 = false; + if (t1) { + this._warn$3(string$.Using__o + A.S(new A._EvaluateVisitor__slash_recommendation().call$1(node)) + " or " + A.expressionToCalc(node).toString$0(0) + string$.x0a_Morex20, node.get$span(0), B.Deprecation_BvP); + return result; + } + return result; + }, + _operandAllowsSlash$1(node) { + var t1; + if (node instanceof A.FunctionExpression) + if (node.namespace == null) { + t1 = node.name; + t1 = B.Set_Pr3yj.contains$1(0, t1.toLowerCase()) && this._environment.getFunction$1(t1) == null; + } else + t1 = false; + else + t1 = true; + return t1; + }, + visitValueExpression$1(_, node) { + return node.value; + }, + visitVariableExpression$1(_, node) { + var result = this._addExceptionSpan$2(node, new A._EvaluateVisitor_visitVariableExpression_closure(this, node)); + if (result != null) + return result; + throw A.wrapException(this._evaluate$_exception$2("Undefined variable.", node.span)); + }, + visitUnaryOperationExpression$1(_, node) { + return this._addExceptionSpan$2(node, new A._EvaluateVisitor_visitUnaryOperationExpression_closure(node, node.operand.accept$1(this))); + }, + visitBooleanExpression$1(_, node) { + return node.value ? B.SassBoolean_true : B.SassBoolean_false; + }, + visitIfExpression$1(_, node) { + var condition, t1, ifTrue, ifFalse, result, _this = this, + _0_0 = _this._evaluateMacroArguments$1(node), + positional = _0_0._0, + named = _0_0._1; + _this._verifyArguments$4(positional.length, named, $.$get$IfExpression_declaration(), node); + condition = A.ListExtensions_elementAtOrNull(positional, 0); + if (condition == null) { + t1 = named.$index(0, "condition"); + t1.toString; + condition = t1; + } + ifTrue = A.ListExtensions_elementAtOrNull(positional, 1); + if (ifTrue == null) { + t1 = named.$index(0, "if-true"); + t1.toString; + ifTrue = t1; + } + ifFalse = A.ListExtensions_elementAtOrNull(positional, 2); + if (ifFalse == null) { + t1 = named.$index(0, "if-false"); + t1.toString; + ifFalse = t1; + } + result = condition.accept$1(_this).get$isTruthy() ? ifTrue : ifFalse; + return _this._withoutSlash$2(result.accept$1(_this), _this._expressionNode$1(result)); + }, + visitNullExpression$1(_, node) { + return B.C__SassNull; + }, + visitNumberExpression$1(_, node) { + return A.SassNumber_SassNumber(node.value, node.unit); + }, + visitParenthesizedExpression$1(_, node) { + var _this = this; + return _this._assertInModule$2(_this.__stylesheet, "_stylesheet").plainCss ? A.throwExpression(_this._evaluate$_exception$2("Parentheses aren't allowed in plain CSS.", node.span)) : node.expression.accept$1(_this); + }, + visitColorExpression$1(_, node) { + return node.value; + }, + visitListExpression$1(_, node) { + var t1 = node.contents; + return A.SassList$(new A.MappedListIterable(t1, new A._EvaluateVisitor_visitListExpression_closure(this), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Value>")), node.separator, node.hasBrackets); + }, + visitMapExpression$1(_, node) { + var t2, t3, _i, t4, key, keyValue, valueValue, oldValueSpan, + t1 = type$.Value, + map = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1), + keyNodes = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.AstNode); + for (t2 = node.pairs, t3 = t2.length, _i = 0; _i < t3; ++_i) { + t4 = t2[_i]; + key = t4._0; + keyValue = key.accept$1(this); + valueValue = t4._1.accept$1(this); + if (map.containsKey$1(keyValue)) { + t1 = keyNodes.$index(0, keyValue); + oldValueSpan = t1 == null ? null : t1.get$span(t1); + t1 = key.get$span(key); + t2 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + if (oldValueSpan != null) + t2.$indexSet(0, oldValueSpan, "first key"); + throw A.wrapException(A.MultiSpanSassRuntimeException$("Duplicate key.", t1, "second key", t2, this._evaluate$_stackTrace$1(key.get$span(key)), null)); + } + map.$indexSet(0, keyValue, valueValue); + keyNodes.$indexSet(0, keyValue, key); + } + return new A.SassMap(A.ConstantMap_ConstantMap$from(map, t1, t1)); + }, + visitFunctionExpression$1(_, node) { + var t2, _0_0, t3, t4, $name, oldInFunction, result, _this = this, + _s11_ = "_stylesheet", + t1 = {}, + $function = _this._assertInModule$2(_this.__stylesheet, _s11_).plainCss ? null : _this._addExceptionSpan$2(node, new A._EvaluateVisitor_visitFunctionExpression_closure(_this, node)); + t1.$function = $function; + if ($function == null) { + if (node.namespace != null) + throw A.wrapException(_this._evaluate$_exception$2("Undefined function.", node.span)); + t2 = node.name; + _0_0 = t2.toLowerCase(); + t3 = false; + if ("min" === _0_0 || "max" === _0_0 || "round" === _0_0 || "abs" === _0_0) { + t3 = node.$arguments; + t4 = t3.named; + t3 = t4.get$isEmpty(t4) && t3.rest == null && B.JSArray_methods.every$1(t3.positional, new A._EvaluateVisitor_visitFunctionExpression_closure0()); + $name = _0_0; + } else + $name = null; + if (t3) + return _this._visitCalculation$2$inLegacySassFunction(node, $name); + if ("calc" === _0_0 || "clamp" === _0_0 || "hypot" === _0_0 || "sin" === _0_0 || "cos" === _0_0 || "tan" === _0_0 || "asin" === _0_0 || "acos" === _0_0 || "atan" === _0_0 || "sqrt" === _0_0 || "exp" === _0_0 || "sign" === _0_0 || "mod" === _0_0 || "rem" === _0_0 || "atan2" === _0_0 || "pow" === _0_0 || "log" === _0_0 || "calc-size" === _0_0) + return _this._visitCalculation$1(node); + $function = _this._assertInModule$2(_this.__stylesheet, _s11_).plainCss ? null : _this._builtInFunctions.$index(0, t2); + t2 = t1.$function = $function == null ? new A.PlainCssCallable(node.originalName) : $function; + } else + t2 = $function; + if (B.JSString_methods.startsWith$1(node.originalName, "--") && t2 instanceof A.UserDefinedCallable && !B.JSString_methods.startsWith$1(t2.declaration.originalName, "--")) + _this._warn$3(string$.Sassx20_f_, node.get$nameSpan(), B.Deprecation_Kg6); + oldInFunction = _this._inFunction; + _this._inFunction = true; + result = _this._addErrorSpan$2(node, new A._EvaluateVisitor_visitFunctionExpression_closure1(t1, _this, node)); + _this._inFunction = oldInFunction; + return result; + }, + _visitCalculation$2$inLegacySassFunction(node, inLegacySassFunction) { + var $arguments, oldCallableNode, t1, _0_0, error, stackTrace, t4, _i, exception, _this = this, + t2 = node.$arguments, + t3 = t2.named; + if (t3.get$isNotEmpty(t3)) + throw A.wrapException(_this._evaluate$_exception$2(string$.Keywor, node.span)); + else if (t2.rest != null) + throw A.wrapException(_this._evaluate$_exception$2(string$.Rest_a, node.span)); + _this._checkCalculationArguments$1(node); + t3 = A._setArrayType([], type$.JSArray_Object); + for (t2 = t2.positional, t4 = t2.length, _i = 0; _i < t4; ++_i) + t3.push(_this._visitCalculationExpression$2$inLegacySassFunction(t2[_i], inLegacySassFunction)); + $arguments = t3; + if (_this._inSupportsDeclaration) + return new A.SassCalculation(node.name, A.List_List$unmodifiable($arguments, type$.Object)); + oldCallableNode = _this._callableNode; + _this._callableNode = node; + try { + t1 = null; + t3 = node.name; + _0_0 = t3.toLowerCase(); + $label0$0: { + if ("calc" === _0_0) { + t1 = A.SassCalculation_calc(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("sqrt" === _0_0) { + t1 = A.SassCalculation__singleArgument("sqrt", J.$index$asx($arguments, 0), A.number0__sqrt$closure(), true); + break $label0$0; + } + if ("sin" === _0_0) { + t1 = A.SassCalculation__singleArgument("sin", J.$index$asx($arguments, 0), A.number0__sin$closure(), false); + break $label0$0; + } + if ("cos" === _0_0) { + t1 = A.SassCalculation__singleArgument("cos", J.$index$asx($arguments, 0), A.number0__cos$closure(), false); + break $label0$0; + } + if ("tan" === _0_0) { + t1 = A.SassCalculation__singleArgument("tan", J.$index$asx($arguments, 0), A.number0__tan$closure(), false); + break $label0$0; + } + if ("asin" === _0_0) { + t1 = A.SassCalculation__singleArgument("asin", J.$index$asx($arguments, 0), A.number0__asin$closure(), true); + break $label0$0; + } + if ("acos" === _0_0) { + t1 = A.SassCalculation__singleArgument("acos", J.$index$asx($arguments, 0), A.number0__acos$closure(), true); + break $label0$0; + } + if ("atan" === _0_0) { + t1 = A.SassCalculation__singleArgument("atan", J.$index$asx($arguments, 0), A.number0__atan$closure(), true); + break $label0$0; + } + if ("abs" === _0_0) { + t1 = A.SassCalculation_abs(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("exp" === _0_0) { + t1 = A.SassCalculation_exp(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("sign" === _0_0) { + t1 = A.SassCalculation_sign(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("min" === _0_0) { + t1 = A.SassCalculation_min($arguments); + break $label0$0; + } + if ("max" === _0_0) { + t1 = A.SassCalculation_max($arguments); + break $label0$0; + } + if ("hypot" === _0_0) { + t1 = A.SassCalculation_hypot($arguments); + break $label0$0; + } + if ("pow" === _0_0) { + t1 = A.SassCalculation_pow(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("atan2" === _0_0) { + t1 = A.SassCalculation_atan2(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("log" === _0_0) { + t1 = A.SassCalculation_log(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("mod" === _0_0) { + t1 = A.SassCalculation_mod(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("rem" === _0_0) { + t1 = A.SassCalculation_rem(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("round" === _0_0) { + t1 = A.SassCalculation_roundInternal(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1), A.ListExtensions_elementAtOrNull($arguments, 2), inLegacySassFunction, node.span, new A._EvaluateVisitor__visitCalculation_closure(_this, node)); + break $label0$0; + } + if ("clamp" === _0_0) { + t1 = A.SassCalculation_clamp(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1), A.ListExtensions_elementAtOrNull($arguments, 2)); + break $label0$0; + } + if ("calc-size" === _0_0) { + t1 = A.SassCalculation_calcSize(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + t3 = A.UnsupportedError$('Unknown calculation name "' + t3 + '".'); + t1 = A.throwExpression(t3); + } + t1 = t1; + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassScriptException) { + error = t1; + stackTrace = A.getTraceFromException(exception); + if (B.JSString_methods.contains$1(error.message, "compatible")) + _this._verifyCompatibleNumbers$2($arguments, t2); + A.throwWithTrace(_this._evaluate$_exception$2(error.message, node.span), error, stackTrace); + } else + throw exception; + } finally { + _this._callableNode = oldCallableNode; + } + }, + _visitCalculation$1(node) { + return this._visitCalculation$2$inLegacySassFunction(node, null); + }, + _checkCalculationArguments$1(node) { + var t1, _0_0, + check = new A._EvaluateVisitor__checkCalculationArguments_check(this, node); + $label0$0: { + t1 = node.name; + _0_0 = t1.toLowerCase(); + if ("calc" === _0_0 || "sqrt" === _0_0 || "sin" === _0_0 || "cos" === _0_0 || "tan" === _0_0 || "asin" === _0_0 || "acos" === _0_0 || "atan" === _0_0 || "abs" === _0_0 || "exp" === _0_0 || "sign" === _0_0) { + check.call$1(1); + break $label0$0; + } + if ("min" === _0_0 || "max" === _0_0 || "hypot" === _0_0) { + check.call$0(); + break $label0$0; + } + if ("pow" === _0_0 || "atan2" === _0_0 || "log" === _0_0 || "mod" === _0_0 || "rem" === _0_0 || "calc-size" === _0_0) { + check.call$1(2); + break $label0$0; + } + if ("round" === _0_0 || "clamp" === _0_0) { + check.call$1(3); + break $label0$0; + } + throw A.wrapException(A.UnsupportedError$('Unknown calculation name "' + t1 + '".')); + } + }, + _verifyCompatibleNumbers$2(args, nodesWithSpans) { + var i, t1, _0_0, arg, t2, number1, j, number2, t3, t4, t5, t6; + for (i = 0; t1 = args.length, i < t1; ++i) { + _0_0 = args[i]; + if (_0_0 instanceof A.SassNumber) { + t1 = _0_0.get$hasComplexUnits(); + arg = _0_0; + } else { + arg = null; + t1 = false; + } + if (t1) { + t1 = A.S(arg); + t2 = nodesWithSpans[i]; + throw A.wrapException(this._evaluate$_exception$2("Number " + t1 + " isn't compatible with CSS calculations.", t2.get$span(t2))); + } + } + for (i = 0; i < t1 - 1; ++i) { + number1 = args[i]; + if (!(number1 instanceof A.SassNumber)) + continue; + for (j = i + 1; t1 = args.length, j < t1; ++j) { + number2 = args[j]; + if (!(number2 instanceof A.SassNumber)) + continue; + if (number1.hasPossiblyCompatibleUnits$1(number2)) + continue; + t1 = number1.toString$0(0); + t2 = number2.toString$0(0); + t3 = nodesWithSpans[i]; + t3 = t3.get$span(t3); + t4 = number1.toString$0(0); + t5 = nodesWithSpans[j]; + t5 = A.LinkedHashMap_LinkedHashMap$_literal([t5.get$span(t5), number2.toString$0(0)], type$.FileSpan, type$.String); + t6 = nodesWithSpans[i]; + throw A.wrapException(A.MultiSpanSassRuntimeException$(t1 + " and " + t2 + " are incompatible.", t3, t4, t5, this._evaluate$_stackTrace$1(t6.get$span(t6)), null)); + } + } + }, + _visitCalculationExpression$2$inLegacySassFunction(node, inLegacySassFunction) { + var result, t2, _0_0, _box_0, _1_0, t3, _i, i, _this = this, _null = null, + t1 = node instanceof A.ParenthesizedExpression, + inner = t1 ? node.expression : _null; + if (t1) { + result = _this._visitCalculationExpression$2$inLegacySassFunction(inner, inLegacySassFunction); + return result instanceof A.SassString ? new A.SassString("(" + result._string$_text + ")", false) : result; + } + if (node instanceof A.StringExpression && node.accept$1(B.C_IsCalculationSafeVisitor)) { + t1 = node.text; + t2 = t1.get$asPlain(); + _0_0 = t2 == null ? _null : t2.toLowerCase(); + $label0$0: { + if ("pi" === _0_0) { + t1 = A.SassNumber_SassNumber(3.141592653589793, _null); + break $label0$0; + } + if ("e" === _0_0) { + t1 = A.SassNumber_SassNumber(2.718281828459045, _null); + break $label0$0; + } + if ("infinity" === _0_0) { + t1 = A.SassNumber_SassNumber(1 / 0, _null); + break $label0$0; + } + if ("-infinity" === _0_0) { + t1 = A.SassNumber_SassNumber(-1 / 0, _null); + break $label0$0; + } + if ("nan" === _0_0) { + t1 = A.SassNumber_SassNumber(0 / 0, _null); + break $label0$0; + } + t1 = new A.SassString(_this._performInterpolation$1(t1), false); + break $label0$0; + } + return t1; + } + _box_0 = {}; + _box_0.right = _box_0.left = _box_0.operator = null; + t1 = node instanceof A.BinaryOperationExpression; + if (t1) { + _box_0.operator = node.operator; + _box_0.left = node.left; + _box_0.right = node.right; + } + if (t1) { + _this._checkWhitespaceAroundCalculationOperator$1(node); + return _this._addExceptionSpan$2(node, new A._EvaluateVisitor__visitCalculationExpression_closure(_box_0, _this, node, inLegacySassFunction)); + } + if (node instanceof A.NumberExpression || node instanceof A.VariableExpression || node instanceof A.FunctionExpression || node instanceof A.IfExpression) { + _1_0 = node.accept$1(_this); + $label1$1: { + if (_1_0 instanceof A.SassNumber) { + t1 = _1_0; + break $label1$1; + } + if (_1_0 instanceof A.SassCalculation) { + t1 = _1_0; + break $label1$1; + } + if (_1_0 instanceof A.SassString) { + t1 = !_1_0._hasQuotes; + result = _1_0; + } else { + result = _null; + t1 = false; + } + if (t1) { + t1 = result; + break $label1$1; + } + t1 = A.throwExpression(_this._evaluate$_exception$2("Value " + _1_0.toString$0(0) + " can't be used in a calculation.", node.get$span(node))); + } + return t1; + } + if (node instanceof A.ListExpression && !node.hasBrackets && B.ListSeparator_qSL === node.separator && node.contents.length >= 2) { + t1 = A._setArrayType([], type$.JSArray_Object); + for (t2 = node.contents, t3 = t2.length, _i = 0; _i < t3; ++_i) + t1.push(_this._visitCalculationExpression$2$inLegacySassFunction(t2[_i], inLegacySassFunction)); + _this._checkAdjacentCalculationValues$2(t1, node); + for (i = 0; i < t1.length; ++i) { + t3 = t1[i]; + if (t3 instanceof A.CalculationOperation && t2[i] instanceof A.ParenthesizedExpression) + t1[i] = new A.SassString("(" + A.S(t3) + ")", false); + } + return new A.SassString(B.JSArray_methods.join$1(t1, " "), false); + } + throw A.wrapException(_this._evaluate$_exception$2(string$.This_e, node.get$span(node))); + }, + _checkWhitespaceAroundCalculationOperator$1(node) { + var t2, t3, t4, textBetweenOperands, first, last, + t1 = node.operator; + if (t1 !== B.BinaryOperator_Swh && t1 !== B.BinaryOperator_QG1) + return; + t1 = node.left; + t2 = t1.get$span(t1); + t2 = t2.get$file(t2); + t3 = node.right; + t4 = t3.get$span(t3); + if (t2 !== t4.get$file(t4)) + return; + t2 = t1.get$span(t1); + t2 = t2.get$end(t2); + t4 = t3.get$span(t3); + if (t2.offset >= t4.get$start(t4).offset) + return; + t2 = t1.get$span(t1); + t2 = t2.get$file(t2); + t1 = t1.get$span(t1); + t1 = t1.get$end(t1); + t3 = t3.get$span(t3); + textBetweenOperands = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t2._decodedChars, t1.offset, t3.get$start(t3).offset), 0, null); + first = textBetweenOperands.charCodeAt(0); + last = textBetweenOperands.charCodeAt(textBetweenOperands.length - 1); + if (first === 32 || first === 9 || first === 10 || first === 13 || first === 12 || first === 47) + t1 = !(last === 32 || last === 9 || last === 10 || last === 13 || last === 12 || last === 47); + else + t1 = true; + if (t1) + throw A.wrapException(this._evaluate$_exception$2(string$.x22x2b__an, node.get$operatorSpan())); + }, + _binaryOperatorToCalculationOperator$2(operator, node) { + var t1; + $label0$0: { + if (B.BinaryOperator_Swh === operator) { + t1 = B.CalculationOperator_F7i; + break $label0$0; + } + if (B.BinaryOperator_QG1 === operator) { + t1 = B.CalculationOperator_oum; + break $label0$0; + } + if (B.BinaryOperator_tht === operator) { + t1 = B.CalculationOperator_kkN; + break $label0$0; + } + if (B.BinaryOperator_Mh5 === operator) { + t1 = B.CalculationOperator_bo5; + break $label0$0; + } + t1 = A.throwExpression(this._evaluate$_exception$2(string$.This_o, node.get$operatorSpan())); + } + return t1; + }, + _checkAdjacentCalculationValues$2(elements, node) { + var t1, i, t2, previous, current, previousNode, currentNode, _0_2; + for (t1 = elements.length, i = 1; i < t1; ++i) { + t2 = i - 1; + previous = elements[t2]; + current = elements[i]; + if (previous instanceof A.SassString || current instanceof A.SassString) + continue; + t1 = node.contents; + previousNode = t1[t2]; + currentNode = t1[i]; + if (currentNode instanceof A.UnaryOperationExpression) { + _0_2 = currentNode.operator; + if (B.UnaryOperator_UCP !== _0_2) + t1 = B.UnaryOperator_Rbl === _0_2; + else + t1 = true; + } else + t1 = false; + if (!t1) + t1 = currentNode instanceof A.NumberExpression && currentNode.value < 0; + else + t1 = true; + if (t1) + throw A.wrapException(this._evaluate$_exception$2(string$.x22x2b__an, A.FileSpanExtension_subspan(currentNode.get$span(currentNode), 0, 1))); + else + throw A.wrapException(this._evaluate$_exception$2("Missing math operator.", previousNode.get$span(previousNode).expand$1(0, currentNode.get$span(currentNode)))); + } + }, + visitInterpolatedFunctionExpression$1(_, node) { + var result, _this = this, + t1 = _this._performInterpolation$1(node.name), + oldInFunction = _this._inFunction; + _this._inFunction = true; + result = _this._addErrorSpan$2(node, new A._EvaluateVisitor_visitInterpolatedFunctionExpression_closure(_this, node, new A.PlainCssCallable(t1))); + _this._inFunction = oldInFunction; + return result; + }, + _runUserDefinedCallable$1$4($arguments, callable, nodeWithSpan, run, $V) { + var oldCallable, oldInDependency, result, _this = this, + evaluated = _this._evaluateArguments$1($arguments), + $name = callable.declaration.name; + if ($name !== "@content") + $name += "()"; + oldCallable = _this._currentCallable; + oldInDependency = _this._inDependency; + _this._currentCallable = callable; + _this._inDependency = callable.inDependency; + result = _this._withStackFrame$3($name, nodeWithSpan, new A._EvaluateVisitor__runUserDefinedCallable_closure(_this, callable, evaluated, nodeWithSpan, run, $V)); + _this._currentCallable = oldCallable; + _this._inDependency = oldInDependency; + return result; + }, + _runFunctionCallable$3($arguments, callable, nodeWithSpan) { + var buffer, first, argument, restArg, rest, error, t1, t2, _i, t3, t4, exception, _this = this; + if (callable instanceof A.BuiltInCallable) + return _this._withoutSlash$2(_this._runBuiltInCallable$3($arguments, callable, nodeWithSpan), nodeWithSpan); + else if (type$.UserDefinedCallable_Environment._is(callable)) + return _this._runUserDefinedCallable$1$4($arguments, callable, nodeWithSpan, new A._EvaluateVisitor__runFunctionCallable_closure(_this, callable), type$.Value); + else if (callable instanceof A.PlainCssCallable) { + t1 = $arguments.named; + if (t1.get$isNotEmpty(t1) || $arguments.keywordRest != null) + throw A.wrapException(_this._evaluate$_exception$2(string$.Plain_, nodeWithSpan.get$span(nodeWithSpan))); + buffer = new A.StringBuffer(callable.name + "("); + try { + first = true; + for (t1 = $arguments.positional, t2 = t1.length, _i = 0; _i < t2; ++_i) { + argument = t1[_i]; + if (first) + first = false; + else + buffer._contents += ", "; + t3 = buffer; + t4 = argument; + t4 = _this._evaluate$_serialize$3$quote(t4.accept$1(_this), t4, true); + t3._contents += t4; + } + restArg = $arguments.rest; + if (restArg != null) { + rest = restArg.accept$1(_this); + if (!first) + buffer._contents += ", "; + t1 = buffer; + t2 = _this._evaluate$_serialize$2(rest, restArg); + t1._contents += t2; + } + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.SassRuntimeException._is(t1)) { + error = t1; + if (!B.JSString_methods.endsWith$1(error._span_exception$_message, "isn't a valid CSS value.")) + throw exception; + throw A.wrapException(A.MultiSpanSassRuntimeException$(error._span_exception$_message, J.get$span$z(error), "value", A.LinkedHashMap_LinkedHashMap$_literal([nodeWithSpan.get$span(nodeWithSpan), "unknown function treated as plain CSS"], type$.FileSpan, type$.String), J.get$trace$z(error), null)); + } else + throw exception; + } + t1 = buffer; + t2 = A.Primitives_stringFromCharCode(41); + t1._contents += t2; + t2 = buffer._contents; + return new A.SassString(t2.charCodeAt(0) == 0 ? t2 : t2, false); + } else + throw A.wrapException(A.ArgumentError$("Unknown callable type " + J.get$runtimeType$(callable).toString$0(0) + ".", null)); + }, + _runBuiltInCallable$3($arguments, callable, nodeWithSpan) { + var result, error, stackTrace, namedSet, _0_0, parameters, i, t1, parameter, t2, t3, rest, argumentList, exception, _this = this, _box_0 = {}, + evaluated = _this._evaluateArguments$1($arguments), + oldCallableNode = _this._callableNode; + _this._callableNode = nodeWithSpan; + namedSet = new A.MapKeySet(evaluated._values[0], type$.MapKeySet_String); + _box_0.callback = _box_0.overload = null; + _0_0 = callable.callbackFor$2(evaluated._values[2].length, namedSet); + _box_0.overload = _0_0._0; + _box_0.callback = _0_0._1; + _this._addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__runBuiltInCallable_closure(_box_0, evaluated, namedSet)); + parameters = _box_0.overload.parameters; + for (i = evaluated._values[2].length, t1 = parameters.length; i < t1; ++i) { + parameter = parameters[i]; + t2 = evaluated._values[2]; + t3 = evaluated._values[0].remove$1(0, parameter.name); + if (t3 == null) { + t3 = parameter.defaultValue; + t3 = _this._withoutSlash$2(t3.accept$1(_this), t3); + } + t2.push(t3); + } + if (_box_0.overload.restParameter != null) { + if (evaluated._values[2].length > t1) { + rest = B.JSArray_methods.sublist$1(evaluated._values[2], t1); + B.JSArray_methods.removeRange$2(evaluated._values[2], t1, evaluated._values[2].length); + } else + rest = B.List_empty8; + t1 = evaluated._values[0]; + argumentList = A.SassArgumentList$(rest, t1, evaluated._values[4] === B.ListSeparator_undecided_null_undecided ? B.ListSeparator_qVN : evaluated._values[4]); + evaluated._values[2].push(argumentList); + } else + argumentList = null; + result = null; + try { + result = _this._addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__runBuiltInCallable_closure0(_box_0, evaluated)); + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException) + throw exception; + else { + error = t1; + stackTrace = A.getTraceFromException(exception); + A.throwWithTrace(_this._evaluate$_exception$2(_this._getErrorMessage$1(error), nodeWithSpan.get$span(nodeWithSpan)), error, stackTrace); + } + } + _this._callableNode = oldCallableNode; + if (argumentList == null) + return result; + if (evaluated._values[0].__js_helper$_length === 0) + return result; + if (argumentList._wereKeywordsAccessed) + return result; + throw A.wrapException(A.MultiSpanSassRuntimeException$("No " + A.pluralize("parameter", evaluated._values[0].get$keys(0).get$length(0), null) + " named " + A.toSentence(evaluated._values[0].get$keys(0).map$1$1(0, new A._EvaluateVisitor__runBuiltInCallable_closure1(), type$.Object), "or") + ".", nodeWithSpan.get$span(nodeWithSpan), "invocation", A.LinkedHashMap_LinkedHashMap$_literal([_box_0.overload.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), _this._evaluate$_stackTrace$1(nodeWithSpan.get$span(nodeWithSpan)), null)); + }, + _evaluateArguments$1($arguments) { + var t1, t2, _i, expression, nodeForSpan, named, namedNodes, t3, t4, $name, value, restArgs, rest, restNodeForSpan, t5, separator, keywordRestArgs, keywordRest, keywordRestNodeForSpan, _this = this, + positional = A._setArrayType([], type$.JSArray_Value), + positionalNodes = A._setArrayType([], type$.JSArray_AstNode); + for (t1 = $arguments.positional, t2 = t1.length, _i = 0; _i < t2; ++_i) { + expression = t1[_i]; + nodeForSpan = _this._expressionNode$1(expression); + positional.push(_this._withoutSlash$2(expression.accept$1(_this), nodeForSpan)); + positionalNodes.push(nodeForSpan); + } + t1 = type$.String; + named = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Value); + t2 = type$.AstNode; + namedNodes = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t3 = A.MapExtensions_get_pairs($arguments.named, t1, type$.Expression), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + $name = t4._0; + value = t4._1; + nodeForSpan = _this._expressionNode$1(value); + named.$indexSet(0, $name, _this._withoutSlash$2(value.accept$1(_this), nodeForSpan)); + namedNodes.$indexSet(0, $name, nodeForSpan); + } + restArgs = $arguments.rest; + if (restArgs == null) + return new A._Record_5_named_namedNodes_positional_positionalNodes_separator([named, namedNodes, positional, positionalNodes, B.ListSeparator_undecided_null_undecided]); + rest = restArgs.accept$1(_this); + restNodeForSpan = _this._expressionNode$1(restArgs); + if (rest instanceof A.SassMap) { + _this._addRestMap$4(named, rest, restArgs, new A._EvaluateVisitor__evaluateArguments_closure()); + t3 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t4 = rest._map$_contents, t4 = J.get$iterator$ax(t4.get$keys(t4)), t5 = type$.SassString; t4.moveNext$0();) + t3.$indexSet(0, t5._as(t4.get$current(t4))._string$_text, restNodeForSpan); + namedNodes.addAll$1(0, t3); + separator = B.ListSeparator_undecided_null_undecided; + } else if (rest instanceof A.SassList) { + t3 = rest._list$_contents; + B.JSArray_methods.addAll$1(positional, new A.MappedListIterable(t3, new A._EvaluateVisitor__evaluateArguments_closure0(_this, restNodeForSpan), A._arrayInstanceType(t3)._eval$1("MappedListIterable<1,Value>"))); + B.JSArray_methods.addAll$1(positionalNodes, A.List_List$filled(t3.length, restNodeForSpan, false, t2)); + separator = rest._separator; + if (rest instanceof A.SassArgumentList) { + rest._wereKeywordsAccessed = true; + rest._keywords.forEach$1(0, new A._EvaluateVisitor__evaluateArguments_closure1(_this, named, restNodeForSpan, namedNodes)); + } + } else { + positional.push(_this._withoutSlash$2(rest, restNodeForSpan)); + positionalNodes.push(restNodeForSpan); + separator = B.ListSeparator_undecided_null_undecided; + } + keywordRestArgs = $arguments.keywordRest; + if (keywordRestArgs == null) + return new A._Record_5_named_namedNodes_positional_positionalNodes_separator([named, namedNodes, positional, positionalNodes, separator]); + keywordRest = keywordRestArgs.accept$1(_this); + keywordRestNodeForSpan = _this._expressionNode$1(keywordRestArgs); + if (keywordRest instanceof A.SassMap) { + _this._addRestMap$4(named, keywordRest, keywordRestArgs, new A._EvaluateVisitor__evaluateArguments_closure2()); + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t2 = keywordRest._map$_contents, t2 = J.get$iterator$ax(t2.get$keys(t2)), t3 = type$.SassString; t2.moveNext$0();) + t1.$indexSet(0, t3._as(t2.get$current(t2))._string$_text, keywordRestNodeForSpan); + namedNodes.addAll$1(0, t1); + return new A._Record_5_named_namedNodes_positional_positionalNodes_separator([named, namedNodes, positional, positionalNodes, separator]); + } else + throw A.wrapException(_this._evaluate$_exception$2(string$.Variabs + keywordRest.toString$0(0) + ").", keywordRestArgs.get$span(keywordRestArgs))); + }, + _evaluateMacroArguments$1(invocation) { + var t2, positional, named, rest, restNodeForSpan, keywordRestArgs_, keywordRest, keywordRestNodeForSpan, _this = this, + t1 = invocation.$arguments, + restArgs_ = t1.rest; + if (restArgs_ == null) + return new A._Record_2(t1.positional, t1.named); + t2 = t1.positional; + positional = A._setArrayType(t2.slice(0), A._arrayInstanceType(t2)); + named = A.LinkedHashMap_LinkedHashMap$of(t1.named, type$.String, type$.Expression); + rest = restArgs_.accept$1(_this); + restNodeForSpan = _this._expressionNode$1(restArgs_); + if (rest instanceof A.SassMap) + _this._addRestMap$4(named, rest, invocation, new A._EvaluateVisitor__evaluateMacroArguments_closure(restArgs_)); + else if (rest instanceof A.SassList) { + t2 = rest._list$_contents; + B.JSArray_methods.addAll$1(positional, new A.MappedListIterable(t2, new A._EvaluateVisitor__evaluateMacroArguments_closure0(_this, restNodeForSpan, restArgs_), A._arrayInstanceType(t2)._eval$1("MappedListIterable<1,Expression>"))); + if (rest instanceof A.SassArgumentList) { + rest._wereKeywordsAccessed = true; + rest._keywords.forEach$1(0, new A._EvaluateVisitor__evaluateMacroArguments_closure1(_this, named, restNodeForSpan, restArgs_)); + } + } else + positional.push(new A.ValueExpression(_this._withoutSlash$2(rest, restNodeForSpan), restArgs_.get$span(restArgs_))); + keywordRestArgs_ = t1.keywordRest; + if (keywordRestArgs_ == null) + return new A._Record_2(positional, named); + keywordRest = keywordRestArgs_.accept$1(_this); + keywordRestNodeForSpan = _this._expressionNode$1(keywordRestArgs_); + if (keywordRest instanceof A.SassMap) { + _this._addRestMap$4(named, keywordRest, invocation, new A._EvaluateVisitor__evaluateMacroArguments_closure2(_this, keywordRestNodeForSpan, keywordRestArgs_)); + return new A._Record_2(positional, named); + } else + throw A.wrapException(_this._evaluate$_exception$2(string$.Variabs + keywordRest.toString$0(0) + ").", keywordRestArgs_.get$span(keywordRestArgs_))); + }, + _addRestMap$1$4(values, map, nodeWithSpan, convert) { + map._map$_contents.forEach$1(0, new A._EvaluateVisitor__addRestMap_closure(this, values, convert, this._expressionNode$1(nodeWithSpan), map, nodeWithSpan)); + }, + _addRestMap$4(values, map, nodeWithSpan, convert) { + return this._addRestMap$1$4(values, map, nodeWithSpan, convert, type$.dynamic); + }, + _verifyArguments$4(positional, named, parameters, nodeWithSpan) { + return this._addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__verifyArguments_closure(parameters, positional, named)); + }, + visitSelectorExpression$1(_, node) { + var t1 = this._styleRuleIgnoringAtRoot; + t1 = t1 == null ? null : t1.originalSelector.get$asSassList(); + return t1 == null ? B.C__SassNull : t1; + }, + visitStringExpression$1(_, node) { + var t1, t2, t3, _i, value, t4, _0_0, text, _this = this, + oldInSupportsDeclaration = _this._inSupportsDeclaration; + _this._inSupportsDeclaration = false; + t1 = A._setArrayType([], type$.JSArray_String); + for (t2 = node.text.contents, t3 = t2.length, _i = 0; _i < t3; ++_i) { + value = t2[_i]; + $label0$0: { + if (typeof value == "string") { + t4 = value; + break $label0$0; + } + if (value instanceof A.Expression) { + _0_0 = value.accept$1(_this); + $label1$1: { + if (_0_0 instanceof A.SassString) { + text = _0_0._string$_text; + t4 = text; + break $label1$1; + } + t4 = _this._evaluate$_serialize$3$quote(_0_0, value, false); + break $label1$1; + } + break $label0$0; + } + t4 = A.throwExpression(A.UnsupportedError$("Unknown interpolation value " + A.S(value))); + } + t1.push(t4); + } + t1 = B.JSArray_methods.join$0(t1); + _this._inSupportsDeclaration = oldInSupportsDeclaration; + return new A.SassString(t1, node.hasQuotes); + }, + visitSupportsExpression$1(_, expression) { + return new A.SassString(this._visitSupportsCondition$1(expression.condition), false); + }, + visitCssAtRule$1(node) { + var wasInKeyframes, wasInUnknownAtRule, t1, _this = this; + if (_this._declarationName != null) + throw A.wrapException(_this._evaluate$_exception$2(string$.At_rul, node.span)); + if (node.isChildless) { + _this._assertInModule$2(_this.__parent, "__parent").addChild$1(A.ModifiableCssAtRule$(node.name, node.span, true, node.value)); + return; + } + wasInKeyframes = _this._inKeyframes; + wasInUnknownAtRule = _this._inUnknownAtRule; + t1 = node.name; + if (A.unvendor(t1.value) === "keyframes") + _this._inKeyframes = true; + else + _this._inUnknownAtRule = true; + _this._withParent$2$4$scopeWhen$through(A.ModifiableCssAtRule$(t1, node.span, false, node.value), new A._EvaluateVisitor_visitCssAtRule_closure(_this, node), false, new A._EvaluateVisitor_visitCssAtRule_closure0(), type$.ModifiableCssAtRule, type$.Null); + _this._inUnknownAtRule = wasInUnknownAtRule; + _this._inKeyframes = wasInKeyframes; + }, + visitCssComment$1(node) { + var _this = this, + _s8_ = "__parent", + _s13_ = "_endOfImports"; + if (_this._assertInModule$2(_this.__parent, _s8_) === _this._assertInModule$2(_this.__root, "_root") && _this._assertInModule$2(_this.__endOfImports, _s13_) === J.get$length$asx(_this._assertInModule$2(_this.__root, "_root").children._collection$_source)) + _this.__endOfImports = _this._assertInModule$2(_this.__endOfImports, _s13_) + 1; + _this._assertInModule$2(_this.__parent, _s8_).addChild$1(new A.ModifiableCssComment(node.text, node.span)); + }, + visitCssDeclaration$1(node) { + this._assertInModule$2(this.__parent, "__parent").addChild$1(A.ModifiableCssDeclaration$(node.name, node.value, node.span, null, node.parsedAsCustomProperty, null, node.valueSpanForMap)); + }, + visitCssImport$1(node) { + var t1, _this = this, + _s8_ = "__parent", + _s5_ = "_root", + _s13_ = "_endOfImports", + modifiableNode = new A.ModifiableCssImport(node.url, node.modifiers, node.span); + if (_this._assertInModule$2(_this.__parent, _s8_) !== _this._assertInModule$2(_this.__root, _s5_)) + _this._assertInModule$2(_this.__parent, _s8_).addChild$1(modifiableNode); + else if (_this._assertInModule$2(_this.__endOfImports, _s13_) === J.get$length$asx(_this._assertInModule$2(_this.__root, _s5_).children._collection$_source)) { + _this._assertInModule$2(_this.__root, _s5_).addChild$1(modifiableNode); + _this.__endOfImports = _this._assertInModule$2(_this.__endOfImports, _s13_) + 1; + } else { + t1 = _this._outOfOrderImports; + (t1 == null ? _this._outOfOrderImports = A._setArrayType([], type$.JSArray_ModifiableCssImport) : t1).push(modifiableNode); + } + }, + visitCssKeyframeBlock$1(node) { + this._withParent$2$4$scopeWhen$through(A.ModifiableCssKeyframeBlock$(node.selector, node.span), new A._EvaluateVisitor_visitCssKeyframeBlock_closure(this, node), false, new A._EvaluateVisitor_visitCssKeyframeBlock_closure0(), type$.ModifiableCssKeyframeBlock, type$.Null); + }, + visitCssMediaRule$1(node) { + var mergedQueries, t1, mergedSources, t2, t3, _this = this; + if (_this._declarationName != null) + throw A.wrapException(_this._evaluate$_exception$2(string$.Media_, node.span)); + mergedQueries = A.NullableExtension_andThen(_this._mediaQueries, new A._EvaluateVisitor_visitCssMediaRule_closure(_this, node)); + t1 = mergedQueries == null; + if (!t1 && J.get$isEmpty$asx(mergedQueries)) + return; + if (t1) + mergedSources = B.Set_empty1; + else { + t2 = _this._mediaQuerySources; + t2.toString; + t2 = A.LinkedHashSet_LinkedHashSet$of(t2, type$.CssMediaQuery); + t3 = _this._mediaQueries; + t3.toString; + t2.addAll$1(0, t3); + t2.addAll$1(0, node.queries); + mergedSources = t2; + } + t1 = t1 ? node.queries : mergedQueries; + _this._withParent$2$4$scopeWhen$through(A.ModifiableCssMediaRule$(t1, node.span), new A._EvaluateVisitor_visitCssMediaRule_closure0(_this, mergedQueries, node, mergedSources), false, new A._EvaluateVisitor_visitCssMediaRule_closure1(mergedSources), type$.ModifiableCssMediaRule, type$.Null); + }, + visitCssStyleRule$1(node) { + var t1, styleRule, t2, nest, t3, originalSelector, rule, oldAtRootExcludingStyleRule, _0_1, lastChild, _this = this, _null = null, + _s8_ = "__parent"; + if (_this._declarationName != null) + throw A.wrapException(_this._evaluate$_exception$2(string$.Style_n, node.span)); + else if (_this._inKeyframes && _this._assertInModule$2(_this.__parent, _s8_) instanceof A.ModifiableCssKeyframeBlock) + throw A.wrapException(_this._evaluate$_exception$2(string$.Style_k, node.span)); + t1 = _this._atRootExcludingStyleRule; + styleRule = t1 ? _null : _this._styleRuleIgnoringAtRoot; + t2 = t1 ? _null : _this._styleRuleIgnoringAtRoot; + t2 = t2 == null ? _null : t2.fromPlainCss; + nest = t2 !== true; + t2 = node._style_rule$_selector._box$_inner; + if (nest) { + t2 = t2.value; + t3 = styleRule == null ? _null : styleRule.originalSelector; + originalSelector = t2.nestWithin$3$implicitParent$preserveParentSelectors(t3, !t1, node.fromPlainCss); + } else + originalSelector = t2.value; + rule = A.ModifiableCssStyleRule$(_this._assertInModule$2(_this.__extensionStore, "_extensionStore").addSelector$2(originalSelector, _this._mediaQueries), node.span, node.fromPlainCss, originalSelector); + oldAtRootExcludingStyleRule = _this._atRootExcludingStyleRule; + _this._atRootExcludingStyleRule = false; + t1 = nest ? new A._EvaluateVisitor_visitCssStyleRule_closure() : _null; + _this._withParent$2$4$scopeWhen$through(rule, new A._EvaluateVisitor_visitCssStyleRule_closure0(_this, rule, node), false, t1, type$.ModifiableCssStyleRule, type$.Null); + _this._atRootExcludingStyleRule = oldAtRootExcludingStyleRule; + t1 = _this._assertInModule$2(_this.__parent, _s8_).children._collection$_source; + t2 = J.getInterceptor$asx(t1); + _0_1 = t2.get$length(t1); + if (_0_1 >= 1) { + lastChild = t2.elementAt$1(t1, _0_1 - 1); + t1 = styleRule == null; + } else { + lastChild = _null; + t1 = false; + } + if (t1) + lastChild.isGroupEnd = true; + }, + visitCssStylesheet$1(node) { + var t1; + for (t1 = J.get$iterator$ax(node.get$children(node)); t1.moveNext$0();) + t1.get$current(t1).accept$1(this); + }, + visitCssSupportsRule$1(node) { + var _this = this; + if (_this._declarationName != null) + throw A.wrapException(_this._evaluate$_exception$2(string$.Suppor, node.span)); + _this._withParent$2$4$scopeWhen$through(A.ModifiableCssSupportsRule$(node.condition, node.span), new A._EvaluateVisitor_visitCssSupportsRule_closure(_this, node), false, new A._EvaluateVisitor_visitCssSupportsRule_closure0(), type$.ModifiableCssSupportsRule, type$.Null); + }, + _handleReturn$1$2(list, callback) { + var t1, _i, _0_0; + for (t1 = list.length, _i = 0; _i < list.length; list.length === t1 || (0, A.throwConcurrentModificationError)(list), ++_i) { + _0_0 = callback.call$1(list[_i]); + if (_0_0 != null) + return _0_0; + } + return null; + }, + _handleReturn$2(list, callback) { + return this._handleReturn$1$2(list, callback, type$.dynamic); + }, + _withEnvironment$1$2(environment, callback) { + var result, + oldEnvironment = this._environment; + this._environment = environment; + result = callback.call$0(); + this._environment = oldEnvironment; + return result; + }, + _withEnvironment$2(environment, callback) { + return this._withEnvironment$1$2(environment, callback, type$.dynamic); + }, + _interpolationToValue$3$trim$warnForColor(interpolation, trim, warnForColor) { + var result = this._performInterpolation$2$warnForColor(interpolation, warnForColor), + t1 = trim ? A.trimAscii(result, true) : result; + return new A.CssValue(t1, interpolation.span, type$.CssValue_String); + }, + _interpolationToValue$1(interpolation) { + return this._interpolationToValue$3$trim$warnForColor(interpolation, false, false); + }, + _interpolationToValue$2$warnForColor(interpolation, warnForColor) { + return this._interpolationToValue$3$trim$warnForColor(interpolation, false, warnForColor); + }, + _performInterpolation$2$warnForColor(interpolation, warnForColor) { + return this._performInterpolationHelper$3$sourceMap$warnForColor(interpolation, false, warnForColor)._0; + }, + _performInterpolation$1(interpolation) { + return this._performInterpolation$2$warnForColor(interpolation, false); + }, + _performInterpolationWithMap$2$warnForColor(interpolation, warnForColor) { + var _0_0 = this._performInterpolationHelper$3$sourceMap$warnForColor(interpolation, true, true), + map = _0_0._1; + map.toString; + return new A._Record_2(_0_0._0, map); + }, + _performInterpolationHelper$3$sourceMap$warnForColor(interpolation, sourceMap, warnForColor) { + var t1, t2, t3, t4, t5, t6, first, _i, t7, value, result, result0, t8, _this = this, _null = null, + targetLocations = sourceMap ? A._setArrayType([], type$.JSArray_SourceLocation) : _null, + oldInSupportsDeclaration = _this._inSupportsDeclaration; + _this._inSupportsDeclaration = false; + for (t1 = interpolation.contents, t2 = t1.length, t3 = type$.Expression, t4 = targetLocations == null, t5 = interpolation.span, t6 = type$.Object, first = true, _i = 0, t7 = ""; _i < t2; ++_i, first = false) { + value = t1[_i]; + if (!first) + if (!t4) + targetLocations.push(A.SourceLocation$(t7.length, _null, _null, _null)); + if (typeof value == "string") { + t7 += value; + continue; + } + t3._as(value); + result = value.accept$1(_this); + if (warnForColor && $.$get$namesByColor().containsKey$1(result)) { + result0 = A.List_List$from([""], false, t6); + result0.$flags = 3; + t8 = $.$get$namesByColor(); + _this._warn$2(string$.You_pr + A.S(t8.$index(0, result)) + string$.x20in_in + result.toString$0(0) + string$.x2c_whicw + A.S(t8.$index(0, result)) + string$.x22x29__If + new A.BinaryOperationExpression(B.BinaryOperator_Swh, new A.StringExpression(new A.Interpolation(result0, B.List_null, t5), true), value, false).toString$0(0) + "'.", value.get$span(value)); + } + t7 += _this._evaluate$_serialize$3$quote(result, value, false); + } + _this._inSupportsDeclaration = oldInSupportsDeclaration; + return new A._Record_2(t7.charCodeAt(0) == 0 ? t7 : t7, A.NullableExtension_andThen(targetLocations, new A._EvaluateVisitor__performInterpolationHelper_closure(interpolation))); + }, + _evaluate$_serialize$3$quote(value, nodeWithSpan, quote) { + return this._addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__serialize_closure(value, quote)); + }, + _evaluate$_serialize$2(value, nodeWithSpan) { + return this._evaluate$_serialize$3$quote(value, nodeWithSpan, true); + }, + _expressionNode$1(expression) { + var t1; + if (expression instanceof A.VariableExpression) { + t1 = this._addExceptionSpan$2(expression, new A._EvaluateVisitor__expressionNode_closure(this, expression)); + return t1 == null ? expression : t1; + } else + return expression; + }, + _withParent$2$4$scopeWhen$through(node, callback, scopeWhen, through, $S, $T) { + var oldParent, result, _this = this; + _this._addChild$2$through(node, through); + oldParent = _this._assertInModule$2(_this.__parent, "__parent"); + _this.__parent = node; + result = _this._environment.scope$1$2$when(callback, scopeWhen, $T); + _this.__parent = oldParent; + return result; + }, + _withParent$2$3$scopeWhen(node, callback, scopeWhen, $S, $T) { + return this._withParent$2$4$scopeWhen$through(node, callback, scopeWhen, null, $S, $T); + }, + _withParent$2$2(node, callback, $S, $T) { + return this._withParent$2$4$scopeWhen$through(node, callback, true, null, $S, $T); + }, + _addChild$2$through(node, through) { + var _0_0, grandparent, t1, + $parent = this._assertInModule$2(this.__parent, "__parent"); + if (through != null) { + for (; through.call$1($parent); $parent = _0_0) { + _0_0 = $parent._parent; + if (_0_0 == null) + throw A.wrapException(A.ArgumentError$(string$.throug + node.toString$0(0) + ".", null)); + } + if ($parent.get$hasFollowingSibling()) { + grandparent = $parent._parent; + t1 = grandparent.children; + if ($parent.equalsIgnoringChildren$1(t1.get$last(t1))) + $parent = type$.ModifiableCssParentNode._as(t1.get$last(t1)); + else { + $parent = $parent.copyWithoutChildren$0(); + grandparent.addChild$1($parent); + } + } + } + $parent.addChild$1(node); + }, + _addChild$1(node) { + return this._addChild$2$through(node, null); + }, + _withStyleRule$1$2(rule, callback) { + var result, + oldRule = this._styleRuleIgnoringAtRoot; + this._styleRuleIgnoringAtRoot = rule; + result = callback.call$0(); + this._styleRuleIgnoringAtRoot = oldRule; + return result; + }, + _withStyleRule$2(rule, callback) { + return this._withStyleRule$1$2(rule, callback, type$.dynamic); + }, + _withMediaQueries$1$3(queries, sources, callback) { + var result, _this = this, + oldMediaQueries = _this._mediaQueries, + oldSources = _this._mediaQuerySources; + _this._mediaQueries = queries; + _this._mediaQuerySources = sources; + result = callback.call$0(); + _this._mediaQueries = oldMediaQueries; + _this._mediaQuerySources = oldSources; + return result; + }, + _withMediaQueries$3(queries, sources, callback) { + return this._withMediaQueries$1$3(queries, sources, callback, type$.dynamic); + }, + _withStackFrame$1$3(member, nodeWithSpan, callback) { + var oldMember, result, _this = this, + t1 = _this._stack; + t1.push(new A._Record_2(_this._member, nodeWithSpan)); + oldMember = _this._member; + _this._member = member; + result = callback.call$0(); + _this._member = oldMember; + t1.pop(); + return result; + }, + _withStackFrame$3(member, nodeWithSpan, callback) { + return this._withStackFrame$1$3(member, nodeWithSpan, callback, type$.dynamic); + }, + _withoutSlash$2(value, nodeForSpan) { + var t1; + if (value instanceof A.SassNumber) + t1 = value.asSlash != null; + else + t1 = false; + if (t1) + this._warn$3(string$.Using__i + A.S(new A._EvaluateVisitor__withoutSlash_recommendation().call$1(value)) + string$.x0a_Morex20, nodeForSpan.get$span(nodeForSpan), B.Deprecation_BvP); + return value.withoutSlash$0(); + }, + _stackFrame$2(member, span) { + return A.frameForSpan(span, member, A.NullableExtension_andThen(span.get$sourceUrl(span), new A._EvaluateVisitor__stackFrame_closure(this))); + }, + _evaluate$_stackTrace$1(span) { + var t2, t3, _i, t4, nodeWithSpan, _this = this, + t1 = A._setArrayType([], type$.JSArray_Frame); + for (t2 = _this._stack, t3 = t2.length, _i = 0; _i < t2.length; t2.length === t3 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + t4 = t2[_i]; + nodeWithSpan = t4._1; + t1.push(_this._stackFrame$2(t4._0, nodeWithSpan.get$span(nodeWithSpan))); + } + if (span != null) + t1.push(_this._stackFrame$2(_this._member, span)); + return A.Trace$(new A.ReversedListIterable(t1, type$.ReversedListIterable_Frame), null); + }, + _evaluate$_stackTrace$0() { + return this._evaluate$_stackTrace$1(null); + }, + _warn$3(message, span, deprecation) { + var trace, t1, _this = this; + if (_this._quietDeps && _this._inDependency) + return; + if (!_this._warningsEmitted.add$1(0, new A._Record_2(message, span))) + return; + trace = _this._evaluate$_stackTrace$1(span); + t1 = _this._logger; + if (deprecation == null) + t1.internalWarn$4$deprecation$span$trace(message, null, span, trace); + else + A.WarnForDeprecation_warnForDeprecation(t1, deprecation, message, span, trace); + }, + _warn$2(message, span) { + return this._warn$3(message, span, null); + }, + _evaluate$_exception$2(message, span) { + var t1, t2; + if (span == null) { + t1 = B.JSArray_methods.get$last(this._stack)._1; + t1 = t1.get$span(t1); + } else + t1 = span; + t2 = this._evaluate$_stackTrace$1(span); + return new A.SassRuntimeException(t2, B.Set_empty, message, t1); + }, + _evaluate$_exception$1(message) { + return this._evaluate$_exception$2(message, null); + }, + _multiSpanException$3(message, primaryLabel, secondaryLabels) { + var t1 = B.JSArray_methods.get$last(this._stack)._1; + return A.MultiSpanSassRuntimeException$(message, t1.get$span(t1), primaryLabel, secondaryLabels, this._evaluate$_stackTrace$0(), null); + }, + _addExceptionSpan$1$3$addStackFrame(nodeWithSpan, callback, addStackFrame) { + var error, stackTrace, t1, exception; + try { + t1 = callback.call$0(); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassScriptException) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = error.withSpan$1(nodeWithSpan.get$span(nodeWithSpan)); + A.throwWithTrace(t1.withTrace$1(this._evaluate$_stackTrace$1(addStackFrame ? nodeWithSpan.get$span(nodeWithSpan) : null)), error, stackTrace); + } else + throw exception; + } + }, + _addExceptionSpan$2(nodeWithSpan, callback) { + return this._addExceptionSpan$1$3$addStackFrame(nodeWithSpan, callback, true, type$.dynamic); + }, + _addExceptionSpan$3$addStackFrame(nodeWithSpan, callback, addStackFrame) { + return this._addExceptionSpan$1$3$addStackFrame(nodeWithSpan, callback, addStackFrame, type$.dynamic); + }, + _addExceptionTrace$1$1(callback) { + var error, stackTrace, t1, exception, t2; + try { + t1 = callback.call$0(); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.SassRuntimeException._is(t1)) + throw exception; + else if (t1 instanceof A.SassException) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = error; + t2 = J.getInterceptor$z(t1); + A.throwWithTrace(error.withTrace$1(this._evaluate$_stackTrace$1(A.SourceSpanException.prototype.get$span.call(t2, t1))), error, stackTrace); + } else + throw exception; + } + }, + _addExceptionTrace$1(callback) { + return this._addExceptionTrace$1$1(callback, type$.dynamic); + }, + _addErrorSpan$1$2(nodeWithSpan, callback) { + var error, stackTrace, t1, exception, t2, t3; + try { + t1 = callback.call$0(); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.SassRuntimeException._is(t1)) { + error = t1; + stackTrace = A.getTraceFromException(exception); + if (!B.JSString_methods.startsWith$1(J.get$span$z(error).get$text(), "@error")) + throw exception; + t1 = error._span_exception$_message; + t2 = nodeWithSpan.get$span(nodeWithSpan); + t3 = this._evaluate$_stackTrace$0(); + A.throwWithTrace(new A.SassRuntimeException(t3, B.Set_empty, t1, t2), error, stackTrace); + } else + throw exception; + } + }, + _addErrorSpan$2(nodeWithSpan, callback) { + return this._addErrorSpan$1$2(nodeWithSpan, callback, type$.dynamic); + }, + _getErrorMessage$1(error) { + var t1, exception; + if (type$.Error._is(error)) + return error.toString$0(0); + try { + t1 = A._asString(J.get$message$x(error)); + return t1; + } catch (exception) { + t1 = J.toString$0$(error); + return t1; + } + } + }; + A._EvaluateVisitor_closure.prototype = { + call$1($arguments) { + var module, t2, + t1 = J.getInterceptor$asx($arguments), + variable = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this._environment; + t2 = A.stringReplaceAllUnchecked(variable._string$_text, "_", "-"); + return t1.globalVariableExists$2$namespace(t2, module == null ? null : module._string$_text) ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._EvaluateVisitor_closure0.prototype = { + call$1($arguments) { + var variable = J.$index$asx($arguments, 0).assertString$1("name"), + t1 = this.$this._environment; + return t1.getVariable$1(A.stringReplaceAllUnchecked(variable._string$_text, "_", "-")) != null ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._EvaluateVisitor_closure1.prototype = { + call$1($arguments) { + var module, t2, t3, t4, + t1 = J.getInterceptor$asx($arguments), + variable = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this; + t2 = t1._environment; + t3 = variable._string$_text; + t4 = A.stringReplaceAllUnchecked(t3, "_", "-"); + return t2.getFunction$2$namespace(t4, module == null ? null : module._string$_text) != null || t1._builtInFunctions.containsKey$1(t3) ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._EvaluateVisitor_closure2.prototype = { + call$1($arguments) { + var module, t2, + t1 = J.getInterceptor$asx($arguments), + variable = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this._environment; + t2 = A.stringReplaceAllUnchecked(variable._string$_text, "_", "-"); + return t1.getMixin$2$namespace(t2, module == null ? null : module._string$_text) != null ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._EvaluateVisitor_closure3.prototype = { + call$1($arguments) { + var t1 = this.$this._environment; + if (!t1._inMixin) + throw A.wrapException(A.SassScriptException$(string$.conten, null)); + return t1._content != null ? B.SassBoolean_true : B.SassBoolean_false; + }, + $signature: 12 + }; + A._EvaluateVisitor_closure4.prototype = { + call$1($arguments) { + var t2, t3, t4, + t1 = J.$index$asx($arguments, 0).assertString$1("module")._string$_text, + module = this.$this._environment._environment$_modules.$index(0, t1); + if (module == null) + throw A.wrapException('There is no module with namespace "' + t1 + '".'); + t1 = type$.Value; + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t3 = A.MapExtensions_get_pairs(module.get$variables(), type$.String, t1), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t2.$indexSet(0, new A.SassString(t4._0, true), t4._1); + } + return new A.SassMap(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 38 + }; + A._EvaluateVisitor_closure5.prototype = { + call$1($arguments) { + var t2, t3, t4, + t1 = J.$index$asx($arguments, 0).assertString$1("module")._string$_text, + module = this.$this._environment._environment$_modules.$index(0, t1); + if (module == null) + throw A.wrapException('There is no module with namespace "' + t1 + '".'); + t1 = type$.Value; + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t3 = A.MapExtensions_get_pairs(module.get$functions(module), type$.String, type$.Callable), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t2.$indexSet(0, new A.SassString(t4._0, true), new A.SassFunction(t4._1)); + } + return new A.SassMap(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 38 + }; + A._EvaluateVisitor_closure6.prototype = { + call$1($arguments) { + var t2, t3, t4, + t1 = J.$index$asx($arguments, 0).assertString$1("module")._string$_text, + module = this.$this._environment._environment$_modules.$index(0, t1); + if (module == null) + throw A.wrapException('There is no module with namespace "' + t1 + '".'); + t1 = type$.Value; + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t3 = A.MapExtensions_get_pairs(module.get$mixins(), type$.String, type$.Callable), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t2.$indexSet(0, new A.SassString(t4._0, true), new A.SassMixin(t4._1)); + } + return new A.SassMap(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 38 + }; + A._EvaluateVisitor_closure7.prototype = { + call$1($arguments) { + var module, t2, callable, + t1 = J.getInterceptor$asx($arguments), + $name = t1.$index($arguments, 0).assertString$1("name"), + css = t1.$index($arguments, 1).get$isTruthy(); + t1 = t1.$index($arguments, 2).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + if (css) { + if (module != null) + throw A.wrapException(string$.x24css_a); + return new A.SassFunction(new A.PlainCssCallable($name._string$_text)); + } + t1 = this.$this; + t2 = t1._callableNode; + t2.toString; + callable = t1._addExceptionSpan$2(t2, new A._EvaluateVisitor__closure2(t1, $name, module)); + if (callable == null) + throw A.wrapException("Function not found: " + $name.toString$0(0)); + return new A.SassFunction(callable); + }, + $signature: 167 + }; + A._EvaluateVisitor__closure2.prototype = { + call$0() { + var local, + normalizedName = A.stringReplaceAllUnchecked(this.name._string$_text, "_", "-"), + t1 = this.module, + namespace = t1 == null ? null : t1._string$_text; + t1 = this.$this; + local = t1._environment.getFunction$2$namespace(normalizedName, namespace); + if (local != null || namespace != null) + return local; + return t1._builtInFunctions.$index(0, normalizedName); + }, + $signature: 81 + }; + A._EvaluateVisitor_closure8.prototype = { + call$1($arguments) { + var module, t2, callable, + t1 = J.getInterceptor$asx($arguments), + $name = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this; + t2 = t1._callableNode; + t2.toString; + callable = t1._addExceptionSpan$2(t2, new A._EvaluateVisitor__closure1(t1, $name, module)); + if (callable == null) + throw A.wrapException("Mixin not found: " + $name.toString$0(0)); + return new A.SassMixin(callable); + }, + $signature: 168 + }; + A._EvaluateVisitor__closure1.prototype = { + call$0() { + var t1 = this.$this._environment, + t2 = A.stringReplaceAllUnchecked(this.name._string$_text, "_", "-"), + t3 = this.module; + return t1.getMixin$2$namespace(t2, t3 == null ? null : t3._string$_text); + }, + $signature: 81 + }; + A._EvaluateVisitor_closure9.prototype = { + call$1($arguments) { + var t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, invocation, callableNode, callable, + t1 = J.getInterceptor$asx($arguments), + $function = t1.$index($arguments, 0), + args = type$.SassArgumentList._as(t1.$index($arguments, 1)); + t1 = this.$this; + t2 = t1._callableNode; + t2.toString; + t3 = A._setArrayType([], type$.JSArray_Expression); + t4 = type$.String; + t5 = type$.Expression; + t6 = t2.get$span(t2); + t7 = t2.get$span(t2); + args._wereKeywordsAccessed = true; + t8 = args._keywords; + if (t8.get$isEmpty(t8)) + t2 = null; + else { + t9 = type$.Value; + t10 = A.LinkedHashMap_LinkedHashMap$_empty(t9, t9); + args._wereKeywordsAccessed = true; + t8 = A.MapExtensions_get_pairs(t8, t4, t9); + t8 = t8.get$iterator(t8); + for (; t8.moveNext$0();) { + t11 = t8.get$current(t8); + t10.$indexSet(0, new A.SassString(t11._0, false), t11._1); + } + t2 = new A.ValueExpression(new A.SassMap(A.ConstantMap_ConstantMap$from(t10, t9, t9)), t2.get$span(t2)); + } + invocation = new A.ArgumentList(A.List_List$unmodifiable(t3, t5), A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_empty(t4, t5), t4, t5), new A.ValueExpression(args, t7), t2, t6); + if ($function instanceof A.SassString) { + A.warnForDeprecation(string$.Passina + $function.toString$0(0) + "))", B.Deprecation_dAn); + callableNode = t1._callableNode; + t2 = $function._string$_text; + t3 = callableNode.get$span(callableNode); + return t1.visitFunctionExpression$1(0, new A.FunctionExpression(null, A.stringReplaceAllUnchecked(t2, "_", "-"), t2, invocation, t3)); + } + callable = $function.assertFunction$1("function").callable; + if (type$.Callable._is(callable)) { + t2 = t1._callableNode; + t2.toString; + return t1._runFunctionCallable$3(invocation, callable, t2); + } else + throw A.wrapException(A.SassScriptException$("The function " + callable.get$name(callable) + string$.x20is_as, null)); + }, + $signature: 4 + }; + A._EvaluateVisitor_closure10.prototype = { + call$1($arguments) { + var withMap, t2, values, configuration, t3, + t1 = J.getInterceptor$asx($arguments), + url = A.Uri_parse(t1.$index($arguments, 0).assertString$1("url")._string$_text); + t1 = t1.$index($arguments, 1).get$realNull(); + withMap = t1 == null ? null : t1.assertMap$1("with")._map$_contents; + t1 = this.$this; + t2 = t1._callableNode; + t2.toString; + if (withMap != null) { + values = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.ConfiguredValue); + withMap.forEach$1(0, new A._EvaluateVisitor__closure(values, t2.get$span(t2), t2)); + configuration = new A.ExplicitConfiguration(t2, values, null); + } else + configuration = B.Configuration_Map_empty_null; + t3 = t2.get$span(t2); + t1._loadModule$7$baseUrl$configuration$namesInErrors(url, "load-css()", t2, new A._EvaluateVisitor__closure0(t1), t3.get$sourceUrl(t3), configuration, true); + t1._assertConfigurationIsEmpty$2$nameInError(configuration, true); + }, + $signature: 188 + }; + A._EvaluateVisitor__closure.prototype = { + call$2(variable, value) { + var t1 = variable.assertString$1("with key"), + $name = A.stringReplaceAllUnchecked(t1._string$_text, "_", "-"); + t1 = this.values; + if (t1.containsKey$1($name)) + throw A.wrapException("The variable $" + $name + " was configured twice."); + t1.$indexSet(0, $name, new A.ConfiguredValue(value, this.span, this.callableNode)); + }, + $signature: 101 + }; + A._EvaluateVisitor__closure0.prototype = { + call$2(module, _) { + var t1 = this.$this; + return t1._combineCss$2$clone(module, true).accept$1(t1); + }, + $signature: 82 + }; + A._EvaluateVisitor_closure11.prototype = { + call$1($arguments) { + var callableNode, t2, t3, t4, t5, callable, $content, + t1 = J.getInterceptor$asx($arguments), + mixin = t1.$index($arguments, 0), + args = type$.SassArgumentList._as(t1.$index($arguments, 1)); + t1 = this.$this; + callableNode = t1._callableNode; + t2 = callableNode.get$span(callableNode); + t3 = callableNode.get$span(callableNode); + t4 = type$.Expression; + t5 = A.List_List$unmodifiable(B.List_empty9, t4); + t4 = A.ConstantMap_ConstantMap$from(B.Map_empty5, type$.String, t4); + callable = mixin.assertMixin$1("mixin").callable; + $content = t1._environment._content; + if (type$.Callable._is(callable)) + t1._applyMixin$5(callable, $content, new A.ArgumentList(t5, t4, new A.ValueExpression(args, t3), null, t2), callableNode, callableNode); + else + throw A.wrapException(A.SassScriptException$("The mixin " + callable.get$name(callable) + string$.x20is_as, null)); + }, + $signature: 188 + }; + A._EvaluateVisitor_run_closure.prototype = { + call$0() { + var module, _this = this, + t1 = _this.node, + t2 = t1.span, + _0_0 = t2.get$sourceUrl(t2), + url = null; + if (_0_0 != null) { + url = _0_0; + t2 = _this.$this; + t2._activeModules.$indexSet(0, url, null); + t2._loadedUrls.add$1(0, url); + } + t2 = _this.$this; + module = t2._addExceptionTrace$1(new A._EvaluateVisitor_run__closure(t2, _this.importer, t1)); + return new A._Record_2_loadedUrls_stylesheet(t2._loadedUrls, t2._combineCss$1(module)); + }, + $signature: 569 + }; + A._EvaluateVisitor_run__closure.prototype = { + call$0() { + return this.$this._execute$2(this.importer, this.node); + }, + $signature: 570 + }; + A._EvaluateVisitor_runExpression_closure.prototype = { + call$0() { + var t1 = this.$this, + t2 = this.expression; + return t1._withFakeStylesheet$3(this.importer, t2, new A._EvaluateVisitor_runExpression__closure(t1, t2)); + }, + $signature: 33 + }; + A._EvaluateVisitor_runExpression__closure.prototype = { + call$0() { + var t1 = this.$this; + return t1._addExceptionTrace$1(new A._EvaluateVisitor_runExpression___closure(t1, this.expression)); + }, + $signature: 33 + }; + A._EvaluateVisitor_runExpression___closure.prototype = { + call$0() { + return this.expression.accept$1(this.$this); + }, + $signature: 33 + }; + A._EvaluateVisitor_runStatement_closure.prototype = { + call$0() { + var t1 = this.$this, + t2 = this.statement; + return t1._withFakeStylesheet$3(this.importer, t2, new A._EvaluateVisitor_runStatement__closure(t1, t2)); + }, + $signature: 0 + }; + A._EvaluateVisitor_runStatement__closure.prototype = { + call$0() { + var t1 = this.$this; + return t1._addExceptionTrace$1(new A._EvaluateVisitor_runStatement___closure(t1, this.statement)); + }, + $signature: 0 + }; + A._EvaluateVisitor_runStatement___closure.prototype = { + call$0() { + return this.statement.accept$1(this.$this); + }, + $signature: 0 + }; + A._EvaluateVisitor__loadModule_closure.prototype = { + call$0() { + return this.callback.call$2(this._box_0.builtInModule, false); + }, + $signature: 0 + }; + A._EvaluateVisitor__loadModule_closure0.prototype = { + call$0() { + var canonicalUrl, oldInDependency, t4, message, _this = this, t1 = {}, stylesheet = null, importer = null, + t2 = _this.$this, + t3 = _this.nodeWithSpan, + _1_0 = t2._loadStylesheet$3$baseUrl(_this.url.toString$0(0), t3.get$span(t3), _this.baseUrl); + stylesheet = _1_0._0; + importer = _1_0._1; + t4 = stylesheet.span; + canonicalUrl = t4.get$sourceUrl(t4); + if (canonicalUrl != null) { + t4 = t2._activeModules; + if (t4.containsKey$1(canonicalUrl)) { + if (_this.namesInErrors) { + t1 = canonicalUrl; + t3 = $.$get$context(); + t1.toString; + message = "Module loop: " + t3.prettyUri$1(t1) + " is already being loaded."; + } else + message = string$.Modulel; + t1 = A.NullableExtension_andThen(t4.$index(0, canonicalUrl), new A._EvaluateVisitor__loadModule__closure(t2, message)); + throw A.wrapException(t1 == null ? t2._evaluate$_exception$1(message) : t1); + } else + t4.$indexSet(0, canonicalUrl, t3); + } + t4 = t2._modules.containsKey$1(canonicalUrl); + oldInDependency = t2._inDependency; + t2._inDependency = _1_0._2; + t1.module = null; + try { + t1.module = t2._execute$5$configuration$namesInErrors$nodeWithSpan(importer, stylesheet, _this.configuration, _this.namesInErrors, t3); + } finally { + t2._activeModules.remove$1(0, canonicalUrl); + t2._inDependency = oldInDependency; + } + t2._addExceptionSpan$3$addStackFrame(t3, new A._EvaluateVisitor__loadModule__closure0(t1, _this.callback, !t4), false); + }, + $signature: 1 + }; + A._EvaluateVisitor__loadModule__closure.prototype = { + call$1(previousLoad) { + return this.$this._multiSpanException$3(this.message, "new load", A.LinkedHashMap_LinkedHashMap$_literal([previousLoad.get$span(previousLoad), "original load"], type$.FileSpan, type$.String)); + }, + $signature: 85 + }; + A._EvaluateVisitor__loadModule__closure0.prototype = { + call$0() { + return this.callback.call$2(this._box_1.module, this.firstLoad); + }, + $signature: 0 + }; + A._EvaluateVisitor__execute_closure.prototype = { + call$0() { + var t3, t4, t5, t6, _this = this, + t1 = _this.$this, + oldImporter = t1._importer, + oldStylesheet = t1.__stylesheet, + oldRoot = t1.__root, + oldPreModuleComments = t1._preModuleComments, + oldParent = t1.__parent, + oldEndOfImports = t1.__endOfImports, + oldOutOfOrderImports = t1._outOfOrderImports, + oldExtensionStore = t1.__extensionStore, + t2 = t1._atRootExcludingStyleRule, + oldStyleRule = t2 ? null : t1._styleRuleIgnoringAtRoot, + oldMediaQueries = t1._mediaQueries, + oldDeclarationName = t1._declarationName, + oldInUnknownAtRule = t1._inUnknownAtRule, + oldInKeyframes = t1._inKeyframes, + oldConfiguration = t1._configuration; + t1._importer = _this.importer; + t3 = t1.__stylesheet = _this.stylesheet; + t4 = t3.span; + t5 = t1.__parent = t1.__root = A.ModifiableCssStylesheet$(t4); + t1.__endOfImports = 0; + t1._outOfOrderImports = null; + t1.__extensionStore = _this.extensionStore; + t1._declarationName = t1._mediaQueries = t1._styleRuleIgnoringAtRoot = null; + t1._inKeyframes = t1._atRootExcludingStyleRule = t1._inUnknownAtRule = false; + t6 = _this.configuration; + if (t6 != null) + t1._configuration = t6; + t1.visitStylesheet$1(0, t3); + t3 = t1._outOfOrderImports == null ? t5 : new A.CssStylesheet(new A.UnmodifiableListView(t1._addOutOfOrderImports$0(), type$.UnmodifiableListView_CssNode), t4); + _this.css.__late_helper$_value = t3; + _this.preModuleComments.__late_helper$_value = t1._preModuleComments; + t1._importer = oldImporter; + t1.__stylesheet = oldStylesheet; + t1.__root = oldRoot; + t1._preModuleComments = oldPreModuleComments; + t1.__parent = oldParent; + t1.__endOfImports = oldEndOfImports; + t1._outOfOrderImports = oldOutOfOrderImports; + t1.__extensionStore = oldExtensionStore; + t1._styleRuleIgnoringAtRoot = oldStyleRule; + t1._mediaQueries = oldMediaQueries; + t1._declarationName = oldDeclarationName; + t1._inUnknownAtRule = oldInUnknownAtRule; + t1._atRootExcludingStyleRule = t2; + t1._inKeyframes = oldInKeyframes; + t1._configuration = oldConfiguration; + }, + $signature: 1 + }; + A._EvaluateVisitor__combineCss_closure.prototype = { + call$1(module) { + return module.get$transitivelyContainsCss(); + }, + $signature: 129 + }; + A._EvaluateVisitor__combineCss_closure0.prototype = { + call$1(target) { + return !this.selectors.contains$1(0, target); + }, + $signature: 13 + }; + A._EvaluateVisitor__combineCss_visitModule.prototype = { + call$1(module) { + var t1, t2, t3, t4, _i, upstream, _1_0, statements, index, _this = this; + if (!_this.seen.add$1(0, module)) + return; + if (_this.clone) + module = module.cloneCss$0(); + for (t1 = module.get$upstream(), t2 = t1.length, t3 = _this.css, t4 = _this.imports, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + upstream = t1[_i]; + if (upstream.get$transitivelyContainsCss()) { + _1_0 = module.get$preModuleComments().$index(0, upstream); + if (_1_0 != null) + B.JSArray_methods.addAll$1(t3.length === 0 ? t4 : t3, _1_0); + _this.call$1(upstream); + } + } + _this.sorted.addFirst$1(module); + t1 = module.get$css(module); + statements = t1.get$children(t1); + index = _this.$this._indexAfterImports$1(statements); + t1 = J.getInterceptor$ax(statements); + B.JSArray_methods.addAll$1(t4, t1.getRange$2(statements, 0, index)); + B.JSArray_methods.addAll$1(t3, t1.getRange$2(statements, index, t1.get$length(statements))); + }, + $signature: 579 + }; + A._EvaluateVisitor__extendModules_closure.prototype = { + call$1(target) { + return !this.originalSelectors.contains$1(0, target); + }, + $signature: 13 + }; + A._EvaluateVisitor__extendModules_closure0.prototype = { + call$0() { + return A._setArrayType([], type$.JSArray_ExtensionStore); + }, + $signature: 141 + }; + A._EvaluateVisitor_visitAtRootRule_closure.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.node.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitAtRootRule_closure0.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.node.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 0 + }; + A._EvaluateVisitor__scopeForAtRoot_closure.prototype = { + call$1(callback) { + var t1 = this.$this, + oldParent = t1._assertInModule$2(t1.__parent, "__parent"); + t1.__parent = this.newParent; + t1._environment.scope$1$2$when(callback, this.node.hasDeclarations, type$.void); + t1.__parent = oldParent; + }, + $signature: 35 + }; + A._EvaluateVisitor__scopeForAtRoot_closure0.prototype = { + call$1(callback) { + var t1 = this.$this, + oldAtRootExcludingStyleRule = t1._atRootExcludingStyleRule; + t1._atRootExcludingStyleRule = true; + this.innerScope.call$1(callback); + t1._atRootExcludingStyleRule = oldAtRootExcludingStyleRule; + }, + $signature: 35 + }; + A._EvaluateVisitor__scopeForAtRoot_closure1.prototype = { + call$1(callback) { + return this.$this._withMediaQueries$3(null, null, new A._EvaluateVisitor__scopeForAtRoot__closure(this.innerScope, callback)); + }, + $signature: 35 + }; + A._EvaluateVisitor__scopeForAtRoot__closure.prototype = { + call$0() { + return this.innerScope.call$1(this.callback); + }, + $signature: 1 + }; + A._EvaluateVisitor__scopeForAtRoot_closure2.prototype = { + call$1(callback) { + var t1 = this.$this, + wasInKeyframes = t1._inKeyframes; + t1._inKeyframes = false; + this.innerScope.call$1(callback); + t1._inKeyframes = wasInKeyframes; + }, + $signature: 35 + }; + A._EvaluateVisitor__scopeForAtRoot_closure3.prototype = { + call$1($parent) { + return $parent instanceof A.ModifiableCssAtRule; + }, + $signature: 172 + }; + A._EvaluateVisitor__scopeForAtRoot_closure4.prototype = { + call$1(callback) { + var t1 = this.$this, + wasInUnknownAtRule = t1._inUnknownAtRule; + t1._inUnknownAtRule = false; + this.innerScope.call$1(callback); + t1._inUnknownAtRule = wasInUnknownAtRule; + }, + $signature: 35 + }; + A._EvaluateVisitor_visitContentRule_closure.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.content.declaration.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + return null; + }, + $signature: 1 + }; + A._EvaluateVisitor_visitDeclaration_closure.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this._box_0.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitEachRule_closure.prototype = { + call$1(value) { + var t1 = this.$this, + t2 = this.nodeWithSpan; + return t1._environment.setLocalVariable$3(this._box_0.variable, t1._withoutSlash$2(value, t2), t2); + }, + $signature: 62 + }; + A._EvaluateVisitor_visitEachRule_closure0.prototype = { + call$1(value) { + return this.$this._setMultipleVariables$3(this._box_1.variables, value, this.nodeWithSpan); + }, + $signature: 62 + }; + A._EvaluateVisitor_visitEachRule_closure1.prototype = { + call$0() { + var _this = this, + t1 = _this.$this; + return t1._handleReturn$2(_this.list.get$asList(), new A._EvaluateVisitor_visitEachRule__closure(t1, _this.setVariables, _this.node)); + }, + $signature: 41 + }; + A._EvaluateVisitor_visitEachRule__closure.prototype = { + call$1(element) { + var t1; + this.setVariables.call$1(element); + t1 = this.$this; + return t1._handleReturn$2(this.node.children, new A._EvaluateVisitor_visitEachRule___closure(t1)); + }, + $signature: 581 + }; + A._EvaluateVisitor_visitEachRule___closure.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 83 + }; + A._EvaluateVisitor_visitAtRule_closure.prototype = { + call$1(value) { + return this.$this._interpolationToValue$3$trim$warnForColor(value, true, true); + }, + $signature: 583 + }; + A._EvaluateVisitor_visitAtRule_closure0.prototype = { + call$0() { + var t2, t3, _i, _this = this, + t1 = _this.$this, + styleRule = t1._atRootExcludingStyleRule ? null : t1._styleRuleIgnoringAtRoot; + if (styleRule == null || t1._inKeyframes || J.$eq$(_this.name.value, "font-face")) + for (t2 = _this.children, t3 = t2.length, _i = 0; _i < t3; ++_i) + t2[_i].accept$1(t1); + else + t1._withParent$2$3$scopeWhen(A.ModifiableCssStyleRule$(styleRule._style_rule$_selector, styleRule.span, false, styleRule.originalSelector), new A._EvaluateVisitor_visitAtRule__closure(t1, _this.children), false, type$.ModifiableCssStyleRule, type$.Null); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitAtRule__closure.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitAtRule_closure1.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitForRule_closure.prototype = { + call$0() { + return this.node.from.accept$1(this.$this).assertNumber$0(); + }, + $signature: 189 + }; + A._EvaluateVisitor_visitForRule_closure0.prototype = { + call$0() { + return this.node.to.accept$1(this.$this).assertNumber$0(); + }, + $signature: 189 + }; + A._EvaluateVisitor_visitForRule_closure1.prototype = { + call$0() { + return this.fromNumber.assertInt$0(); + }, + $signature: 10 + }; + A._EvaluateVisitor_visitForRule_closure2.prototype = { + call$0() { + var t1 = this.fromNumber; + return this.toNumber.coerce$2(t1.get$numeratorUnits(t1), t1.get$denominatorUnits(t1)).assertInt$0(); + }, + $signature: 10 + }; + A._EvaluateVisitor_visitForRule_closure3.prototype = { + call$0() { + var i, t3, t4, t5, t6, t7, t8, _0_0, _this = this, + t1 = _this.$this, + t2 = _this.node, + nodeWithSpan = t1._expressionNode$1(t2.from); + for (i = _this.from, t3 = _this._box_0, t4 = _this.direction, t5 = t2.variable, t6 = _this.fromNumber, t2 = t2.children; i !== t3.to; i += t4) { + t7 = t1._environment; + t8 = t6.get$numeratorUnits(t6); + t7.setLocalVariable$3(t5, A.SassNumber_SassNumber$withUnits(i, t6.get$denominatorUnits(t6), t8), nodeWithSpan); + _0_0 = t1._handleReturn$2(t2, new A._EvaluateVisitor_visitForRule__closure(t1)); + if (_0_0 != null) + return _0_0; + } + return null; + }, + $signature: 41 + }; + A._EvaluateVisitor_visitForRule__closure.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 83 + }; + A._EvaluateVisitor_visitForwardRule_closure.prototype = { + call$2(module, firstLoad) { + if (firstLoad) + this.$this._registerCommentsForModule$1(module); + this.$this._environment.forwardModule$2(module, this.node); + }, + $signature: 82 + }; + A._EvaluateVisitor_visitForwardRule_closure0.prototype = { + call$2(module, firstLoad) { + if (firstLoad) + this.$this._registerCommentsForModule$1(module); + this.$this._environment.forwardModule$2(module, this.node); + }, + $signature: 82 + }; + A._EvaluateVisitor__registerCommentsForModule_closure.prototype = { + call$0() { + return A._setArrayType([], type$.JSArray_CssComment); + }, + $signature: 177 + }; + A._EvaluateVisitor_visitIfRule_closure.prototype = { + call$1(clause) { + var t1 = this.$this; + return t1._environment.scope$1$3$semiGlobal$when(new A._EvaluateVisitor_visitIfRule__closure(t1, clause), true, clause.hasDeclarations, type$.nullable_Value); + }, + $signature: 611 + }; + A._EvaluateVisitor_visitIfRule__closure.prototype = { + call$0() { + var t1 = this.$this; + return t1._handleReturn$2(this.clause.children, new A._EvaluateVisitor_visitIfRule___closure(t1)); + }, + $signature: 41 + }; + A._EvaluateVisitor_visitIfRule___closure.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 83 + }; + A._EvaluateVisitor__visitDynamicImport_closure.prototype = { + call$0() { + var t1, t2, _0_0, stylesheet, importer, isDependency, t3, url, oldImporter, oldStylesheet, oldInDependency, loadsUserDefinedModules, children, t4, t5, t6, t7, t8, t9, t10, environment, module, visitor, _box_0 = {}; + _box_0.isDependency = _box_0.importer = _box_0.stylesheet = null; + t1 = this.$this; + t2 = this.$import; + _0_0 = t1._loadStylesheet$3$forImport(t2.urlString, t2.span, true); + stylesheet = _box_0.stylesheet = _0_0._0; + importer = _0_0._1; + _box_0.importer = importer; + isDependency = _0_0._2; + _box_0.isDependency = isDependency; + t3 = stylesheet.span; + url = t3.get$sourceUrl(t3); + if (url != null) { + t3 = t1._activeModules; + if (t3.containsKey$1(url)) { + t2 = A.NullableExtension_andThen(t3.$index(0, url), new A._EvaluateVisitor__visitDynamicImport__closure(t1)); + throw A.wrapException(t2 == null ? t1._evaluate$_exception$1("This file is already being loaded.") : t2); + } + t3.$indexSet(0, url, t2); + } + t2 = stylesheet._uses; + t3 = type$.UnmodifiableListView_UseRule; + if (new A.UnmodifiableListView(t2, t3).get$length(0) === 0 && new A.UnmodifiableListView(stylesheet._forwards, type$.UnmodifiableListView_ForwardRule).get$length(0) === 0) { + oldImporter = t1._importer; + oldStylesheet = t1._assertInModule$2(t1.__stylesheet, "_stylesheet"); + oldInDependency = t1._inDependency; + t1._importer = importer; + t1.__stylesheet = stylesheet; + t1._inDependency = isDependency; + t1.visitStylesheet$1(0, stylesheet); + t1._importer = oldImporter; + t1.__stylesheet = oldStylesheet; + t1._inDependency = oldInDependency; + t1._activeModules.remove$1(0, url); + return; + } + t2 = new A.UnmodifiableListView(t2, t3); + if (!t2.any$1(t2, new A._EvaluateVisitor__visitDynamicImport__closure0())) { + t2 = new A.UnmodifiableListView(stylesheet._forwards, type$.UnmodifiableListView_ForwardRule); + loadsUserDefinedModules = t2.any$1(t2, new A._EvaluateVisitor__visitDynamicImport__closure1()); + } else + loadsUserDefinedModules = true; + children = A._Cell$(); + t2 = t1._environment; + t3 = type$.String; + t4 = type$.Module_Callable; + t5 = type$.AstNode; + t6 = A._setArrayType([], type$.JSArray_Module_Callable); + t7 = t2._variables; + t7 = A._setArrayType(t7.slice(0), A._arrayInstanceType(t7)); + t8 = t2._variableNodes; + t8 = A._setArrayType(t8.slice(0), A._arrayInstanceType(t8)); + t9 = t2._functions; + t9 = A._setArrayType(t9.slice(0), A._arrayInstanceType(t9)); + t10 = t2._mixins; + t10 = A._setArrayType(t10.slice(0), A._arrayInstanceType(t10)); + environment = A.Environment$_(A.LinkedHashMap_LinkedHashMap$_empty(t3, t4), A.LinkedHashMap_LinkedHashMap$_empty(t3, t5), A.LinkedHashMap_LinkedHashMap$_empty(t4, t5), t2._importedModules, null, null, t6, t7, t8, t9, t10, t2._content); + t1._withEnvironment$2(environment, new A._EvaluateVisitor__visitDynamicImport__closure2(_box_0, t1, loadsUserDefinedModules, environment, children)); + module = environment.toDummyModule$0(); + t1._environment.importForwards$1(module); + if (loadsUserDefinedModules) { + if (module.transitivelyContainsCss) + t1._combineCss$2$clone(module, module.transitivelyContainsExtensions).accept$1(t1); + visitor = new A._ImportedCssVisitor(t1); + for (t2 = J.get$iterator$ax(children._readLocal$0()); t2.moveNext$0();) + t2.get$current(t2).accept$1(visitor); + } + t1._activeModules.remove$1(0, url); + }, + $signature: 0 + }; + A._EvaluateVisitor__visitDynamicImport__closure.prototype = { + call$1(previousLoad) { + return this.$this._multiSpanException$3("This file is already being loaded.", "new load", A.LinkedHashMap_LinkedHashMap$_literal([previousLoad.get$span(previousLoad), "original load"], type$.FileSpan, type$.String)); + }, + $signature: 85 + }; + A._EvaluateVisitor__visitDynamicImport__closure0.prototype = { + call$1(rule) { + return rule.url.get$scheme() !== "sass"; + }, + $signature: 178 + }; + A._EvaluateVisitor__visitDynamicImport__closure1.prototype = { + call$1(rule) { + return rule.url.get$scheme() !== "sass"; + }, + $signature: 179 + }; + A._EvaluateVisitor__visitDynamicImport__closure2.prototype = { + call$0() { + var t3, t4, _this = this, + t1 = _this.$this, + oldImporter = t1._importer, + oldStylesheet = t1._assertInModule$2(t1.__stylesheet, "_stylesheet"), + oldRoot = t1._assertInModule$2(t1.__root, "_root"), + oldParent = t1._assertInModule$2(t1.__parent, "__parent"), + oldEndOfImports = t1._assertInModule$2(t1.__endOfImports, "_endOfImports"), + oldOutOfOrderImports = t1._outOfOrderImports, + oldConfiguration = t1._configuration, + oldInDependency = t1._inDependency, + t2 = _this._box_0; + t1._importer = t2.importer; + t3 = t2.stylesheet; + t1.__stylesheet = t3; + t4 = _this.loadsUserDefinedModules; + if (t4) { + t3 = A.ModifiableCssStylesheet$(t3.span); + t1.__root = t3; + t1.__parent = t1._assertInModule$2(t3, "_root"); + t1.__endOfImports = 0; + t1._outOfOrderImports = null; + } + t1._inDependency = t2.isDependency; + t3 = new A.UnmodifiableListView(t2.stylesheet._forwards, type$.UnmodifiableListView_ForwardRule); + if (!t3.get$isEmpty(t3)) + t1._configuration = _this.environment.toImplicitConfiguration$0(); + t1.visitStylesheet$1(0, t2.stylesheet); + t2 = t4 ? t1._addOutOfOrderImports$0() : A._setArrayType([], type$.JSArray_ModifiableCssNode); + _this.children.__late_helper$_value = t2; + t1._importer = oldImporter; + t1.__stylesheet = oldStylesheet; + if (t4) { + t1.__root = oldRoot; + t1.__parent = oldParent; + t1.__endOfImports = oldEndOfImports; + t1._outOfOrderImports = oldOutOfOrderImports; + } + t1._configuration = oldConfiguration; + t1._inDependency = oldInDependency; + }, + $signature: 1 + }; + A._EvaluateVisitor__applyMixin_closure.prototype = { + call$0() { + var _this = this, + t1 = _this.$this; + t1._environment.asMixin$1(new A._EvaluateVisitor__applyMixin__closure0(t1, _this.$arguments, _this.mixin, _this.nodeWithSpanWithoutContent)); + }, + $signature: 0 + }; + A._EvaluateVisitor__applyMixin__closure0.prototype = { + call$0() { + var _this = this; + _this.$this._runBuiltInCallable$3(_this.$arguments, _this.mixin, _this.nodeWithSpanWithoutContent); + }, + $signature: 0 + }; + A._EvaluateVisitor__applyMixin_closure0.prototype = { + call$0() { + var _this = this, + t1 = _this.$this; + t1._environment.withContent$2(_this.contentCallable, new A._EvaluateVisitor__applyMixin__closure(t1, _this.mixin, _this.nodeWithSpanWithoutContent)); + }, + $signature: 1 + }; + A._EvaluateVisitor__applyMixin__closure.prototype = { + call$0() { + var t1 = this.$this; + t1._environment.asMixin$1(new A._EvaluateVisitor__applyMixin___closure(t1, this.mixin, this.nodeWithSpanWithoutContent)); + }, + $signature: 0 + }; + A._EvaluateVisitor__applyMixin___closure.prototype = { + call$0() { + var t1, t2, t3, t4, _i; + for (t1 = this.mixin.declaration.children, t2 = t1.length, t3 = this.$this, t4 = this.nodeWithSpanWithoutContent, _i = 0; _i < t2; ++_i) + t3._addErrorSpan$2(t4, new A._EvaluateVisitor__applyMixin____closure(t3, t1[_i])); + }, + $signature: 0 + }; + A._EvaluateVisitor__applyMixin____closure.prototype = { + call$0() { + return this.statement.accept$1(this.$this); + }, + $signature: 41 + }; + A._EvaluateVisitor_visitIncludeRule_closure.prototype = { + call$0() { + var t1 = this.node; + return this.$this._environment.getMixin$2$namespace(t1.name, t1.namespace); + }, + $signature: 81 + }; + A._EvaluateVisitor_visitIncludeRule_closure0.prototype = { + call$1($content) { + var t1 = this.$this; + return new A.UserDefinedCallable($content, t1._environment.closure$0(), t1._inDependency, type$.UserDefinedCallable_Environment); + }, + $signature: 632 + }; + A._EvaluateVisitor_visitIncludeRule_closure1.prototype = { + call$0() { + return this.node.get$spanWithoutContent(); + }, + $signature: 29 + }; + A._EvaluateVisitor_visitMediaRule_closure.prototype = { + call$1(mediaQueries) { + return this.$this._mergeMediaQueries$2(mediaQueries, this.queries); + }, + $signature: 96 + }; + A._EvaluateVisitor_visitMediaRule_closure0.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this.mergedQueries; + if (t2 == null) + t2 = _this.queries; + t1._withMediaQueries$3(t2, _this.mergedSources, new A._EvaluateVisitor_visitMediaRule__closure(t1, _this.node)); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitMediaRule__closure.prototype = { + call$0() { + var t2, t3, _i, + t1 = this.$this, + _0_0 = t1._atRootExcludingStyleRule ? null : t1._styleRuleIgnoringAtRoot; + if (_0_0 != null) + t1._withParent$2$3$scopeWhen(A.ModifiableCssStyleRule$(_0_0._style_rule$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitMediaRule___closure(t1, this.node), false, type$.ModifiableCssStyleRule, type$.Null); + else + for (t2 = this.node.children, t3 = t2.length, _i = 0; _i < t3; ++_i) + t2[_i].accept$1(t1); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitMediaRule___closure.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.node.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitMediaRule_closure1.prototype = { + call$1(node) { + var t1; + if (!(node instanceof A.ModifiableCssStyleRule)) { + t1 = this.mergedSources; + t1 = t1.get$isNotEmpty(t1) && node instanceof A.ModifiableCssMediaRule && B.JSArray_methods.every$1(node.queries, t1.get$contains(t1)); + } else + t1 = true; + return t1; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitStyleRule_closure.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.node.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitStyleRule_closure0.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitStyleRule_closure2.prototype = { + call$0() { + var t1 = this.$this; + t1._withStyleRule$2(this.rule, new A._EvaluateVisitor_visitStyleRule__closure(t1, this.node)); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitStyleRule__closure.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.node.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitStyleRule_closure1.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor__warnForBogusCombinators_closure.prototype = { + call$1(child) { + return child instanceof A.ModifiableCssComment; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitSupportsRule_closure.prototype = { + call$0() { + var t2, t3, _i, + t1 = this.$this, + _0_0 = t1._atRootExcludingStyleRule ? null : t1._styleRuleIgnoringAtRoot; + if (_0_0 != null) + t1._withParent$2$2(A.ModifiableCssStyleRule$(_0_0._style_rule$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitSupportsRule__closure(t1, this.node), type$.ModifiableCssStyleRule, type$.Null); + else + for (t2 = this.node.children, t3 = t2.length, _i = 0; _i < t3; ++_i) + t2[_i].accept$1(t1); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitSupportsRule__closure.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.node.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitSupportsRule_closure0.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor__visitSupportsCondition_closure.prototype = { + call$0() { + var t4, + t1 = this.$this, + t2 = this._box_0, + t3 = t2.declaration.name; + t3 = t1._evaluate$_serialize$3$quote(t3.accept$1(t1), t3, true); + t4 = t2.declaration.get$isCustomProperty() ? "" : " "; + t2 = t2.declaration.value; + return "(" + t3 + ":" + t4 + t1._evaluate$_serialize$3$quote(t2.accept$1(t1), t2, true) + ")"; + }, + $signature: 26 + }; + A._EvaluateVisitor_visitVariableDeclaration_closure.prototype = { + call$0() { + var t1 = this.$this._environment, + t2 = this._box_0.override; + t1.setVariable$4$global(this.node.name, t2.value, t2.assignmentNode, true); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitVariableDeclaration_closure0.prototype = { + call$0() { + var t1 = this.node; + return this.$this._environment.getVariable$2$namespace(t1.name, t1.namespace); + }, + $signature: 41 + }; + A._EvaluateVisitor_visitVariableDeclaration_closure1.prototype = { + call$0() { + var t1 = this.$this, + t2 = this.node; + t1._environment.setVariable$5$global$namespace(t2.name, this.value, t1._expressionNode$1(t2.expression), t2.isGlobal, t2.namespace); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitUseRule_closure.prototype = { + call$2(module, firstLoad) { + var t1, t2, t3, _0_0, t4, t5, span; + if (firstLoad) + this.$this._registerCommentsForModule$1(module); + t1 = this.$this._environment; + t2 = this.node; + t3 = t2.namespace; + if (t3 == null) { + t1._globalModules.$indexSet(0, module, t2); + t1._allModules.push(module); + _0_0 = A.IterableExtension_firstWhereOrNull(J.get$keys$z(B.JSArray_methods.get$first(t1._variables)), module.get$variables().get$containsKey()); + if (_0_0 != null) + A.throwExpression(A.SassScriptException$(string$.This_ma + _0_0 + '".', null)); + } else { + t4 = t1._environment$_modules; + if (t4.containsKey$1(t3)) { + t5 = t1._namespaceNodes.$index(0, t3); + span = t5 == null ? null : t5.span; + t5 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + if (span != null) + t5.$indexSet(0, span, "original @use"); + A.throwExpression(A.MultiSpanSassScriptException$(string$.There_ + t3 + '".', "new @use", t5)); + } + t4.$indexSet(0, t3, module); + t1._namespaceNodes.$indexSet(0, t3, t2); + t1._allModules.push(module); + } + }, + $signature: 82 + }; + A._EvaluateVisitor_visitWarnRule_closure.prototype = { + call$0() { + return this.node.expression.accept$1(this.$this); + }, + $signature: 33 + }; + A._EvaluateVisitor_visitWhileRule_closure.prototype = { + call$0() { + var t1, t2, t3, _0_0; + for (t1 = this.node, t2 = t1.condition, t3 = this.$this, t1 = t1.children; t2.accept$1(t3).get$isTruthy();) { + _0_0 = t3._handleReturn$2(t1, new A._EvaluateVisitor_visitWhileRule__closure(t3)); + if (_0_0 != null) + return _0_0; + } + return null; + }, + $signature: 41 + }; + A._EvaluateVisitor_visitWhileRule__closure.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 83 + }; + A._EvaluateVisitor_visitBinaryOperationExpression_closure.prototype = { + call$0() { + var t1 = this.node, + t2 = this.$this, + left = t1.left.accept$1(t2); + switch (t1.operator) { + case B.BinaryOperator_Kyq: + t1 = t1.right.accept$1(t2); + t1 = new A.SassString(A.serializeValue(left, false, true) + "=" + A.serializeValue(t1, false, true), false); + break; + case B.BinaryOperator_tKu: + t1 = left.get$isTruthy() ? left : t1.right.accept$1(t2); + break; + case B.BinaryOperator_uke: + t1 = left.get$isTruthy() ? t1.right.accept$1(t2) : left; + break; + case B.BinaryOperator_r84: + t1 = left.$eq(0, t1.right.accept$1(t2)) ? B.SassBoolean_true : B.SassBoolean_false; + break; + case B.BinaryOperator_qGq: + t1 = !left.$eq(0, t1.right.accept$1(t2)) ? B.SassBoolean_true : B.SassBoolean_false; + break; + case B.BinaryOperator_o8O: + t1 = left.greaterThan$1(t1.right.accept$1(t2)); + break; + case B.BinaryOperator_JiR: + t1 = left.greaterThanOrEquals$1(t1.right.accept$1(t2)); + break; + case B.BinaryOperator_qHy: + t1 = left.lessThan$1(t1.right.accept$1(t2)); + break; + case B.BinaryOperator_FPG: + t1 = left.lessThanOrEquals$1(t1.right.accept$1(t2)); + break; + case B.BinaryOperator_Swh: + t1 = left.plus$1(t1.right.accept$1(t2)); + break; + case B.BinaryOperator_QG1: + t1 = left.minus$1(t1.right.accept$1(t2)); + break; + case B.BinaryOperator_tht: + t1 = left.times$1(t1.right.accept$1(t2)); + break; + case B.BinaryOperator_Mh5: + t1 = t2._slash$3(left, t1.right.accept$1(t2), t1); + break; + case B.BinaryOperator_s7T: + t1 = left.modulo$1(t1.right.accept$1(t2)); + break; + default: + t1 = null; + } + return t1; + }, + $signature: 33 + }; + A._EvaluateVisitor__slash_recommendation.prototype = { + call$1(expression) { + var t1; + $label0$0: { + if (expression instanceof A.BinaryOperationExpression && B.BinaryOperator_Mh5 === expression.operator) { + t1 = "math.div(" + A.S(this.call$1(expression.left)) + ", " + A.S(this.call$1(expression.right)) + ")"; + break $label0$0; + } + if (expression instanceof A.ParenthesizedExpression) { + t1 = expression.expression.toString$0(0); + break $label0$0; + } + t1 = expression.toString$0(0); + break $label0$0; + } + return t1; + }, + $signature: 133 + }; + A._EvaluateVisitor_visitVariableExpression_closure.prototype = { + call$0() { + var t1 = this.node; + return this.$this._environment.getVariable$2$namespace(t1.name, t1.namespace); + }, + $signature: 41 + }; + A._EvaluateVisitor_visitUnaryOperationExpression_closure.prototype = { + call$0() { + var t1, _this = this; + switch (_this.node.operator) { + case B.UnaryOperator_Rbl: + t1 = _this.operand.unaryPlus$0(); + break; + case B.UnaryOperator_UCP: + t1 = _this.operand.unaryMinus$0(); + break; + case B.UnaryOperator_lZV: + t1 = new A.SassString("/" + A.serializeValue(_this.operand, false, true), false); + break; + case B.UnaryOperator_not_not_not: + t1 = _this.operand.unaryNot$0(); + break; + default: + t1 = null; + } + return t1; + }, + $signature: 33 + }; + A._EvaluateVisitor_visitListExpression_closure.prototype = { + call$1(expression) { + return expression.accept$1(this.$this); + }, + $signature: 647 + }; + A._EvaluateVisitor_visitFunctionExpression_closure.prototype = { + call$0() { + var t1 = this.node; + return this.$this._environment.getFunction$2$namespace(t1.name, t1.namespace); + }, + $signature: 81 + }; + A._EvaluateVisitor_visitFunctionExpression_closure0.prototype = { + call$1(argument) { + return argument.accept$1(B.C_IsCalculationSafeVisitor); + }, + $signature: 118 + }; + A._EvaluateVisitor_visitFunctionExpression_closure1.prototype = { + call$0() { + var t1 = this.node; + return this.$this._runFunctionCallable$3(t1.$arguments, this._box_0.$function, t1); + }, + $signature: 33 + }; + A._EvaluateVisitor__visitCalculation_closure.prototype = { + call$2(message, deprecation) { + return this.$this._warn$3(message, this.node.span, deprecation); + }, + call$1(message) { + return this.call$2(message, null); + }, + $signature: 105 + }; + A._EvaluateVisitor__checkCalculationArguments_check.prototype = { + call$1(maxArgs) { + var t1 = this.node, + t2 = t1.$arguments.positional.length; + if (t2 === 0) + throw A.wrapException(this.$this._evaluate$_exception$2("Missing argument.", t1.span)); + else if (maxArgs != null && t2 > maxArgs) + throw A.wrapException(this.$this._evaluate$_exception$2("Only " + A.S(maxArgs) + " " + A.pluralize("argument", maxArgs, null) + " allowed, but " + t2 + " " + A.pluralize("was", t2, "were") + " passed.", t1.span)); + }, + call$0() { + return this.call$1(null); + }, + $signature: 106 + }; + A._EvaluateVisitor__visitCalculationExpression_closure.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this._box_0, + t3 = _this.node, + t4 = _this.inLegacySassFunction; + return A.SassCalculation_operateInternal(t1._binaryOperatorToCalculationOperator$2(t2.operator, t3), t1._visitCalculationExpression$2$inLegacySassFunction(t2.left, t4), t1._visitCalculationExpression$2$inLegacySassFunction(t2.right, t4), t4, !t1._inSupportsDeclaration, new A._EvaluateVisitor__visitCalculationExpression__closure(t1, t3)); + }, + $signature: 84 + }; + A._EvaluateVisitor__visitCalculationExpression__closure.prototype = { + call$2(message, deprecation) { + return this.$this._warn$3(message, this.node.get$span(0), deprecation); + }, + call$1(message) { + return this.call$2(message, null); + }, + $signature: 105 + }; + A._EvaluateVisitor_visitInterpolatedFunctionExpression_closure.prototype = { + call$0() { + var t1 = this.node; + return this.$this._runFunctionCallable$3(t1.$arguments, this.$function, t1); + }, + $signature: 33 + }; + A._EvaluateVisitor__runUserDefinedCallable_closure.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this.callable; + return t1._withEnvironment$2(t2.environment.closure$0(), new A._EvaluateVisitor__runUserDefinedCallable__closure(t1, _this.evaluated, t2, _this.nodeWithSpan, _this.run, _this.V)); + }, + $signature() { + return this.V._eval$1("0()"); + } + }; + A._EvaluateVisitor__runUserDefinedCallable__closure.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this.V; + return t1._environment.scope$1$1(new A._EvaluateVisitor__runUserDefinedCallable___closure(t1, _this.evaluated, _this.callable, _this.nodeWithSpan, _this.run, t2), t2); + }, + $signature() { + return this.V._eval$1("0()"); + } + }; + A._EvaluateVisitor__runUserDefinedCallable___closure.prototype = { + call$0() { + var parameters, t5, minLength, i, parameter, t6, value, t7, t8, restParameter, rest, argumentList, result, parameterWord, _this = this, + t1 = _this.$this, + t2 = _this.evaluated._values, + t3 = _this.callable.declaration.parameters, + t4 = _this.nodeWithSpan; + t1._verifyArguments$4(t2[2].length, t2[0], t3, t4); + parameters = t3.parameters; + t5 = parameters.length; + minLength = Math.min(t2[2].length, t5); + for (i = 0; i < minLength; ++i) + t1._environment.setLocalVariable$3(parameters[i].name, t2[2][i], t2[3][i]); + for (i = t2[2].length; i < t5; ++i) { + parameter = parameters[i]; + t6 = parameter.name; + value = t2[0].remove$1(0, t6); + if (value == null) { + t7 = parameter.defaultValue; + value = t1._withoutSlash$2(t7.accept$1(t1), t1._expressionNode$1(t7)); + } + t7 = t1._environment; + t8 = t2[1].$index(0, t6); + if (t8 == null) { + t8 = parameter.defaultValue; + t8.toString; + t8 = t1._expressionNode$1(t8); + } + t7.setLocalVariable$3(t6, value, t8); + } + restParameter = t3.restParameter; + if (restParameter != null) { + t6 = t2[2]; + rest = t6.length > t5 ? B.JSArray_methods.sublist$1(t6, t5) : B.List_empty8; + t5 = t2[0]; + t6 = t2[4]; + argumentList = A.SassArgumentList$(rest, t5, t6 === B.ListSeparator_undecided_null_undecided ? B.ListSeparator_qVN : t6); + t1._environment.setLocalVariable$3(restParameter, argumentList, t4); + } else + argumentList = null; + result = _this.run.call$0(); + if (argumentList == null) + return result; + t5 = t2[0].__js_helper$_length; + if (t5 === 0) + return result; + if (argumentList._wereKeywordsAccessed) + return result; + parameterWord = A.pluralize("parameter", t5, null); + t2 = t2[0]; + t5 = A._instanceType(t2)._eval$1("LinkedHashMapKeysIterable<1>"); + throw A.wrapException(A.MultiSpanSassRuntimeException$("No " + parameterWord + " named " + A.toSentence(A.MappedIterable_MappedIterable(new A.LinkedHashMapKeysIterable(t2, t5), new A._EvaluateVisitor__runUserDefinedCallable____closure(), t5._eval$1("Iterable.E"), type$.Object), "or") + ".", t4.get$span(t4), "invocation", A.LinkedHashMap_LinkedHashMap$_literal([t3.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), t1._evaluate$_stackTrace$1(t4.get$span(t4)), null)); + }, + $signature() { + return this.V._eval$1("0()"); + } + }; + A._EvaluateVisitor__runUserDefinedCallable____closure.prototype = { + call$1($name) { + return "$" + $name; + }, + $signature: 6 + }; + A._EvaluateVisitor__runFunctionCallable_closure.prototype = { + call$0() { + var t1, t2, t3, t4, _i, $returnValue; + for (t1 = this.callable.declaration, t2 = t1.children, t3 = t2.length, t4 = this.$this, _i = 0; _i < t3; ++_i) { + $returnValue = t2[_i].accept$1(t4); + if ($returnValue instanceof A.Value) + return $returnValue; + } + throw A.wrapException(t4._evaluate$_exception$2("Function finished without @return.", t1.span)); + }, + $signature: 33 + }; + A._EvaluateVisitor__runBuiltInCallable_closure.prototype = { + call$0() { + return this._box_0.overload.verify$2(this.evaluated._values[2].length, this.namedSet); + }, + $signature: 0 + }; + A._EvaluateVisitor__runBuiltInCallable_closure0.prototype = { + call$0() { + return this._box_0.callback.call$1(this.evaluated._values[2]); + }, + $signature: 33 + }; + A._EvaluateVisitor__runBuiltInCallable_closure1.prototype = { + call$1($name) { + return "$" + $name; + }, + $signature: 6 + }; + A._EvaluateVisitor__evaluateArguments_closure.prototype = { + call$1(value) { + return value; + }, + $signature: 42 + }; + A._EvaluateVisitor__evaluateArguments_closure0.prototype = { + call$1(value) { + return this.$this._withoutSlash$2(value, this.restNodeForSpan); + }, + $signature: 42 + }; + A._EvaluateVisitor__evaluateArguments_closure1.prototype = { + call$2(key, value) { + var _this = this, + t1 = _this.restNodeForSpan; + _this.named.$indexSet(0, key, _this.$this._withoutSlash$2(value, t1)); + _this.namedNodes.$indexSet(0, key, t1); + }, + $signature: 107 + }; + A._EvaluateVisitor__evaluateArguments_closure2.prototype = { + call$1(value) { + return value; + }, + $signature: 42 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure.prototype = { + call$1(value) { + var t1 = this.restArgs; + return new A.ValueExpression(value, t1.get$span(t1)); + }, + $signature: 64 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure0.prototype = { + call$1(value) { + var t1 = this.restArgs; + return new A.ValueExpression(this.$this._withoutSlash$2(value, this.restNodeForSpan), t1.get$span(t1)); + }, + $signature: 64 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure1.prototype = { + call$2(key, value) { + var _this = this, + t1 = _this.restArgs; + _this.named.$indexSet(0, key, new A.ValueExpression(_this.$this._withoutSlash$2(value, _this.restNodeForSpan), t1.get$span(t1))); + }, + $signature: 107 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure2.prototype = { + call$1(value) { + var t1 = this.keywordRestArgs; + return new A.ValueExpression(this.$this._withoutSlash$2(value, this.keywordRestNodeForSpan), t1.get$span(t1)); + }, + $signature: 64 + }; + A._EvaluateVisitor__addRestMap_closure.prototype = { + call$2(key, value) { + var t2, _this = this, + t1 = _this.$this; + if (key instanceof A.SassString) + _this.values.$indexSet(0, key._string$_text, _this.convert.call$1(t1._withoutSlash$2(value, _this.expressionNode))); + else { + t2 = _this.nodeWithSpan; + throw A.wrapException(t1._evaluate$_exception$2(string$.Variab_ + key.toString$0(0) + " is not a string in " + _this.map.toString$0(0) + ".", t2.get$span(t2))); + } + }, + $signature: 101 + }; + A._EvaluateVisitor__verifyArguments_closure.prototype = { + call$0() { + return this.parameters.verify$2(this.positional, new A.MapKeySet(this.named, type$.MapKeySet_String)); + }, + $signature: 0 + }; + A._EvaluateVisitor_visitCssAtRule_closure.prototype = { + call$0() { + var t1, t2, t3, t4; + for (t1 = this.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = this.$this, t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t4 = t1.__internal$_current; + (t4 == null ? t2._as(t4) : t4).accept$1(t3); + } + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssAtRule_closure0.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitCssKeyframeBlock_closure.prototype = { + call$0() { + var t1, t2, t3, t4; + for (t1 = this.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = this.$this, t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t4 = t1.__internal$_current; + (t4 == null ? t2._as(t4) : t4).accept$1(t3); + } + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssKeyframeBlock_closure0.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitCssMediaRule_closure.prototype = { + call$1(mediaQueries) { + return this.$this._mergeMediaQueries$2(mediaQueries, this.node.queries); + }, + $signature: 96 + }; + A._EvaluateVisitor_visitCssMediaRule_closure0.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this.mergedQueries; + if (t2 == null) + t2 = _this.node.queries; + t1._withMediaQueries$3(t2, _this.mergedSources, new A._EvaluateVisitor_visitCssMediaRule__closure(t1, _this.node)); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssMediaRule__closure.prototype = { + call$0() { + var t2, t3, t4, + t1 = this.$this, + _0_0 = t1._atRootExcludingStyleRule ? null : t1._styleRuleIgnoringAtRoot; + if (_0_0 != null) + t1._withParent$2$3$scopeWhen(A.ModifiableCssStyleRule$(_0_0._style_rule$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitCssMediaRule___closure(t1, this.node), false, type$.ModifiableCssStyleRule, type$.Null); + else + for (t2 = this.node.children, t3 = t2.$ti, t2 = new A.ListIterator(t2, t2.get$length(0), t3._eval$1("ListIterator")), t3 = t3._eval$1("ListBase.E"); t2.moveNext$0();) { + t4 = t2.__internal$_current; + (t4 == null ? t3._as(t4) : t4).accept$1(t1); + } + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssMediaRule___closure.prototype = { + call$0() { + var t1, t2, t3, t4; + for (t1 = this.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = this.$this, t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t4 = t1.__internal$_current; + (t4 == null ? t2._as(t4) : t4).accept$1(t3); + } + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssMediaRule_closure1.prototype = { + call$1(node) { + var t1; + if (!(node instanceof A.ModifiableCssStyleRule)) { + t1 = this.mergedSources; + t1 = t1.get$isNotEmpty(t1) && node instanceof A.ModifiableCssMediaRule && B.JSArray_methods.every$1(node.queries, t1.get$contains(t1)); + } else + t1 = true; + return t1; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitCssStyleRule_closure0.prototype = { + call$0() { + var t1 = this.$this; + t1._withStyleRule$2(this.rule, new A._EvaluateVisitor_visitCssStyleRule__closure(t1, this.node)); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssStyleRule__closure.prototype = { + call$0() { + var t1, t2, t3, t4; + for (t1 = this.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = this.$this, t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t4 = t1.__internal$_current; + (t4 == null ? t2._as(t4) : t4).accept$1(t3); + } + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssStyleRule_closure.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor_visitCssSupportsRule_closure.prototype = { + call$0() { + var t2, t3, t4, + t1 = this.$this, + _0_0 = t1._atRootExcludingStyleRule ? null : t1._styleRuleIgnoringAtRoot; + if (_0_0 != null) + t1._withParent$2$2(A.ModifiableCssStyleRule$(_0_0._style_rule$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitCssSupportsRule__closure(t1, this.node), type$.ModifiableCssStyleRule, type$.Null); + else + for (t2 = this.node.children, t3 = t2.$ti, t2 = new A.ListIterator(t2, t2.get$length(0), t3._eval$1("ListIterator")), t3 = t3._eval$1("ListBase.E"); t2.moveNext$0();) { + t4 = t2.__internal$_current; + (t4 == null ? t3._as(t4) : t4).accept$1(t1); + } + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssSupportsRule__closure.prototype = { + call$0() { + var t1, t2, t3, t4; + for (t1 = this.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = this.$this, t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t4 = t1.__internal$_current; + (t4 == null ? t2._as(t4) : t4).accept$1(t3); + } + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssSupportsRule_closure0.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluateVisitor__performInterpolationHelper_closure.prototype = { + call$1(targetLocations) { + return A.InterpolationMap$(this.interpolation, targetLocations); + }, + $signature: 184 + }; + A._EvaluateVisitor__serialize_closure.prototype = { + call$0() { + return A.serializeValue(this.value, false, this.quote); + }, + $signature: 26 + }; + A._EvaluateVisitor__expressionNode_closure.prototype = { + call$0() { + var t1 = this.expression; + return this.$this._environment.getVariableNode$2$namespace(t1.name, t1.namespace); + }, + $signature: 142 + }; + A._EvaluateVisitor__withoutSlash_recommendation.prototype = { + call$1(number) { + var before, after, t1, + _1_0 = number.asSlash; + $label0$0: { + if (type$.Record_2_nullable_Object_and_nullable_Object._is(_1_0)) { + before = _1_0._0; + after = _1_0._1; + t1 = "math.div(" + A.S(this.call$1(before)) + ", " + A.S(this.call$1(after)) + ")"; + break $label0$0; + } + t1 = A.serializeValue(number, true, true); + break $label0$0; + } + return t1; + }, + $signature: 186 + }; + A._EvaluateVisitor__stackFrame_closure.prototype = { + call$1(url) { + var t1 = this.$this._evaluate$_importCache; + t1 = t1 == null ? null : t1.humanize$1(url); + return t1 == null ? url : t1; + }, + $signature: 50 + }; + A._ImportedCssVisitor.prototype = { + visitCssAtRule$1(node) { + var t1 = node.isChildless ? null : new A._ImportedCssVisitor_visitCssAtRule_closure(); + this._visitor._addChild$2$through(node, t1); + }, + visitCssComment$1(node) { + return this._visitor._addChild$1(node); + }, + visitCssDeclaration$1(node) { + }, + visitCssImport$1(node) { + var t2, + _s13_ = "_endOfImports", + t1 = this._visitor; + if (t1._assertInModule$2(t1.__parent, "__parent") !== t1._assertInModule$2(t1.__root, "_root")) + t1._addChild$1(node); + else if (t1._assertInModule$2(t1.__endOfImports, _s13_) === J.get$length$asx(t1._assertInModule$2(t1.__root, "_root").children._collection$_source)) { + t1._addChild$1(node); + t1.__endOfImports = t1._assertInModule$2(t1.__endOfImports, _s13_) + 1; + } else { + t2 = t1._outOfOrderImports; + (t2 == null ? t1._outOfOrderImports = A._setArrayType([], type$.JSArray_ModifiableCssImport) : t2).push(node); + } + }, + visitCssKeyframeBlock$1(node) { + }, + visitCssMediaRule$1(node) { + var t1 = this._visitor, + mediaQueries = t1._mediaQueries; + t1._addChild$2$through(node, new A._ImportedCssVisitor_visitCssMediaRule_closure(mediaQueries == null || t1._mergeMediaQueries$2(mediaQueries, node.queries) != null)); + }, + visitCssStyleRule$1(node) { + return this._visitor._addChild$2$through(node, new A._ImportedCssVisitor_visitCssStyleRule_closure()); + }, + visitCssStylesheet$1(node) { + var t1, t2, t3; + for (t1 = node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t3 = t1.__internal$_current; + (t3 == null ? t2._as(t3) : t3).accept$1(this); + } + }, + visitCssSupportsRule$1(node) { + return this._visitor._addChild$2$through(node, new A._ImportedCssVisitor_visitCssSupportsRule_closure()); + } + }; + A._ImportedCssVisitor_visitCssAtRule_closure.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._ImportedCssVisitor_visitCssMediaRule_closure.prototype = { + call$1(node) { + var t1; + if (!(node instanceof A.ModifiableCssStyleRule)) + t1 = this.hasBeenMerged && node instanceof A.ModifiableCssMediaRule; + else + t1 = true; + return t1; + }, + $signature: 8 + }; + A._ImportedCssVisitor_visitCssStyleRule_closure.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._ImportedCssVisitor_visitCssSupportsRule_closure.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule; + }, + $signature: 8 + }; + A._EvaluationContext.prototype = { + get$currentCallableSpan() { + var _0_0 = this._visitor._callableNode; + if (_0_0 != null) + return _0_0.get$span(_0_0); + throw A.wrapException(A.StateError$(string$.No_Sasc)); + }, + warn$2(_, message, deprecation) { + var t1 = this._visitor, + t2 = t1._importSpan; + if (t2 == null) { + t2 = t1._callableNode; + t2 = t2 == null ? null : t2.get$span(t2); + } + if (t2 == null) { + t2 = this._defaultWarnNodeWithSpan; + t2 = t2.get$span(t2); + } + t1._warn$3(message, t2, deprecation); + }, + $isEvaluationContext: 1 + }; + A.EveryCssVisitor.prototype = { + visitCssAtRule$1(node) { + var t1 = node.children; + return t1.every$1(t1, new A.EveryCssVisitor_visitCssAtRule_closure(this)); + }, + visitCssComment$1(node) { + return false; + }, + visitCssDeclaration$1(node) { + return false; + }, + visitCssImport$1(node) { + return false; + }, + visitCssKeyframeBlock$1(node) { + var t1 = node.children; + return t1.every$1(t1, new A.EveryCssVisitor_visitCssKeyframeBlock_closure(this)); + }, + visitCssMediaRule$1(node) { + var t1 = node.children; + return t1.every$1(t1, new A.EveryCssVisitor_visitCssMediaRule_closure(this)); + }, + visitCssStyleRule$1(node) { + var t1 = node.children; + return t1.every$1(t1, new A.EveryCssVisitor_visitCssStyleRule_closure(this)); + }, + visitCssStylesheet$1(node) { + return J.every$1$ax(node.get$children(node), new A.EveryCssVisitor_visitCssStylesheet_closure(this)); + }, + visitCssSupportsRule$1(node) { + var t1 = node.children; + return t1.every$1(t1, new A.EveryCssVisitor_visitCssSupportsRule_closure(this)); + } + }; + A.EveryCssVisitor_visitCssAtRule_closure.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 8 + }; + A.EveryCssVisitor_visitCssKeyframeBlock_closure.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 8 + }; + A.EveryCssVisitor_visitCssMediaRule_closure.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 8 + }; + A.EveryCssVisitor_visitCssStyleRule_closure.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 8 + }; + A.EveryCssVisitor_visitCssStylesheet_closure.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 8 + }; + A.EveryCssVisitor_visitCssSupportsRule_closure.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 8 + }; + A._MakeExpressionCalculationSafe.prototype = { + visitBinaryOperationExpression$1(_, node) { + var t1, t2, t3, t4; + if (node.operator === B.BinaryOperator_s7T) { + t1 = A._setArrayType([node], type$.JSArray_Expression); + t2 = node.get$span(0); + t3 = type$.Expression; + t1 = A.List_List$unmodifiable(t1, t3); + t3 = A.ConstantMap_ConstantMap$from(B.Map_empty5, type$.String, t3); + t4 = node.get$span(0); + t1 = new A.FunctionExpression("math", A.stringReplaceAllUnchecked("max", "_", "-"), "max", new A.ArgumentList(t1, t3, null, null, t2), t4); + } else + t1 = this.super$ReplaceExpressionVisitor$visitBinaryOperationExpression(0, node); + return t1; + }, + visitInterpolatedFunctionExpression$1(_, node) { + return node; + }, + visitUnaryOperationExpression$1(_, node) { + var t1, + _0_0 = node.operator; + $label0$0: { + if (B.UnaryOperator_Rbl === _0_0) { + t1 = node.operand; + break $label0$0; + } + if (B.UnaryOperator_UCP === _0_0) { + t1 = new A.BinaryOperationExpression(B.BinaryOperator_tht, new A.NumberExpression(-1, null, node.span), node.operand, false); + break $label0$0; + } + t1 = this.super$ReplaceExpressionVisitor$visitUnaryOperationExpression(0, node); + break $label0$0; + } + return t1; + } + }; + A.__MakeExpressionCalculationSafe_Object_ReplaceExpressionVisitor.prototype = {}; + A._FindDependenciesVisitor.prototype = { + visitEachRule$1(_, node) { + }, + visitForRule$1(_, node) { + }, + visitIfRule$1(_, node) { + }, + visitWhileRule$1(_, node) { + }, + visitUseRule$1(_, node) { + var t1 = node.url; + if (t1.get$scheme() !== "sass") + this._find_dependencies$_uses.add$1(0, t1); + else if (t1.toString$0(0) === "sass:meta") + this._metaNamespaces.add$1(0, node.namespace); + }, + visitForwardRule$1(_, node) { + var t1 = node.url; + if (t1.get$scheme() !== "sass") + this._find_dependencies$_forwards.add$1(0, t1); + }, + visitImportRule$1(_, node) { + var t1, t2, t3, _i, $import; + for (t1 = node.imports, t2 = t1.length, t3 = this._imports, _i = 0; _i < t2; ++_i) { + $import = t1[_i]; + if ($import instanceof A.DynamicImport) + t3.add$1(0, A.Uri_parse($import.urlString)); + } + }, + visitIncludeRule$1(_, node) { + var url, _0_0, _0_4_isSet, _0_7, t1, _0_4, _0_7_isSet, url0, exception; + if (node.name !== "load-css") + return; + if (!this._metaNamespaces.contains$1(0, node.namespace)) + return; + _0_0 = node.$arguments.positional; + url = null; + _0_4_isSet = _0_0.length === 1; + _0_7 = null; + t1 = false; + if (_0_4_isSet) { + _0_4 = _0_0[0]; + _0_7_isSet = _0_4 instanceof A.StringExpression; + if (_0_7_isSet) { + type$.StringExpression._as(_0_4); + _0_7 = _0_4.text.get$asPlain(); + t1 = _0_7; + t1 = t1 != null; + } + } else { + _0_4 = null; + _0_7_isSet = false; + } + if (t1) { + if (_0_7_isSet) + url0 = _0_7; + else { + t1 = _0_4_isSet ? _0_4 : _0_0[0]; + _0_7 = type$.StringExpression._as(t1).text.get$asPlain(); + url0 = _0_7; + } + url = url0 == null ? A._asString(url0) : url0; + try { + this._metaLoadCss.add$1(0, A.Uri_parse(url)); + } catch (exception) { + if (!type$.FormatException._is(A.unwrapException(exception))) + throw exception; + } + } + } + }; + A.DependencyReport.prototype = {}; + A.__FindDependenciesVisitor_Object_RecursiveStatementVisitor.prototype = {}; + A.IsCalculationSafeVisitor.prototype = { + visitBinaryOperationExpression$1(_, node) { + return B.Set_oQTdo.contains$1(0, node.operator) && node.left.accept$1(this) && node.right.accept$1(this); + }, + visitBooleanExpression$1(_, node) { + return false; + }, + visitColorExpression$1(_, node) { + return false; + }, + visitFunctionExpression$1(_, node) { + return true; + }, + visitInterpolatedFunctionExpression$1(_, node) { + return true; + }, + visitIfExpression$1(_, node) { + return true; + }, + visitListExpression$1(_, node) { + var t1 = false; + if (node.separator === B.ListSeparator_qSL) + if (!node.hasBrackets) { + t1 = node.contents; + t1 = t1.length > 1 && B.JSArray_methods.every$1(t1, new A.IsCalculationSafeVisitor_visitListExpression_closure(this)); + } + return t1; + }, + visitMapExpression$1(_, node) { + return false; + }, + visitNullExpression$1(_, node) { + return false; + }, + visitNumberExpression$1(_, node) { + return true; + }, + visitParenthesizedExpression$1(_, node) { + return node.expression.accept$1(this); + }, + visitSelectorExpression$1(_, node) { + return false; + }, + visitStringExpression$1(_, node) { + var text, t1, t2; + if (node.hasQuotes) + return false; + text = node.text.get$initialPlain(); + t1 = false; + if (!B.JSString_methods.startsWith$1(text, "!")) + if (!B.JSString_methods.startsWith$1(text, "#")) { + t2 = text.length; + if ((1 >= t2 ? null : text.charCodeAt(1)) !== 43) + t1 = (3 >= t2 ? null : text.charCodeAt(3)) !== 40; + } + return t1; + }, + visitSupportsExpression$1(_, node) { + return false; + }, + visitUnaryOperationExpression$1(_, node) { + return false; + }, + visitValueExpression$1(_, node) { + return false; + }, + visitVariableExpression$1(_, node) { + return true; + } + }; + A.IsCalculationSafeVisitor_visitListExpression_closure.prototype = { + call$1(expression) { + return expression.accept$1(this.$this); + }, + $signature: 118 + }; + A.RecursiveStatementVisitor.prototype = { + visitAtRootRule$1(_, node) { + this.visitChildren$1(node.children); + }, + visitAtRule$1(_, node) { + return A.NullableExtension_andThen(node.children, this.get$visitChildren()); + }, + visitContentBlock$1(_, node) { + return null; + }, + visitContentRule$1(_, node) { + }, + visitDebugRule$1(_, node) { + }, + visitDeclaration$1(_, node) { + return A.NullableExtension_andThen(node.children, this.get$visitChildren()); + }, + visitEachRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitErrorRule$1(_, node) { + }, + visitExtendRule$1(_, node) { + }, + visitForRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitForwardRule$1(_, node) { + }, + visitFunctionRule$1(_, node) { + return null; + }, + visitIfRule$1(_, node) { + var t1, t2, _i, t3, t4, _i0, _0_0; + for (t1 = node.clauses, t2 = t1.length, _i = 0; _i < t2; ++_i) + for (t3 = t1[_i].children, t4 = t3.length, _i0 = 0; _i0 < t4; ++_i0) + t3[_i0].accept$1(this); + _0_0 = node.lastClause; + if (_0_0 != null) + for (t1 = _0_0.children, t2 = t1.length, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(this); + }, + visitImportRule$1(_, node) { + }, + visitIncludeRule$1(_, node) { + return A.NullableExtension_andThen(node.content, this.get$visitContentBlock(this)); + }, + visitLoudComment$1(_, node) { + }, + visitMediaRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitMixinRule$1(_, node) { + return null; + }, + visitReturnRule$1(_, node) { + }, + visitSilentComment$1(_, node) { + }, + visitStyleRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitStylesheet$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitSupportsRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitUseRule$1(_, node) { + }, + visitVariableDeclaration$1(_, node) { + }, + visitWarnRule$1(_, node) { + }, + visitWhileRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitChildren$1(children) { + var t1; + for (t1 = J.get$iterator$ax(children); t1.moveNext$0();) + t1.get$current(t1).accept$1(this); + } + }; + A.ReplaceExpressionVisitor.prototype = { + visitBinaryOperationExpression$1(_, node) { + return new A.BinaryOperationExpression(node.operator, node.left.accept$1(this), node.right.accept$1(this), false); + }, + visitBooleanExpression$1(_, node) { + return node; + }, + visitColorExpression$1(_, node) { + return node; + }, + visitFunctionExpression$1(_, node) { + var t1 = node.originalName, + t2 = this.visitArgumentList$1(node.$arguments); + return new A.FunctionExpression(node.namespace, A.stringReplaceAllUnchecked(t1, "_", "-"), t1, t2, node.span); + }, + visitInterpolatedFunctionExpression$1(_, node) { + return new A.InterpolatedFunctionExpression(this.visitInterpolation$1(node.name), this.visitArgumentList$1(node.$arguments), node.span); + }, + visitIfExpression$1(_, node) { + return new A.IfExpression(this.visitArgumentList$1(node.$arguments), node.span); + }, + visitListExpression$1(_, node) { + var t1 = node.contents; + return new A.ListExpression(A.List_List$unmodifiable(new A.MappedListIterable(t1, new A.ReplaceExpressionVisitor_visitListExpression_closure(this), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Expression>")), type$.Expression), node.separator, node.hasBrackets, node.span); + }, + visitMapExpression$1(_, node) { + var t2, t3, _i, t4, + t1 = A._setArrayType([], type$.JSArray_Record_2_Expression_and_Expression); + for (t2 = node.pairs, t3 = t2.length, _i = 0; _i < t3; ++_i) { + t4 = t2[_i]; + t1.push(new A._Record_2(t4._0.accept$1(this), t4._1.accept$1(this))); + } + return new A.MapExpression(A.List_List$unmodifiable(t1, type$.Record_2_Expression_and_Expression), node.span); + }, + visitNullExpression$1(_, node) { + return node; + }, + visitNumberExpression$1(_, node) { + return node; + }, + visitParenthesizedExpression$1(_, node) { + return new A.ParenthesizedExpression(node.expression.accept$1(this), node.span); + }, + visitSelectorExpression$1(_, node) { + return node; + }, + visitStringExpression$1(_, node) { + return new A.StringExpression(this.visitInterpolation$1(node.text), node.hasQuotes); + }, + visitSupportsExpression$1(_, node) { + return new A.SupportsExpression(this.visitSupportsCondition$1(node.condition)); + }, + visitUnaryOperationExpression$1(_, node) { + return new A.UnaryOperationExpression(node.operator, node.operand.accept$1(this), node.span); + }, + visitValueExpression$1(_, node) { + return node; + }, + visitVariableExpression$1(_, node) { + return node; + }, + visitArgumentList$1(invocation) { + var t5, t6, _this = this, + t1 = invocation.positional, + t2 = type$.String, + t3 = type$.Expression, + t4 = A.LinkedHashMap_LinkedHashMap$_empty(t2, t3); + for (t5 = A.MapExtensions_get_pairs(invocation.named, t2, t3), t5 = t5.get$iterator(t5); t5.moveNext$0();) { + t6 = t5.get$current(t5); + t4.$indexSet(0, t6._0, t6._1.accept$1(_this)); + } + t5 = invocation.rest; + t5 = t5 == null ? null : t5.accept$1(_this); + t6 = invocation.keywordRest; + t6 = t6 == null ? null : t6.accept$1(_this); + return new A.ArgumentList(A.List_List$unmodifiable(new A.MappedListIterable(t1, new A.ReplaceExpressionVisitor_visitArgumentList_closure(_this), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Expression>")), t3), A.ConstantMap_ConstantMap$from(t4, t2, t3), t5, t6, invocation.span); + }, + visitSupportsCondition$1(condition) { + var _this = this; + if (condition instanceof A.SupportsOperation) + return A.SupportsOperation$(_this.visitSupportsCondition$1(condition.left), _this.visitSupportsCondition$1(condition.right), condition.operator, condition.span); + else if (condition instanceof A.SupportsNegation) + return new A.SupportsNegation(_this.visitSupportsCondition$1(condition.condition), condition.span); + else if (condition instanceof A.SupportsInterpolation) + return new A.SupportsInterpolation(condition.expression.accept$1(_this), condition.span); + else if (condition instanceof A.SupportsDeclaration) + return new A.SupportsDeclaration(condition.name.accept$1(_this), condition.value.accept$1(_this), condition.span); + else + throw A.wrapException(A.SassException$("BUG: Unknown SupportsCondition " + condition.toString$0(0) + ".", condition.get$span(condition), null)); + }, + visitInterpolation$1(interpolation) { + var t1 = interpolation.contents; + return A.Interpolation$(new A.MappedListIterable(t1, new A.ReplaceExpressionVisitor_visitInterpolation_closure(this), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Object>")), interpolation.spans, interpolation.span); + } + }; + A.ReplaceExpressionVisitor_visitListExpression_closure.prototype = { + call$1(item) { + return item.accept$1(this.$this); + }, + $signature: 190 + }; + A.ReplaceExpressionVisitor_visitArgumentList_closure.prototype = { + call$1(expression) { + return expression.accept$1(this.$this); + }, + $signature: 190 + }; + A.ReplaceExpressionVisitor_visitInterpolation_closure.prototype = { + call$1(node) { + return node instanceof A.Expression ? node.accept$1(this.$this) : node; + }, + $signature: 79 + }; + A.SelectorSearchVisitor.prototype = { + visitAttributeSelector$1(attribute) { + return null; + }, + visitClassSelector$1(klass) { + return null; + }, + visitIDSelector$1(id) { + return null; + }, + visitParentSelector$1(placeholder) { + return null; + }, + visitPlaceholderSelector$1(placeholder) { + return null; + }, + visitTypeSelector$1(type) { + return null; + }, + visitUniversalSelector$1(universal) { + return null; + }, + visitComplexSelector$1(complex) { + return A.IterableExtension_search(complex.components, new A.SelectorSearchVisitor_visitComplexSelector_closure(this)); + }, + visitCompoundSelector$1(compound) { + return A.IterableExtension_search(compound.components, new A.SelectorSearchVisitor_visitCompoundSelector_closure(this)); + }, + visitPseudoSelector$1(pseudo) { + return A.NullableExtension_andThen(pseudo.selector, this.get$visitSelectorList()); + }, + visitSelectorList$1(list) { + return A.IterableExtension_search(list.components, this.get$visitComplexSelector()); + } + }; + A.SelectorSearchVisitor_visitComplexSelector_closure.prototype = { + call$1(component) { + return this.$this.visitCompoundSelector$1(component.selector); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("SelectorSearchVisitor.T?(ComplexSelectorComponent)"); + } + }; + A.SelectorSearchVisitor_visitCompoundSelector_closure.prototype = { + call$1(simple) { + return simple.accept$1(this.$this); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("SelectorSearchVisitor.T?(SimpleSelector)"); + } + }; + A.serialize_closure.prototype = { + call$1(codeUnit) { + return codeUnit > 127; + }, + $signature: 48 + }; + A._SerializeVisitor.prototype = { + visitCssStylesheet$1(node) { + var t1, t2, t3, t4, t5, t6, previous, previous0, t7, _this = this; + for (t1 = J.get$iterator$ax(node.get$children(node)), t2 = !_this._inspect, t3 = _this._style === B.OutputStyle_1, t4 = !t3, t5 = type$.CssParentNode, t6 = _this._serialize$_buffer, previous = null; t1.moveNext$0();) { + previous0 = t1.get$current(t1); + if (t2) + t7 = t3 ? previous0.accept$1(B._IsInvisibleVisitor_true_true) : previous0.accept$1(B._IsInvisibleVisitor_true_false); + else + t7 = false; + if (t7) + continue; + if (previous != null) { + if (t5._is(previous) ? previous.get$isChildless() : !(previous instanceof A.ModifiableCssComment)) + t6.writeCharCode$1(59); + if (_this._isTrailingComment$2(previous0, previous)) { + if (t4) + t6.writeCharCode$1(32); + } else { + if (t4) + t6.write$1(0, "\n"); + if (previous.get$isGroupEnd()) + if (t4) + t6.write$1(0, "\n"); + } + } + previous0.accept$1(_this); + previous = previous0; + } + if (previous != null) + t1 = (t5._is(previous) ? previous.get$isChildless() : !(previous instanceof A.ModifiableCssComment)) && t4; + else + t1 = false; + if (t1) + t6.writeCharCode$1(59); + }, + visitCssComment$1(node) { + this._serialize$_buffer.forSpan$2(node.span, new A._SerializeVisitor_visitCssComment_closure(this, node)); + }, + visitCssAtRule$1(node) { + var t1, _this = this; + _this._writeIndentation$0(); + t1 = _this._serialize$_buffer; + t1.forSpan$2(node.span, new A._SerializeVisitor_visitCssAtRule_closure(_this, node)); + if (!node.isChildless) { + if (_this._style !== B.OutputStyle_1) + t1.writeCharCode$1(32); + _this._serialize$_visitChildren$1(node); + } + }, + visitCssMediaRule$1(node) { + var t1, _this = this; + _this._writeIndentation$0(); + t1 = _this._serialize$_buffer; + t1.forSpan$2(node.span, new A._SerializeVisitor_visitCssMediaRule_closure(_this, node)); + if (_this._style !== B.OutputStyle_1) + t1.writeCharCode$1(32); + _this._serialize$_visitChildren$1(node); + }, + visitCssImport$1(node) { + this._writeIndentation$0(); + this._serialize$_buffer.forSpan$2(node.span, new A._SerializeVisitor_visitCssImport_closure(this, node)); + }, + _writeImportUrl$1(url) { + var urlContents, maybeQuote, _this = this; + if (_this._style !== B.OutputStyle_1 || url.charCodeAt(0) !== 117) { + _this._serialize$_buffer.write$1(0, url); + return; + } + urlContents = B.JSString_methods.substring$2(url, 4, url.length - 1); + maybeQuote = urlContents.charCodeAt(0); + if (maybeQuote === 39 || maybeQuote === 34) + _this._serialize$_buffer.write$1(0, urlContents); + else + _this._visitQuotedString$1(urlContents); + }, + visitCssKeyframeBlock$1(node) { + var t1, _this = this; + _this._writeIndentation$0(); + t1 = _this._serialize$_buffer; + t1.forSpan$2(node.selector.span, new A._SerializeVisitor_visitCssKeyframeBlock_closure(_this, node)); + if (_this._style !== B.OutputStyle_1) + t1.writeCharCode$1(32); + _this._serialize$_visitChildren$1(node); + }, + _visitMediaQuery$1(query) { + var t1, _1_0, _2_0, condition, operator, t2, _this = this, + _0_0 = query.modifier; + if (_0_0 != null) { + t1 = _this._serialize$_buffer; + t1.write$1(0, _0_0); + t1.writeCharCode$1(32); + } + _1_0 = query.type; + if (_1_0 != null) { + t1 = _this._serialize$_buffer; + t1.write$1(0, _1_0); + if (query.conditions.length !== 0) + t1.write$1(0, " and "); + } + _2_0 = query.conditions; + if (_2_0.length === 1) + t1 = B.JSString_methods.startsWith$1(_2_0[0], "(not "); + else + t1 = false; + if (t1) { + t1 = _this._serialize$_buffer; + t1.write$1(0, "not "); + condition = B.JSArray_methods.get$first(_2_0); + t1.write$1(0, B.JSString_methods.substring$2(condition, 5, condition.length - 1)); + } else { + operator = query.conjunction ? "and" : "or"; + t1 = _this._style === B.OutputStyle_1 ? operator + " " : " " + operator + " "; + t2 = _this._serialize$_buffer; + _this._writeBetween$3(_2_0, t1, t2.get$write(t2)); + } + }, + visitCssStyleRule$1(node) { + var t1, _this = this; + _this._writeIndentation$0(); + t1 = _this._serialize$_buffer; + t1.forSpan$2(node._style_rule$_selector._box$_inner.value.span, new A._SerializeVisitor_visitCssStyleRule_closure(_this, node)); + if (_this._style !== B.OutputStyle_1) + t1.writeCharCode$1(32); + _this._serialize$_visitChildren$1(node); + }, + visitCssSupportsRule$1(node) { + var t1, _this = this; + _this._writeIndentation$0(); + t1 = _this._serialize$_buffer; + t1.forSpan$2(node.span, new A._SerializeVisitor_visitCssSupportsRule_closure(_this, node)); + if (_this._style !== B.OutputStyle_1) + t1.writeCharCode$1(32); + _this._serialize$_visitChildren$1(node); + }, + visitCssDeclaration$1(node) { + var error, stackTrace, error0, stackTrace0, t3, declSpecificities, t4, t5, t6, t7, _i, rule, ruleSpecificities, exception, _this = this, + t1 = node.interleavedRules, + t2 = t1.length; + if (t2 !== 0) { + t3 = node._parent; + t3.toString; + declSpecificities = _this._specificities$1(t3); + for (t3 = _this._serialize$_logger, t4 = node.span, t5 = type$.SourceSpan, t6 = type$.String, t7 = node.trace, _i = 0; _i < t2; ++_i) { + rule = t1[_i]; + ruleSpecificities = _this._specificities$1(rule); + if (!declSpecificities.any$1(0, ruleSpecificities.get$contains(ruleSpecificities))) + continue; + A.WarnForDeprecation_warnForDeprecation(t3, B.Deprecation_39u, string$.Sassx27s, new A.MultiSpan(t4, "declaration", A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_literal([rule.span, "nested rule"], t5, t6), t5, t6)), t7); + } + } + _this._writeIndentation$0(); + t1 = node.name; + _this._serialize$_write$1(t1); + t2 = _this._serialize$_buffer; + t2.writeCharCode$1(58); + if (J.startsWith$1$s(t1.value, "--") && node.parsedAsCustomProperty) + t2.forSpan$2(node.value.span, new A._SerializeVisitor_visitCssDeclaration_closure(_this, node)); + else { + if (_this._style !== B.OutputStyle_1) + t2.writeCharCode$1(32); + try { + t2.forSpan$2(node.valueSpanForMap, new A._SerializeVisitor_visitCssDeclaration_closure0(_this, node)); + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.MultiSpanSassScriptException) { + error = t1; + stackTrace = A.getTraceFromException(exception); + A.throwWithTrace(A.MultiSpanSassException$(error.message, node.value.span, error.primaryLabel, error.secondarySpans, null), error, stackTrace); + } else if (t1 instanceof A.SassScriptException) { + error0 = t1; + stackTrace0 = A.getTraceFromException(exception); + t1 = error0.message; + A.throwWithTrace(new A.SassException(B.Set_empty, t1, node.value.span), error0, stackTrace0); + } else + throw exception; + } + } + }, + _specificities$1(node) { + var $parent, t2, t3, _i, + t1 = this.get$_specificities(); + if (node instanceof A.ModifiableCssStyleRule) { + t1 = A.NullableExtension_andThen(node._parent, t1); + $parent = t1 == null ? null : A.IterableIntegerExtension_get_max(t1); + if ($parent == null) + $parent = 0; + t1 = A.LinkedHashSet_LinkedHashSet$_empty(type$.int); + for (t2 = node._style_rule$_selector._box$_inner.value.components, t3 = t2.length, _i = 0; _i < t3; ++_i) + t1.add$1(0, $parent + t2[_i].get$specificity()); + return t1; + } else { + t1 = A.NullableExtension_andThen(node.get$parent(node), t1); + return t1 == null ? B.Set_WDSXk : t1; + } + }, + _writeFoldedValue$1(node) { + var t1, t2, next, t3, + scanner = A.StringScanner$(type$.SassString._as(node.value.value)._string$_text, null, null); + for (t1 = scanner.string.length, t2 = this._serialize$_buffer; scanner._string_scanner$_position !== t1;) { + next = scanner.readChar$0(); + if (next !== 10) { + t2.writeCharCode$1(next); + continue; + } + t2.writeCharCode$1(32); + while (true) { + t3 = scanner.peekChar$0(); + if (!(t3 === 32 || t3 === 9 || t3 === 10 || t3 === 13 || t3 === 12)) + break; + scanner.readChar$0(); + } + } + }, + _writeReindentedValue$1(node) { + var _0_0, t1, _this = this, + value = type$.SassString._as(node.value.value)._string$_text; + $label0$0: { + _0_0 = _this._minimumIndentation$1(value); + if (_0_0 == null) { + _this._serialize$_buffer.write$1(0, value); + break $label0$0; + } + if (-1 === _0_0) { + t1 = _this._serialize$_buffer; + t1.write$1(0, A.trimAsciiRight(value, true)); + t1.writeCharCode$1(32); + break $label0$0; + } + t1 = node.name.span; + t1 = t1.get$start(t1); + _this._writeWithIndent$2(value, Math.min(_0_0, t1.file.getColumn$1(t1.offset))); + } + }, + _minimumIndentation$1(text) { + var character, t2, min, next, min0, + scanner = A.LineScanner$(text), + t1 = scanner.string.length; + while (true) { + if (scanner._string_scanner$_position !== t1) { + character = scanner.super$StringScanner$readChar(); + scanner._adjustLineAndColumn$1(character); + t2 = character !== 10; + } else + t2 = false; + if (!t2) + break; + } + if (scanner._string_scanner$_position === t1) + return scanner.peekChar$1(-1) === 10 ? -1 : null; + for (min = null; scanner._string_scanner$_position !== t1;) { + for (; scanner._string_scanner$_position !== t1;) { + next = scanner.peekChar$0(); + if (next !== 32 && next !== 9) + break; + scanner._adjustLineAndColumn$1(scanner.super$StringScanner$readChar()); + } + if (scanner._string_scanner$_position === t1 || scanner.scanChar$1(10)) + continue; + min0 = scanner._line_scanner$_column; + min = min == null ? min0 : Math.min(min, min0); + while (true) { + if (scanner._string_scanner$_position !== t1) { + character = scanner.super$StringScanner$readChar(); + scanner._adjustLineAndColumn$1(character); + t2 = character !== 10; + } else + t2 = false; + if (!t2) + break; + } + } + return min == null ? -1 : min; + }, + _writeWithIndent$2(text, minimumIndentation) { + var t1, t2, t3, character, lineStart, newlines, end, + scanner = A.LineScanner$(text); + for (t1 = scanner.string, t2 = t1.length, t3 = this._serialize$_buffer; scanner._string_scanner$_position !== t2;) { + character = scanner.super$StringScanner$readChar(); + scanner._adjustLineAndColumn$1(character); + if (character === 10) + break; + t3.writeCharCode$1(character); + } + for (; true;) { + lineStart = scanner._string_scanner$_position; + for (newlines = 1; true;) { + if (scanner._string_scanner$_position === t2) { + t3.writeCharCode$1(32); + return; + } + $label0$2: { + character = scanner.super$StringScanner$readChar(); + scanner._adjustLineAndColumn$1(character); + if (32 === character || 9 === character) + continue; + if (10 === character) { + lineStart = scanner._string_scanner$_position; + ++newlines; + break $label0$2; + } + break; + } + } + this._writeTimes$2(10, newlines); + this._writeIndentation$0(); + end = scanner._string_scanner$_position; + t3.write$1(0, B.JSString_methods.substring$2(t1, lineStart + minimumIndentation, end)); + for (; true;) { + if (scanner._string_scanner$_position === t2) + return; + character = scanner.super$StringScanner$readChar(); + scanner._adjustLineAndColumn$1(character); + if (character === 10) + break; + t3.writeCharCode$1(character); + } + } + }, + visitCalculation$1(value) { + var t2, _this = this, + t1 = _this._serialize$_buffer; + t1.write$1(0, value.name); + t1.writeCharCode$1(40); + t2 = _this._style === B.OutputStyle_1 ? "," : ", "; + _this._writeBetween$3(value.$arguments, t2, _this.get$_writeCalculationValue()); + t1.writeCharCode$1(41); + }, + _writeCalculationValue$1(value) { + var _2_4_isSet, _2_4, t1, _0_0, _1_0, first, rest, left, right, operator, parenthesizeLeft, operatorWhitespace, parenthesizeRight, t2, _this = this, _null = null; + $label1$1: { + _2_4_isSet = value instanceof A.SassNumber; + if (_2_4_isSet) { + _2_4 = value.get$hasComplexUnits(); + t1 = _2_4 && !_this._inspect; + } else { + _2_4 = _null; + t1 = false; + } + if (t1) + throw A.wrapException(A.SassScriptException$(A.S(value) + " isn't a valid CSS value.", _null)); + if (_2_4_isSet && !isFinite(value._number$_value)) { + $label0$0: { + _0_0 = value._number$_value; + if (1 / 0 === _0_0) { + _this._serialize$_buffer.write$1(0, "infinity"); + break $label0$0; + } + if (-1 / 0 === _0_0) { + _this._serialize$_buffer.write$1(0, "-infinity"); + break $label0$0; + } + if (isNaN(_0_0)) + _this._serialize$_buffer.write$1(0, "NaN"); + } + t1 = J.getInterceptor$x(value); + _this._writeCalculationUnits$2(t1.get$numeratorUnits(value), t1.get$denominatorUnits(value)); + break $label1$1; + } + if (_2_4_isSet) + t1 = _2_4; + else + t1 = false; + if (t1) { + _this._writeNumber$1(value._number$_value); + t1 = J.getInterceptor$x(value); + _1_0 = t1.get$numeratorUnits(value); + if (_1_0.length >= 1) { + first = _1_0[0]; + rest = B.JSArray_methods.sublist$1(_1_0, 1); + _this._serialize$_buffer.write$1(0, first); + _this._writeCalculationUnits$2(rest, t1.get$denominatorUnits(value)); + } else + _this._writeCalculationUnits$2(A._setArrayType([], type$.JSArray_String), t1.get$denominatorUnits(value)); + break $label1$1; + } + if (value instanceof A.Value) { + value.accept$1(_this); + break $label1$1; + } + t1 = value instanceof A.CalculationOperation; + left = _null; + right = _null; + if (t1) { + operator = value._operator; + left = value._left; + right = value._right; + right = right; + } else + operator = _null; + if (t1) { + parenthesizeLeft = left instanceof A.CalculationOperation && left._operator.precedence < operator.precedence; + if (parenthesizeLeft) + _this._serialize$_buffer.writeCharCode$1(40); + _this._writeCalculationValue$1(left); + if (parenthesizeLeft) + _this._serialize$_buffer.writeCharCode$1(41); + operatorWhitespace = _this._style !== B.OutputStyle_1 || operator.precedence === 1; + if (operatorWhitespace) + _this._serialize$_buffer.writeCharCode$1(32); + t1 = _this._serialize$_buffer; + t1.write$1(0, operator.operator); + if (operatorWhitespace) + t1.writeCharCode$1(32); + if (!(right instanceof A.CalculationOperation && _this._parenthesizeCalculationRhs$2(operator, right._operator))) { + parenthesizeRight = false; + if (operator === B.CalculationOperator_bo5) { + if (right instanceof A.SassNumber) + t2 = isFinite(right._number$_value) ? right.get$hasComplexUnits() : right.get$hasUnits(); + else + t2 = parenthesizeRight; + parenthesizeRight = t2; + } + } else + parenthesizeRight = true; + if (parenthesizeRight) + t1.writeCharCode$1(40); + _this._writeCalculationValue$1(right); + if (parenthesizeRight) + t1.writeCharCode$1(41); + } + } + }, + _writeCalculationUnits$2(numeratorUnits, denominatorUnits) { + var t1, t2, t3, t4; + for (t1 = J.get$iterator$ax(numeratorUnits), t2 = this._serialize$_buffer, t3 = this._style !== B.OutputStyle_1; t1.moveNext$0();) { + t4 = t1.get$current(t1); + if (t3) + t2.writeCharCode$1(32); + t2.writeCharCode$1(42); + if (t3) + t2.writeCharCode$1(32); + t2.writeCharCode$1(49); + t2.write$1(0, t4); + } + for (t1 = J.get$iterator$ax(denominatorUnits); t1.moveNext$0();) { + t4 = t1.get$current(t1); + if (t3) + t2.writeCharCode$1(32); + t2.writeCharCode$1(47); + if (t3) + t2.writeCharCode$1(32); + t2.writeCharCode$1(49); + t2.write$1(0, t4); + } + }, + _parenthesizeCalculationRhs$2(outer, right) { + var t1; + $label0$0: { + if (B.CalculationOperator_bo5 === outer) { + t1 = true; + break $label0$0; + } + if (B.CalculationOperator_F7i === outer) { + t1 = false; + break $label0$0; + } + t1 = right === B.CalculationOperator_F7i || right === B.CalculationOperator_oum; + break $label0$0; + } + return t1; + }, + visitColor$1(value) { + var _0_0, _0_2, _0_6, t1, _0_4, _0_6_isSet, t2, _0_10_isSet, _0_10, _0_12_isSet, _0_14, _0_12, _0_14_isSet, t3, _0_10_isSet0, polar, t4, t5, _this = this, _null = null; + $label0$0: { + _0_0 = value._space; + _0_2 = B.RgbColorSpace_i0P === _0_0; + _0_6 = _null; + t1 = true; + if (!_0_2) { + _0_4 = B.HslColorSpace_JQ2 === _0_0; + _0_6_isSet = !_0_4; + if (_0_6_isSet) { + _0_6 = B.HwbColorSpace_guQ === _0_0; + t1 = _0_6; + } + } else { + _0_4 = _null; + _0_6_isSet = false; + } + if (t1 && value.channel0OrNull != null && value.channel1OrNull != null && value.channel2OrNull != null && value.alphaOrNull != null) { + _this._writeLegacyColor$1(value); + break $label0$0; + } + if (_0_2) { + t1 = _this._serialize$_buffer; + t1.write$1(0, "rgb("); + _this._writeChannel$1(value.channel0OrNull); + t1.writeCharCode$1(32); + _this._writeChannel$1(value.channel1OrNull); + t1.writeCharCode$1(32); + _this._writeChannel$1(value.channel2OrNull); + _this._maybeWriteSlashAlpha$1(value); + t1.writeCharCode$1(41); + break $label0$0; + } + if (!_0_4) + t1 = _0_6_isSet ? _0_6 : B.HwbColorSpace_guQ === _0_0; + else + t1 = true; + if (t1) { + t1 = _this._serialize$_buffer; + t1.write$1(0, _0_0); + t1.writeCharCode$1(40); + t2 = _this._style === B.OutputStyle_1 ? _null : "deg"; + _this._writeChannel$2(value.channel0OrNull, t2); + t1.writeCharCode$1(32); + _this._writeChannel$2(value.channel1OrNull, "%"); + t1.writeCharCode$1(32); + _this._writeChannel$2(value.channel2OrNull, "%"); + _this._maybeWriteSlashAlpha$1(value); + t1.writeCharCode$1(41); + break $label0$0; + } + _0_10_isSet = B.LabColorSpace_2nT !== _0_0; + if (_0_10_isSet) { + _0_10 = B.LchColorSpace_Bpv === _0_0; + t1 = _0_10; + } else { + _0_10 = _null; + t1 = true; + } + t2 = false; + if (t1) + if (!_this._inspect) { + t1 = value.channel0OrNull; + if (t1 == null) + t1 = 0; + if (t1 > 0 || A.fuzzyEquals(t1, 0)) + t1 = t1 < 100 || A.fuzzyEquals(t1, 100); + else + t1 = false; + t1 = !t1 && value.channel1OrNull != null && value.channel2OrNull != null; + } else + t1 = t2; + else + t1 = t2; + _0_12_isSet = !t1; + _0_14 = _null; + if (_0_12_isSet) { + _0_12 = B.OklabColorSpace_540 === _0_0; + t1 = false; + _0_14_isSet = !_0_12; + if (_0_14_isSet) { + _0_14 = B.OklchColorSpace_9Gj === _0_0; + t2 = _0_14; + } else + t2 = true; + t3 = false; + if (t2) + if (!_this._inspect) { + t2 = value.channel0OrNull; + if (t2 == null) + t2 = 0; + if (t2 > 0 || A.fuzzyEquals(t2, 0)) + t2 = t2 < 1 || A.fuzzyEquals(t2, 1); + else + t2 = false; + t2 = !t2 && value.channel1OrNull != null && value.channel2OrNull != null; + } else + t2 = t3; + else + t2 = t3; + if (!t2) { + if (_0_10_isSet) { + t2 = _0_10; + _0_10_isSet0 = _0_10_isSet; + } else { + _0_10 = B.LchColorSpace_Bpv === _0_0; + t2 = _0_10; + _0_10_isSet0 = true; + } + if (!t2) + if (_0_14_isSet) + t2 = _0_14; + else { + _0_14 = B.OklchColorSpace_9Gj === _0_0; + t2 = _0_14; + _0_14_isSet = true; + } + else + t2 = true; + if (t2) + if (!_this._inspect) { + t1 = value.channel1OrNull; + t2 = t1 == null; + if (t2) + t1 = 0; + t1 = t1 < 0 && !A.fuzzyEquals(t1, 0) && value.channel0OrNull != null && !t2; + } + } else { + _0_10_isSet0 = _0_10_isSet; + t1 = true; + } + } else { + _0_12 = _null; + _0_10_isSet0 = _0_10_isSet; + _0_14_isSet = false; + t1 = true; + } + if (t1) { + t1 = _this._serialize$_buffer; + t1.write$1(0, "color-mix(in "); + t1.write$1(0, _0_0); + t2 = _this._style === B.OutputStyle_1; + t1.write$1(0, t2 ? "," : ", "); + _this._writeColorFunction$1(value.toSpace$1(B.XyzD65ColorSpace_WiJ)); + if (!t2) + t1.writeCharCode$1(32); + t1.write$1(0, "100%"); + t1.write$1(0, t2 ? "," : ", "); + t1.write$1(0, t2 ? "red" : "black"); + t1.writeCharCode$1(41); + break $label0$0; + } + t1 = true; + if (_0_10_isSet) + if (!(_0_12_isSet ? _0_12 : B.OklabColorSpace_540 === _0_0)) + if (!(_0_10_isSet0 ? _0_10 : B.LchColorSpace_Bpv === _0_0)) + t1 = _0_14_isSet ? _0_14 : B.OklchColorSpace_9Gj === _0_0; + if (t1) { + t1 = _this._serialize$_buffer; + t1.write$1(0, _0_0); + t1.writeCharCode$1(40); + t2 = _0_0._channels; + polar = t2[2].isPolarAngle; + t3 = false; + if (!_this._inspect) { + t4 = value.channel0OrNull; + if (t4 == null) + t4 = 0; + if (t4 > 0 || A.fuzzyEquals(t4, 0)) + t4 = t4 < 100 || A.fuzzyEquals(t4, 100); + else + t4 = false; + if (t4) { + if (polar) { + t3 = value.channel1OrNull; + if (t3 == null) + t3 = 0; + t3 = t3 < 0 && !A.fuzzyEquals(t3, 0); + } + } else + t3 = true; + } + if (t3) { + t1.write$1(0, "from "); + t1.write$1(0, _this._style === B.OutputStyle_1 ? "red" : "black"); + t1.writeCharCode$1(32); + } + t3 = _this._style !== B.OutputStyle_1; + t4 = t3 && value.channel0OrNull != null; + t5 = value.channel0OrNull; + if (t4) { + t2 = type$.LinearChannel._as(t2[0]); + _this._writeNumber$1((t5 == null ? 0 : t5) * 100 / t2.max); + t1.writeCharCode$1(37); + } else + _this._writeChannel$1(t5); + t1.writeCharCode$1(32); + _this._writeChannel$1(value.channel1OrNull); + t1.writeCharCode$1(32); + t2 = polar && t3 ? "deg" : _null; + _this._writeChannel$2(value.channel2OrNull, t2); + _this._maybeWriteSlashAlpha$1(value); + t1.writeCharCode$1(41); + break $label0$0; + } + _this._writeColorFunction$1(value); + } + }, + _writeChannel$2(channel, unit) { + var _this = this; + if (channel == null) + _this._serialize$_buffer.write$1(0, "none"); + else if (isFinite(channel)) { + _this._writeNumber$1(channel); + if (unit != null) + _this._serialize$_buffer.write$1(0, unit); + } else + _this.visitNumber$1(A.SassNumber_SassNumber(channel, unit)); + }, + _writeChannel$1(channel) { + return this._writeChannel$2(channel, null); + }, + _writeLegacyColor$1(color) { + var rgb, t3, red, green, blue, hsl, hue, saturation, lightness, hwb, _0_0, format, _1_0, _this = this, + t1 = color.alphaOrNull, + t2 = t1 == null, + opaque = A.fuzzyEquals(t2 ? 0 : t1, 1); + if (!color.get$isInGamut() && !_this._inspect) { + _this._writeHsl$1(color); + return; + } + if (_this._style === B.OutputStyle_1) { + rgb = color.toSpace$1(B.RgbColorSpace_i0P); + if (opaque && _this._tryIntegerRgb$1(rgb)) + return; + t3 = rgb.channel0OrNull; + red = _this._writeNumberToString$1(t3 == null ? 0 : t3); + t3 = rgb.channel1OrNull; + green = _this._writeNumberToString$1(t3 == null ? 0 : t3); + t3 = rgb.channel2OrNull; + blue = _this._writeNumberToString$1(t3 == null ? 0 : t3); + hsl = color.toSpace$1(B.HslColorSpace_JQ2); + t3 = hsl.channel0OrNull; + hue = _this._writeNumberToString$1(t3 == null ? 0 : t3); + t3 = hsl.channel1OrNull; + saturation = _this._writeNumberToString$1(t3 == null ? 0 : t3); + t3 = hsl.channel2OrNull; + lightness = _this._writeNumberToString$1(t3 == null ? 0 : t3); + t3 = _this._serialize$_buffer; + if (red.length + green.length + blue.length <= hue.length + saturation.length + lightness.length + 2) { + t3.write$1(0, opaque ? "rgb(" : "rgba("); + t3.write$1(0, red); + t3.writeCharCode$1(44); + t3.write$1(0, green); + t3.writeCharCode$1(44); + t3.write$1(0, blue); + } else { + t3.write$1(0, opaque ? "hsl(" : "hsla("); + t3.write$1(0, hue); + t3.writeCharCode$1(44); + t3.write$1(0, saturation); + t3.write$1(0, "%,"); + t3.write$1(0, lightness); + t3.writeCharCode$1(37); + } + if (!opaque) { + t3.writeCharCode$1(44); + _this._writeNumber$1(t2 ? 0 : t1); + } + t3.writeCharCode$1(41); + return; + } + t3 = color._space; + if (t3 === B.HslColorSpace_JQ2) { + _this._writeHsl$1(color); + return; + } else if (_this._inspect && t3 === B.HwbColorSpace_guQ) { + t3 = _this._serialize$_buffer; + t3.write$1(0, "hwb("); + hwb = color.toSpace$1(B.HwbColorSpace_guQ); + _this._writeNumber$1(hwb.channel$1(0, "hue")); + t3.writeCharCode$1(32); + _this._writeNumber$1(hwb.channel$1(0, "whiteness")); + t3.writeCharCode$1(37); + t3.writeCharCode$1(32); + _this._writeNumber$1(hwb.channel$1(0, "blackness")); + t3.writeCharCode$1(37); + if (!A.fuzzyEquals(t2 ? 0 : t1, 1)) { + t3.write$1(0, " / "); + _this._writeNumber$1(t2 ? 0 : t1); + } + t3.writeCharCode$1(41); + return; + } + _0_0 = color.format; + if (B.C__ColorFormatEnum === _0_0) { + _this._writeRgb$1(color); + return; + } + t1 = _0_0 instanceof A.SpanColorFormat; + format = t1 ? _0_0 : null; + if (t1) { + t1 = format._color$_span; + _this._serialize$_buffer.write$1(0, A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1.file._decodedChars, t1._file$_start, t1._end), 0, null)); + return; + } + if (opaque) { + rgb = color.toSpace$1(B.RgbColorSpace_i0P); + _1_0 = $.$get$namesByColor().$index(0, rgb); + if (_1_0 != null) { + _this._serialize$_buffer.write$1(0, _1_0); + return; + } + if (_this._canUseHex$1(rgb)) { + _this._serialize$_buffer.writeCharCode$1(35); + t1 = rgb.channel0OrNull; + _this._writeHexComponent$1(B.JSNumber_methods.round$0(t1 == null ? 0 : t1)); + t1 = rgb.channel1OrNull; + _this._writeHexComponent$1(B.JSNumber_methods.round$0(t1 == null ? 0 : t1)); + t1 = rgb.channel2OrNull; + _this._writeHexComponent$1(B.JSNumber_methods.round$0(t1 == null ? 0 : t1)); + return; + } + } + if (t3 === B.HwbColorSpace_guQ) + _this._writeHsl$1(color); + else + _this._writeRgb$1(color); + }, + _tryIntegerRgb$1(rgb) { + var t1, redInt, greenInt, blueInt, shortHex, _0_0, t2, t3, $name, _this = this; + if (!_this._canUseHex$1(rgb)) + return false; + t1 = rgb.channel0OrNull; + redInt = B.JSNumber_methods.round$0(t1 == null ? 0 : t1); + t1 = rgb.channel1OrNull; + greenInt = B.JSNumber_methods.round$0(t1 == null ? 0 : t1); + t1 = rgb.channel2OrNull; + blueInt = B.JSNumber_methods.round$0(t1 == null ? 0 : t1); + t1 = redInt & 15; + shortHex = t1 === B.JSInt_methods._shrOtherPositive$1(redInt, 4) && (greenInt & 15) === B.JSInt_methods._shrOtherPositive$1(greenInt, 4) && (blueInt & 15) === B.JSInt_methods._shrOtherPositive$1(blueInt, 4); + _0_0 = $.$get$namesByColor().$index(0, rgb); + t2 = false; + if (_0_0 != null) { + t3 = _0_0.length; + t2 = t3 <= (shortHex ? 4 : 7); + $name = _0_0; + } else + $name = null; + if (t2) + _this._serialize$_buffer.write$1(0, $name); + else { + t2 = _this._serialize$_buffer; + if (shortHex) { + t2.writeCharCode$1(35); + t2.writeCharCode$1(A.hexCharFor(t1)); + t2.writeCharCode$1(A.hexCharFor(greenInt & 15)); + t2.writeCharCode$1(A.hexCharFor(blueInt & 15)); + } else { + t2.writeCharCode$1(35); + _this._writeHexComponent$1(redInt); + _this._writeHexComponent$1(greenInt); + _this._writeHexComponent$1(blueInt); + } + } + return true; + }, + _canUseHex$1(rgb) { + var t2, + t1 = rgb.channel0OrNull; + if (t1 == null) + t1 = 0; + if (A.fuzzyIsInt(t1)) + t1 = (t1 > 0 || A.fuzzyEquals(t1, 0)) && t1 < 256 && !A.fuzzyEquals(t1, 256); + else + t1 = false; + t2 = false; + if (t1) { + t1 = rgb.channel1OrNull; + if (t1 == null) + t1 = 0; + if (A.fuzzyIsInt(t1)) + t1 = (t1 > 0 || A.fuzzyEquals(t1, 0)) && t1 < 256 && !A.fuzzyEquals(t1, 256); + else + t1 = false; + if (t1) { + t1 = rgb.channel2OrNull; + if (t1 == null) + t1 = 0; + if (A.fuzzyIsInt(t1)) + t1 = (t1 > 0 || A.fuzzyEquals(t1, 0)) && t1 < 256 && !A.fuzzyEquals(t1, 256); + else + t1 = t2; + } else + t1 = t2; + } else + t1 = t2; + return t1; + }, + _writeRgb$1(color) { + var t4, _this = this, + t1 = color.alphaOrNull, + t2 = t1 == null, + opaque = A.fuzzyEquals(t2 ? 0 : t1, 1), + rgb = color.toSpace$1(B.RgbColorSpace_i0P), + t3 = _this._serialize$_buffer; + t3.write$1(0, opaque ? "rgb(" : "rgba("); + _this._writeNumber$1(rgb.channel$1(0, "red")); + t4 = _this._style === B.OutputStyle_1; + t3.write$1(0, t4 ? "," : ", "); + _this._writeNumber$1(rgb.channel$1(0, "green")); + t3.write$1(0, t4 ? "," : ", "); + _this._writeNumber$1(rgb.channel$1(0, "blue")); + if (!opaque) { + t3.write$1(0, t4 ? "," : ", "); + _this._writeNumber$1(t2 ? 0 : t1); + } + t3.writeCharCode$1(41); + }, + _writeHsl$1(color) { + var t4, _this = this, + t1 = color.alphaOrNull, + t2 = t1 == null, + opaque = A.fuzzyEquals(t2 ? 0 : t1, 1), + hsl = color.toSpace$1(B.HslColorSpace_JQ2), + t3 = _this._serialize$_buffer; + t3.write$1(0, opaque ? "hsl(" : "hsla("); + _this._writeChannel$1(hsl.channel$1(0, "hue")); + t4 = _this._style === B.OutputStyle_1; + t3.write$1(0, t4 ? "," : ", "); + _this._writeChannel$2(hsl.channel$1(0, "saturation"), "%"); + t3.write$1(0, t4 ? "," : ", "); + _this._writeChannel$2(hsl.channel$1(0, "lightness"), "%"); + if (!opaque) { + t3.write$1(0, t4 ? "," : ", "); + _this._writeNumber$1(t2 ? 0 : t1); + } + t3.writeCharCode$1(41); + }, + _writeColorFunction$1(color) { + var _this = this, + t1 = _this._serialize$_buffer; + t1.write$1(0, "color("); + t1.write$1(0, color._space); + t1.writeCharCode$1(32); + _this._writeBetween$3(color.get$channelsOrNull(), " ", _this.get$_writeChannel()); + _this._maybeWriteSlashAlpha$1(color); + t1.writeCharCode$1(41); + }, + _writeHexComponent$1(color) { + var t1 = this._serialize$_buffer; + t1.writeCharCode$1(A.hexCharFor(B.JSInt_methods._shrOtherPositive$1(color, 4))); + t1.writeCharCode$1(A.hexCharFor(color & 15)); + }, + _maybeWriteSlashAlpha$1(color) { + var t2, t3, _this = this, + t1 = color.alphaOrNull; + if (A.fuzzyEquals(t1 == null ? 0 : t1, 1)) + return; + t2 = _this._style !== B.OutputStyle_1; + if (t2) + _this._serialize$_buffer.writeCharCode$1(32); + t3 = _this._serialize$_buffer; + t3.writeCharCode$1(47); + if (t2) + t3.writeCharCode$1(32); + _this._writeChannel$1(t1); + }, + visitList$1(value) { + var t2, singleton, t3, t4, t5, _this = this, + t1 = value._hasBrackets; + if (t1) + _this._serialize$_buffer.writeCharCode$1(91); + else if (value._list$_contents.length === 0) { + if (!_this._inspect) + throw A.wrapException(A.SassScriptException$("() isn't a valid CSS value.", null)); + _this._serialize$_buffer.write$1(0, "()"); + return; + } + t2 = _this._inspect; + singleton = false; + if (t2) + if (value._list$_contents.length === 1) { + t3 = value._separator; + t3 = t3 === B.ListSeparator_qVN || t3 === B.ListSeparator_bRz; + singleton = t3; + } + if (singleton && !t1) + _this._serialize$_buffer.writeCharCode$1(40); + t3 = value._list$_contents; + t3 = t2 ? t3 : new A.WhereIterable(t3, new A._SerializeVisitor_visitList_closure(), A._arrayInstanceType(t3)._eval$1("WhereIterable<1>")); + t4 = value._separator; + t5 = _this._separatorString$1(t4); + _this._writeBetween$3(t3, t5, t2 ? new A._SerializeVisitor_visitList_closure0(_this, value) : new A._SerializeVisitor_visitList_closure1(_this)); + if (singleton) { + t2 = _this._serialize$_buffer; + t2.write$1(0, t4.separator); + if (!t1) + t2.writeCharCode$1(41); + } + if (t1) + _this._serialize$_buffer.writeCharCode$1(93); + }, + _separatorString$1(separator) { + var t1; + $label0$0: { + if (B.ListSeparator_qVN === separator) { + t1 = this._style === B.OutputStyle_1 ? "," : ", "; + break $label0$0; + } + if (B.ListSeparator_bRz === separator) { + t1 = this._style === B.OutputStyle_1 ? "/" : " / "; + break $label0$0; + } + if (B.ListSeparator_qSL === separator) { + t1 = " "; + break $label0$0; + } + t1 = ""; + break $label0$0; + } + return t1; + }, + _elementNeedsParens$2(separator, value) { + var t1; + $label1$1: { + if (value instanceof A.SassList && value._list$_contents.length > 1 && !value._hasBrackets) { + $label0$0: { + if (B.ListSeparator_qVN === separator) { + t1 = value._separator === B.ListSeparator_qVN; + break $label0$0; + } + if (B.ListSeparator_bRz === separator) { + t1 = value._separator; + t1 = t1 === B.ListSeparator_qVN || t1 === B.ListSeparator_bRz; + break $label0$0; + } + t1 = value._separator !== B.ListSeparator_undecided_null_undecided; + break $label0$0; + } + break $label1$1; + } + t1 = false; + break $label1$1; + } + return t1; + }, + visitMap$1(map) { + var t1, t2, _this = this; + if (!_this._inspect) + throw A.wrapException(A.SassScriptException$(map.toString$0(0) + " isn't a valid CSS value.", null)); + t1 = _this._serialize$_buffer; + t1.writeCharCode$1(40); + t2 = map._map$_contents; + _this._writeBetween$3(t2.get$entries(t2), ", ", new A._SerializeVisitor_visitMap_closure(_this)); + t1.writeCharCode$1(41); + }, + _writeMapElement$1(value) { + var needsParens = value instanceof A.SassList && value._separator === B.ListSeparator_qVN && !value._hasBrackets; + if (needsParens) + this._serialize$_buffer.writeCharCode$1(40); + value.accept$1(this); + if (needsParens) + this._serialize$_buffer.writeCharCode$1(41); + }, + visitNumber$1(value) { + var before, after, t1, _1_0, _this = this, + _0_0 = value.asSlash; + if (type$.Record_2_nullable_Object_and_nullable_Object._is(_0_0)) { + before = _0_0._0; + after = _0_0._1; + _this.visitNumber$1(before); + _this._serialize$_buffer.writeCharCode$1(47); + _this.visitNumber$1(after); + return; + } + t1 = value._number$_value; + if (!isFinite(t1)) { + _this.visitCalculation$1(new A.SassCalculation("calc", A.List_List$unmodifiable(A._setArrayType([value], type$.JSArray_Object), type$.Object))); + return; + } + if (value.get$hasComplexUnits()) { + if (!_this._inspect) + throw A.wrapException(A.SassScriptException$(value.toString$0(0) + " isn't a valid CSS value.", null)); + _this.visitCalculation$1(new A.SassCalculation("calc", A.List_List$unmodifiable(A._setArrayType([value], type$.JSArray_Object), type$.Object))); + } else { + _this._writeNumber$1(t1); + _1_0 = value.get$numeratorUnits(value); + if (_1_0.length === 1) + _this._serialize$_buffer.write$1(0, _1_0[0]); + } + }, + _writeNumberToString$1(number) { + var t1 = new A.StringBuffer(""); + this._writeNumber$2(number, new A.NoSourceMapBuffer(t1)); + t1 = t1._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _writeNumber$2(number, buffer) { + var _0_0, text, _this = this; + if (buffer == null) + buffer = _this._serialize$_buffer; + _0_0 = A.fuzzyAsInt(number); + if (_0_0 != null) { + buffer.write$1(0, _this._removeExponent$1(B.JSInt_methods.toString$0(_0_0))); + return; + } + text = _this._removeExponent$1(B.JSNumber_methods.toString$0(number)); + if (text.length < 12) { + buffer.write$1(0, _this._style === B.OutputStyle_1 && text.charCodeAt(0) === 48 ? B.JSString_methods.substring$1(text, 1) : text); + return; + } + _this._writeRounded$2(text, buffer); + }, + _writeNumber$1(number) { + return this._writeNumber$2(number, null); + }, + _removeExponent$1(text) { + var buffer, t2, t3, additionalZeroes, + negative = text.charCodeAt(0) === 45, + exponent = A._Cell$(), + t1 = text.length, + i = 0; + while (true) { + if (!(i < t1)) { + buffer = null; + break; + } + c$0: { + if (text.charCodeAt(i) !== 101) + break c$0; + buffer = new A.StringBuffer(""); + t2 = buffer._contents = "" + A.Primitives_stringFromCharCode(text.charCodeAt(0)); + if (negative) { + t2 += A.Primitives_stringFromCharCode(text.charCodeAt(1)); + buffer._contents = t2; + if (i > 3) + buffer._contents = t2 + B.JSString_methods.substring$2(text, 3, i); + } else if (i > 2) + buffer._contents = t2 + B.JSString_methods.substring$2(text, 2, i); + exponent.__late_helper$_value = A.int_parse(B.JSString_methods.substring$2(text, i + 1, t1), null); + break; + } + ++i; + } + if (buffer == null) + return text; + if (exponent._readLocal$0() > 0) { + t1 = exponent._readLocal$0(); + t2 = buffer._contents; + t3 = negative ? 1 : 0; + additionalZeroes = t1 - (t2.length - 1 - t3); + for (t1 = t2, i = 0; i < additionalZeroes; ++i) { + t1 = A.Primitives_stringFromCharCode(48); + t1 = buffer._contents += t1; + } + return t1.charCodeAt(0) == 0 ? t1 : t1; + } else { + negative = text.charCodeAt(0) === 45; + t1 = (negative ? "" + A.Primitives_stringFromCharCode(45) : "") + "0."; + i = -1; + while (true) { + t2 = exponent.__late_helper$_value; + if (t2 === exponent) + A.throwExpression(A.LateError$localNI("")); + if (!(i > t2)) + break; + t1 += A.Primitives_stringFromCharCode(48); + --i; + } + if (negative) { + t2 = buffer._contents; + t2 = B.JSString_methods.substring$1(t2.charCodeAt(0) == 0 ? t2 : t2, 1); + } else + t2 = buffer; + t2 = t1 + A.S(t2); + return t2.charCodeAt(0) == 0 ? t2 : t2; + } + }, + _writeRounded$2(text, buffer) { + var t1, digits, negative, textIndex, digitsIndex, textIndex0, codeUnit, digitsIndex0, indexAfterPrecision, digitsIndex1, newDigit, writtenIndex; + if (B.JSString_methods.endsWith$1(text, ".0")) { + buffer.write$1(0, B.JSString_methods.substring$2(text, 0, text.length - 2)); + return; + } + t1 = text.length; + digits = new Uint8Array(t1 + 1); + negative = text.charCodeAt(0) === 45; + textIndex = negative ? 1 : 0; + for (digitsIndex = 1; true; textIndex = textIndex0, digitsIndex = digitsIndex0) { + if (textIndex === t1) { + buffer.write$1(0, text); + return; + } + textIndex0 = textIndex + 1; + codeUnit = text.charCodeAt(textIndex); + if (codeUnit === 46) { + textIndex = textIndex0; + break; + } + digitsIndex0 = digitsIndex + 1; + digits[digitsIndex] = codeUnit - 48; + } + indexAfterPrecision = textIndex + 10; + if (indexAfterPrecision >= t1) { + buffer.write$1(0, text); + return; + } + for (digitsIndex0 = digitsIndex; textIndex < indexAfterPrecision; textIndex = textIndex0, digitsIndex0 = digitsIndex1) { + digitsIndex1 = digitsIndex0 + 1; + textIndex0 = textIndex + 1; + digits[digitsIndex0] = text.charCodeAt(textIndex) - 48; + } + if (text.charCodeAt(textIndex) - 48 >= 5) + for (; true; digitsIndex0 = digitsIndex1) { + digitsIndex1 = digitsIndex0 - 1; + newDigit = digits[digitsIndex1] + 1; + digits[digitsIndex1] = newDigit; + if (newDigit !== 10) + break; + } + for (; digitsIndex0 < digitsIndex; ++digitsIndex0) + digits[digitsIndex0] = 0; + while (true) { + t1 = digitsIndex0 > digitsIndex; + if (!(t1 && digits[digitsIndex0 - 1] === 0)) + break; + --digitsIndex0; + } + if (digitsIndex0 === 2 && digits[0] === 0 && digits[1] === 0) { + buffer.writeCharCode$1(48); + return; + } + if (negative) + buffer.writeCharCode$1(45); + if (digits[0] === 0) + writtenIndex = this._style === B.OutputStyle_1 && digits[1] === 0 ? 2 : 1; + else + writtenIndex = 0; + for (; writtenIndex < digitsIndex; ++writtenIndex) + buffer.writeCharCode$1(48 + digits[writtenIndex]); + if (t1) { + buffer.writeCharCode$1(46); + for (; writtenIndex < digitsIndex0; ++writtenIndex) + buffer.writeCharCode$1(48 + digits[writtenIndex]); + } + }, + _visitQuotedString$2$forceDoubleQuote(string, forceDoubleQuote) { + var t1, includesSingleQuote, includesDoubleQuote, i, char, _1_2, _1_4, _0_0, quote, _this = this, + buffer = forceDoubleQuote ? _this._serialize$_buffer : new A.StringBuffer(""); + if (forceDoubleQuote) + buffer.writeCharCode$1(34); + for (t1 = string.length, includesSingleQuote = false, includesDoubleQuote = false, i = 0; i < t1; ++i) { + char = string.charCodeAt(i); + _1_2 = 39 === char; + if (_1_2 && forceDoubleQuote) { + buffer.writeCharCode$1(39); + continue; + } + if (_1_2 && includesDoubleQuote) { + _this._visitQuotedString$2$forceDoubleQuote(string, true); + return; + } + if (_1_2) { + buffer.writeCharCode$1(39); + includesSingleQuote = true; + continue; + } + _1_4 = 34 === char; + if (_1_4 && forceDoubleQuote) { + buffer.writeCharCode$1(92); + buffer.writeCharCode$1(34); + continue; + } + if (_1_4 && includesSingleQuote) { + _this._visitQuotedString$2$forceDoubleQuote(string, true); + return; + } + if (_1_4) { + buffer.writeCharCode$1(34); + includesDoubleQuote = true; + continue; + } + if (0 === char || 1 === char || 2 === char || 3 === char || 4 === char || 5 === char || 6 === char || 7 === char || 8 === char || 10 === char || 11 === char || 12 === char || 13 === char || 14 === char || 15 === char || 16 === char || 17 === char || 18 === char || 19 === char || 20 === char || 21 === char || 22 === char || 23 === char || 24 === char || 25 === char || 26 === char || 27 === char || 28 === char || 29 === char || 30 === char || 31 === char || 127 === char) { + _this._writeEscape$4(buffer, char, string, i); + continue; + } + if (92 === char) { + buffer.writeCharCode$1(92); + buffer.writeCharCode$1(92); + continue; + } + _0_0 = _this._tryPrivateUseCharacter$4(buffer, char, string, i); + if (_0_0 != null) + i = _0_0; + else + buffer.writeCharCode$1(char); + } + if (forceDoubleQuote) + buffer.writeCharCode$1(34); + else { + quote = includesDoubleQuote ? 39 : 34; + t1 = _this._serialize$_buffer; + t1.writeCharCode$1(quote); + t1.write$1(0, buffer); + t1.writeCharCode$1(quote); + } + }, + _visitQuotedString$1(string) { + return this._visitQuotedString$2$forceDoubleQuote(string, false); + }, + _visitUnquotedString$1(string) { + var t1, t2, afterNewline, i, _1_0, _0_0; + for (t1 = string.length, t2 = this._serialize$_buffer, afterNewline = false, i = 0; i < t1; ++i) { + _1_0 = string.charCodeAt(i); + if (10 === _1_0) { + t2.writeCharCode$1(32); + afterNewline = true; + continue; + } + if (32 === _1_0) { + if (!afterNewline) + t2.writeCharCode$1(32); + continue; + } + _0_0 = this._tryPrivateUseCharacter$4(t2, _1_0, string, i); + if (_0_0 != null) + i = _0_0; + else + t2.writeCharCode$1(_1_0); + afterNewline = false; + } + }, + _tryPrivateUseCharacter$4(buffer, codeUnit, string, i) { + var t1; + if (this._style === B.OutputStyle_1) + return null; + if (codeUnit >= 57344 && codeUnit <= 63743) { + this._writeEscape$4(buffer, codeUnit, string, i); + return i; + } + if (codeUnit >>> 7 === 439 && string.length > i + 1) { + t1 = i + 1; + this._writeEscape$4(buffer, 65536 + ((codeUnit & 1023) << 10) + (string.charCodeAt(t1) & 1023), string, t1); + return t1; + } + return null; + }, + _writeEscape$4(buffer, character, string, i) { + var t1, next; + buffer.writeCharCode$1(92); + buffer.write$1(0, B.JSInt_methods.toRadixString$1(character, 16)); + t1 = i + 1; + if (string.length === t1) + return; + next = string.charCodeAt(t1); + if (A.CharacterExtension_get_isHex(next) || 32 === next || 9 === next) + buffer.writeCharCode$1(32); + }, + visitAttributeSelector$1(attribute) { + var _0_0, t2, + t1 = this._serialize$_buffer; + t1.writeCharCode$1(91); + t1.write$1(0, attribute.name); + _0_0 = attribute.value; + if (_0_0 != null) { + t1.write$1(0, attribute.op); + if (A.Parser_isIdentifier(_0_0) && !B.JSString_methods.startsWith$1(_0_0, "--")) { + t1.write$1(0, _0_0); + t2 = attribute.modifier; + if (t2 != null) + t1.writeCharCode$1(32); + } else { + this._visitQuotedString$1(_0_0); + t2 = attribute.modifier; + if (t2 != null) + if (this._style !== B.OutputStyle_1) + t1.writeCharCode$1(32); + } + A.NullableExtension_andThen(t2, t1.get$write(t1)); + } + t1.writeCharCode$1(93); + }, + visitClassSelector$1(klass) { + var t1 = this._serialize$_buffer; + t1.writeCharCode$1(46); + t1.write$1(0, klass.name); + }, + visitComplexSelector$1(complex) { + var t2, t3, t4, t5, t6, i, component, t7, t8, t9, _this = this, + t1 = complex.leadingCombinators; + _this._writeCombinators$1(t1); + if (t1.length >= 1 && complex.components.length >= 1) + if (_this._style !== B.OutputStyle_1) + _this._serialize$_buffer.writeCharCode$1(32); + for (t1 = complex.components, t2 = t1.length, t3 = t2 - 1, t4 = _this._serialize$_buffer, t5 = _this._style === B.OutputStyle_1, t6 = !t5, i = 0; i < t2; ++i) { + component = t1[i]; + _this.visitCompoundSelector$1(component.selector); + t7 = component.combinators; + t8 = t7.length === 0; + if (!t8) + if (t6) + t4.writeCharCode$1(32); + t9 = t5 ? "" : " "; + _this._writeBetween$3(t7, t9, t4.get$write(t4)); + if (i !== t3) + t7 = !t5 || t8; + else + t7 = false; + if (t7) + t4.writeCharCode$1(32); + } + }, + _writeCombinators$1(combinators) { + var t1 = this._style === B.OutputStyle_1 ? "" : " ", + t2 = this._serialize$_buffer; + return this._writeBetween$3(combinators, t1, t2.get$write(t2)); + }, + visitCompoundSelector$1(compound) { + var t2, t3, _i, + t1 = this._serialize$_buffer, + start = t1.get$length(t1); + for (t2 = compound.components, t3 = t2.length, _i = 0; _i < t3; ++_i) + t2[_i].accept$1(this); + if (t1.get$length(t1) === start) + t1.writeCharCode$1(42); + }, + visitIDSelector$1(id) { + var t1 = this._serialize$_buffer; + t1.writeCharCode$1(35); + t1.write$1(0, id.name); + }, + visitSelectorList$1(list) { + var t1, t2, t3, first, t4, _this = this, + complexes = list.components; + for (t1 = J.get$iterator$ax(_this._inspect ? complexes : new A.WhereIterable(complexes, new A._SerializeVisitor_visitSelectorList_closure(), A._arrayInstanceType(complexes)._eval$1("WhereIterable<1>"))), t2 = _this._style !== B.OutputStyle_1, t3 = _this._serialize$_buffer, first = true; t1.moveNext$0();) { + t4 = t1.get$current(t1); + if (first) + first = false; + else { + t3.writeCharCode$1(44); + if (t4.lineBreak) { + if (t2) + t3.write$1(0, "\n"); + _this._writeIndentation$0(); + } else if (t2) + t3.writeCharCode$1(32); + } + _this.visitComplexSelector$1(t4); + } + }, + visitParentSelector$1($parent) { + var t1 = this._serialize$_buffer; + t1.writeCharCode$1(38); + A.NullableExtension_andThen($parent.suffix, t1.get$write(t1)); + }, + visitPlaceholderSelector$1(placeholder) { + var t1 = this._serialize$_buffer; + t1.writeCharCode$1(37); + t1.write$1(0, placeholder.name); + }, + visitPseudoSelector$1(pseudo) { + var _0_4, t3, + t1 = pseudo.name, + t2 = false; + if ("not" === t1) { + _0_4 = pseudo.selector; + if (_0_4 instanceof A.SelectorList) + t2 = (_0_4 == null ? type$.SelectorList._as(_0_4) : _0_4).accept$1(B._IsInvisibleVisitor_true); + } + if (t2) + return; + t2 = this._serialize$_buffer; + t2.writeCharCode$1(58); + if (!pseudo.isSyntacticClass) + t2.writeCharCode$1(58); + t2.write$1(0, t1); + t1 = pseudo.argument; + t3 = t1 == null; + if (t3 && pseudo.selector == null) + return; + t2.writeCharCode$1(40); + if (!t3) { + t2.write$1(0, t1); + if (pseudo.selector != null) + t2.writeCharCode$1(32); + } + A.NullableExtension_andThen(pseudo.selector, this.get$visitSelectorList()); + t2.writeCharCode$1(41); + }, + visitTypeSelector$1(type) { + this._serialize$_buffer.write$1(0, type.name); + }, + visitUniversalSelector$1(universal) { + var t2, + t1 = universal.namespace; + if (t1 != null) { + t2 = this._serialize$_buffer; + t2.write$1(0, t1); + t2.writeCharCode$1(124); + } + this._serialize$_buffer.writeCharCode$1(42); + }, + _serialize$_write$1(value) { + return this._serialize$_buffer.forSpan$2(value.span, new A._SerializeVisitor__write_closure(this, value)); + }, + _serialize$_visitChildren$1($parent) { + var t2, t3, t4, t5, t6, t7, prePrevious, previous, t8, previous0, t9, savedIndentation, _this = this, + t1 = _this._serialize$_buffer; + t1.writeCharCode$1(123); + for (t2 = $parent.children, t3 = t2.$ti, t2 = new A.ListIterator(t2, t2.get$length(0), t3._eval$1("ListIterator")), t4 = _this._style === B.OutputStyle_1, t5 = !t4, t6 = _this.get$_requiresSemicolon(), t7 = !_this._inspect, t3 = t3._eval$1("ListBase.E"), prePrevious = null, previous = null; t2.moveNext$0();) { + t8 = t2.__internal$_current; + previous0 = t8 == null ? t3._as(t8) : t8; + if (t7) + t8 = t4 ? previous0.accept$1(B._IsInvisibleVisitor_true_true) : previous0.accept$1(B._IsInvisibleVisitor_true_false); + else + t8 = false; + if (t8) + continue; + t8 = previous == null; + t9 = t8 ? null : t6.call$1(previous); + if (t9 == null ? false : t9) + t1.writeCharCode$1(59); + if (_this._isTrailingComment$2(previous0, t8 ? $parent : previous)) { + if (t5) + t1.writeCharCode$1(32); + savedIndentation = _this._indentation; + _this._indentation = 0; + new A._SerializeVisitor__visitChildren_closure(_this, previous0).call$0(); + _this._indentation = savedIndentation; + } else { + if (t5) + t1.write$1(0, "\n"); + ++_this._indentation; + new A._SerializeVisitor__visitChildren_closure0(_this, previous0).call$0(); + --_this._indentation; + } + prePrevious = previous; + previous = previous0; + } + if (previous != null) { + if ((type$.CssParentNode._is(previous) ? previous.get$isChildless() : !(previous instanceof A.ModifiableCssComment)) && t5) + t1.writeCharCode$1(59); + if (prePrevious == null && _this._isTrailingComment$2(previous, $parent)) { + if (t5) + t1.writeCharCode$1(32); + } else { + _this._writeLineFeed$0(); + _this._writeIndentation$0(); + } + } + t1.writeCharCode$1(125); + }, + _requiresSemicolon$1(node) { + return type$.CssParentNode._is(node) ? node.get$isChildless() : !(node instanceof A.ModifiableCssComment); + }, + _isTrailingComment$2(node, previous) { + var t1, t2, t3, t4, searchFrom, endOffset, t5, span; + if (this._style === B.OutputStyle_1) + return false; + if (!(node instanceof A.ModifiableCssComment)) + return false; + t1 = node.span; + t2 = t1.file; + t3 = t2.url; + t4 = previous.get$span(previous); + if (!J.$eq$(t3, t4.get$sourceUrl(t4))) + return false; + t4 = previous.get$span(previous); + if (!(J.$eq$(t4.get$file(t4).url, t3) && t4.get$start(t4).offset <= A.FileLocation$_(t2, t1._file$_start).offset && t4.get$end(t4).offset >= A.FileLocation$_(t2, t1._end).offset)) { + t1 = A.FileLocation$_(t2, t1._file$_start); + t1 = t1.file.getLine$1(t1.offset); + t2 = previous.get$span(previous); + t2 = t2.get$end(t2); + return t1 === t2.file.getLine$1(t2.offset); + } + t1 = t1._file$_start; + t3 = A.FileLocation$_(t2, t1); + t4 = previous.get$span(previous); + searchFrom = t3.offset - t4.get$start(t4).offset - 1; + if (searchFrom < 0) + return false; + endOffset = Math.max(0, B.JSString_methods.lastIndexOf$2(previous.get$span(previous).get$text(), "{", searchFrom)); + t3 = previous.get$span(previous); + t3 = t3.get$file(t3); + t4 = previous.get$span(previous); + t4 = t4.get$start(t4); + t5 = previous.get$span(previous); + span = t3.span$2(0, t4.offset, t5.get$start(t5).offset + endOffset); + t1 = A.FileLocation$_(t2, t1); + t1 = t1.file.getLine$1(t1.offset); + t2 = A.FileLocation$_(span.file, span._end); + return t1 === t2.file.getLine$1(t2.offset); + }, + _writeLineFeed$0() { + if (this._style !== B.OutputStyle_1) + this._serialize$_buffer.write$1(0, "\n"); + }, + _writeIndentation$0() { + var _this = this; + if (_this._style === B.OutputStyle_1) + return; + _this._writeTimes$2(_this._indentCharacter, _this._indentation * _this._indentWidth); + }, + _writeTimes$2(char, times) { + var t1, i; + for (t1 = this._serialize$_buffer, i = 0; i < times; ++i) + t1.writeCharCode$1(char); + }, + _writeBetween$1$3(iterable, text, callback) { + var t1, t2, first, value; + for (t1 = J.get$iterator$ax(iterable), t2 = this._serialize$_buffer, first = true; t1.moveNext$0();) { + value = t1.get$current(t1); + if (first) + first = false; + else + t2.write$1(0, text); + callback.call$1(value); + } + }, + _writeBetween$3(iterable, text, callback) { + return this._writeBetween$1$3(iterable, text, callback, type$.dynamic); + } + }; + A._SerializeVisitor_visitCssComment_closure.prototype = { + call$0() { + var t2, t3, _0_0, minimumIndentation, + t1 = this.$this; + if (t1._style === B.OutputStyle_1 && this.node.text.charCodeAt(2) !== 33) + return; + t2 = this.node; + t3 = t2.text; + if (B.JSString_methods.startsWith$1(t3, A.RegExp_RegExp("/\\*# source(Mapping)?URL=", false))) + return; + _0_0 = t1._minimumIndentation$1(t3); + if (_0_0 != null) { + t2 = t2.span; + t2 = A.FileLocation$_(t2.file, t2._file$_start); + minimumIndentation = Math.min(_0_0, t2.file.getColumn$1(t2.offset)); + t1._writeIndentation$0(); + t1._writeWithIndent$2(t3, minimumIndentation); + } else { + t1._writeIndentation$0(); + t1._serialize$_buffer.write$1(0, t3); + } + }, + $signature: 1 + }; + A._SerializeVisitor_visitCssAtRule_closure.prototype = { + call$0() { + var t3, _0_0, + t1 = this.$this, + t2 = t1._serialize$_buffer; + t2.writeCharCode$1(64); + t3 = this.node; + t1._serialize$_write$1(t3.name); + _0_0 = t3.value; + if (_0_0 != null) { + t2.writeCharCode$1(32); + t1._serialize$_write$1(_0_0); + } + }, + $signature: 1 + }; + A._SerializeVisitor_visitCssMediaRule_closure.prototype = { + call$0() { + var t3, firstQuery, t4, t5, + t1 = this.$this, + t2 = t1._serialize$_buffer; + t2.write$1(0, "@media"); + t3 = this.node.queries; + firstQuery = B.JSArray_methods.get$first(t3); + t4 = t1._style === B.OutputStyle_1; + t5 = true; + if (t4) + if (firstQuery.modifier == null) + if (firstQuery.type == null) { + t5 = firstQuery.conditions; + t5 = t5.length === 1 && J.startsWith$1$s(B.JSArray_methods.get$first(t5), "(not "); + } + if (t5) + t2.writeCharCode$1(32); + t2 = t4 ? "," : ", "; + t1._writeBetween$3(t3, t2, t1.get$_visitMediaQuery()); + }, + $signature: 1 + }; + A._SerializeVisitor_visitCssImport_closure.prototype = { + call$0() { + var t3, t4, _0_0, + t1 = this.$this, + t2 = t1._serialize$_buffer; + t2.write$1(0, "@import"); + t3 = t1._style !== B.OutputStyle_1; + if (t3) + t2.writeCharCode$1(32); + t4 = this.node; + t2.forSpan$2(t4.url.span, new A._SerializeVisitor_visitCssImport__closure(t1, t4)); + _0_0 = t4.modifiers; + if (_0_0 != null) { + if (t3) + t2.writeCharCode$1(32); + t2.write$1(0, _0_0); + } + }, + $signature: 1 + }; + A._SerializeVisitor_visitCssImport__closure.prototype = { + call$0() { + return this.$this._writeImportUrl$1(this.node.url.value); + }, + $signature: 0 + }; + A._SerializeVisitor_visitCssKeyframeBlock_closure.prototype = { + call$0() { + var t1 = this.$this, + t2 = t1._style === B.OutputStyle_1 ? "," : ", ", + t3 = t1._serialize$_buffer; + return t1._writeBetween$3(this.node.selector.value, t2, t3.get$write(t3)); + }, + $signature: 0 + }; + A._SerializeVisitor_visitCssStyleRule_closure.prototype = { + call$0() { + return this.$this.visitSelectorList$1(this.node._style_rule$_selector._box$_inner.value); + }, + $signature: 0 + }; + A._SerializeVisitor_visitCssSupportsRule_closure.prototype = { + call$0() { + var t1 = this.$this, + t2 = t1._serialize$_buffer; + t2.write$1(0, "@supports"); + if (!(t1._style === B.OutputStyle_1 && J.codeUnitAt$1$s(this.node.condition.value, 0) === 40)) + t2.writeCharCode$1(32); + t1._serialize$_write$1(this.node.condition); + }, + $signature: 1 + }; + A._SerializeVisitor_visitCssDeclaration_closure.prototype = { + call$0() { + var t1 = this.$this, + t2 = this.node; + if (t1._style === B.OutputStyle_1) + t1._writeFoldedValue$1(t2); + else + t1._writeReindentedValue$1(t2); + }, + $signature: 1 + }; + A._SerializeVisitor_visitCssDeclaration_closure0.prototype = { + call$0() { + return this.node.value.value.accept$1(this.$this); + }, + $signature: 0 + }; + A._SerializeVisitor_visitList_closure.prototype = { + call$1(element) { + return !element.get$isBlank(); + }, + $signature: 72 + }; + A._SerializeVisitor_visitList_closure0.prototype = { + call$1(element) { + var t1 = this.$this, + needsParens = t1._elementNeedsParens$2(this.value._separator, element); + if (needsParens) + t1._serialize$_buffer.writeCharCode$1(40); + element.accept$1(t1); + if (needsParens) + t1._serialize$_buffer.writeCharCode$1(41); + }, + $signature: 62 + }; + A._SerializeVisitor_visitList_closure1.prototype = { + call$1(element) { + element.accept$1(this.$this); + }, + $signature: 62 + }; + A._SerializeVisitor_visitMap_closure.prototype = { + call$1(entry) { + var t1 = this.$this; + t1._writeMapElement$1(entry.key); + t1._serialize$_buffer.write$1(0, ": "); + t1._writeMapElement$1(entry.value); + }, + $signature: 280 + }; + A._SerializeVisitor_visitSelectorList_closure.prototype = { + call$1(complex) { + return !complex.accept$1(B._IsInvisibleVisitor_true); + }, + $signature: 20 + }; + A._SerializeVisitor__write_closure.prototype = { + call$0() { + return this.$this._serialize$_buffer.write$1(0, this.value.value); + }, + $signature: 0 + }; + A._SerializeVisitor__visitChildren_closure.prototype = { + call$0() { + return this.child.accept$1(this.$this); + }, + $signature: 0 + }; + A._SerializeVisitor__visitChildren_closure0.prototype = { + call$0() { + this.child.accept$1(this.$this); + }, + $signature: 0 + }; + A.OutputStyle.prototype = { + _enumToString$0() { + return "OutputStyle." + this._name; + } + }; + A.LineFeed.prototype = { + _enumToString$0() { + return "LineFeed." + this._name; + }, + toString$0(_) { + return "lf"; + } + }; + A.StatementSearchVisitor.prototype = { + visitAtRootRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitAtRule$1(_, node) { + return A.NullableExtension_andThen(node.children, this.get$visitChildren()); + }, + visitContentBlock$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitContentRule$1(_, node) { + return null; + }, + visitDebugRule$1(_, node) { + return null; + }, + visitDeclaration$1(_, node) { + return A.NullableExtension_andThen(node.children, this.get$visitChildren()); + }, + visitEachRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitErrorRule$1(_, node) { + return null; + }, + visitExtendRule$1(_, node) { + return null; + }, + visitForRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitForwardRule$1(_, node) { + return null; + }, + visitFunctionRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitIfRule$1(_, node) { + var t1 = A.IterableExtension_search(node.clauses, new A.StatementSearchVisitor_visitIfRule_closure(this)); + return t1 == null ? A.NullableExtension_andThen(node.lastClause, new A.StatementSearchVisitor_visitIfRule_closure0(this)) : t1; + }, + visitImportRule$1(_, node) { + return null; + }, + visitIncludeRule$1(_, node) { + return A.NullableExtension_andThen(node.content, this.get$visitContentBlock(this)); + }, + visitLoudComment$1(_, node) { + return null; + }, + visitMediaRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitMixinRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitReturnRule$1(_, node) { + return null; + }, + visitSilentComment$1(_, node) { + return null; + }, + visitStyleRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitStylesheet$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitSupportsRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitUseRule$1(_, node) { + return null; + }, + visitVariableDeclaration$1(_, node) { + return null; + }, + visitWarnRule$1(_, node) { + return null; + }, + visitWhileRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitChildren$1(children) { + return A.IterableExtension_search(children, new A.StatementSearchVisitor_visitChildren_closure(this)); + } + }; + A.StatementSearchVisitor_visitIfRule_closure.prototype = { + call$1(clause) { + return A.IterableExtension_search(clause.children, new A.StatementSearchVisitor_visitIfRule__closure0(this.$this)); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("StatementSearchVisitor.T?(IfClause)"); + } + }; + A.StatementSearchVisitor_visitIfRule__closure0.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("StatementSearchVisitor.T?(Statement)"); + } + }; + A.StatementSearchVisitor_visitIfRule_closure0.prototype = { + call$1(lastClause) { + return A.IterableExtension_search(lastClause.children, new A.StatementSearchVisitor_visitIfRule__closure(this.$this)); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("StatementSearchVisitor.T?(ElseClause)"); + } + }; + A.StatementSearchVisitor_visitIfRule__closure.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("StatementSearchVisitor.T?(Statement)"); + } + }; + A.StatementSearchVisitor_visitChildren_closure.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("StatementSearchVisitor.T?(Statement)"); + } + }; + A.Entry.prototype = { + compareTo$1(_, other) { + var t1, t2, + res = this.target.compareTo$1(0, other.target); + if (res !== 0) + return res; + t1 = this.source; + t2 = other.source; + res = B.JSString_methods.compareTo$1(J.toString$0$(t1.file.url), J.toString$0$(t2.file.url)); + if (res !== 0) + return res; + return t1.compareTo$1(0, t2); + }, + $isComparable: 1 + }; + A.Mapping.prototype = {}; + A.SingleMapping.prototype = { + toJson$1$includeSourceContents(includeSourceContents) { + var t1, t2, line, column, srcLine, srcColumn, srcUrlId, srcNameId, first, _i, entry, nextLine, i, t3, t4, column0, t5, newUrlId, srcLine0, srcColumn0, srcNameId0, result, _this = this, + buff = new A.StringBuffer(""); + for (t1 = _this.lines, t2 = t1.length, line = 0, column = 0, srcLine = 0, srcColumn = 0, srcUrlId = 0, srcNameId = 0, first = true, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + entry = t1[_i]; + nextLine = entry.line; + if (nextLine > line) { + for (i = line; i < nextLine; ++i) + buff._contents += ";"; + line = nextLine; + column = 0; + first = true; + } + for (t3 = J.get$iterator$ax(entry.entries); t3.moveNext$0(); column = column0, first = false) { + t4 = t3.get$current(t3); + if (!first) + buff._contents += ","; + column0 = t4.column; + t5 = A.encodeVlq(column0 - column); + t5 = A.StringBuffer__writeAll(buff._contents, t5, ""); + buff._contents = t5; + newUrlId = t4.sourceUrlId; + t5 = A.StringBuffer__writeAll(t5, A.encodeVlq(newUrlId - srcUrlId), ""); + buff._contents = t5; + srcLine0 = t4.sourceLine; + t5 = A.StringBuffer__writeAll(t5, A.encodeVlq(srcLine0 - srcLine), ""); + buff._contents = t5; + srcColumn0 = t4.sourceColumn; + t5 = A.StringBuffer__writeAll(t5, A.encodeVlq(srcColumn0 - srcColumn), ""); + buff._contents = t5; + srcNameId0 = t4.sourceNameId; + if (srcNameId0 == null) { + srcUrlId = newUrlId; + srcColumn = srcColumn0; + srcLine = srcLine0; + continue; + } + buff._contents = A.StringBuffer__writeAll(t5, A.encodeVlq(srcNameId0 - srcNameId), ""); + srcNameId = srcNameId0; + srcUrlId = newUrlId; + srcColumn = srcColumn0; + srcLine = srcLine0; + } + } + t1 = _this.sourceRoot; + if (t1 == null) + t1 = ""; + t2 = buff._contents; + result = A.LinkedHashMap_LinkedHashMap$_literal(["version", 3, "sourceRoot", t1, "sources", _this.urls, "names", _this.names, "mappings", t2.charCodeAt(0) == 0 ? t2 : t2], type$.String, type$.dynamic); + t1 = _this.targetUrl; + if (t1 != null) + result.$indexSet(0, "file", t1); + if (includeSourceContents) { + t1 = _this.files; + t2 = A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,String?>"); + result.$indexSet(0, "sourcesContent", A.List_List$of(new A.MappedListIterable(t1, new A.SingleMapping_toJson_closure(), t2), true, t2._eval$1("ListIterable.E"))); + } + _this.extensions.forEach$1(0, new A.SingleMapping_toJson_closure0(result)); + return result; + }, + toJson$0() { + return this.toJson$1$includeSourceContents(false); + }, + toString$0(_) { + var _this = this, + t1 = A.getRuntimeTypeOfDartObject(_this).toString$0(0) + " : [" + "targetUrl: " + A.S(_this.targetUrl) + ", sourceRoot: " + A.S(_this.sourceRoot) + ", urls: " + A.S(_this.urls) + ", names: " + A.S(_this.names) + ", lines: " + A.S(_this.lines) + "]"; + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + }; + A.SingleMapping_SingleMapping$fromEntries_closure.prototype = { + call$0() { + return this.urls.__js_helper$_length; + }, + $signature: 10 + }; + A.SingleMapping_SingleMapping$fromEntries_closure0.prototype = { + call$0() { + return this.sourceEntry.source.file; + }, + $signature: 281 + }; + A.SingleMapping_SingleMapping$fromEntries_closure1.prototype = { + call$1(i) { + return this.files.$index(0, i); + }, + $signature: 282 + }; + A.SingleMapping_toJson_closure.prototype = { + call$1(file) { + return file == null ? null : A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(file._decodedChars, 0, null), 0, null); + }, + $signature: 283 + }; + A.SingleMapping_toJson_closure0.prototype = { + call$2($name, value) { + this.result.$indexSet(0, $name, value); + return value; + }, + $signature: 139 + }; + A.TargetLineEntry.prototype = { + toString$0(_) { + return A.getRuntimeTypeOfDartObject(this).toString$0(0) + ": " + this.line + " " + A.S(this.entries); + } + }; + A.TargetEntry.prototype = { + toString$0(_) { + var _this = this; + return A.getRuntimeTypeOfDartObject(_this).toString$0(0) + ": (" + _this.column + ", " + _this.sourceUrlId + ", " + _this.sourceLine + ", " + _this.sourceColumn + ", " + A.S(_this.sourceNameId) + ")"; + } + }; + A.SourceFile.prototype = { + get$length(_) { + return this._decodedChars.length; + }, + get$lines() { + return this._lineStarts.length; + }, + SourceFile$decoded$2$url(decodedChars, url) { + var t1, t2, t3, i, c, j; + for (t1 = this._decodedChars, t2 = t1.length, t3 = this._lineStarts, i = 0; i < t2; ++i) { + c = t1[i]; + if (c === 13) { + j = i + 1; + if (j >= t2 || t1[j] !== 10) + c = 10; + } + if (c === 10) + t3.push(i + 1); + } + }, + span$2(_, start, end) { + return A._FileSpan$(this, start, end == null ? this._decodedChars.length : end); + }, + span$1(_, start) { + return this.span$2(0, start, null); + }, + getLine$1(offset) { + var t1, _this = this; + if (offset < 0) + throw A.wrapException(A.RangeError$("Offset may not be negative, was " + offset + ".")); + else if (offset > _this._decodedChars.length) + throw A.wrapException(A.RangeError$("Offset " + offset + string$.x20must_n + _this.get$length(0) + ".")); + t1 = _this._lineStarts; + if (offset < B.JSArray_methods.get$first(t1)) + return -1; + if (offset >= B.JSArray_methods.get$last(t1)) + return t1.length - 1; + if (_this._isNearCachedLine$1(offset)) { + t1 = _this._cachedLine; + t1.toString; + return t1; + } + return _this._cachedLine = _this._binarySearch$1(offset) - 1; + }, + _isNearCachedLine$1(offset) { + var t2, t3, + t1 = this._cachedLine; + if (t1 == null) + return false; + t2 = this._lineStarts; + if (offset < t2[t1]) + return false; + t3 = t2.length; + if (t1 >= t3 - 1 || offset < t2[t1 + 1]) + return true; + if (t1 >= t3 - 2 || offset < t2[t1 + 2]) { + this._cachedLine = t1 + 1; + return true; + } + return false; + }, + _binarySearch$1(offset) { + var min, half, + t1 = this._lineStarts, + max = t1.length - 1; + for (min = 0; min < max;) { + half = min + B.JSInt_methods._tdivFast$1(max - min, 2); + if (t1[half] > offset) + max = half; + else + min = half + 1; + } + return max; + }, + getColumn$1(offset) { + var line, lineStart, _this = this; + if (offset < 0) + throw A.wrapException(A.RangeError$("Offset may not be negative, was " + offset + ".")); + else if (offset > _this._decodedChars.length) + throw A.wrapException(A.RangeError$("Offset " + offset + " must be not be greater than the number of characters in the file, " + _this.get$length(0) + ".")); + line = _this.getLine$1(offset); + lineStart = _this._lineStarts[line]; + if (lineStart > offset) + throw A.wrapException(A.RangeError$("Line " + line + " comes after offset " + offset + ".")); + return offset - lineStart; + }, + getOffset$1(line) { + var t1, t2, result, t3; + if (line < 0) + throw A.wrapException(A.RangeError$("Line may not be negative, was " + line + ".")); + else { + t1 = this._lineStarts; + t2 = t1.length; + if (line >= t2) + throw A.wrapException(A.RangeError$("Line " + line + " must be less than the number of lines in the file, " + this.get$lines() + ".")); + } + result = t1[line]; + if (result <= this._decodedChars.length) { + t3 = line + 1; + t1 = t3 < t2 && result >= t1[t3]; + } else + t1 = true; + if (t1) + throw A.wrapException(A.RangeError$("Line " + line + " doesn't have 0 columns.")); + return result; + } + }; + A.FileLocation.prototype = { + get$sourceUrl(_) { + return this.file.url; + }, + get$line() { + return this.file.getLine$1(this.offset); + }, + get$column() { + return this.file.getColumn$1(this.offset); + }, + FileLocation$_$2(file, offset) { + var t2, + t1 = this.offset; + if (t1 < 0) + throw A.wrapException(A.RangeError$("Offset may not be negative, was " + t1 + ".")); + else { + t2 = this.file; + if (t1 > t2._decodedChars.length) + throw A.wrapException(A.RangeError$("Offset " + t1 + string$.x20must_n + t2.get$length(0) + ".")); + } + }, + pointSpan$0() { + var t1 = this.offset; + return A._FileSpan$(this.file, t1, t1); + }, + get$offset() { + return this.offset; + } + }; + A._FileSpan.prototype = { + get$sourceUrl(_) { + return this.file.url; + }, + get$length(_) { + return this._end - this._file$_start; + }, + get$start(_) { + return A.FileLocation$_(this.file, this._file$_start); + }, + get$end(_) { + return A.FileLocation$_(this.file, this._end); + }, + get$text() { + return A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(this.file._decodedChars, this._file$_start, this._end), 0, null); + }, + get$context(_) { + var _this = this, + t1 = _this.file, + endOffset = _this._end, + endLine = t1.getLine$1(endOffset); + if (t1.getColumn$1(endOffset) === 0 && endLine !== 0) { + if (endOffset - _this._file$_start === 0) + return endLine === t1._lineStarts.length - 1 ? "" : A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1._decodedChars, t1.getOffset$1(endLine), t1.getOffset$1(endLine + 1)), 0, null); + } else + endOffset = endLine === t1._lineStarts.length - 1 ? t1._decodedChars.length : t1.getOffset$1(endLine + 1); + return A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1._decodedChars, t1.getOffset$1(t1.getLine$1(_this._file$_start)), endOffset), 0, null); + }, + _FileSpan$3(file, _start, _end) { + var t3, + t1 = this._end, + t2 = this._file$_start; + if (t1 < t2) + throw A.wrapException(A.ArgumentError$("End " + t1 + " must come after start " + t2 + ".", null)); + else { + t3 = this.file; + if (t1 > t3._decodedChars.length) + throw A.wrapException(A.RangeError$("End " + t1 + string$.x20must_n + t3.get$length(0) + ".")); + else if (t2 < 0) + throw A.wrapException(A.RangeError$("Start may not be negative, was " + t2 + ".")); + } + }, + compareTo$1(_, other) { + var result; + if (!(other instanceof A._FileSpan)) + return this.super$SourceSpanMixin$compareTo(0, other); + result = B.JSInt_methods.compareTo$1(this._file$_start, other._file$_start); + return result === 0 ? B.JSInt_methods.compareTo$1(this._end, other._end) : result; + }, + $eq(_, other) { + var _this = this; + if (other == null) + return false; + if (!type$.FileSpan._is(other)) + return _this.super$SourceSpanMixin$$eq(0, other); + if (!(other instanceof A._FileSpan)) + return _this.super$SourceSpanMixin$$eq(0, other) && J.$eq$(_this.file.url, other.get$sourceUrl(other)); + return _this._file$_start === other._file$_start && _this._end === other._end && J.$eq$(_this.file.url, other.file.url); + }, + get$hashCode(_) { + return A.Object_hash(this._file$_start, this._end, this.file.url, B.C_SentinelValue); + }, + expand$1(_, other) { + var t2, t3, _this = this, + t1 = _this.file; + if (!J.$eq$(t1.url, other.get$sourceUrl(other))) + throw A.wrapException(A.ArgumentError$('Source URLs "' + A.S(_this.get$sourceUrl(0)) + '" and "' + A.S(other.get$sourceUrl(other)) + "\" don't match.", null)); + t2 = _this._file$_start; + t3 = _this._end; + if (other instanceof A._FileSpan) + return A._FileSpan$(t1, Math.min(t2, other._file$_start), Math.max(t3, other._end)); + else + return A._FileSpan$(t1, Math.min(t2, other.get$start(other).offset), Math.max(t3, other.get$end(other).offset)); + }, + $isFileSpan: 1, + $isSourceSpanWithContext: 1, + get$file(receiver) { + return this.file; + } + }; + A.Highlighter.prototype = { + highlight$0() { + var t2, highlightsByColumn, t3, t4, i, line, lastLine, t5, t6, t7, t8, t9, t10, t11, index, primaryIdx, primary, _i, highlight, _this = this, _null = null, + t1 = _this._lines; + _this._writeFileStart$1(B.JSArray_methods.get$first(t1).url); + t2 = _this._maxMultilineSpans; + highlightsByColumn = A.List_List$filled(t2, _null, false, type$.nullable__Highlight); + for (t3 = _this._highlighter$_buffer, t2 = t2 !== 0, t4 = _this._primaryColor, i = 0; i < t1.length; ++i) { + line = t1[i]; + if (i > 0) { + lastLine = t1[i - 1]; + t5 = line.url; + if (!J.$eq$(lastLine.url, t5)) { + _this._writeSidebar$1$end($._glyphs.get$upEnd()); + t3._contents += "\n"; + _this._writeFileStart$1(t5); + } else if (lastLine.number + 1 !== line.number) { + _this._writeSidebar$1$text("..."); + t3._contents += "\n"; + } + } + for (t5 = line.highlights, t6 = A._arrayInstanceType(t5)._eval$1("ReversedListIterable<1>"), t7 = new A.ReversedListIterable(t5, t6), t7 = new A.ListIterator(t7, t7.get$length(0), t6._eval$1("ListIterator")), t6 = t6._eval$1("ListIterable.E"), t8 = line.number, t9 = line.text; t7.moveNext$0();) { + t10 = t7.__internal$_current; + if (t10 == null) + t10 = t6._as(t10); + t11 = t10.span; + if (t11.get$start(t11).get$line() !== t11.get$end(t11).get$line() && t11.get$start(t11).get$line() === t8 && _this._isOnlyWhitespace$1(B.JSString_methods.substring$2(t9, 0, t11.get$start(t11).get$column()))) { + index = B.JSArray_methods.indexOf$1(highlightsByColumn, _null); + if (index < 0) + A.throwExpression(A.ArgumentError$(A.S(highlightsByColumn) + " contains no null elements.", _null)); + highlightsByColumn[index] = t10; + } + } + _this._writeSidebar$1$line(t8); + t3._contents += " "; + _this._writeMultilineHighlights$2(line, highlightsByColumn); + if (t2) + t3._contents += " "; + primaryIdx = B.JSArray_methods.indexWhere$1(t5, new A.Highlighter_highlight_closure()); + primary = primaryIdx === -1 ? _null : t5[primaryIdx]; + t6 = primary != null; + if (t6) { + t7 = primary.span; + t10 = t7.get$start(t7).get$line() === t8 ? t7.get$start(t7).get$column() : 0; + _this._writeHighlightedText$4$color(t9, t10, t7.get$end(t7).get$line() === t8 ? t7.get$end(t7).get$column() : t9.length, t4); + } else + _this._writeText$1(t9); + t3._contents += "\n"; + if (t6) + _this._writeIndicator$3(line, primary, highlightsByColumn); + for (t6 = t5.length, _i = 0; _i < t5.length; t5.length === t6 || (0, A.throwConcurrentModificationError)(t5), ++_i) { + highlight = t5[_i]; + if (highlight.isPrimary) + continue; + _this._writeIndicator$3(line, highlight, highlightsByColumn); + } + } + _this._writeSidebar$1$end($._glyphs.get$upEnd()); + t1 = t3._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _writeFileStart$1(url) { + var _this = this, + t1 = !_this._multipleFiles || !type$.Uri._is(url), + t2 = $._glyphs; + if (t1) + _this._writeSidebar$1$end(t2.get$downEnd()); + else { + _this._writeSidebar$1$end(t2.get$topLeftCorner()); + _this._colorize$2$color(new A.Highlighter__writeFileStart_closure(_this), "\x1b[34m"); + t1 = _this._highlighter$_buffer; + t2 = " " + $.$get$context().prettyUri$1(url); + t1._contents += t2; + } + _this._highlighter$_buffer._contents += "\n"; + }, + _writeMultilineHighlights$3$current(line, highlightsByColumn, current) { + var t1, currentColor, t2, t3, t4, t5, foundCurrent, _i, highlight, t6, startLine, t7, endLine, _this = this, _box_0 = {}; + _box_0.openedOnThisLine = false; + _box_0.openedOnThisLineColor = null; + t1 = current == null; + if (t1) + currentColor = null; + else + currentColor = current.isPrimary ? _this._primaryColor : _this._secondaryColor; + for (t2 = highlightsByColumn.length, t3 = _this._secondaryColor, t1 = !t1, t4 = _this._primaryColor, t5 = _this._highlighter$_buffer, foundCurrent = false, _i = 0; _i < t2; ++_i) { + highlight = highlightsByColumn[_i]; + t6 = highlight == null; + if (t6) + startLine = null; + else { + t7 = highlight.span; + startLine = t7.get$start(t7).get$line(); + } + if (t6) + endLine = null; + else { + t7 = highlight.span; + endLine = t7.get$end(t7).get$line(); + } + if (t1 && highlight === current) { + _this._colorize$2$color(new A.Highlighter__writeMultilineHighlights_closure(_this, startLine, line), currentColor); + foundCurrent = true; + } else if (foundCurrent) + _this._colorize$2$color(new A.Highlighter__writeMultilineHighlights_closure0(_this, highlight), currentColor); + else if (t6) + if (_box_0.openedOnThisLine) + _this._colorize$2$color(new A.Highlighter__writeMultilineHighlights_closure1(_this), _box_0.openedOnThisLineColor); + else + t5._contents += " "; + else { + t6 = highlight.isPrimary ? t4 : t3; + _this._colorize$2$color(new A.Highlighter__writeMultilineHighlights_closure2(_box_0, _this, current, startLine, line, highlight, endLine), t6); + } + } + }, + _writeMultilineHighlights$2(line, highlightsByColumn) { + return this._writeMultilineHighlights$3$current(line, highlightsByColumn, null); + }, + _writeHighlightedText$4$color(text, startColumn, endColumn, color) { + var _this = this; + _this._writeText$1(B.JSString_methods.substring$2(text, 0, startColumn)); + _this._colorize$2$color(new A.Highlighter__writeHighlightedText_closure(_this, text, startColumn, endColumn), color); + _this._writeText$1(B.JSString_methods.substring$2(text, endColumn, text.length)); + }, + _writeIndicator$3(line, highlight, highlightsByColumn) { + var t2, coversWholeLine, _this = this, + color = highlight.isPrimary ? _this._primaryColor : _this._secondaryColor, + t1 = highlight.span; + if (t1.get$start(t1).get$line() === t1.get$end(t1).get$line()) { + _this._writeSidebar$0(); + t1 = _this._highlighter$_buffer; + t1._contents += " "; + _this._writeMultilineHighlights$3$current(line, highlightsByColumn, highlight); + if (highlightsByColumn.length !== 0) + t1._contents += " "; + _this._writeLabel$3(highlight, highlightsByColumn, _this._colorize$2$color(new A.Highlighter__writeIndicator_closure(_this, line, highlight), color)); + } else { + t2 = line.number; + if (t1.get$start(t1).get$line() === t2) { + if (B.JSArray_methods.contains$1(highlightsByColumn, highlight)) + return; + A.replaceFirstNull(highlightsByColumn, highlight); + _this._writeSidebar$0(); + t1 = _this._highlighter$_buffer; + t1._contents += " "; + _this._writeMultilineHighlights$3$current(line, highlightsByColumn, highlight); + _this._colorize$2$color(new A.Highlighter__writeIndicator_closure0(_this, line, highlight), color); + t1._contents += "\n"; + } else if (t1.get$end(t1).get$line() === t2) { + coversWholeLine = t1.get$end(t1).get$column() === line.text.length; + if (coversWholeLine && highlight.label == null) { + A.replaceWithNull(highlightsByColumn, highlight); + return; + } + _this._writeSidebar$0(); + _this._highlighter$_buffer._contents += " "; + _this._writeMultilineHighlights$3$current(line, highlightsByColumn, highlight); + _this._writeLabel$3(highlight, highlightsByColumn, _this._colorize$2$color(new A.Highlighter__writeIndicator_closure1(_this, coversWholeLine, line, highlight), color)); + A.replaceWithNull(highlightsByColumn, highlight); + } + } + }, + _writeArrow$3$beginning(line, column, beginning) { + var t2, + t1 = beginning ? 0 : 1, + tabs = this._countTabs$1(B.JSString_methods.substring$2(line.text, 0, column + t1)); + t1 = this._highlighter$_buffer; + t2 = B.JSString_methods.$mul($._glyphs.get$horizontalLine(), 1 + column + tabs * 3); + t2 = t1._contents += t2; + t1._contents = t2 + "^"; + }, + _writeArrow$2(line, column) { + return this._writeArrow$3$beginning(line, column, true); + }, + _writeLabel$3(highlight, highlightsByColumn, underlineLength) { + var lines, color, t1, t2, t3, t4, t5, t6, _i, columnHighlight, _this = this, + label = highlight.label; + if (label == null) { + _this._highlighter$_buffer._contents += "\n"; + return; + } + lines = A._setArrayType(label.split("\n"), type$.JSArray_String); + color = highlight.isPrimary ? _this._primaryColor : _this._secondaryColor; + _this._colorize$2$color(new A.Highlighter__writeLabel_closure(_this, lines), color); + t1 = _this._highlighter$_buffer; + t1._contents += "\n"; + for (t2 = A.SubListIterable$(lines, 1, null, type$.String), t3 = t2.$ti, t2 = new A.ListIterator(t2, t2.get$length(0), t3._eval$1("ListIterator")), t4 = highlightsByColumn.length, t3 = t3._eval$1("ListIterable.E"); t2.moveNext$0();) { + t5 = t2.__internal$_current; + if (t5 == null) + t5 = t3._as(t5); + _this._writeSidebar$0(); + t6 = t1._contents += " "; + for (_i = 0; _i < t4; ++_i) { + columnHighlight = highlightsByColumn[_i]; + if (columnHighlight == null || columnHighlight === highlight) { + t6 += " "; + t1._contents = t6; + } else { + t6 = $._glyphs.get$verticalLine(); + t6 = t1._contents += t6; + } + } + t6 = B.JSString_methods.$mul(" ", underlineLength); + t1._contents += t6; + _this._colorize$2$color(new A.Highlighter__writeLabel_closure0(_this, t5), color); + t1._contents += "\n"; + } + }, + _writeText$1(text) { + var t1, t2, t3, t4; + for (t1 = new A.CodeUnits(text), t2 = type$.CodeUnits, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = this._highlighter$_buffer, t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t4 = t1.__internal$_current; + if (t4 == null) + t4 = t2._as(t4); + if (t4 === 9) { + t4 = B.JSString_methods.$mul(" ", 4); + t3._contents += t4; + } else { + t4 = A.Primitives_stringFromCharCode(t4); + t3._contents += t4; + } + } + }, + _writeSidebar$3$end$line$text(end, line, text) { + var t1 = {}; + t1.text = text; + if (line != null) + t1.text = B.JSInt_methods.toString$0(line + 1); + this._colorize$2$color(new A.Highlighter__writeSidebar_closure(t1, this, end), "\x1b[34m"); + }, + _writeSidebar$1$end(end) { + return this._writeSidebar$3$end$line$text(end, null, null); + }, + _writeSidebar$1$text(text) { + return this._writeSidebar$3$end$line$text(null, null, text); + }, + _writeSidebar$1$line(line) { + return this._writeSidebar$3$end$line$text(null, line, null); + }, + _writeSidebar$0() { + return this._writeSidebar$3$end$line$text(null, null, null); + }, + _countTabs$1(text) { + var t1, t2, count, t3; + for (t1 = new A.CodeUnits(text), t2 = type$.CodeUnits, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"), count = 0; t1.moveNext$0();) { + t3 = t1.__internal$_current; + if ((t3 == null ? t2._as(t3) : t3) === 9) + ++count; + } + return count; + }, + _isOnlyWhitespace$1(text) { + var t1, t2, t3; + for (t1 = new A.CodeUnits(text), t2 = type$.CodeUnits, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t3 = t1.__internal$_current; + if (t3 == null) + t3 = t2._as(t3); + if (t3 !== 32 && t3 !== 9) + return false; + } + return true; + }, + _colorize$1$2$color(callback, color) { + var result, + t1 = this._primaryColor != null; + if (t1 && color != null) + this._highlighter$_buffer._contents += color; + result = callback.call$0(); + if (t1 && color != null) + this._highlighter$_buffer._contents += "\x1b[0m"; + return result; + }, + _colorize$2$color(callback, color) { + return this._colorize$1$2$color(callback, color, type$.dynamic); + } + }; + A.Highlighter_closure.prototype = { + call$0() { + var t1 = this.color, + t2 = J.getInterceptor$(t1); + if (t2.$eq(t1, true)) + return "\x1b[31m"; + if (t2.$eq(t1, false)) + return null; + return A._asStringQ(t1); + }, + $signature: 47 + }; + A.Highlighter$__closure.prototype = { + call$1(line) { + var t1 = line.highlights; + return new A.WhereIterable(t1, new A.Highlighter$___closure(), A._arrayInstanceType(t1)._eval$1("WhereIterable<1>")).get$length(0); + }, + $signature: 284 + }; + A.Highlighter$___closure.prototype = { + call$1(highlight) { + var t1 = highlight.span; + return t1.get$start(t1).get$line() !== t1.get$end(t1).get$line(); + }, + $signature: 117 + }; + A.Highlighter$__closure0.prototype = { + call$1(line) { + return line.url; + }, + $signature: 286 + }; + A.Highlighter__collateLines_closure.prototype = { + call$1(highlight) { + var t1 = highlight.span; + t1 = t1.get$sourceUrl(t1); + return t1 == null ? new A.Object() : t1; + }, + $signature: 287 + }; + A.Highlighter__collateLines_closure0.prototype = { + call$2(highlight1, highlight2) { + return highlight1.span.compareTo$1(0, highlight2.span); + }, + $signature: 288 + }; + A.Highlighter__collateLines_closure1.prototype = { + call$1(entry) { + var t1, t2, t3, t4, context, t5, linesBeforeSpan, lineNumber, _i, line, activeHighlights, flags, highlightIndex, oldHighlightLength, t6, t7, + url = entry.key, + highlightsForFile = entry.value, + lines = A._setArrayType([], type$.JSArray__Line); + for (t1 = J.getInterceptor$ax(highlightsForFile), t2 = t1.get$iterator(highlightsForFile), t3 = type$.JSArray__Highlight; t2.moveNext$0();) { + t4 = t2.get$current(t2).span; + context = t4.get$context(t4); + t5 = A.findLineStart(context, t4.get$text(), t4.get$start(t4).get$column()); + t5.toString; + linesBeforeSpan = B.JSString_methods.allMatches$1("\n", B.JSString_methods.substring$2(context, 0, t5)).get$length(0); + lineNumber = t4.get$start(t4).get$line() - linesBeforeSpan; + for (t4 = context.split("\n"), t5 = t4.length, _i = 0; _i < t5; ++_i) { + line = t4[_i]; + if (lines.length === 0 || lineNumber > B.JSArray_methods.get$last(lines).number) + lines.push(new A._Line(line, lineNumber, url, A._setArrayType([], t3))); + ++lineNumber; + } + } + activeHighlights = A._setArrayType([], t3); + for (t2 = lines.length, flags = activeHighlights.$flags | 0, highlightIndex = 0, _i = 0; _i < lines.length; lines.length === t2 || (0, A.throwConcurrentModificationError)(lines), ++_i) { + line = lines[_i]; + flags & 1 && A.throwUnsupportedOperation(activeHighlights, 16); + B.JSArray_methods._removeWhere$2(activeHighlights, new A.Highlighter__collateLines__closure(line), true); + oldHighlightLength = activeHighlights.length; + for (t3 = t1.skip$1(highlightsForFile, highlightIndex), t4 = t3.$ti, t3 = new A.ListIterator(t3, t3.get$length(0), t4._eval$1("ListIterator")), t5 = line.number, t4 = t4._eval$1("ListIterable.E"); t3.moveNext$0();) { + t6 = t3.__internal$_current; + if (t6 == null) + t6 = t4._as(t6); + t7 = t6.span; + if (t7.get$start(t7).get$line() > t5) + break; + activeHighlights.push(t6); + } + highlightIndex += activeHighlights.length - oldHighlightLength; + B.JSArray_methods.addAll$1(line.highlights, activeHighlights); + } + return lines; + }, + $signature: 289 + }; + A.Highlighter__collateLines__closure.prototype = { + call$1(highlight) { + var t1 = highlight.span; + return t1.get$end(t1).get$line() < this.line.number; + }, + $signature: 117 + }; + A.Highlighter_highlight_closure.prototype = { + call$1(highlight) { + return highlight.isPrimary; + }, + $signature: 117 + }; + A.Highlighter__writeFileStart_closure.prototype = { + call$0() { + var t1 = this.$this._highlighter$_buffer, + t2 = B.JSString_methods.$mul($._glyphs.get$horizontalLine(), 2) + ">"; + t1._contents += t2; + return null; + }, + $signature: 0 + }; + A.Highlighter__writeMultilineHighlights_closure.prototype = { + call$0() { + var t1 = this.$this._highlighter$_buffer, + t2 = $._glyphs; + t2 = this.startLine === this.line.number ? t2.get$topLeftCorner() : t2.get$bottomLeftCorner(); + t1._contents += t2; + }, + $signature: 1 + }; + A.Highlighter__writeMultilineHighlights_closure0.prototype = { + call$0() { + var t1 = this.$this._highlighter$_buffer, + t2 = $._glyphs; + t2 = this.highlight == null ? t2.get$horizontalLine() : t2.get$cross(); + t1._contents += t2; + }, + $signature: 1 + }; + A.Highlighter__writeMultilineHighlights_closure1.prototype = { + call$0() { + var t1 = this.$this._highlighter$_buffer, + t2 = $._glyphs.get$horizontalLine(); + t1._contents += t2; + return null; + }, + $signature: 0 + }; + A.Highlighter__writeMultilineHighlights_closure2.prototype = { + call$0() { + var _this = this, + t1 = _this._box_0, + t2 = t1.openedOnThisLine, + t3 = $._glyphs, + vertical = t2 ? t3.get$cross() : t3.get$verticalLine(); + if (_this.current != null) + _this.$this._highlighter$_buffer._contents += vertical; + else { + t2 = _this.line; + t3 = t2.number; + if (_this.startLine === t3) { + t2 = _this.$this; + t2._colorize$2$color(new A.Highlighter__writeMultilineHighlights__closure(t1, t2), t1.openedOnThisLineColor); + t1.openedOnThisLine = true; + if (t1.openedOnThisLineColor == null) + t1.openedOnThisLineColor = _this.highlight.isPrimary ? t2._primaryColor : t2._secondaryColor; + } else { + if (_this.endLine === t3) { + t3 = _this.highlight.span; + t2 = t3.get$end(t3).get$column() === t2.text.length; + } else + t2 = false; + t3 = _this.$this; + if (t2) { + t1 = t3._highlighter$_buffer; + t2 = _this.highlight.label == null ? $._glyphs.glyphOrAscii$2("\u2514", "\\") : vertical; + t1._contents += t2; + } else + t3._colorize$2$color(new A.Highlighter__writeMultilineHighlights__closure0(t3, vertical), t1.openedOnThisLineColor); + } + } + }, + $signature: 1 + }; + A.Highlighter__writeMultilineHighlights__closure.prototype = { + call$0() { + var t1 = this.$this._highlighter$_buffer, + t2 = this._box_0.openedOnThisLine ? "\u252c" : "\u250c"; + t2 = $._glyphs.glyphOrAscii$2(t2, "/"); + t1._contents += t2; + }, + $signature: 1 + }; + A.Highlighter__writeMultilineHighlights__closure0.prototype = { + call$0() { + this.$this._highlighter$_buffer._contents += this.vertical; + }, + $signature: 1 + }; + A.Highlighter__writeHighlightedText_closure.prototype = { + call$0() { + var _this = this; + return _this.$this._writeText$1(B.JSString_methods.substring$2(_this.text, _this.startColumn, _this.endColumn)); + }, + $signature: 0 + }; + A.Highlighter__writeIndicator_closure.prototype = { + call$0() { + var startColumn, endColumn, tabsBefore, tabsInside, + t1 = this.$this, + t2 = t1._highlighter$_buffer, + t3 = t2._contents, + t4 = this.highlight, + t5 = t4.span; + t4 = t4.isPrimary ? "^" : $._glyphs.get$horizontalLineBold(); + startColumn = t5.get$start(t5).get$column(); + endColumn = t5.get$end(t5).get$column(); + t5 = this.line.text; + tabsBefore = t1._countTabs$1(B.JSString_methods.substring$2(t5, 0, startColumn)); + tabsInside = t1._countTabs$1(B.JSString_methods.substring$2(t5, startColumn, endColumn)); + startColumn += tabsBefore * 3; + t5 = B.JSString_methods.$mul(" ", startColumn); + t2._contents += t5; + t4 = B.JSString_methods.$mul(t4, Math.max(endColumn + (tabsBefore + tabsInside) * 3 - startColumn, 1)); + t4 = t2._contents += t4; + return t4.length - t3.length; + }, + $signature: 10 + }; + A.Highlighter__writeIndicator_closure0.prototype = { + call$0() { + var t1 = this.highlight.span; + return this.$this._writeArrow$2(this.line, t1.get$start(t1).get$column()); + }, + $signature: 0 + }; + A.Highlighter__writeIndicator_closure1.prototype = { + call$0() { + var t4, _this = this, + t1 = _this.$this, + t2 = t1._highlighter$_buffer, + t3 = t2._contents; + if (_this.coversWholeLine) { + t1 = B.JSString_methods.$mul($._glyphs.get$horizontalLine(), 3); + t2._contents += t1; + } else { + t4 = _this.highlight.span; + t1._writeArrow$3$beginning(_this.line, Math.max(t4.get$end(t4).get$column() - 1, 0), false); + } + return t2._contents.length - t3.length; + }, + $signature: 10 + }; + A.Highlighter__writeLabel_closure.prototype = { + call$0() { + var t1 = this.$this._highlighter$_buffer, + t2 = " " + A.S(B.JSArray_methods.get$first(this.lines)); + t1._contents += t2; + return null; + }, + $signature: 0 + }; + A.Highlighter__writeLabel_closure0.prototype = { + call$0() { + this.$this._highlighter$_buffer._contents += " " + this.text; + return null; + }, + $signature: 0 + }; + A.Highlighter__writeSidebar_closure.prototype = { + call$0() { + var t1 = this.$this, + t2 = t1._highlighter$_buffer, + t3 = this._box_0.text; + if (t3 == null) + t3 = ""; + t1 = B.JSString_methods.padRight$1(t3, t1._paddingBeforeSidebar); + t2._contents += t1; + t1 = this.end; + if (t1 == null) + t1 = $._glyphs.get$verticalLine(); + t2._contents += t1; + }, + $signature: 1 + }; + A._Highlight.prototype = { + toString$0(_) { + var t1 = this.isPrimary ? "" + "primary " : "", + t2 = this.span; + t2 = t1 + ("" + t2.get$start(t2).get$line() + ":" + t2.get$start(t2).get$column() + "-" + t2.get$end(t2).get$line() + ":" + t2.get$end(t2).get$column()); + t1 = this.label; + t1 = t1 != null ? t2 + (" (" + t1 + ")") : t2; + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + }; + A._Highlight_closure.prototype = { + call$0() { + var t2, t3, t4, t5, + t1 = this.span; + if (!(type$.SourceSpanWithContext._is(t1) && A.findLineStart(t1.get$context(t1), t1.get$text(), t1.get$start(t1).get$column()) != null)) { + t2 = A.SourceLocation$(t1.get$start(t1).get$offset(), 0, 0, t1.get$sourceUrl(t1)); + t3 = t1.get$end(t1).get$offset(); + t4 = t1.get$sourceUrl(t1); + t5 = A.countCodeUnits(t1.get$text(), 10); + t1 = A.SourceSpanWithContext$(t2, A.SourceLocation$(t3, A._Highlight__lastLineLength(t1.get$text()), t5, t4), t1.get$text(), t1.get$text()); + } + return A._Highlight__normalizeEndOfLine(A._Highlight__normalizeTrailingNewline(A._Highlight__normalizeNewlines(t1))); + }, + $signature: 290 + }; + A._Line.prototype = { + toString$0(_) { + return "" + this.number + ': "' + this.text + '" (' + B.JSArray_methods.join$1(this.highlights, ", ") + ")"; + } + }; + A.SourceLocation.prototype = { + distance$1(other) { + var t1 = this.sourceUrl; + if (!J.$eq$(t1, other.get$sourceUrl(other))) + throw A.wrapException(A.ArgumentError$('Source URLs "' + A.S(t1) + '" and "' + A.S(other.get$sourceUrl(other)) + "\" don't match.", null)); + return Math.abs(this.offset - other.get$offset()); + }, + compareTo$1(_, other) { + var t1 = this.sourceUrl; + if (!J.$eq$(t1, other.get$sourceUrl(other))) + throw A.wrapException(A.ArgumentError$('Source URLs "' + A.S(t1) + '" and "' + A.S(other.get$sourceUrl(other)) + "\" don't match.", null)); + return this.offset - other.get$offset(); + }, + $eq(_, other) { + if (other == null) + return false; + return type$.SourceLocation._is(other) && J.$eq$(this.sourceUrl, other.get$sourceUrl(other)) && this.offset === other.get$offset(); + }, + get$hashCode(_) { + var t1 = this.sourceUrl; + t1 = t1 == null ? null : t1.get$hashCode(t1); + if (t1 == null) + t1 = 0; + return t1 + this.offset; + }, + toString$0(_) { + var _this = this, + t1 = A.getRuntimeTypeOfDartObject(_this).toString$0(0), + source = _this.sourceUrl; + return "<" + t1 + ": " + _this.offset + " " + (A.S(source == null ? "unknown source" : source) + ":" + (_this.line + 1) + ":" + (_this.column + 1)) + ">"; + }, + $isComparable: 1, + get$sourceUrl(receiver) { + return this.sourceUrl; + }, + get$offset() { + return this.offset; + }, + get$line() { + return this.line; + }, + get$column() { + return this.column; + } + }; + A.SourceLocationMixin.prototype = { + distance$1(other) { + if (!J.$eq$(this.file.url, other.get$sourceUrl(other))) + throw A.wrapException(A.ArgumentError$('Source URLs "' + A.S(this.get$sourceUrl(0)) + '" and "' + A.S(other.get$sourceUrl(other)) + "\" don't match.", null)); + return Math.abs(this.offset - other.get$offset()); + }, + compareTo$1(_, other) { + if (!J.$eq$(this.file.url, other.get$sourceUrl(other))) + throw A.wrapException(A.ArgumentError$('Source URLs "' + A.S(this.get$sourceUrl(0)) + '" and "' + A.S(other.get$sourceUrl(other)) + "\" don't match.", null)); + return this.offset - other.get$offset(); + }, + $eq(_, other) { + if (other == null) + return false; + return type$.SourceLocation._is(other) && J.$eq$(this.file.url, other.get$sourceUrl(other)) && this.offset === other.get$offset(); + }, + get$hashCode(_) { + var t1 = this.file.url; + t1 = t1 == null ? null : t1.get$hashCode(t1); + if (t1 == null) + t1 = 0; + return t1 + this.offset; + }, + toString$0(_) { + var t1 = A.getRuntimeTypeOfDartObject(this).toString$0(0), + t2 = this.offset, + t3 = this.file, + source = t3.url; + return "<" + t1 + ": " + t2 + " " + (A.S(source == null ? "unknown source" : source) + ":" + (t3.getLine$1(t2) + 1) + ":" + (t3.getColumn$1(t2) + 1)) + ">"; + }, + $isComparable: 1, + $isSourceLocation: 1 + }; + A.SourceSpanBase.prototype = { + SourceSpanBase$3(start, end, text) { + var t3, + t1 = this.end, + t2 = this.start; + if (!J.$eq$(t1.get$sourceUrl(t1), t2.get$sourceUrl(t2))) + throw A.wrapException(A.ArgumentError$('Source URLs "' + A.S(t2.get$sourceUrl(t2)) + '" and "' + A.S(t1.get$sourceUrl(t1)) + "\" don't match.", null)); + else if (t1.get$offset() < t2.get$offset()) + throw A.wrapException(A.ArgumentError$("End " + t1.toString$0(0) + " must come after start " + t2.toString$0(0) + ".", null)); + else { + t3 = this.text; + if (t3.length !== t2.distance$1(t1)) + throw A.wrapException(A.ArgumentError$('Text "' + t3 + '" must be ' + t2.distance$1(t1) + " characters long.", null)); + } + }, + get$start(receiver) { + return this.start; + }, + get$end(receiver) { + return this.end; + }, + get$text() { + return this.text; + } + }; + A.SourceSpanException.prototype = { + get$message(_) { + return this._span_exception$_message; + }, + get$span(_) { + return this._span; + }, + toString$1$color(_, color) { + var _this = this; + _this.get$span(_this); + return "Error on " + _this.get$span(_this).message$2$color(0, _this._span_exception$_message, color); + }, + toString$0(_) { + return this.toString$1$color(0, null); + }, + $isException: 1 + }; + A.SourceSpanFormatException.prototype = {$isFormatException: 1, + get$source() { + return this.source; + } + }; + A.MultiSourceSpanException.prototype = { + toString$0(_) { + var _this = this; + return "Error on " + A.SourceSpanExtension_messageMultiple(_this._span, _this._span_exception$_message, _this.primaryLabel, _this.secondarySpans, false, null, null); + }, + get$primaryLabel() { + return this.primaryLabel; + }, + get$secondarySpans() { + return this.secondarySpans; + } + }; + A.MultiSourceSpanFormatException.prototype = {$isFormatException: 1}; + A.SourceSpanMixin.prototype = { + get$sourceUrl(_) { + var t1 = this.get$start(this); + return t1.get$sourceUrl(t1); + }, + get$length(_) { + var _this = this; + return _this.get$end(_this).get$offset() - _this.get$start(_this).get$offset(); + }, + compareTo$1(_, other) { + var _this = this, + result = _this.get$start(_this).compareTo$1(0, other.get$start(other)); + return result === 0 ? _this.get$end(_this).compareTo$1(0, other.get$end(other)) : result; + }, + message$2$color(_, message, color) { + var t2, t3, highlight, _this = this, + t1 = "" + ("line " + (_this.get$start(_this).get$line() + 1) + ", column " + (_this.get$start(_this).get$column() + 1)); + if (_this.get$sourceUrl(_this) != null) { + t2 = _this.get$sourceUrl(_this); + t3 = $.$get$context(); + t2.toString; + t2 = t1 + (" of " + t3.prettyUri$1(t2)); + t1 = t2; + } + t1 += ": " + message; + highlight = _this.highlight$1$color(color); + if (highlight.length !== 0) + t1 = t1 + "\n" + highlight; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + message$1(_, message) { + return this.message$2$color(0, message, null); + }, + highlight$1$color(color) { + var _this = this; + if (!type$.SourceSpanWithContext._is(_this) && _this.get$length(_this) === 0) + return ""; + return A.Highlighter$(_this, color).highlight$0(); + }, + $eq(_, other) { + var _this = this; + if (other == null) + return false; + return type$.SourceSpan._is(other) && _this.get$start(_this).$eq(0, other.get$start(other)) && _this.get$end(_this).$eq(0, other.get$end(other)); + }, + get$hashCode(_) { + var _this = this; + return A.Object_hash(_this.get$start(_this), _this.get$end(_this), B.C_SentinelValue, B.C_SentinelValue); + }, + toString$0(_) { + var _this = this; + return "<" + A.getRuntimeTypeOfDartObject(_this).toString$0(0) + ": from " + _this.get$start(_this).toString$0(0) + " to " + _this.get$end(_this).toString$0(0) + ' "' + _this.get$text() + '">'; + }, + $isComparable: 1, + $isSourceSpan: 1 + }; + A.SourceSpanWithContext.prototype = { + get$context(_) { + return this._context; + } + }; + A.Chain.prototype = { + toTrace$0() { + var t1 = this.traces; + return A.Trace$(new A.ExpandIterable(t1, new A.Chain_toTrace_closure(), A._arrayInstanceType(t1)._eval$1("ExpandIterable<1,Frame>")), null); + }, + toString$0(_) { + var t1 = this.traces, + t2 = A._arrayInstanceType(t1); + return new A.MappedListIterable(t1, new A.Chain_toString_closure(new A.MappedListIterable(t1, new A.Chain_toString_closure0(), t2._eval$1("MappedListIterable<1,int>")).fold$2(0, 0, B.CONSTANT)), t2._eval$1("MappedListIterable<1,String>")).join$1(0, string$.x3d_____); + }, + $isStackTrace: 1 + }; + A.Chain_Chain$parse_closure.prototype = { + call$1(line) { + return line.length !== 0; + }, + $signature: 5 + }; + A.Chain_toTrace_closure.prototype = { + call$1(trace) { + return trace.get$frames(); + }, + $signature: 291 + }; + A.Chain_toString_closure0.prototype = { + call$1(trace) { + var t1 = trace.get$frames(); + return new A.MappedListIterable(t1, new A.Chain_toString__closure0(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,int>")).fold$2(0, 0, B.CONSTANT); + }, + $signature: 292 + }; + A.Chain_toString__closure0.prototype = { + call$1(frame) { + return frame.get$location().length; + }, + $signature: 192 + }; + A.Chain_toString_closure.prototype = { + call$1(trace) { + var t1 = trace.get$frames(); + return new A.MappedListIterable(t1, new A.Chain_toString__closure(this.longest), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,String>")).join$0(0); + }, + $signature: 294 + }; + A.Chain_toString__closure.prototype = { + call$1(frame) { + return B.JSString_methods.padRight$1(frame.get$location(), this.longest) + " " + A.S(frame.get$member()) + "\n"; + }, + $signature: 193 + }; + A.Frame.prototype = { + get$isCore() { + return this.uri.get$scheme() === "dart"; + }, + get$library() { + var t1 = this.uri; + if (t1.get$scheme() === "data") + return "data:..."; + return $.$get$context().prettyUri$1(t1); + }, + get$$package() { + var t1 = this.uri; + if (t1.get$scheme() !== "package") + return null; + return B.JSArray_methods.get$first(t1.get$path(t1).split("/")); + }, + get$location() { + var t2, _this = this, + t1 = _this.line; + if (t1 == null) + return _this.get$library(); + t2 = _this.column; + if (t2 == null) + return _this.get$library() + " " + A.S(t1); + return _this.get$library() + " " + A.S(t1) + ":" + A.S(t2); + }, + toString$0(_) { + return this.get$location() + " in " + A.S(this.member); + }, + get$uri() { + return this.uri; + }, + get$line() { + return this.line; + }, + get$column() { + return this.column; + }, + get$member() { + return this.member; + } + }; + A.Frame_Frame$parseVM_closure.prototype = { + call$0() { + var match, t2, t3, member, uri, lineAndColumn, line, _null = null, + t1 = this.frame; + if (t1 === "...") + return new A.Frame(A._Uri__Uri(_null, _null, _null, _null), _null, _null, "..."); + match = $.$get$_vmFrame().firstMatch$1(t1); + if (match == null) + return new A.UnparsedFrame(A._Uri__Uri(_null, "unparsed", _null, _null), t1); + t1 = match._match; + t2 = t1[1]; + t2.toString; + t3 = $.$get$_asyncBody(); + t2 = A.stringReplaceAllUnchecked(t2, t3, ""); + member = A.stringReplaceAllUnchecked(t2, "", ""); + t2 = t1[2]; + t3 = t2; + t3.toString; + if (B.JSString_methods.startsWith$1(t3, " 1 ? A.int_parse(lineAndColumn[1], _null) : _null; + return new A.Frame(uri, line, t1 > 2 ? A.int_parse(lineAndColumn[2], _null) : _null, member); + }, + $signature: 69 + }; + A.Frame_Frame$parseV8_closure.prototype = { + call$0() { + var member, uri, t2, functionOffset, t3, _s4_ = "", + t1 = this.frame, + match = $.$get$_v8WasmFrame().firstMatch$1(t1); + if (match != null) { + member = match.namedGroup$1("member"); + t1 = match.namedGroup$1("uri"); + t1.toString; + uri = A.Frame__uriOrPathToUri(t1); + t1 = match.namedGroup$1("index"); + t1.toString; + t2 = match.namedGroup$1("offset"); + t2.toString; + functionOffset = A.int_parse(t2, 16); + if (!(member == null)) + t1 = member; + return new A.Frame(uri, 1, functionOffset + 1, t1); + } + match = $.$get$_v8JsFrame().firstMatch$1(t1); + if (match != null) { + t1 = new A.Frame_Frame$parseV8_closure_parseJsLocation(t1); + t2 = match._match; + t3 = t2[2]; + if (t3 != null) { + t3 = t3; + t3.toString; + t2 = t2[1]; + t2.toString; + t2 = A.stringReplaceAllUnchecked(t2, "", _s4_); + t2 = A.stringReplaceAllUnchecked(t2, "Anonymous function", _s4_); + return t1.call$2(t3, A.stringReplaceAllUnchecked(t2, "(anonymous function)", _s4_)); + } else { + t2 = t2[3]; + t2.toString; + return t1.call$2(t2, _s4_); + } + } + return new A.UnparsedFrame(A._Uri__Uri(null, "unparsed", null, null), t1); + }, + $signature: 69 + }; + A.Frame_Frame$parseV8_closure_parseJsLocation.prototype = { + call$2($location, member) { + var t2, urlMatch, uri, line, columnMatch, _null = null, + t1 = $.$get$_v8EvalLocation(), + evalMatch = t1.firstMatch$1($location); + for (; evalMatch != null; $location = t2) { + t2 = evalMatch._match[1]; + t2.toString; + evalMatch = t1.firstMatch$1(t2); + } + if ($location === "native") + return new A.Frame(A.Uri_parse("native"), _null, _null, member); + urlMatch = $.$get$_v8JsUrlLocation().firstMatch$1($location); + if (urlMatch == null) + return new A.UnparsedFrame(A._Uri__Uri(_null, "unparsed", _null, _null), this.frame); + t1 = urlMatch._match; + t2 = t1[1]; + t2.toString; + uri = A.Frame__uriOrPathToUri(t2); + t2 = t1[2]; + t2.toString; + line = A.int_parse(t2, _null); + columnMatch = t1[3]; + return new A.Frame(uri, line, columnMatch != null ? A.int_parse(columnMatch, _null) : _null, member); + }, + $signature: 297 + }; + A.Frame_Frame$_parseFirefoxEval_closure.prototype = { + call$0() { + var t2, member, uri, line, _null = null, + t1 = this.frame, + match = $.$get$_firefoxEvalLocation().firstMatch$1(t1); + if (match == null) + return new A.UnparsedFrame(A._Uri__Uri(_null, "unparsed", _null, _null), t1); + t1 = match._match; + t2 = t1[1]; + t2.toString; + member = A.stringReplaceAllUnchecked(t2, "/<", ""); + t2 = t1[2]; + t2.toString; + uri = A.Frame__uriOrPathToUri(t2); + t1 = t1[3]; + t1.toString; + line = A.int_parse(t1, _null); + return new A.Frame(uri, line, _null, member.length === 0 || member === "anonymous" ? "" : member); + }, + $signature: 69 + }; + A.Frame_Frame$parseFirefox_closure.prototype = { + call$0() { + var t2, t3, t4, uri, member, line, column, functionOffset, _null = null, + t1 = this.frame, + match = $.$get$_firefoxSafariJSFrame().firstMatch$1(t1); + if (match != null) { + t2 = match._match; + t3 = t2[3]; + t4 = t3; + t4.toString; + if (B.JSString_methods.contains$1(t4, " line ")) + return A.Frame_Frame$_parseFirefoxEval(t1); + t1 = t3; + t1.toString; + uri = A.Frame__uriOrPathToUri(t1); + member = t2[1]; + if (member != null) { + t1 = t2[2]; + t1.toString; + member += B.JSArray_methods.join$0(A.List_List$filled(B.JSString_methods.allMatches$1("/", t1).get$length(0), ".", false, type$.String)); + if (member === "") + member = ""; + member = B.JSString_methods.replaceFirst$2(member, $.$get$_initialDot(), ""); + } else + member = ""; + t1 = t2[4]; + if (t1 === "") + line = _null; + else { + t1 = t1; + t1.toString; + line = A.int_parse(t1, _null); + } + t1 = t2[5]; + if (t1 == null || t1 === "") + column = _null; + else { + t1 = t1; + t1.toString; + column = A.int_parse(t1, _null); + } + return new A.Frame(uri, line, column, member); + } + match = $.$get$_firefoxWasmFrame().firstMatch$1(t1); + if (match != null) { + t1 = match.namedGroup$1("member"); + t1.toString; + t2 = match.namedGroup$1("uri"); + t2.toString; + uri = A.Frame__uriOrPathToUri(t2); + t2 = match.namedGroup$1("index"); + t2.toString; + t3 = match.namedGroup$1("offset"); + t3.toString; + functionOffset = A.int_parse(t3, 16); + if (!(t1.length !== 0)) + t1 = t2; + return new A.Frame(uri, 1, functionOffset + 1, t1); + } + match = $.$get$_safariWasmFrame().firstMatch$1(t1); + if (match != null) { + t1 = match.namedGroup$1("member"); + t1.toString; + return new A.Frame(A._Uri__Uri(_null, "wasm code", _null, _null), _null, _null, t1); + } + return new A.UnparsedFrame(A._Uri__Uri(_null, "unparsed", _null, _null), t1); + }, + $signature: 69 + }; + A.Frame_Frame$parseFriendly_closure.prototype = { + call$0() { + var t2, uri, line, column, _null = null, + t1 = this.frame, + match = $.$get$_friendlyFrame().firstMatch$1(t1); + if (match == null) + throw A.wrapException(A.FormatException$("Couldn't parse package:stack_trace stack trace line '" + t1 + "'.", _null, _null)); + t1 = match._match; + t2 = t1[1]; + if (t2 === "data:...") + uri = A.Uri_Uri$dataFromString("", _null, _null); + else { + t2 = t2; + t2.toString; + uri = A.Uri_parse(t2); + } + if (uri.get$scheme() === "") { + t2 = $.$get$context(); + uri = t2.toUri$1(A.absolute(t2.style.pathFromUri$1(A._parseUri(uri)), _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null)); + } + t2 = t1[2]; + if (t2 == null) + line = _null; + else { + t2 = t2; + t2.toString; + line = A.int_parse(t2, _null); + } + t2 = t1[3]; + if (t2 == null) + column = _null; + else { + t2 = t2; + t2.toString; + column = A.int_parse(t2, _null); + } + return new A.Frame(uri, line, column, t1[4]); + }, + $signature: 69 + }; + A.LazyTrace.prototype = { + get$_lazy_trace$_trace() { + var result, _this = this, + value = _this.__LazyTrace__trace_FI; + if (value === $) { + result = _this._thunk.call$0(); + _this.__LazyTrace__trace_FI !== $ && A.throwUnnamedLateFieldADI(); + _this.__LazyTrace__trace_FI = result; + value = result; + } + return value; + }, + get$frames() { + return this.get$_lazy_trace$_trace().get$frames(); + }, + get$terse() { + return new A.LazyTrace(new A.LazyTrace_terse_closure(this)); + }, + toString$0(_) { + return this.get$_lazy_trace$_trace().toString$0(0); + }, + $isStackTrace: 1, + $isTrace: 1 + }; + A.LazyTrace_terse_closure.prototype = { + call$0() { + return this.$this.get$_lazy_trace$_trace().get$terse(); + }, + $signature: 195 + }; + A.Trace.prototype = { + get$terse() { + return this.foldFrames$2$terse(new A.Trace_terse_closure(), true); + }, + foldFrames$2$terse(predicate, terse) { + var newFrames, t1, t2, t3, _box_0 = {}; + _box_0.predicate = predicate; + _box_0.predicate = new A.Trace_foldFrames_closure(predicate); + newFrames = A._setArrayType([], type$.JSArray_Frame); + for (t1 = this.frames, t2 = A._arrayInstanceType(t1)._eval$1("ReversedListIterable<1>"), t1 = new A.ReversedListIterable(t1, t2), t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListIterable.E"); t1.moveNext$0();) { + t3 = t1.__internal$_current; + if (t3 == null) + t3 = t2._as(t3); + if (t3 instanceof A.UnparsedFrame || !_box_0.predicate.call$1(t3)) + newFrames.push(t3); + else if (newFrames.length === 0 || !_box_0.predicate.call$1(B.JSArray_methods.get$last(newFrames))) + newFrames.push(new A.Frame(t3.get$uri(), t3.get$line(), t3.get$column(), t3.get$member())); + } + t1 = type$.MappedListIterable_Frame_Frame; + newFrames = A.List_List$of(new A.MappedListIterable(newFrames, new A.Trace_foldFrames_closure0(_box_0), t1), true, t1._eval$1("ListIterable.E")); + if (newFrames.length > 1 && _box_0.predicate.call$1(B.JSArray_methods.get$first(newFrames))) + B.JSArray_methods.removeAt$1(newFrames, 0); + return A.Trace$(new A.ReversedListIterable(newFrames, A._arrayInstanceType(newFrames)._eval$1("ReversedListIterable<1>")), this.original._stackTrace); + }, + toString$0(_) { + var t1 = this.frames, + t2 = A._arrayInstanceType(t1); + return new A.MappedListIterable(t1, new A.Trace_toString_closure(new A.MappedListIterable(t1, new A.Trace_toString_closure0(), t2._eval$1("MappedListIterable<1,int>")).fold$2(0, 0, B.CONSTANT)), t2._eval$1("MappedListIterable<1,String>")).join$0(0); + }, + $isStackTrace: 1, + get$frames() { + return this.frames; + } + }; + A.Trace_Trace$from_closure.prototype = { + call$0() { + return A.Trace_Trace$parse(this.trace.toString$0(0)); + }, + $signature: 195 + }; + A.Trace__parseVM_closure.prototype = { + call$1(line) { + return line.length !== 0; + }, + $signature: 5 + }; + A.Trace$parseV8_closure.prototype = { + call$1(line) { + return !B.JSString_methods.startsWith$1(line, $.$get$_v8TraceLine()); + }, + $signature: 5 + }; + A.Trace$parseJSCore_closure.prototype = { + call$1(line) { + return line !== "\tat "; + }, + $signature: 5 + }; + A.Trace$parseFirefox_closure.prototype = { + call$1(line) { + return line.length !== 0 && line !== "[native code]"; + }, + $signature: 5 + }; + A.Trace$parseFriendly_closure.prototype = { + call$1(line) { + return !B.JSString_methods.startsWith$1(line, "====="); + }, + $signature: 5 + }; + A.Trace_terse_closure.prototype = { + call$1(_) { + return false; + }, + $signature: 196 + }; + A.Trace_foldFrames_closure.prototype = { + call$1(frame) { + var t1; + if (this.oldPredicate.call$1(frame)) + return true; + if (frame.get$isCore()) + return true; + if (frame.get$$package() === "stack_trace") + return true; + t1 = frame.get$member(); + t1.toString; + if (!B.JSString_methods.contains$1(t1, "")) + return false; + return frame.get$line() == null; + }, + $signature: 196 + }; + A.Trace_foldFrames_closure0.prototype = { + call$1(frame) { + var t1, t2; + if (frame instanceof A.UnparsedFrame || !this._box_0.predicate.call$1(frame)) + return frame; + t1 = frame.get$library(); + t2 = $.$get$_terseRegExp(); + return new A.Frame(A.Uri_parse(A.stringReplaceAllUnchecked(t1, t2, "")), null, null, frame.get$member()); + }, + $signature: 300 + }; + A.Trace_toString_closure0.prototype = { + call$1(frame) { + return frame.get$location().length; + }, + $signature: 192 + }; + A.Trace_toString_closure.prototype = { + call$1(frame) { + if (frame instanceof A.UnparsedFrame) + return frame.toString$0(0) + "\n"; + return B.JSString_methods.padRight$1(frame.get$location(), this.longest) + " " + A.S(frame.get$member()) + "\n"; + }, + $signature: 193 + }; + A.UnparsedFrame.prototype = { + toString$0(_) { + return this.member; + }, + $isFrame: 1, + get$uri() { + return this.uri; + }, + get$line() { + return null; + }, + get$column() { + return null; + }, + get$isCore() { + return false; + }, + get$library() { + return "unparsed"; + }, + get$$package() { + return null; + }, + get$location() { + return "unparsed"; + }, + get$member() { + return this.member; + } + }; + A.TransformByHandlers_transformByHandlers_closure.prototype = { + call$0() { + var t2, subscription, t3, t4, _this = this, t1 = {}; + t1.valuesDone = false; + t2 = _this.controller; + subscription = _this._this.listen$3$onDone$onError(0, new A.TransformByHandlers_transformByHandlers__closure(_this.onData, t2, _this.S), new A.TransformByHandlers_transformByHandlers__closure0(t1, _this.handleDone, t2), new A.TransformByHandlers_transformByHandlers__closure1(_this.handleError, t2)); + t3 = _this._box_1; + t3.subscription = subscription; + t2.set$onPause(subscription.get$pause(subscription)); + t4 = t3.subscription; + t2.set$onResume(t4.get$resume(t4)); + t2.set$onCancel(new A.TransformByHandlers_transformByHandlers__closure2(t3, t1)); + }, + $signature: 0 + }; + A.TransformByHandlers_transformByHandlers__closure.prototype = { + call$1(value) { + return this.onData.call$2(value, this.controller); + }, + $signature() { + return this.S._eval$1("~(0)"); + } + }; + A.TransformByHandlers_transformByHandlers__closure1.prototype = { + call$2(error, stackTrace) { + this.handleError.call$3(error, stackTrace, this.controller); + }, + $signature: 46 + }; + A.TransformByHandlers_transformByHandlers__closure0.prototype = { + call$0() { + this._box_0.valuesDone = true; + this.handleDone.call$1(this.controller); + }, + $signature: 0 + }; + A.TransformByHandlers_transformByHandlers__closure2.prototype = { + call$0() { + var t1 = this._box_1, + toCancel = t1.subscription; + t1.subscription = null; + if (!this._box_0.valuesDone) + return toCancel.cancel$0(); + return null; + }, + $signature: 224 + }; + A.RateLimit__debounceAggregate_closure.prototype = { + call$2(value, sink) { + var _this = this, + t1 = _this._box_0, + t2 = new A.RateLimit__debounceAggregate_closure_emit(t1, sink, _this.S), + t3 = t1.timer; + if (t3 != null) + t3.cancel$0(); + t1.soFar = _this.collect.call$2(value, t1.soFar); + t1.hasPending = true; + if (t1.timer == null && _this.leading) { + t1.emittedLatestAsLeading = true; + t2.call$0(); + } else + t1.emittedLatestAsLeading = false; + t1.timer = A.Timer_Timer(_this.duration, new A.RateLimit__debounceAggregate__closure(t1, _this.trailing, t2, sink)); + }, + $signature() { + return this.T._eval$1("@<0>")._bind$1(this.S)._eval$1("~(1,EventSink<2>)"); + } + }; + A.RateLimit__debounceAggregate_closure_emit.prototype = { + call$0() { + var t1 = this._box_0, + t2 = t1.soFar; + if (t2 == null) + t2 = this.S._as(t2); + this.sink.add$1(0, t2); + t1.soFar = null; + t1.hasPending = false; + }, + $signature: 0 + }; + A.RateLimit__debounceAggregate__closure.prototype = { + call$0() { + var t1 = this._box_0, + t2 = t1.emittedLatestAsLeading; + if (!t2) + this.emit.call$0(); + if (t1.shouldClose) + this.sink.close$0(0); + t1.timer = null; + }, + $signature: 0 + }; + A.RateLimit__debounceAggregate_closure0.prototype = { + call$1(sink) { + var t1 = this._box_0; + if (t1.hasPending && this.trailing) + t1.shouldClose = true; + else { + t1 = t1.timer; + if (t1 != null) + t1.cancel$0(); + sink.close$0(0); + } + }, + $signature() { + return this.S._eval$1("~(EventSink<0>)"); + } + }; + A.StringScannerException.prototype = { + get$source() { + return A._asString(this.source); + } + }; + A.LineScanner.prototype = { + scanChar$1(character) { + if (!this.super$StringScanner$scanChar(character)) + return false; + this._adjustLineAndColumn$1(character); + return true; + }, + readChar$0() { + var character = this.super$StringScanner$readChar(); + this._adjustLineAndColumn$1(character); + return character; + }, + _adjustLineAndColumn$1(character) { + var t1, _this = this; + if (character !== 10) + t1 = character === 13 && _this.peekChar$0() !== 10; + else + t1 = true; + if (t1) { + ++_this._line_scanner$_line; + _this._line_scanner$_column = 0; + } else { + t1 = _this._line_scanner$_column; + _this._line_scanner$_column = t1 + (character >= 65536 && character <= 1114111 ? 2 : 1); + } + }, + scan$1(pattern) { + var t1, newlines, t2, _this = this; + if (!_this.super$StringScanner$scan(pattern)) + return false; + t1 = _this.get$lastMatch(); + newlines = _this._newlinesIn$2$endPosition(t1.pattern, _this._string_scanner$_position); + t1 = _this._line_scanner$_line; + t2 = newlines.length; + _this._line_scanner$_line = t1 + t2; + if (t2 === 0) { + t1 = _this._line_scanner$_column; + t2 = _this.get$lastMatch(); + _this._line_scanner$_column = t1 + t2.pattern.length; + } else { + t1 = _this.get$lastMatch(); + _this._line_scanner$_column = t1.pattern.length - J.get$end$z(B.JSArray_methods.get$last(newlines)); + } + return true; + }, + _newlinesIn$2$endPosition(text, endPosition) { + var t1 = $.$get$_newlineRegExp().allMatches$1(0, text), + newlines = A.List_List$of(t1, true, A._instanceType(t1)._eval$1("Iterable.E")); + t1 = this.string; + if (endPosition < t1.length && B.JSString_methods.endsWith$1(text, "\r") && t1[endPosition] === "\n") + B.JSArray_methods.removeLast$0(newlines); + return newlines; + } + }; + A.SpanScanner.prototype = { + set$state(state) { + if (state._scanner !== this) + throw A.wrapException(A.ArgumentError$(string$.The_gi, null)); + this.set$position(state.position); + }, + spanFrom$2(startState, endState) { + var endPosition = endState == null ? this._string_scanner$_position : endState.position; + return this._sourceFile.span$2(0, startState.position, endPosition); + }, + spanFrom$1(startState) { + return this.spanFrom$2(startState, null); + }, + spanFromPosition$1(startPosition) { + var t1 = this._string_scanner$_position; + return this._sourceFile.span$2(0, startPosition, t1); + }, + matches$1(pattern) { + var t1, t2, _this = this; + if (!_this.super$StringScanner$matches(pattern)) + return false; + t1 = _this._string_scanner$_position; + t2 = _this.get$lastMatch(); + _this._sourceFile.span$2(0, t1, t2.start + t2.pattern.length); + return true; + }, + error$3$length$position(_, message, $length, position) { + var match, t2, _this = this, + t1 = _this.string; + A.validateErrorArgs(t1, null, position, $length); + match = position == null && $length == null ? _this.get$lastMatch() : null; + if (position == null) + position = match == null ? _this._string_scanner$_position : match.start; + if ($length == null) + if (match == null) + $length = 0; + else { + t2 = match.start; + $length = t2 + match.pattern.length - t2; + } + throw A.wrapException(A.StringScannerException$(message, _this._sourceFile.span$2(0, position, position + $length), t1)); + }, + error$1(_, message) { + return this.error$3$length$position(0, message, null, null); + }, + error$2$position(_, message, position) { + return this.error$3$length$position(0, message, null, position); + }, + error$2$length(_, message, $length) { + return this.error$3$length$position(0, message, $length, null); + } + }; + A._SpanScannerState.prototype = {}; + A.StringScanner.prototype = { + set$position(position) { + if (B.JSInt_methods.get$isNegative(position) || position > this.string.length) + throw A.wrapException(A.ArgumentError$("Invalid position " + position, null)); + this._string_scanner$_position = position; + this._lastMatch = null; + }, + get$lastMatch() { + var _this = this; + if (_this._string_scanner$_position !== _this._lastMatchPosition) + _this._lastMatch = null; + return _this._lastMatch; + }, + readChar$0() { + var _this = this, + t1 = _this.string; + if (_this._string_scanner$_position === t1.length) + _this._fail$1("more input"); + return t1.charCodeAt(_this._string_scanner$_position++); + }, + peekChar$1(offset) { + var index; + if (offset == null) + offset = 0; + index = this._string_scanner$_position + offset; + if (index < 0 || index >= this.string.length) + return null; + return this.string.charCodeAt(index); + }, + peekChar$0() { + return this.peekChar$1(null); + }, + scanChar$1(character) { + var t1, t2, t3, t4, _this = this; + if (character >= 65536 && character <= 1114111) { + t1 = _this._string_scanner$_position; + t2 = t1 + 1; + t3 = _this.string; + if (t2 < t3.length) { + t4 = character - 65536; + t2 = t3.charCodeAt(t1) !== B.JSInt_methods._shrOtherPositive$1(t4, 10) + 55296 || t3.charCodeAt(t2) !== (t4 & 1023) + 56320; + } else + t2 = true; + if (t2) + return false; + else { + _this._string_scanner$_position = t1 + 2; + return true; + } + } else { + t1 = _this._string_scanner$_position; + t2 = _this.string; + if (t1 === t2.length) + return false; + if (t2.charCodeAt(t1) !== character) + return false; + _this._string_scanner$_position = t1 + 1; + return true; + } + }, + expectChar$2$name(character, $name) { + if (this.scanChar$1(character)) + return; + if ($name == null) + if (character === 92) + $name = '"\\"'; + else + $name = character === 34 ? '"\\""' : '"' + A.Primitives_stringFromCharCode(character) + '"'; + this._fail$1($name); + }, + expectChar$1(character) { + return this.expectChar$2$name(character, null); + }, + scan$1(pattern) { + var t1, _this = this, + success = _this.matches$1(pattern); + if (success) { + t1 = _this._lastMatch; + _this._lastMatchPosition = _this._string_scanner$_position = t1.start + t1.pattern.length; + } + return success; + }, + expect$1(pattern) { + var t1, $name; + if (this.scan$1(pattern)) + return; + t1 = A.stringReplaceAllUnchecked(pattern, "\\", "\\\\"); + $name = '"' + A.stringReplaceAllUnchecked(t1, '"', '\\"') + '"'; + this._fail$1($name); + }, + expectDone$0() { + if (this._string_scanner$_position === this.string.length) + return; + this._fail$1("no more input"); + }, + matches$1(pattern) { + var _this = this, + t1 = B.JSString_methods.matchAsPrefix$2(pattern, _this.string, _this._string_scanner$_position); + _this._lastMatch = t1; + _this._lastMatchPosition = _this._string_scanner$_position; + return t1 != null; + }, + substring$1(_, start) { + var end = this._string_scanner$_position; + return B.JSString_methods.substring$2(this.string, start, end); + }, + error$3$length$position(_, message, $length, position) { + var match, t2, _this = this, + t1 = _this.string; + A.validateErrorArgs(t1, null, position, $length); + match = position == null && $length == null ? _this.get$lastMatch() : null; + if (position == null) + position = match == null ? _this._string_scanner$_position : match.start; + if ($length == null) + if (match == null) + $length = 0; + else { + t2 = match.start; + $length = t2 + match.pattern.length - t2; + } + throw A.wrapException(A.StringScannerException$(message, A.SourceFile$fromString(t1, _this.sourceUrl).span$2(0, position, position + $length), t1)); + }, + error$1(_, message) { + return this.error$3$length$position(0, message, null, null); + }, + _fail$1($name) { + this.error$3$length$position(0, "expected " + $name + ".", 0, this._string_scanner$_position); + } + }; + A.AsciiGlyphSet.prototype = { + glyphOrAscii$2(glyph, alternative) { + return alternative; + }, + get$horizontalLine() { + return "-"; + }, + get$verticalLine() { + return "|"; + }, + get$topLeftCorner() { + return ","; + }, + get$bottomLeftCorner() { + return "'"; + }, + get$cross() { + return "+"; + }, + get$upEnd() { + return "'"; + }, + get$downEnd() { + return ","; + }, + get$horizontalLineBold() { + return "="; + } + }; + A.UnicodeGlyphSet.prototype = { + glyphOrAscii$2(glyph, alternative) { + return glyph; + }, + get$horizontalLine() { + return "\u2500"; + }, + get$verticalLine() { + return "\u2502"; + }, + get$topLeftCorner() { + return "\u250c"; + }, + get$bottomLeftCorner() { + return "\u2514"; + }, + get$cross() { + return "\u253c"; + }, + get$upEnd() { + return "\u2575"; + }, + get$downEnd() { + return "\u2577"; + }, + get$horizontalLineBold() { + return "\u2501"; + } + }; + A.WatchEvent.prototype = { + toString$0(_) { + return this.type.toString$0(0) + " " + this.path; + } + }; + A.ChangeType.prototype = { + toString$0(_) { + return this._watch_event$_name; + } + }; + A.A98RgbColorSpace0.prototype = { + get$isBoundedInternal() { + return true; + }, + toLinear$1(channel) { + return J.get$sign$in(channel) * Math.pow(Math.abs(channel), 2.19921875); + }, + fromLinear$1(channel) { + return J.get$sign$in(channel) * Math.pow(Math.abs(channel), 0.4547069271758437); + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.SrgbLinearColorSpace_kUj0 === dest || B.SrgbColorSpace_thf0 === dest || B.RgbColorSpace_i0P0 === dest) { + t1 = $.$get$linearA98RgbToLinearSrgb0(); + break $label0$0; + } + if (B.DisplayP3ColorSpace_MmT0 === dest) { + t1 = $.$get$linearA98RgbToLinearDisplayP30(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz0 === dest) { + t1 = $.$get$linearA98RgbToLinearProphotoRgb0(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo0 === dest) { + t1 = $.$get$linearA98RgbToLinearRec20200(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ0 === dest) { + t1 = $.$get$linearA98RgbToXyzD650(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB0 === dest) { + t1 = $.$get$linearA98RgbToXyzD500(); + break $label0$0; + } + if (B.LmsColorSpace_Os30 === dest) { + t1 = $.$get$linearA98RgbToLms0(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix0(dest); + break $label0$0; + } + return t1; + } + }; + A.AnySelectorVisitor0.prototype = { + visitComplexSelector$1(complex) { + return B.JSArray_methods.any$1(complex.components, new A.AnySelectorVisitor_visitComplexSelector_closure0(this)); + }, + visitCompoundSelector$1(compound) { + return B.JSArray_methods.any$1(compound.components, new A.AnySelectorVisitor_visitCompoundSelector_closure0(this)); + }, + visitPseudoSelector$1(pseudo) { + var selector = pseudo.selector; + return selector == null ? false : this.visitSelectorList$1(selector); + }, + visitSelectorList$1(list) { + return B.JSArray_methods.any$1(list.components, this.get$visitComplexSelector()); + }, + visitAttributeSelector$1(attribute) { + return false; + }, + visitClassSelector$1(klass) { + return false; + }, + visitIDSelector$1(id) { + return false; + }, + visitParentSelector$1($parent) { + return false; + }, + visitPlaceholderSelector$1(placeholder) { + return false; + }, + visitTypeSelector$1(type) { + return false; + }, + visitUniversalSelector$1(universal) { + return false; + } + }; + A.AnySelectorVisitor_visitComplexSelector_closure0.prototype = { + call$1(component) { + return this.$this.visitCompoundSelector$1(component.selector); + }, + $signature: 57 + }; + A.AnySelectorVisitor_visitCompoundSelector_closure0.prototype = { + call$1(simple) { + return simple.accept$1(this.$this); + }, + $signature: 14 + }; + A.SupportsAnything0.prototype = { + toInterpolation$0() { + var t1 = new A.StringBuffer(""), + t2 = new A.InterpolationBuffer0(t1, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)), + t3 = this.span, + t4 = this.contents, + t5 = t4.span, + t6 = A.SpanExtensions_before(t3, t5); + t6 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t6.file._decodedChars, t6._file$_start, t6._end), 0, null); + t1._contents += t6; + t2.addInterpolation$1(t4); + t5 = A.SpanExtensions_after(t3, t5); + t5 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t5.file._decodedChars, t5._file$_start, t5._end), 0, null); + t1._contents += t5; + return t2.interpolation$1(t3); + }, + withSpan$1(span) { + return new A.SupportsAnything0(this.contents, span); + }, + toString$0(_) { + return "(" + this.contents.toString$0(0) + ")"; + }, + $isAstNode0: 1, + $isSassNode: 1, + $isSupportsCondition: 1, + get$span(receiver) { + return this.span; + } + }; + A.ArgumentList0.prototype = { + get$isEmpty(_) { + var t1; + if (this.positional.length === 0) { + t1 = this.named; + t1 = t1.get$isEmpty(t1) && this.rest == null; + } else + t1 = false; + return t1; + }, + toString$0(_) { + var t2, t3, _i, _1_0, _2_0, _this = this, + t1 = A._setArrayType([], type$.JSArray_String); + for (t2 = _this.positional, t3 = t2.length, _i = 0; _i < t3; ++_i) + t1.push(_this._argument_list0$_parenthesizeArgument$1(t2[_i])); + for (t2 = A.MapExtensions_get_pairs0(_this.named, type$.String, type$.Expression_2), t2 = t2.get$iterator(t2); t2.moveNext$0();) { + t3 = t2.get$current(t2); + t1.push("$" + t3._0 + ": " + _this._argument_list0$_parenthesizeArgument$1(t3._1)); + } + _1_0 = _this.rest; + if (_1_0 != null) + t1.push(_this._argument_list0$_parenthesizeArgument$1(_1_0) + "..."); + _2_0 = _this.keywordRest; + if (_2_0 != null) + t1.push(_this._argument_list0$_parenthesizeArgument$1(_2_0) + "..."); + return "(" + B.JSArray_methods.join$1(t1, ", ") + ")"; + }, + _argument_list0$_parenthesizeArgument$1(argument) { + var t1; + $label0$0: { + if (argument instanceof A.ListExpression0 && B.ListSeparator_qVN0 === argument.separator && !argument.hasBrackets && argument.contents.length >= 2) { + t1 = "(" + argument.toString$0(0) + ")"; + break $label0$0; + } + t1 = argument.toString$0(0); + break $label0$0; + } + return t1; + }, + $isAstNode0: 1, + $isSassNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.argumentListClass_closure.prototype = { + call$0() { + var t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.SassArgumentList", new A.argumentListClass__closure())); + A.defineGetter(J.get$$prototype$x(jsClass), "keywords", new A.argumentListClass__closure0(), null); + A.JSClassExtension_injectSuperclass(t1._as(A.SassArgumentList$0(A._setArrayType([], type$.JSArray_Value_2), A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.Value_2), B.ListSeparator_undecided_null_undecided0).constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.argumentListClass__closure.prototype = { + call$4($self, contents, keywords, separator) { + var t3, + t1 = self.immutable.isOrderedMap(contents) ? J.toArray$0$x(type$.ImmutableList._as(contents)) : type$.List_dynamic._as(contents), + t2 = type$.Value_2; + t1 = J.cast$1$0$ax(t1, t2); + t3 = self.immutable.isOrderedMap(keywords) ? A.immutableMapToDartMap(type$.ImmutableMap._as(keywords)) : A.objectToMap(keywords); + return A.SassArgumentList$0(t1, t3.cast$2$0(0, type$.String, t2), A.jsToDartSeparator(separator)); + }, + call$3($self, contents, keywords) { + return this.call$4($self, contents, keywords, ","); + }, + "call*": "call$4", + $requiredArgCount: 3, + $defaultValues() { + return [","]; + }, + $signature: 305 + }; + A.argumentListClass__closure0.prototype = { + call$1($self) { + $self._argument_list$_wereKeywordsAccessed = true; + return A.dartMapToImmutableMap($self._argument_list$_keywords); + }, + $signature: 306 + }; + A.SassArgumentList0.prototype = {}; + A.JSArray1.prototype = {}; + A.AsyncImporter0.prototype = { + isNonCanonicalScheme$1(scheme) { + return false; + } + }; + A.JSToDartAsyncImporter.prototype = { + canonicalize$1(_, url) { + return this.canonicalize$body$JSToDartAsyncImporter(0, url); + }, + canonicalize$body$JSToDartAsyncImporter(_, url) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Uri), + $async$returnValue, $async$self = this, t1, result; + var $async$canonicalize$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + result = A.wrapJSExceptions(new A.JSToDartAsyncImporter_canonicalize_closure($async$self, url)); + $async$goto = result != null && result instanceof self.Promise ? 3 : 4; + break; + case 3: + // then + $async$goto = 5; + return A._asyncAwait(A.promiseToFuture0(type$.Promise._as(result), type$.nullable_Object), $async$canonicalize$1); + case 5: + // returning from await. + result = $async$result; + case 4: + // join + if (result == null) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + t1 = self.URL; + if (result instanceof t1) { + $async$returnValue = A.Uri_parse(J.toString$0$(type$.JSUrl._as(result))); + // goto return + $async$goto = 1; + break; + } + A.jsThrow(new self.Error(string$.The_ca)); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$canonicalize$1, $async$completer); + }, + load$1(_, url) { + return this.load$body$JSToDartAsyncImporter(0, url); + }, + load$body$JSToDartAsyncImporter(_, url) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_ImporterResult_2), + $async$returnValue, $async$self = this, t1, contents, syntax, t2, result; + var $async$load$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + result = A.wrapJSExceptions(new A.JSToDartAsyncImporter_load_closure($async$self, url)); + $async$goto = result != null && result instanceof self.Promise ? 3 : 4; + break; + case 3: + // then + $async$goto = 5; + return A._asyncAwait(A.promiseToFuture0(type$.Promise._as(result), type$.nullable_Object), $async$load$1); + case 5: + // returning from await. + result = $async$result; + case 4: + // join + if (result == null) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + type$.JSImporterResult._as(result); + t1 = J.getInterceptor$x(result); + contents = t1.get$contents(result); + if (A._asString(new self.Function("value", "return typeof value").call$1(contents)) !== "string") + A.jsThrow(new A.ArgumentError(true, contents, "contents", "must be a string but was: " + A.jsType(contents))); + syntax = t1.get$syntax(result); + if (contents == null || syntax == null) + A.jsThrow(new self.Error(string$.The_lo)); + t2 = A.parseSyntax(syntax); + $async$returnValue = A.ImporterResult$(contents, A.NullableExtension_andThen0(t1.get$sourceMapUrl(result), A.utils3__jsToDartUrl$closure()), t2); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$load$1, $async$completer); + }, + isNonCanonicalScheme$1(scheme) { + return this._nonCanonicalSchemes.contains$1(0, scheme); + } + }; + A.JSToDartAsyncImporter_canonicalize_closure.prototype = { + call$0() { + return this.$this._async0$_canonicalize.call$2(this.url.toString$0(0), A.canonicalizeContext0()); + }, + $signature: 36 + }; + A.JSToDartAsyncImporter_load_closure.prototype = { + call$0() { + return this.$this._load.call$1(new self.URL(this.url.toString$0(0))); + }, + $signature: 36 + }; + A.AsyncBuiltInCallable0.prototype = { + callbackFor$2(positional, names) { + return new A._Record_2(this._async_built_in0$_parameters, this._async_built_in0$_callback); + }, + withDeprecationWarning$1(module) { + return new A.AsyncBuiltInCallable0(this.name, this._async_built_in0$_parameters, new A.AsyncBuiltInCallable_withDeprecationWarning_closure0(this, module, null), false); + }, + $isAsyncCallable0: 1, + get$name(receiver) { + return this.name; + }, + get$acceptsContent() { + return this.acceptsContent; + } + }; + A.AsyncBuiltInCallable$mixin_closure0.prototype = { + call$1($arguments) { + return this.$call$body$AsyncBuiltInCallable$mixin_closure0($arguments); + }, + $call$body$AsyncBuiltInCallable$mixin_closure0($arguments) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$self = this, t1; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.callback.call$1($arguments); + $async$goto = 3; + return A._asyncAwait(t1 instanceof A._Future ? t1 : A._Future$value(t1, type$.void), $async$call$1); + case 3: + // returning from await. + $async$returnValue = B.C__SassNull0; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 86 + }; + A.AsyncBuiltInCallable_withDeprecationWarning_closure0.prototype = { + call$1(args) { + var t1 = this.$this; + A.warnForDeprecation0(string$.Global + this.module + "." + t1.name + string$.x20inste, B.Deprecation_ZDV); + return t1._async_built_in0$_callback.call$1(args); + }, + $signature: 309 + }; + A._compileStylesheet_closure2.prototype = { + call$1(url) { + return url === "" ? A.Uri_Uri$dataFromString(A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(this.stylesheet.span.file._decodedChars, 0, null), 0, null), B.C_Utf8Codec, null).get$_text() : this.importCache.sourceMapUrl$1(0, A.Uri_parse(url)).toString$0(0); + }, + $signature: 6 + }; + A.AsyncEnvironment0.prototype = { + closure$0() { + var t4, t5, t6, _this = this, + t1 = _this._async_environment0$_forwardedModules, + t2 = _this._async_environment0$_nestedForwardedModules, + t3 = _this._async_environment0$_variables; + t3 = A._setArrayType(t3.slice(0), A._arrayInstanceType(t3)); + t4 = _this._async_environment0$_variableNodes; + t4 = A._setArrayType(t4.slice(0), A._arrayInstanceType(t4)); + t5 = _this._async_environment0$_functions; + t5 = A._setArrayType(t5.slice(0), A._arrayInstanceType(t5)); + t6 = _this._async_environment0$_mixins; + t6 = A._setArrayType(t6.slice(0), A._arrayInstanceType(t6)); + return A.AsyncEnvironment$_0(_this._async_environment0$_modules, _this._async_environment0$_namespaceNodes, _this._async_environment0$_globalModules, _this._async_environment0$_importedModules, t1, t2, _this._async_environment0$_allModules, t3, t4, t5, t6, _this._async_environment0$_content); + }, + forwardModule$2(module, rule) { + var view, t1, t2, _this = this, + forwardedModules = _this._async_environment0$_forwardedModules; + if (forwardedModules == null) + forwardedModules = _this._async_environment0$_forwardedModules = A.LinkedHashMap_LinkedHashMap$_empty(type$.Module_AsyncCallable_2, type$.AstNode_2); + view = A.ForwardedModuleView_ifNecessary0(module, rule, type$.AsyncCallable_2); + for (t1 = new A.LinkedHashMapKeyIterator(forwardedModules, forwardedModules.__js_helper$_modifications, forwardedModules.__js_helper$_first); t1.moveNext$0();) { + t2 = t1.__js_helper$_current; + _this._async_environment0$_assertNoConflicts$5(view.get$variables(), t2.get$variables(), view, t2, "variable"); + _this._async_environment0$_assertNoConflicts$5(view.get$functions(view), t2.get$functions(t2), view, t2, "function"); + _this._async_environment0$_assertNoConflicts$5(view.get$mixins(), t2.get$mixins(), view, t2, "mixin"); + } + _this._async_environment0$_allModules.push(module); + forwardedModules.$indexSet(0, view, rule); + }, + _async_environment0$_assertNoConflicts$5(newMembers, oldMembers, newModule, oldModule, type) { + var larger, smaller, t1, t2, t3, t4, $name, small, large, span; + if (newMembers.get$length(newMembers) < oldMembers.get$length(oldMembers)) { + larger = oldMembers; + smaller = newMembers; + } else { + larger = newMembers; + smaller = oldMembers; + } + for (t1 = type$.String, t2 = A.MapExtensions_get_pairs0(smaller, t1, type$.Object), t2 = t2.get$iterator(t2), t3 = type === "variable"; t2.moveNext$0();) { + t4 = t2.get$current(t2); + $name = t4._0; + small = t4._1; + large = larger.$index(0, $name); + if (large == null) + continue; + if (t3 ? newModule.variableIdentity$1($name) === oldModule.variableIdentity$1($name) : J.$eq$(large, small)) + continue; + if (t3) + $name = "$" + $name; + t2 = this._async_environment0$_forwardedModules; + if (t2 == null) + span = null; + else { + t2 = t2.$index(0, oldModule); + span = t2 == null ? null : t2.get$span(t2); + } + t2 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, t1); + if (span != null) + t2.$indexSet(0, span, "original @forward"); + throw A.wrapException(A.MultiSpanSassScriptException$0("Two forwarded modules both define a " + type + " named " + $name + ".", "new @forward", t2)); + } + }, + importForwards$1(module) { + var forwardedModules, t1, t2, t3, t4, node, t5, t6, t7, t8, t9, t10, _i, t11, shadowed, t12, t13, _length, _list, _this = this, + forwarded = module._async_environment0$_environment._async_environment0$_forwardedModules; + if (forwarded == null) + return; + forwardedModules = _this._async_environment0$_forwardedModules; + if (forwardedModules != null) { + t1 = type$.Module_AsyncCallable_2; + t2 = type$.AstNode_2; + t3 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t1 = A.MapExtensions_get_pairs0(forwarded, t1, t2), t1 = t1.get$iterator(t1), t2 = _this._async_environment0$_globalModules; t1.moveNext$0();) { + t4 = t1.get$current(t1); + module = t4._0; + node = t4._1; + if (!forwardedModules.containsKey$1(module) || !t2.containsKey$1(module)) + t3.$indexSet(0, module, node); + } + forwarded = t3; + } else + forwardedModules = _this._async_environment0$_forwardedModules = A.LinkedHashMap_LinkedHashMap$_empty(type$.Module_AsyncCallable_2, type$.AstNode_2); + t1 = type$.String; + t2 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + for (t3 = new A.LinkedHashMapKeyIterator(forwarded, forwarded.__js_helper$_modifications, forwarded.__js_helper$_first); t3.moveNext$0();) + for (t4 = t3.__js_helper$_current.get$variables(), t4 = J.get$iterator$ax(t4.get$keys(t4)); t4.moveNext$0();) + t2.add$1(0, t4.get$current(t4)); + t3 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + for (t4 = new A.LinkedHashMapKeyIterator(forwarded, forwarded.__js_helper$_modifications, forwarded.__js_helper$_first); t4.moveNext$0();) { + t5 = t4.__js_helper$_current; + for (t5 = t5.get$functions(t5), t5 = J.get$iterator$ax(t5.get$keys(t5)); t5.moveNext$0();) + t3.add$1(0, t5.get$current(t5)); + } + t1 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + for (t4 = new A.LinkedHashMapKeyIterator(forwarded, forwarded.__js_helper$_modifications, forwarded.__js_helper$_first); t4.moveNext$0();) + for (t5 = t4.__js_helper$_current.get$mixins(), t5 = J.get$iterator$ax(t5.get$keys(t5)); t5.moveNext$0();) + t1.add$1(0, t5.get$current(t5)); + t4 = _this._async_environment0$_variables; + t5 = t4.length; + if (t5 === 1) { + for (t5 = _this._async_environment0$_importedModules, t6 = type$.Module_AsyncCallable_2, t7 = type$.AstNode_2, t8 = A.MapExtensions_get_pairs0(t5, t6, t7).toList$0(0), t9 = t8.length, t10 = type$.AsyncCallable_2, _i = 0; _i < t8.length; t8.length === t9 || (0, A.throwConcurrentModificationError)(t8), ++_i) { + t11 = t8[_i]; + module = t11._0; + shadowed = A.ShadowedModuleView_ifNecessary0(module, t3, t1, t2, t10); + if (shadowed != null) { + t5.remove$1(0, module); + t12 = shadowed.variables; + t13 = false; + if (t12.get$isEmpty(t12)) { + t12 = shadowed.functions; + if (t12.get$isEmpty(t12)) { + t12 = shadowed.mixins; + if (t12.get$isEmpty(t12)) { + t12 = shadowed._shadowed_view0$_inner; + t12 = t12.get$css(t12); + t12 = J.get$isEmpty$asx(t12.get$children(t12)); + } else + t12 = t13; + } else + t12 = t13; + } else + t12 = t13; + if (!t12) + t5.$indexSet(0, shadowed, t11._1); + } + } + for (t6 = A.MapExtensions_get_pairs0(forwardedModules, t6, t7).toList$0(0), t7 = t6.length, _i = 0; _i < t6.length; t6.length === t7 || (0, A.throwConcurrentModificationError)(t6), ++_i) { + t8 = t6[_i]; + module = t8._0; + shadowed = A.ShadowedModuleView_ifNecessary0(module, t3, t1, t2, t10); + if (shadowed != null) { + forwardedModules.remove$1(0, module); + t9 = shadowed.variables; + t11 = false; + if (t9.get$isEmpty(t9)) { + t9 = shadowed.functions; + if (t9.get$isEmpty(t9)) { + t9 = shadowed.mixins; + if (t9.get$isEmpty(t9)) { + t9 = shadowed._shadowed_view0$_inner; + t9 = t9.get$css(t9); + t9 = J.get$isEmpty$asx(t9.get$children(t9)); + } else + t9 = t11; + } else + t9 = t11; + } else + t9 = t11; + if (!t9) + forwardedModules.$indexSet(0, shadowed, t8._1); + } + } + t5.addAll$1(0, forwarded); + forwardedModules.addAll$1(0, forwarded); + } else { + t6 = _this._async_environment0$_nestedForwardedModules; + if (t6 == null) { + _length = t5 - 1; + _list = J.JSArray_JSArray$allocateGrowable(_length, type$.List_Module_AsyncCallable_2); + for (t5 = type$.JSArray_Module_AsyncCallable_2, _i = 0; _i < _length; ++_i) + _list[_i] = A._setArrayType([], t5); + _this._async_environment0$_nestedForwardedModules = _list; + t5 = _list; + } else + t5 = t6; + B.JSArray_methods.addAll$1(B.JSArray_methods.get$last(t5), new A.LinkedHashMapKeysIterable(forwarded, A._instanceType(forwarded)._eval$1("LinkedHashMapKeysIterable<1>"))); + } + for (t2 = A._LinkedHashSetIterator$(t2, t2._modifications, t2.$ti._precomputed1), t5 = _this._async_environment0$_variableIndices, t6 = _this._async_environment0$_variableNodes, t7 = t2.$ti._precomputed1; t2.moveNext$0();) { + t8 = t2._collection$_current; + if (t8 == null) + t8 = t7._as(t8); + t5.remove$1(0, t8); + J.remove$1$z(B.JSArray_methods.get$last(t4), t8); + J.remove$1$z(B.JSArray_methods.get$last(t6), t8); + } + for (t2 = A._LinkedHashSetIterator$(t3, t3._modifications, t3.$ti._precomputed1), t3 = _this._async_environment0$_functionIndices, t4 = _this._async_environment0$_functions, t5 = t2.$ti._precomputed1; t2.moveNext$0();) { + t6 = t2._collection$_current; + if (t6 == null) + t6 = t5._as(t6); + t3.remove$1(0, t6); + J.remove$1$z(B.JSArray_methods.get$last(t4), t6); + } + for (t1 = A._LinkedHashSetIterator$(t1, t1._modifications, t1.$ti._precomputed1), t2 = _this._async_environment0$_mixinIndices, t3 = _this._async_environment0$_mixins, t4 = t1.$ti._precomputed1; t1.moveNext$0();) { + t5 = t1._collection$_current; + if (t5 == null) + t5 = t4._as(t5); + t2.remove$1(0, t5); + J.remove$1$z(B.JSArray_methods.get$last(t3), t5); + } + }, + getVariable$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) + return _this._async_environment0$_getModule$1(namespace).get$variables().$index(0, $name); + if (_this._async_environment0$_lastVariableName === $name) { + t1 = _this._async_environment0$_lastVariableIndex; + t1.toString; + t1 = _this._async_environment0$_variables[t1].$index(0, $name); + return t1 == null ? _this._async_environment0$_getVariableFromGlobalModule$1($name) : t1; + } + t1 = _this._async_environment0$_variableIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + _this._async_environment0$_lastVariableName = $name; + _this._async_environment0$_lastVariableIndex = _0_0; + t1 = _this._async_environment0$_variables[_0_0].$index(0, $name); + return t1 == null ? _this._async_environment0$_getVariableFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._async_environment0$_variableIndex$1($name); + if (_1_0 != null) { + _this._async_environment0$_lastVariableName = $name; + _this._async_environment0$_lastVariableIndex = _1_0; + t1.$indexSet(0, $name, _1_0); + t1 = _this._async_environment0$_variables[_1_0].$index(0, $name); + return t1 == null ? _this._async_environment0$_getVariableFromGlobalModule$1($name) : t1; + } else + return _this._async_environment0$_getVariableFromGlobalModule$1($name); + } + }, + getVariable$1($name) { + return this.getVariable$2$namespace($name, null); + }, + _async_environment0$_getVariableFromGlobalModule$1($name) { + return this._async_environment0$_fromOneModule$3($name, "variable", new A.AsyncEnvironment__getVariableFromGlobalModule_closure0($name)); + }, + getVariableNode$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) + return _this._async_environment0$_getModule$1(namespace).get$variableNodes().$index(0, $name); + if (_this._async_environment0$_lastVariableName === $name) { + t1 = _this._async_environment0$_lastVariableIndex; + t1.toString; + t1 = _this._async_environment0$_variableNodes[t1].$index(0, $name); + return t1 == null ? _this._async_environment0$_getVariableNodeFromGlobalModule$1($name) : t1; + } + t1 = _this._async_environment0$_variableIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + _this._async_environment0$_lastVariableName = $name; + _this._async_environment0$_lastVariableIndex = _0_0; + t1 = _this._async_environment0$_variableNodes[_0_0].$index(0, $name); + return t1 == null ? _this._async_environment0$_getVariableNodeFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._async_environment0$_variableIndex$1($name); + if (_1_0 != null) { + _this._async_environment0$_lastVariableName = $name; + _this._async_environment0$_lastVariableIndex = _1_0; + t1.$indexSet(0, $name, _1_0); + t1 = _this._async_environment0$_variableNodes[_1_0].$index(0, $name); + return t1 == null ? _this._async_environment0$_getVariableNodeFromGlobalModule$1($name) : t1; + } else + return _this._async_environment0$_getVariableNodeFromGlobalModule$1($name); + } + }, + _async_environment0$_getVariableNodeFromGlobalModule$1($name) { + var t1, t2, _0_0; + for (t1 = this._async_environment0$_importedModules, t2 = this._async_environment0$_globalModules, t2 = new A.LinkedHashMapKeysIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapKeysIterable<1>")).followedBy$1(0, new A.LinkedHashMapKeysIterable(t2, A._instanceType(t2)._eval$1("LinkedHashMapKeysIterable<1>"))), t2 = new A.FollowedByIterator(J.get$iterator$ax(t2.__internal$_first), t2._second); t2.moveNext$0();) { + t1 = t2._currentIterator; + _0_0 = t1.get$current(t1).get$variableNodes().$index(0, $name); + if (_0_0 != null) + return _0_0; + } + return null; + }, + globalVariableExists$2$namespace($name, namespace) { + if (namespace != null) + return this._async_environment0$_getModule$1(namespace).get$variables().containsKey$1($name); + if (B.JSArray_methods.get$first(this._async_environment0$_variables).containsKey$1($name)) + return true; + return this._async_environment0$_getVariableFromGlobalModule$1($name) != null; + }, + globalVariableExists$1($name) { + return this.globalVariableExists$2$namespace($name, null); + }, + _async_environment0$_variableIndex$1($name) { + var t1, i; + for (t1 = this._async_environment0$_variables, i = t1.length - 1; i >= 0; --i) + if (t1[i].containsKey$1($name)) + return i; + return null; + }, + setVariable$5$global$namespace($name, value, nodeWithSpan, global, namespace) { + var t1, moduleWithName, nestedForwardedModules, t2, t3, t4, t5, index, _this = this; + if (namespace != null) { + _this._async_environment0$_getModule$1(namespace).setVariable$3($name, value, nodeWithSpan); + return; + } + if (global || _this._async_environment0$_variables.length === 1) { + _this._async_environment0$_variableIndices.putIfAbsent$2($name, new A.AsyncEnvironment_setVariable_closure2(_this, $name)); + t1 = _this._async_environment0$_variables; + if (!B.JSArray_methods.get$first(t1).containsKey$1($name)) { + moduleWithName = _this._async_environment0$_fromOneModule$3($name, "variable", new A.AsyncEnvironment_setVariable_closure3($name)); + if (moduleWithName != null) { + moduleWithName.setVariable$3($name, value, nodeWithSpan); + return; + } + } + J.$indexSet$ax(B.JSArray_methods.get$first(t1), $name, value); + J.$indexSet$ax(B.JSArray_methods.get$first(_this._async_environment0$_variableNodes), $name, nodeWithSpan); + return; + } + nestedForwardedModules = _this._async_environment0$_nestedForwardedModules; + if (nestedForwardedModules != null && !_this._async_environment0$_variableIndices.containsKey$1($name) && _this._async_environment0$_variableIndex$1($name) == null) + for (t1 = A._arrayInstanceType(nestedForwardedModules)._eval$1("ReversedListIterable<1>"), t2 = new A.ReversedListIterable(nestedForwardedModules, t1), t2 = new A.ListIterator(t2, t2.get$length(0), t1._eval$1("ListIterator")), t1 = t1._eval$1("ListIterable.E"); t2.moveNext$0();) { + t3 = t2.__internal$_current; + for (t3 = J.get$reversed$ax(t3 == null ? t1._as(t3) : t3), t4 = t3.$ti, t3 = new A.ListIterator(t3, t3.get$length(0), t4._eval$1("ListIterator")), t4 = t4._eval$1("ListIterable.E"); t3.moveNext$0();) { + t5 = t3.__internal$_current; + if (t5 == null) + t5 = t4._as(t5); + if (t5.get$variables().containsKey$1($name)) { + t5.setVariable$3($name, value, nodeWithSpan); + return; + } + } + } + if (_this._async_environment0$_lastVariableName === $name) { + t1 = _this._async_environment0$_lastVariableIndex; + t1.toString; + index = t1; + } else + index = _this._async_environment0$_variableIndices.putIfAbsent$2($name, new A.AsyncEnvironment_setVariable_closure4(_this, $name)); + if (!_this._async_environment0$_inSemiGlobalScope && index === 0) { + index = _this._async_environment0$_variables.length - 1; + _this._async_environment0$_variableIndices.$indexSet(0, $name, index); + } + _this._async_environment0$_lastVariableName = $name; + _this._async_environment0$_lastVariableIndex = index; + _this._async_environment0$_variables[index].$indexSet(0, $name, value); + _this._async_environment0$_variableNodes[index].$indexSet(0, $name, nodeWithSpan); + }, + setVariable$4$global($name, value, nodeWithSpan, global) { + return this.setVariable$5$global$namespace($name, value, nodeWithSpan, global, null); + }, + setLocalVariable$3($name, value, nodeWithSpan) { + var index, _this = this, + t1 = _this._async_environment0$_variables, + t2 = t1.length; + _this._async_environment0$_lastVariableName = $name; + index = _this._async_environment0$_lastVariableIndex = t2 - 1; + _this._async_environment0$_variableIndices.$indexSet(0, $name, index); + t1[index].$indexSet(0, $name, value); + _this._async_environment0$_variableNodes[index].$indexSet(0, $name, nodeWithSpan); + }, + getFunction$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) { + t1 = _this._async_environment0$_getModule$1(namespace); + return t1.get$functions(t1).$index(0, $name); + } + t1 = _this._async_environment0$_functionIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + t1 = _this._async_environment0$_functions[_0_0].$index(0, $name); + return t1 == null ? _this._async_environment0$_getFunctionFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._async_environment0$_functionIndex$1($name); + if (_1_0 != null) { + t1.$indexSet(0, $name, _1_0); + t1 = _this._async_environment0$_functions[_1_0].$index(0, $name); + return t1 == null ? _this._async_environment0$_getFunctionFromGlobalModule$1($name) : t1; + } else + return _this._async_environment0$_getFunctionFromGlobalModule$1($name); + } + }, + getFunction$1($name) { + return this.getFunction$2$namespace($name, null); + }, + _async_environment0$_getFunctionFromGlobalModule$1($name) { + return this._async_environment0$_fromOneModule$3($name, "function", new A.AsyncEnvironment__getFunctionFromGlobalModule_closure0($name)); + }, + _async_environment0$_functionIndex$1($name) { + var t1, i; + for (t1 = this._async_environment0$_functions, i = t1.length - 1; i >= 0; --i) + if (t1[i].containsKey$1($name)) + return i; + return null; + }, + getMixin$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) + return _this._async_environment0$_getModule$1(namespace).get$mixins().$index(0, $name); + t1 = _this._async_environment0$_mixinIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + t1 = _this._async_environment0$_mixins[_0_0].$index(0, $name); + return t1 == null ? _this._async_environment0$_getMixinFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._async_environment0$_mixinIndex$1($name); + if (_1_0 != null) { + t1.$indexSet(0, $name, _1_0); + t1 = _this._async_environment0$_mixins[_1_0].$index(0, $name); + return t1 == null ? _this._async_environment0$_getMixinFromGlobalModule$1($name) : t1; + } else + return _this._async_environment0$_getMixinFromGlobalModule$1($name); + } + }, + _async_environment0$_getMixinFromGlobalModule$1($name) { + return this._async_environment0$_fromOneModule$3($name, "mixin", new A.AsyncEnvironment__getMixinFromGlobalModule_closure0($name)); + }, + _async_environment0$_mixinIndex$1($name) { + var t1, i; + for (t1 = this._async_environment0$_mixins, i = t1.length - 1; i >= 0; --i) + if (t1[i].containsKey$1($name)) + return i; + return null; + }, + withContent$2($content, callback) { + return this.withContent$body$AsyncEnvironment0($content, callback); + }, + withContent$body$AsyncEnvironment0($content, callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, oldContent; + var $async$withContent$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + oldContent = $async$self._async_environment0$_content; + $async$self._async_environment0$_content = $content; + $async$goto = 2; + return A._asyncAwait(callback.call$0(), $async$withContent$2); + case 2: + // returning from await. + $async$self._async_environment0$_content = oldContent; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$withContent$2, $async$completer); + }, + asMixin$1(callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, oldInMixin; + var $async$asMixin$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + oldInMixin = $async$self._async_environment0$_inMixin; + $async$self._async_environment0$_inMixin = true; + $async$goto = 2; + return A._asyncAwait(callback.call$0(), $async$asMixin$1); + case 2: + // returning from await. + $async$self._async_environment0$_inMixin = oldInMixin; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$asMixin$1, $async$completer); + }, + scope$1$3$semiGlobal$when(callback, semiGlobal, when, $T) { + return this.scope$body$AsyncEnvironment0(callback, semiGlobal, when, $T, $T); + }, + scope$1$1(callback, $T) { + return this.scope$1$3$semiGlobal$when(callback, false, true, $T); + }, + scope$1$2$when(callback, when, $T) { + return this.scope$1$3$semiGlobal$when(callback, false, when, $T); + }, + scope$1$2$semiGlobal(callback, semiGlobal, $T) { + return this.scope$1$3$semiGlobal$when(callback, semiGlobal, true, $T); + }, + scope$body$AsyncEnvironment0(callback, semiGlobal, when, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$next = [], $async$self = this, wasInSemiGlobalScope, $name, name0, name1, t1, t2, t3, t4, t5, t6; + var $async$scope$1$3$semiGlobal$when = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + semiGlobal = semiGlobal && $async$self._async_environment0$_inSemiGlobalScope; + wasInSemiGlobalScope = $async$self._async_environment0$_inSemiGlobalScope; + $async$self._async_environment0$_inSemiGlobalScope = semiGlobal; + $async$goto = !when ? 3 : 4; + break; + case 3: + // then + $async$handler = 5; + $async$goto = 8; + return A._asyncAwait(callback.call$0(), $async$scope$1$3$semiGlobal$when); + case 8: + // returning from await. + t1 = $async$result; + $async$returnValue = t1; + $async$next = [1]; + // goto finally + $async$goto = 6; + break; + $async$next.push(7); + // goto finally + $async$goto = 6; + break; + case 5: + // uncaught + $async$next = [2]; + case 6: + // finally + $async$handler = 2; + $async$self._async_environment0$_inSemiGlobalScope = wasInSemiGlobalScope; + // goto the next finally handler + $async$goto = $async$next.pop(); + break; + case 7: + // after finally + case 4: + // join + t1 = $async$self._async_environment0$_variables; + t2 = type$.String; + B.JSArray_methods.add$1(t1, A.LinkedHashMap_LinkedHashMap$_empty(t2, type$.Value_2)); + t3 = $async$self._async_environment0$_variableNodes; + B.JSArray_methods.add$1(t3, A.LinkedHashMap_LinkedHashMap$_empty(t2, type$.AstNode_2)); + t4 = $async$self._async_environment0$_functions; + t5 = type$.AsyncCallable_2; + B.JSArray_methods.add$1(t4, A.LinkedHashMap_LinkedHashMap$_empty(t2, t5)); + t6 = $async$self._async_environment0$_mixins; + B.JSArray_methods.add$1(t6, A.LinkedHashMap_LinkedHashMap$_empty(t2, t5)); + t5 = $async$self._async_environment0$_nestedForwardedModules; + if (t5 != null) + t5.push(A._setArrayType([], type$.JSArray_Module_AsyncCallable_2)); + $async$handler = 9; + $async$goto = 12; + return A._asyncAwait(callback.call$0(), $async$scope$1$3$semiGlobal$when); + case 12: + // returning from await. + t2 = $async$result; + $async$returnValue = t2; + $async$next = [1]; + // goto finally + $async$goto = 10; + break; + $async$next.push(11); + // goto finally + $async$goto = 10; + break; + case 9: + // uncaught + $async$next = [2]; + case 10: + // finally + $async$handler = 2; + $async$self._async_environment0$_inSemiGlobalScope = wasInSemiGlobalScope; + $async$self._async_environment0$_lastVariableIndex = $async$self._async_environment0$_lastVariableName = null; + for (t1 = J.get$iterator$ax(J.get$keys$z(B.JSArray_methods.removeLast$0(t1))), t2 = $async$self._async_environment0$_variableIndices; t1.moveNext$0();) { + $name = t1.get$current(t1); + t2.remove$1(0, $name); + } + B.JSArray_methods.removeLast$0(t3); + for (t1 = J.get$iterator$ax(J.get$keys$z(B.JSArray_methods.removeLast$0(t4))), t2 = $async$self._async_environment0$_functionIndices; t1.moveNext$0();) { + name0 = t1.get$current(t1); + t2.remove$1(0, name0); + } + for (t1 = J.get$iterator$ax(J.get$keys$z(B.JSArray_methods.removeLast$0(t6))), t2 = $async$self._async_environment0$_mixinIndices; t1.moveNext$0();) { + name1 = t1.get$current(t1); + t2.remove$1(0, name1); + } + t1 = $async$self._async_environment0$_nestedForwardedModules; + if (t1 != null) + t1.pop(); + // goto the next finally handler + $async$goto = $async$next.pop(); + break; + case 11: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$scope$1$3$semiGlobal$when, $async$completer); + }, + toImplicitConfiguration$0() { + var t2, t3, t4, i, values, nodes, t5, t6, $name, value, + t1 = type$.String, + configuration = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.ConfiguredValue_2); + for (t2 = this._async_environment0$_variables, t3 = type$.Value_2, t4 = this._async_environment0$_variableNodes, i = 0; i < t2.length; ++i) { + values = t2[i]; + nodes = t4[i]; + for (t5 = A.MapExtensions_get_pairs0(values, t1, t3), t5 = t5.get$iterator(t5); t5.moveNext$0();) { + t6 = t5.get$current(t5); + $name = t6._0; + value = t6._1; + t6 = nodes.$index(0, $name); + t6.toString; + configuration.$indexSet(0, $name, new A.ConfiguredValue0(value, null, t6)); + } + } + return new A.Configuration0(configuration, null); + }, + toModule$3(css, preModuleComments, extensionStore) { + return A._EnvironmentModule__EnvironmentModule2(this, css, preModuleComments, extensionStore, A.NullableExtension_andThen0(this._async_environment0$_forwardedModules, new A.AsyncEnvironment_toModule_closure0())); + }, + toDummyModule$0() { + return A._EnvironmentModule__EnvironmentModule2(this, new A.CssStylesheet0(new A.UnmodifiableListView(B.List_empty17, type$.UnmodifiableListView_CssNode_2), A.SourceFile$decoded(B.List_empty4, "").span$1(0, 0)), B.Map_empty16, B.C_EmptyExtensionStore0, A.NullableExtension_andThen0(this._async_environment0$_forwardedModules, new A.AsyncEnvironment_toDummyModule_closure0())); + }, + _async_environment0$_getModule$1(namespace) { + var _0_0 = this._async_environment0$_modules.$index(0, namespace); + if (_0_0 != null) + return _0_0; + throw A.wrapException(A.SassScriptException$0('There is no module with the namespace "' + namespace + '".', null)); + }, + _async_environment0$_fromOneModule$1$3($name, type, callback) { + var t1, t2, t3, t4, t5, _1_0, _2_0, value, identity, valueInModule, identityFromModule, module, node, + _0_0 = this._async_environment0$_nestedForwardedModules; + if (_0_0 != null) + for (t1 = A._arrayInstanceType(_0_0)._eval$1("ReversedListIterable<1>"), t2 = new A.ReversedListIterable(_0_0, t1), t2 = new A.ListIterator(t2, t2.get$length(0), t1._eval$1("ListIterator")), t1 = t1._eval$1("ListIterable.E"); t2.moveNext$0();) { + t3 = t2.__internal$_current; + for (t3 = J.get$reversed$ax(t3 == null ? t1._as(t3) : t3), t4 = t3.$ti, t3 = new A.ListIterator(t3, t3.get$length(0), t4._eval$1("ListIterator")), t4 = t4._eval$1("ListIterable.E"); t3.moveNext$0();) { + t5 = t3.__internal$_current; + _1_0 = callback.call$1(t5 == null ? t4._as(t5) : t5); + if (_1_0 != null) + return _1_0; + } + } + for (t1 = this._async_environment0$_importedModules, t1 = new A.LinkedHashMapKeyIterator(t1, t1.__js_helper$_modifications, t1.__js_helper$_first); t1.moveNext$0();) { + _2_0 = callback.call$1(t1.__js_helper$_current); + if (_2_0 != null) + return _2_0; + } + for (t1 = this._async_environment0$_globalModules, t2 = new A.LinkedHashMapKeyIterator(t1, t1.__js_helper$_modifications, t1.__js_helper$_first), t3 = type$.AsyncCallable_2, value = null, identity = null; t2.moveNext$0();) { + t4 = t2.__js_helper$_current; + valueInModule = callback.call$1(t4); + if (valueInModule == null) + continue; + identityFromModule = t3._is(valueInModule) ? valueInModule : t4.variableIdentity$1($name); + if (identityFromModule.$eq(0, identity)) + continue; + if (value != null) { + t2 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + for (t3 = A.MapExtensions_get_pairs0(t1, type$.Module_AsyncCallable_2, type$.AstNode_2), t3 = t3.get$iterator(t3), t4 = "includes " + type; t3.moveNext$0();) { + t1 = t3.get$current(t3); + module = t1._0; + node = t1._1; + if (callback.call$1(module) != null) + t2.$indexSet(0, node.get$span(node), t4); + } + throw A.wrapException(A.MultiSpanSassScriptException$0("This " + type + string$.x20is_av, type + " use", t2)); + } + identity = identityFromModule; + value = valueInModule; + } + return value; + }, + _async_environment0$_fromOneModule$3($name, type, callback) { + return this._async_environment0$_fromOneModule$1$3($name, type, callback, type$.dynamic); + } + }; + A.AsyncEnvironment__getVariableFromGlobalModule_closure0.prototype = { + call$1(module) { + return module.get$variables().$index(0, this.name); + }, + $signature: 310 + }; + A.AsyncEnvironment_setVariable_closure2.prototype = { + call$0() { + var t1 = this.$this; + t1._async_environment0$_lastVariableName = this.name; + return t1._async_environment0$_lastVariableIndex = 0; + }, + $signature: 10 + }; + A.AsyncEnvironment_setVariable_closure3.prototype = { + call$1(module) { + return module.get$variables().containsKey$1(this.name) ? module : null; + }, + $signature: 311 + }; + A.AsyncEnvironment_setVariable_closure4.prototype = { + call$0() { + var t1 = this.$this, + t2 = t1._async_environment0$_variableIndex$1(this.name); + return t2 == null ? t1._async_environment0$_variables.length - 1 : t2; + }, + $signature: 10 + }; + A.AsyncEnvironment__getFunctionFromGlobalModule_closure0.prototype = { + call$1(module) { + return module.get$functions(module).$index(0, this.name); + }, + $signature: 200 + }; + A.AsyncEnvironment__getMixinFromGlobalModule_closure0.prototype = { + call$1(module) { + return module.get$mixins().$index(0, this.name); + }, + $signature: 200 + }; + A.AsyncEnvironment_toModule_closure0.prototype = { + call$1(modules) { + return new A.MapKeySet(modules, type$.MapKeySet_Module_AsyncCallable_2); + }, + $signature: 201 + }; + A.AsyncEnvironment_toDummyModule_closure0.prototype = { + call$1(modules) { + return new A.MapKeySet(modules, type$.MapKeySet_Module_AsyncCallable_2); + }, + $signature: 201 + }; + A._EnvironmentModule2.prototype = { + get$url(_) { + var t1 = this.css; + return t1.get$span(t1).file.url; + }, + setVariable$3($name, value, nodeWithSpan) { + var t1, t2, + _0_0 = this._async_environment0$_modulesByVariable.$index(0, $name); + if (_0_0 != null) { + _0_0.setVariable$3($name, value, nodeWithSpan); + return; + } + t1 = this._async_environment0$_environment; + t2 = t1._async_environment0$_variables; + if (!B.JSArray_methods.get$first(t2).containsKey$1($name)) + throw A.wrapException(A.SassScriptException$0("Undefined variable.", null)); + J.$indexSet$ax(B.JSArray_methods.get$first(t2), $name, value); + J.$indexSet$ax(B.JSArray_methods.get$first(t1._async_environment0$_variableNodes), $name, nodeWithSpan); + return; + }, + variableIdentity$1($name) { + var module = this._async_environment0$_modulesByVariable.$index(0, $name); + return module == null ? this : module.variableIdentity$1($name); + }, + cloneCss$0() { + var _0_0, _this = this; + if (!_this.transitivelyContainsCss) + return _this; + _0_0 = A.cloneCssStylesheet0(_this.css, _this.extensionStore); + return A._EnvironmentModule$_2(_this._async_environment0$_environment, _0_0._0, _this.preModuleComments, _0_0._1, _this._async_environment0$_modulesByVariable, _this.variables, _this.variableNodes, _this.functions, _this.mixins, true, _this.transitivelyContainsExtensions); + }, + toString$0(_) { + var t2, + t1 = this.css; + if (t1.get$span(t1).file.url == null) + t1 = ""; + else { + t1 = t1.get$span(t1).file.url; + t2 = $.$get$context(); + t1.toString; + t1 = t2.prettyUri$1(t1); + } + return t1; + }, + $isModule1: 1, + get$upstream() { + return this.upstream; + }, + get$variables() { + return this.variables; + }, + get$variableNodes() { + return this.variableNodes; + }, + get$functions(receiver) { + return this.functions; + }, + get$mixins() { + return this.mixins; + }, + get$extensionStore() { + return this.extensionStore; + }, + get$css(receiver) { + return this.css; + }, + get$preModuleComments() { + return this.preModuleComments; + }, + get$transitivelyContainsCss() { + return this.transitivelyContainsCss; + }, + get$transitivelyContainsExtensions() { + return this.transitivelyContainsExtensions; + } + }; + A._EnvironmentModule__EnvironmentModule_closure17.prototype = { + call$1(module) { + return module.get$variables(); + }, + $signature: 314 + }; + A._EnvironmentModule__EnvironmentModule_closure18.prototype = { + call$1(module) { + return module.get$variableNodes(); + }, + $signature: 315 + }; + A._EnvironmentModule__EnvironmentModule_closure19.prototype = { + call$1(module) { + return module.get$functions(module); + }, + $signature: 202 + }; + A._EnvironmentModule__EnvironmentModule_closure20.prototype = { + call$1(module) { + return module.get$mixins(); + }, + $signature: 202 + }; + A._EnvironmentModule__EnvironmentModule_closure21.prototype = { + call$1(module) { + return module.get$transitivelyContainsCss(); + }, + $signature: 116 + }; + A._EnvironmentModule__EnvironmentModule_closure22.prototype = { + call$1(module) { + return module.get$transitivelyContainsExtensions(); + }, + $signature: 116 + }; + A._EvaluateVisitor2.prototype = { + _EvaluateVisitor$6$functions$importCache$logger$nodeImporter$quietDeps$sourceMap2(functions, importCache, logger, nodeImporter, quietDeps, sourceMap) { + var t2, metaModule, t3, _i, module, $function, t4, _this = this, + _s20_ = "$name, $module: null", + _s9_ = "sass:meta", + _s7_ = "$module", + t1 = type$.JSArray_AsyncBuiltInCallable_2, + metaFunctions = A._setArrayType([A.BuiltInCallable$function0("global-variable-exists", _s20_, new A._EvaluateVisitor_closure38(_this), _s9_), A.BuiltInCallable$function0("variable-exists", "$name", new A._EvaluateVisitor_closure39(_this), _s9_), A.BuiltInCallable$function0("function-exists", _s20_, new A._EvaluateVisitor_closure40(_this), _s9_), A.BuiltInCallable$function0("mixin-exists", _s20_, new A._EvaluateVisitor_closure41(_this), _s9_), A.BuiltInCallable$function0("content-exists", "", new A._EvaluateVisitor_closure42(_this), _s9_), A.BuiltInCallable$function0("module-variables", _s7_, new A._EvaluateVisitor_closure43(_this), _s9_), A.BuiltInCallable$function0("module-functions", _s7_, new A._EvaluateVisitor_closure44(_this), _s9_), A.BuiltInCallable$function0("module-mixins", _s7_, new A._EvaluateVisitor_closure45(_this), _s9_), A.BuiltInCallable$function0("get-function", "$name, $css: false, $module: null", new A._EvaluateVisitor_closure46(_this), _s9_), A.BuiltInCallable$function0("get-mixin", _s20_, new A._EvaluateVisitor_closure47(_this), _s9_), new A.AsyncBuiltInCallable0("call", A.ScssParser$0("@function call($function, $args...) {", _s9_).parseParameterList$0(), new A._EvaluateVisitor_closure48(_this), false)], t1), + metaMixins = A._setArrayType([A.AsyncBuiltInCallable$mixin0("load-css", "$url, $with: null", new A._EvaluateVisitor_closure49(_this), false, _s9_), A.AsyncBuiltInCallable$mixin0("apply", "$mixin, $args...", new A._EvaluateVisitor_closure50(_this), true, _s9_)], t1); + t1 = type$.AsyncBuiltInCallable_2; + t2 = A.List_List$of($.$get$moduleFunctions0(), true, t1); + B.JSArray_methods.addAll$1(t2, metaFunctions); + metaModule = A.BuiltInModule$0("meta", t2, metaMixins, null, t1); + for (t1 = A.List_List$of($.$get$coreModules0(), true, type$.BuiltInModule_AsyncCallable_2), t1.push(metaModule), t2 = t1.length, t3 = _this._async_evaluate0$_builtInModules, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + module = t1[_i]; + t3.$indexSet(0, module.url, module); + } + t1 = type$.JSArray_AsyncCallable_2; + t2 = A._setArrayType([], t1); + B.JSArray_methods.addAll$1(t2, functions); + B.JSArray_methods.addAll$1(t2, $.$get$globalFunctions0()); + t1 = A._setArrayType([], t1); + for (_i = 0; _i < 11; ++_i) + t1.push(metaFunctions[_i].withDeprecationWarning$1("meta")); + B.JSArray_methods.addAll$1(t2, t1); + for (t1 = t2.length, t3 = _this._async_evaluate0$_builtInFunctions, _i = 0; _i < t2.length; t2.length === t1 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + $function = t2[_i]; + t4 = $function.get$name($function); + t3.$indexSet(0, A.stringReplaceAllUnchecked(t4, "_", "-"), $function); + } + }, + run$2(_, importer, node) { + return this.run$body$_EvaluateVisitor0(0, importer, node); + }, + run$body$_EvaluateVisitor0(_, importer, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet_2), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$self = this, error, stackTrace, t1, exception, $async$exception; + var $async$run$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$handler = 4; + t1 = type$.nullable_Object; + t1 = A.runZoned(new A._EvaluateVisitor_run_closure2($async$self, node, importer), A.LinkedHashMap_LinkedHashMap$_literal([B.Symbol__evaluationContext, new A._EvaluationContext2($async$self, node)], t1, t1), type$.FutureOr_Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet_2); + $async$goto = 7; + return A._asyncAwait(type$.Future_Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet_2._is(t1) ? t1 : A._Future$value(t1, type$.Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet_2), $async$run$2); + case 7: + // returning from await. + t1 = $async$result; + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + $async$handler = 2; + // goto after finally + $async$goto = 6; + break; + case 4: + // catch + $async$handler = 3; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (t1 instanceof A.SassException0) { + error = t1; + stackTrace = A.getTraceFromException($async$exception); + A.throwWithTrace0(error.withLoadedUrls$1($async$self._async_evaluate0$_loadedUrls), error, stackTrace); + } else + throw $async$exception; + // goto after finally + $async$goto = 6; + break; + case 3: + // uncaught + // goto rethrow + $async$goto = 2; + break; + case 6: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$run$2, $async$completer); + }, + _async_evaluate0$_assertInModule$1$2(value, $name) { + if (value != null) + return value; + throw A.wrapException(A.StateError$("Can't access " + $name + " outside of a module.")); + }, + _async_evaluate0$_assertInModule$2(value, $name) { + return this._async_evaluate0$_assertInModule$1$2(value, $name, type$.dynamic); + }, + _async_evaluate0$_loadModule$7$baseUrl$configuration$namesInErrors(url, stackFrame, nodeWithSpan, callback, baseUrl, configuration, namesInErrors) { + return this._loadModule$body$_EvaluateVisitor0(url, stackFrame, nodeWithSpan, callback, baseUrl, configuration, namesInErrors); + }, + _async_evaluate0$_loadModule$5$configuration(url, stackFrame, nodeWithSpan, callback, configuration) { + return this._async_evaluate0$_loadModule$7$baseUrl$configuration$namesInErrors(url, stackFrame, nodeWithSpan, callback, null, configuration, false); + }, + _async_evaluate0$_loadModule$4(url, stackFrame, nodeWithSpan, callback) { + return this._async_evaluate0$_loadModule$7$baseUrl$configuration$namesInErrors(url, stackFrame, nodeWithSpan, callback, null, null, false); + }, + _loadModule$body$_EvaluateVisitor0(url, stackFrame, nodeWithSpan, callback, baseUrl, configuration, namesInErrors) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$returnValue, $async$self = this, t2, _0_0, t1; + var $async$_async_evaluate0$_loadModule$7$baseUrl$configuration$namesInErrors = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + _0_0 = $async$self._async_evaluate0$_builtInModules.$index(0, url); + t1 = {}; + t1.builtInModule = null; + $async$goto = _0_0 != null ? 3 : 4; + break; + case 3: + // then + t1.builtInModule = _0_0; + if (configuration instanceof A.ExplicitConfiguration0) { + t1 = namesInErrors ? "Built-in module " + url.toString$0(0) + " can't be configured." : "Built-in modules can't be configured."; + t2 = configuration.nodeWithSpan; + throw A.wrapException($async$self._async_evaluate0$_exception$2(t1, t2.get$span(t2))); + } + $async$goto = 5; + return A._asyncAwait($async$self._async_evaluate0$_addExceptionSpanAsync$1$2(nodeWithSpan, new A._EvaluateVisitor__loadModule_closure5(t1, callback), type$.void), $async$_async_evaluate0$_loadModule$7$baseUrl$configuration$namesInErrors); + case 5: + // returning from await. + // goto return + $async$goto = 1; + break; + case 4: + // join + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate0$_withStackFrame$1$3(stackFrame, nodeWithSpan, new A._EvaluateVisitor__loadModule_closure6($async$self, url, nodeWithSpan, baseUrl, namesInErrors, configuration, callback), type$.Null), $async$_async_evaluate0$_loadModule$7$baseUrl$configuration$namesInErrors); + case 6: + // returning from await. + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_loadModule$7$baseUrl$configuration$namesInErrors, $async$completer); + }, + _async_evaluate0$_execute$5$configuration$namesInErrors$nodeWithSpan(importer, stylesheet, configuration, namesInErrors, nodeWithSpan) { + return this._execute$body$_EvaluateVisitor0(importer, stylesheet, configuration, namesInErrors, nodeWithSpan); + }, + _async_evaluate0$_execute$2(importer, stylesheet) { + return this._async_evaluate0$_execute$5$configuration$namesInErrors$nodeWithSpan(importer, stylesheet, null, false, null); + }, + _execute$body$_EvaluateVisitor0(importer, stylesheet, configuration, namesInErrors, nodeWithSpan) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Module_AsyncCallable_2), + $async$returnValue, $async$self = this, currentConfiguration, t2, t3, message, existingSpan, configurationSpan, environment, css, preModuleComments, extensionStore, module, url, t1, _0_0; + var $async$_async_evaluate0$_execute$5$configuration$namesInErrors$nodeWithSpan = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + url = stylesheet.span.file.url; + t1 = $async$self._async_evaluate0$_modules; + _0_0 = t1.$index(0, url); + if (_0_0 != null) { + t1 = configuration == null; + currentConfiguration = t1 ? $async$self._async_evaluate0$_configuration : configuration; + t2 = $async$self._async_evaluate0$_moduleConfigurations.$index(0, url); + t3 = t2._configuration0$__originalConfiguration; + t2 = t3 == null ? t2 : t3; + t3 = currentConfiguration._configuration0$__originalConfiguration; + if (t2 !== (t3 == null ? currentConfiguration : t3) && currentConfiguration instanceof A.ExplicitConfiguration0) { + if (namesInErrors) { + t2 = $.$get$context(); + url.toString; + message = t2.prettyUri$1(url) + string$.x20was_a; + } else + message = string$.This_mw; + t2 = $async$self._async_evaluate0$_moduleNodes.$index(0, url); + existingSpan = t2 == null ? null : t2.get$span(t2); + if (t1) { + t1 = currentConfiguration.nodeWithSpan; + configurationSpan = t1.get$span(t1); + } else + configurationSpan = null; + t1 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + if (existingSpan != null) + t1.$indexSet(0, existingSpan, "original load"); + if (configurationSpan != null) + t1.$indexSet(0, configurationSpan, "configuration"); + throw A.wrapException(t1.get$isEmpty(0) ? $async$self._async_evaluate0$_exception$1(message) : $async$self._async_evaluate0$_multiSpanException$3(message, "new load", t1)); + } + $async$returnValue = _0_0; + // goto return + $async$goto = 1; + break; + } + environment = A.AsyncEnvironment$0(); + css = A._Cell$(); + preModuleComments = A._Cell$(); + extensionStore = A.ExtensionStore$0(); + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_withEnvironment$1$2(environment, new A._EvaluateVisitor__execute_closure2($async$self, importer, stylesheet, extensionStore, configuration, css, preModuleComments), type$.Null), $async$_async_evaluate0$_execute$5$configuration$namesInErrors$nodeWithSpan); + case 3: + // returning from await. + t2 = css._readLocal$0(); + t3 = preModuleComments._readLocal$0(); + module = environment.toModule$3(t2, t3 == null ? B.Map_empty16 : t3, extensionStore); + if (url != null) { + t1.$indexSet(0, url, module); + $async$self._async_evaluate0$_moduleConfigurations.$indexSet(0, url, $async$self._async_evaluate0$_configuration); + if (nodeWithSpan != null) + $async$self._async_evaluate0$_moduleNodes.$indexSet(0, url, nodeWithSpan); + } + $async$returnValue = module; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_execute$5$configuration$namesInErrors$nodeWithSpan, $async$completer); + }, + _async_evaluate0$_addOutOfOrderImports$0() { + var t1, t2, _this = this, _s5_ = "_root", + _s13_ = "_endOfImports", + _0_0 = _this._async_evaluate0$_outOfOrderImports; + $label0$0: { + if (_0_0 == null) { + t1 = _this._async_evaluate0$_assertInModule$2(_this._async_evaluate0$__root, _s5_).children; + break $label0$0; + } + t1 = _this._async_evaluate0$_assertInModule$2(_this._async_evaluate0$__root, _s5_).children; + t1 = A.List_List$of(A.SubListIterable$(t1, 0, A.checkNotNullable(_this._async_evaluate0$_assertInModule$2(_this._async_evaluate0$__endOfImports, _s13_), "count", type$.int), t1.$ti._eval$1("ListBase.E")), true, type$.ModifiableCssNode_2); + B.JSArray_methods.addAll$1(t1, _0_0); + t2 = _this._async_evaluate0$_assertInModule$2(_this._async_evaluate0$__root, _s5_).children; + B.JSArray_methods.addAll$1(t1, A.SubListIterable$(t2, _this._async_evaluate0$_assertInModule$2(_this._async_evaluate0$__endOfImports, _s13_), null, t2.$ti._eval$1("ListBase.E"))); + break $label0$0; + } + return t1; + }, + _async_evaluate0$_combineCss$2$clone(root, clone) { + var selectors, _0_0, t1, imports, css, sorted, t2; + if (!B.JSArray_methods.any$1(root.get$upstream(), new A._EvaluateVisitor__combineCss_closure5())) { + selectors = root.get$extensionStore().get$simpleSelectors(); + _0_0 = A.IterableExtension_get_firstOrNull(root.get$extensionStore().extensionsWhereTarget$1(new A._EvaluateVisitor__combineCss_closure6(selectors))); + if (_0_0 != null) + this._async_evaluate0$_throwForUnsatisfiedExtension$1(_0_0); + return root.get$css(root); + } + t1 = type$.JSArray_CssNode_2; + imports = A._setArrayType([], t1); + css = A._setArrayType([], t1); + t1 = type$.Module_AsyncCallable_2; + sorted = A.ListQueue$(t1); + new A._EvaluateVisitor__combineCss_visitModule2(this, A.LinkedHashSet_LinkedHashSet$_empty(t1), clone, css, imports, sorted).call$1(root); + if (root.get$transitivelyContainsExtensions()) + this._async_evaluate0$_extendModules$1(sorted); + t1 = B.JSArray_methods.$add(imports, css); + t2 = root.get$css(root); + return new A.CssStylesheet0(new A.UnmodifiableListView(t1, type$.UnmodifiableListView_CssNode_2), t2.get$span(t2)); + }, + _async_evaluate0$_combineCss$1(root) { + return this._async_evaluate0$_combineCss$2$clone(root, false); + }, + _async_evaluate0$_extendModules$1(sortedModules) { + var t1, t2, t3, originalSelectors, $self, t4, t5, _i, upstream, _0_0, + downstreamExtensionStores = A.LinkedHashMap_LinkedHashMap$_empty(type$.Uri, type$.List_ExtensionStore_2), + unsatisfiedExtensions = new A._LinkedIdentityHashSet(type$._LinkedIdentityHashSet_Extension_2); + for (t1 = A._ListQueueIterator$(sortedModules, sortedModules.$ti._precomputed1), t2 = t1.$ti._precomputed1; t1.moveNext$0();) { + t3 = t1._collection$_current; + if (t3 == null) + t3 = t2._as(t3); + originalSelectors = t3.get$extensionStore().get$simpleSelectors().toSet$0(0); + unsatisfiedExtensions.addAll$1(0, t3.get$extensionStore().extensionsWhereTarget$1(new A._EvaluateVisitor__extendModules_closure5(originalSelectors))); + $self = downstreamExtensionStores.$index(0, t3.get$url(t3)); + t4 = t3.get$extensionStore().get$addExtensions(); + if ($self != null) + t4.call$1($self); + t4 = t3.get$extensionStore(); + if (t4.get$isEmpty(t4)) + continue; + for (t4 = t3.get$upstream(), t5 = t4.length, _i = 0; _i < t4.length; t4.length === t5 || (0, A.throwConcurrentModificationError)(t4), ++_i) { + upstream = t4[_i]; + _0_0 = upstream.get$url(upstream); + if (_0_0 != null) + J.add$1$ax(downstreamExtensionStores.putIfAbsent$2(_0_0, new A._EvaluateVisitor__extendModules_closure6()), t3.get$extensionStore()); + } + unsatisfiedExtensions.removeAll$1(t3.get$extensionStore().extensionsWhereTarget$1(originalSelectors.get$contains(originalSelectors))); + } + if (unsatisfiedExtensions._collection$_length !== 0) + this._async_evaluate0$_throwForUnsatisfiedExtension$1(unsatisfiedExtensions.get$first(0)); + }, + _async_evaluate0$_throwForUnsatisfiedExtension$1(extension) { + throw A.wrapException(A.SassException$0(string$.The_ta + extension.target.toString$0(0) + ' !optional" to avoid this error.', extension.span, null)); + }, + _async_evaluate0$_indexAfterImports$1(statements) { + var t1, lastImport, i, _0_0; + for (t1 = J.getInterceptor$asx(statements), lastImport = -1, i = 0; i < t1.get$length(statements); ++i) { + $label0$0: { + _0_0 = t1.$index(statements, i); + if (_0_0 instanceof A.ModifiableCssImport0) + break $label0$0; + if (_0_0 instanceof A.ModifiableCssComment0) + continue; + break; + } + lastImport = i; + } + return lastImport + 1; + }, + visitStylesheet$1(_, node) { + return this.visitStylesheet$body$_EvaluateVisitor0(0, node); + }, + visitStylesheet$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, t1, t2, warning, _i, $name, span; + var $async$visitStylesheet$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + for (t1 = node.parseTimeWarnings, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + warning = t1.__internal$_current; + if (warning == null) + warning = t2._as(warning); + $async$self._async_evaluate0$_warn$3(warning._1, warning._2, warning._0); + } + t1 = node.children, t2 = t1.length, _i = 0; + case 3: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 5; + break; + } + $async$goto = 6; + return A._asyncAwait(t1[_i].accept$1($async$self), $async$visitStylesheet$1); + case 6: + // returning from await. + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + for (t1 = A.MapExtensions_get_pairs0(node.globalVariables, type$.String, type$.FileSpan), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t2 = t1.get$current(t1); + $name = t2._0; + span = t2._1; + $async$self.visitVariableDeclaration$1(0, new A.VariableDeclaration0(null, $name, new A.NullExpression0(span), true, false, span)); + } + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitStylesheet$1, $async$completer); + }, + visitAtRootRule$1(_, node) { + return this.visitAtRootRule$body$_EvaluateVisitor0(0, node); + }, + visitAtRootRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, _1_0, resolved, query, $parent, included, t1, _2_0, root, first, rest, innerCopy, outerCopy, _i, copy, _0_0; + var $async$visitAtRootRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + _0_0 = node.query; + $async$goto = _0_0 != null ? 3 : 5; + break; + case 3: + // then + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate0$_performInterpolationWithMap$2$warnForColor(_0_0, true), $async$visitAtRootRule$1); + case 6: + // returning from await. + _1_0 = $async$result; + resolved = _1_0._0; + _1_0._1; + query = new A.AtRootQueryParser0(A.SpanScanner$(resolved, null), null).parse$0(0); + // goto join + $async$goto = 4; + break; + case 5: + // else + query = B.AtRootQuery_bfj0; + case 4: + // join + $parent = $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent"); + included = A._setArrayType([], type$.JSArray_ModifiableCssParentNode_2); + for (t1 = type$.CssStylesheet_2; !t1._is($parent); $parent = _2_0) { + if (!query.excludes$1($parent)) + included.push($parent); + _2_0 = $parent._node$_parent; + if (_2_0 == null) + throw A.wrapException(A.StateError$(string$.CssNod)); + } + root = $async$self._async_evaluate0$_trimIncluded$1(included); + $async$goto = root === $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent") ? 7 : 8; + break; + case 7: + // then + $async$goto = 9; + return A._asyncAwait($async$self._async_evaluate0$_environment.scope$1$2$when(new A._EvaluateVisitor_visitAtRootRule_closure5($async$self, node), node.hasDeclarations, type$.Null), $async$visitAtRootRule$1); + case 9: + // returning from await. + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 8: + // join + if (included.length >= 1) { + first = included[0]; + rest = B.JSArray_methods.sublist$1(included, 1); + innerCopy = first.copyWithoutChildren$0(); + for (t1 = rest.length, outerCopy = innerCopy, _i = 0; _i < rest.length; rest.length === t1 || (0, A.throwConcurrentModificationError)(rest), ++_i, outerCopy = copy) { + copy = rest[_i].copyWithoutChildren$0(); + copy.addChild$1(outerCopy); + } + root.addChild$1(outerCopy); + } else + innerCopy = root; + $async$goto = 10; + return A._asyncAwait($async$self._async_evaluate0$_scopeForAtRoot$4(node, innerCopy, query, included).call$1(new A._EvaluateVisitor_visitAtRootRule_closure6($async$self, node)), $async$visitAtRootRule$1); + case 10: + // returning from await. + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitAtRootRule$1, $async$completer); + }, + _async_evaluate0$_trimIncluded$1(nodes) { + var $parent, t1, innermostContiguous, i, t2, _0_0, _1_0, root, _this = this, _null = null, _s5_ = "_root", + _s22_ = " to be an ancestor of "; + if (nodes.length === 0) + return _this._async_evaluate0$_assertInModule$2(_this._async_evaluate0$__root, _s5_); + $parent = _this._async_evaluate0$_assertInModule$2(_this._async_evaluate0$__parent, "__parent"); + for (t1 = nodes.length, innermostContiguous = _null, i = 0; i < t1; ++i, $parent = _1_0) { + for (; t2 = nodes[i], $parent !== t2; innermostContiguous = _null, $parent = _0_0) { + _0_0 = $parent._node$_parent; + if (_0_0 == null) + throw A.wrapException(A.ArgumentError$("Expected " + t2.toString$0(0) + _s22_ + _this.toString$0(0) + ".", _null)); + } + if (innermostContiguous == null) + innermostContiguous = i; + _1_0 = $parent._node$_parent; + if (_1_0 == null) + throw A.wrapException(A.ArgumentError$("Expected " + t2.toString$0(0) + _s22_ + _this.toString$0(0) + ".", _null)); + } + if ($parent !== _this._async_evaluate0$_assertInModule$2(_this._async_evaluate0$__root, _s5_)) + return _this._async_evaluate0$_assertInModule$2(_this._async_evaluate0$__root, _s5_); + innermostContiguous.toString; + root = nodes[innermostContiguous]; + B.JSArray_methods.removeRange$2(nodes, innermostContiguous, nodes.length); + return root; + }, + _async_evaluate0$_scopeForAtRoot$4(node, newParent, query, included) { + var _this = this, + scope = new A._EvaluateVisitor__scopeForAtRoot_closure17(_this, newParent, node), + t1 = query._at_root_query0$_all || query._at_root_query0$_rule; + if (t1 !== query.include) + scope = new A._EvaluateVisitor__scopeForAtRoot_closure18(_this, scope); + if (_this._async_evaluate0$_mediaQueries != null && query.excludesName$1("media")) + scope = new A._EvaluateVisitor__scopeForAtRoot_closure19(_this, scope); + if (_this._async_evaluate0$_inKeyframes && query.excludesName$1("keyframes")) + scope = new A._EvaluateVisitor__scopeForAtRoot_closure20(_this, scope); + return _this._async_evaluate0$_inUnknownAtRule && !B.JSArray_methods.any$1(included, new A._EvaluateVisitor__scopeForAtRoot_closure21()) ? new A._EvaluateVisitor__scopeForAtRoot_closure22(_this, scope) : scope; + }, + visitContentBlock$1(_, node) { + return A.throwExpression(A.UnsupportedError$(string$.Evalua)); + }, + visitContentRule$1(_, node) { + return this.visitContentRule$body$_EvaluateVisitor0(0, node); + }, + visitContentRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, $content; + var $async$visitContentRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $content = $async$self._async_evaluate0$_environment._async_environment0$_content; + if ($content == null) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_runUserDefinedCallable$1$4(node.$arguments, $content, node, new A._EvaluateVisitor_visitContentRule_closure2($async$self, $content), type$.Null), $async$visitContentRule$1); + case 3: + // returning from await. + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitContentRule$1, $async$completer); + }, + visitDebugRule$1(_, node) { + return this.visitDebugRule$body$_EvaluateVisitor0(0, node); + }, + visitDebugRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, value, t1; + var $async$visitDebugRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait(node.expression.accept$1($async$self), $async$visitDebugRule$1); + case 3: + // returning from await. + value = $async$result; + t1 = value instanceof A.SassString0 ? value._string0$_text : A.serializeValue0(value, true, true); + $async$self._async_evaluate0$_logger.debug$2(0, t1, node.span); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitDebugRule$1, $async$completer); + }, + visitDeclaration$1(_, node) { + return this.visitDeclaration$body$_EvaluateVisitor0(0, node); + }, + visitDeclaration$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, siblings, interleavedRules, t1, t2, t3, t4, t5, t6, rule, rule0, $name, _1_0, _2_0, value, _3_0, oldDeclarationName; + var $async$visitDeclaration$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if (($async$self._async_evaluate0$_atRootExcludingStyleRule ? null : $async$self._async_evaluate0$_styleRuleIgnoringAtRoot) == null && !$async$self._async_evaluate0$_inUnknownAtRule && !$async$self._async_evaluate0$_inKeyframes) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Declarm, node.span)); + if ($async$self._async_evaluate0$_declarationName != null && B.JSString_methods.startsWith$1(node.name.get$initialPlain(), "--")) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Declarw, node.span)); + siblings = $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent")._node$_parent.children; + interleavedRules = A._setArrayType([], type$.JSArray_CssStyleRule_2); + if (siblings.get$last(siblings) !== $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent")) + t1 = !($async$self._async_evaluate0$_quietDeps && $async$self._async_evaluate0$_inDependency); + else + t1 = false; + if (t1) + for (t1 = A.SubListIterable$(siblings, siblings.indexOf$1(siblings, $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent")) + 1, null, siblings.$ti._eval$1("ListBase.E")), t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = node.span, t4 = type$.SourceSpan, t5 = type$.String, t2 = t2._eval$1("ListIterable.E"); t1.moveNext$0();) { + t6 = t1.__internal$_current; + rule = t6 == null ? t2._as(t6) : t6; + $label0$1: { + if (rule instanceof A.ModifiableCssComment0) + continue; + t6 = rule instanceof A.ModifiableCssStyleRule0; + rule0 = t6 ? rule : null; + if (t6) { + interleavedRules.push(rule0); + break $label0$1; + } + $async$self._async_evaluate0$_warn$3(string$.Sassx27s, new A.MultiSpan0(t3, "declaration", A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_literal([rule.get$span(rule), "nested rule"], t4, t5), t4, t5)), B.Deprecation_MSr); + B.JSArray_methods.clear$0(interleavedRules); + break $label0$1; + } + } + t1 = node.name; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_interpolationToValue$2$warnForColor(t1, true), $async$visitDeclaration$1); + case 3: + // returning from await. + $name = $async$result; + _1_0 = $async$self._async_evaluate0$_declarationName; + if (_1_0 != null) + $name = new A.CssValue0(_1_0 + "-" + A.S($name.value), $name.span, type$.CssValue_String_2); + _2_0 = node.value; + $async$goto = _2_0 != null ? 4 : 5; + break; + case 4: + // then + $async$goto = 6; + return A._asyncAwait(_2_0.accept$1($async$self), $async$visitDeclaration$1); + case 6: + // returning from await. + value = $async$result; + if (!value.get$isBlank() || value.get$asList().length === 0) { + t2 = $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent"); + t3 = _2_0.get$span(_2_0); + t4 = node.span; + t1 = B.JSString_methods.startsWith$1(t1.get$initialPlain(), "--"); + t5 = interleavedRules.length === 0 ? null : $async$self._async_evaluate0$_stackTrace$1(t4); + if ($async$self._async_evaluate0$_sourceMap) { + t6 = A.NullableExtension_andThen0(_2_0, $async$self.get$_async_evaluate0$_expressionNode()); + t6 = t6 == null ? null : J.get$span$z(t6); + } else + t6 = null; + t2.addChild$1(A.ModifiableCssDeclaration$0($name, new A.CssValue0(value, t3, type$.CssValue_Value_2), t4, interleavedRules, t1, t5, t6)); + } else if (J.startsWith$1$s($name.value, "--")) + throw A.wrapException($async$self._async_evaluate0$_exception$2("Custom property values may not be empty.", _2_0.get$span(_2_0))); + case 5: + // join + _3_0 = node.children; + t1 = {}; + t1.children = null; + $async$goto = _3_0 != null ? 7 : 8; + break; + case 7: + // then + t1.children = _3_0; + oldDeclarationName = $async$self._async_evaluate0$_declarationName; + $async$self._async_evaluate0$_declarationName = $name.value; + $async$goto = 9; + return A._asyncAwait($async$self._async_evaluate0$_environment.scope$1$2$when(new A._EvaluateVisitor_visitDeclaration_closure2(t1, $async$self), node.hasDeclarations, type$.Null), $async$visitDeclaration$1); + case 9: + // returning from await. + $async$self._async_evaluate0$_declarationName = oldDeclarationName; + case 8: + // join + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitDeclaration$1, $async$completer); + }, + visitEachRule$1(_, node) { + return this.visitEachRule$body$_EvaluateVisitor0(0, node); + }, + visitEachRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, t1, list, nodeWithSpan, _0_0; + var $async$visitEachRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = node.list; + $async$goto = 3; + return A._asyncAwait(t1.accept$1($async$self), $async$visitEachRule$1); + case 3: + // returning from await. + list = $async$result; + nodeWithSpan = $async$self._async_evaluate0$_expressionNode$1(t1); + _0_0 = node.variables; + $label0$0: { + t1 = {}; + t1.variable = null; + if (_0_0.length === 1) { + t1.variable = _0_0[0]; + t1 = new A._EvaluateVisitor_visitEachRule_closure8(t1, $async$self, nodeWithSpan); + break $label0$0; + } + t1 = {}; + t1.variables = null; + t1.variables = _0_0; + t1 = new A._EvaluateVisitor_visitEachRule_closure9(t1, $async$self, nodeWithSpan); + break $label0$0; + } + $async$returnValue = $async$self._async_evaluate0$_environment.scope$1$2$semiGlobal(new A._EvaluateVisitor_visitEachRule_closure10($async$self, list, t1, node), true, type$.nullable_Value_2); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitEachRule$1, $async$completer); + }, + _async_evaluate0$_setMultipleVariables$3(variables, value, nodeWithSpan) { + var i, + list = value.get$asList(), + t1 = variables.length, + minLength = Math.min(t1, list.length); + for (i = 0; i < minLength; ++i) + this._async_evaluate0$_environment.setLocalVariable$3(variables[i], this._async_evaluate0$_withoutSlash$2(list[i], nodeWithSpan), nodeWithSpan); + for (i = minLength; i < t1; ++i) + this._async_evaluate0$_environment.setLocalVariable$3(variables[i], B.C__SassNull0, nodeWithSpan); + }, + visitErrorRule$1(_, node) { + return this.visitErrorRule$body$_EvaluateVisitor0(0, node); + }, + visitErrorRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$self = this, $async$temp1, $async$temp2; + var $async$visitErrorRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$temp1 = A; + $async$temp2 = J; + $async$goto = 2; + return A._asyncAwait(node.expression.accept$1($async$self), $async$visitErrorRule$1); + case 2: + // returning from await. + throw $async$temp1.wrapException($async$self._async_evaluate0$_exception$2($async$temp2.toString$0$($async$result), node.span)); + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitErrorRule$1, $async$completer); + }, + visitExtendRule$1(_, node) { + return this.visitExtendRule$body$_EvaluateVisitor0(0, node); + }, + visitExtendRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, t1, t2, t3, t4, t5, _i, complex, visitor, t6, t7, _0_0, targetText, targetMap, compound, styleRule; + var $async$visitExtendRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + styleRule = $async$self._async_evaluate0$_atRootExcludingStyleRule ? null : $async$self._async_evaluate0$_styleRuleIgnoringAtRoot; + if (styleRule == null || $async$self._async_evaluate0$_declarationName != null) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.x40exten, node.span)); + for (t1 = styleRule.originalSelector.components, t2 = t1.length, t3 = node.span, t4 = type$.SourceSpan, t5 = type$.String, _i = 0; _i < t2; ++_i) { + complex = t1[_i]; + if (!complex.accept$1(B._IsBogusVisitor_true0)) + continue; + visitor = A._SerializeVisitor$0(null, true, null, null, true, false, null, true); + complex.accept$1(visitor); + t6 = B.JSString_methods.trim$0(visitor._serialize0$_buffer.toString$0(0)); + t7 = complex.accept$1(B.C__IsUselessVisitor0) ? "can't" : "shouldn't"; + $async$self._async_evaluate0$_warn$3('The selector "' + t6 + '" is invalid CSS and ' + t7 + string$.x20be_an, new A.MultiSpan0(A.SpanExtensions_trimRight0(complex.span), "invalid selector", A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_literal([t3, "@extend rule"], t4, t5), t4, t5)), B.Deprecation_SHb); + } + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_performInterpolationWithMap$2$warnForColor(node.selector, true), $async$visitExtendRule$1); + case 3: + // returning from await. + _0_0 = $async$result; + targetText = _0_0._0; + targetMap = _0_0._1; + for (t1 = A.SelectorList_SelectorList$parse0(A.trimAscii0(targetText, true), false, targetMap, false).components, t2 = t1.length, t3 = styleRule._style_rule0$_selector._box0$_inner, _i = 0; _i < t2; ++_i) { + complex = t1[_i]; + compound = complex.get$singleCompound(); + if (compound == null) + throw A.wrapException(A.SassFormatException$0("complex selectors may not be extended.", complex.span, null)); + t4 = compound.components; + t5 = t4.length === 1 ? B.JSArray_methods.get$first(t4) : null; + if (t5 == null) + throw A.wrapException(A.SassFormatException$0(string$.compou + B.JSArray_methods.join$1(t4, ", ") + string$.x60_inst, compound.span, null)); + $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__extensionStore, "_extensionStore").addExtension$4(t3.value, t5, node, $async$self._async_evaluate0$_mediaQueries); + } + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitExtendRule$1, $async$completer); + }, + visitAtRule$1(_, node) { + return this.visitAtRule$body$_EvaluateVisitor0(0, node); + }, + visitAtRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, $name, t1, value, children, wasInKeyframes, wasInUnknownAtRule; + var $async$visitAtRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate0$_declarationName != null) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.At_rul, node.span)); + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_interpolationToValue$1(node.name), $async$visitAtRule$1); + case 3: + // returning from await. + $name = $async$result; + t1 = A.NullableExtension_andThen0(node.value, new A._EvaluateVisitor_visitAtRule_closure8($async$self)); + $async$goto = 4; + return A._asyncAwait(type$.Future_nullable_CssValue_String_2._is(t1) ? t1 : A._Future$value(t1, type$.nullable_CssValue_String_2), $async$visitAtRule$1); + case 4: + // returning from await. + value = $async$result; + children = node.children; + if (children == null) { + $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent").addChild$1(A.ModifiableCssAtRule$0($name, node.span, true, value)); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + wasInKeyframes = $async$self._async_evaluate0$_inKeyframes; + wasInUnknownAtRule = $async$self._async_evaluate0$_inUnknownAtRule; + if (A.unvendor0($name.value) === "keyframes") + $async$self._async_evaluate0$_inKeyframes = true; + else + $async$self._async_evaluate0$_inUnknownAtRule = true; + $async$goto = 5; + return A._asyncAwait($async$self._async_evaluate0$_withParent$2$4$scopeWhen$through(A.ModifiableCssAtRule$0($name, node.span, false, value), new A._EvaluateVisitor_visitAtRule_closure9($async$self, $name, children), node.hasDeclarations, new A._EvaluateVisitor_visitAtRule_closure10(), type$.ModifiableCssAtRule_2, type$.Null), $async$visitAtRule$1); + case 5: + // returning from await. + $async$self._async_evaluate0$_inUnknownAtRule = wasInUnknownAtRule; + $async$self._async_evaluate0$_inKeyframes = wasInKeyframes; + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitAtRule$1, $async$completer); + }, + visitForRule$1(_, node) { + return this.visitForRule$body$_EvaluateVisitor0(0, node); + }, + visitForRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, t1, t2, t3, fromNumber, t4, toNumber, from, to, direction; + var $async$visitForRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = {}; + t2 = node.from; + t3 = type$.SassNumber_2; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_addExceptionSpanAsync$1$2(t2, new A._EvaluateVisitor_visitForRule_closure14($async$self, node), t3), $async$visitForRule$1); + case 3: + // returning from await. + fromNumber = $async$result; + t4 = node.to; + $async$goto = 4; + return A._asyncAwait($async$self._async_evaluate0$_addExceptionSpanAsync$1$2(t4, new A._EvaluateVisitor_visitForRule_closure15($async$self, node), t3), $async$visitForRule$1); + case 4: + // returning from await. + toNumber = $async$result; + from = $async$self._async_evaluate0$_addExceptionSpan$2(t2, new A._EvaluateVisitor_visitForRule_closure16(fromNumber)); + to = t1.to = $async$self._async_evaluate0$_addExceptionSpan$2(t4, new A._EvaluateVisitor_visitForRule_closure17(toNumber, fromNumber)); + direction = from > to ? -1 : 1; + if (from === (!node.isExclusive ? t1.to = to + direction : to)) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + $async$returnValue = $async$self._async_evaluate0$_environment.scope$1$2$semiGlobal(new A._EvaluateVisitor_visitForRule_closure18(t1, $async$self, node, from, direction, fromNumber), true, type$.nullable_Value_2); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitForRule$1, $async$completer); + }, + visitForwardRule$1(_, node) { + return this.visitForwardRule$body$_EvaluateVisitor0(0, node); + }, + visitForwardRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, newConfiguration, t4, _i, variable, $name, oldConfiguration, adjustedConfiguration, t1, t2, t3; + var $async$visitForwardRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + oldConfiguration = $async$self._async_evaluate0$_configuration; + adjustedConfiguration = oldConfiguration.throughForward$1(node); + t1 = node.configuration; + t2 = t1.length; + t3 = node.url; + $async$goto = t2 !== 0 ? 3 : 5; + break; + case 3: + // then + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate0$_addForwardConfiguration$2(adjustedConfiguration, node), $async$visitForwardRule$1); + case 6: + // returning from await. + newConfiguration = $async$result; + $async$goto = 7; + return A._asyncAwait($async$self._async_evaluate0$_loadModule$5$configuration(t3, "@forward", node, new A._EvaluateVisitor_visitForwardRule_closure5($async$self, node), newConfiguration), $async$visitForwardRule$1); + case 7: + // returning from await. + t3 = type$.String; + t4 = A.LinkedHashSet_LinkedHashSet$_empty(t3); + for (_i = 0; _i < t2; ++_i) { + variable = t1[_i]; + if (!variable.isGuarded) + t4.add$1(0, variable.name); + } + $async$self._async_evaluate0$_removeUsedConfiguration$3$except(adjustedConfiguration, newConfiguration, t4); + t3 = A.LinkedHashSet_LinkedHashSet$_empty(t3); + for (_i = 0; _i < t2; ++_i) + t3.add$1(0, t1[_i].name); + for (t1 = newConfiguration._configuration0$_values, t2 = J.toList$0$ax(t1.get$keys(t1)), t4 = t2.length, _i = 0; _i < t2.length; t2.length === t4 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + $name = t2[_i]; + if (!t3.contains$1(0, $name)) + if (!t1.get$isEmpty(t1)) + t1.remove$1(0, $name); + } + $async$self._async_evaluate0$_assertConfigurationIsEmpty$1(newConfiguration); + // goto join + $async$goto = 4; + break; + case 5: + // else + $async$self._async_evaluate0$_configuration = adjustedConfiguration; + $async$goto = 8; + return A._asyncAwait($async$self._async_evaluate0$_loadModule$4(t3, "@forward", node, new A._EvaluateVisitor_visitForwardRule_closure6($async$self, node)), $async$visitForwardRule$1); + case 8: + // returning from await. + $async$self._async_evaluate0$_configuration = oldConfiguration; + case 4: + // join + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitForwardRule$1, $async$completer); + }, + _async_evaluate0$_addForwardConfiguration$2(configuration, node) { + return this._addForwardConfiguration$body$_EvaluateVisitor0(configuration, node); + }, + _addForwardConfiguration$body$_EvaluateVisitor0(configuration, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Configuration_2), + $async$returnValue, $async$self = this, t2, t3, t4, t5, _i, variable, t6, _0_0, t7, oldValue, variableNodeWithSpan, t1, newValues, $async$temp1, $async$temp2, $async$temp3; + var $async$_async_evaluate0$_addForwardConfiguration$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = configuration._configuration0$_values; + newValues = A.LinkedHashMap_LinkedHashMap$of(new A.UnmodifiableMapView(t1, type$.UnmodifiableMapView_String_ConfiguredValue_2), type$.String, type$.ConfiguredValue_2); + t2 = node.configuration, t3 = t2.length, t4 = type$._Future_Value_2, t5 = type$.Future_Value_2, _i = 0; + case 3: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 5; + break; + } + variable = t2[_i]; + if (variable.isGuarded) { + t6 = variable.name; + _0_0 = t1.get$isEmpty(t1) ? null : t1.remove$1(0, t6); + if (_0_0 != null) { + t7 = !_0_0.value.$eq(0, B.C__SassNull0); + oldValue = _0_0; + } else { + oldValue = null; + t7 = false; + } + if (t7) { + newValues.$indexSet(0, t6, oldValue); + // goto for update + $async$goto = 4; + break; + } + } + t6 = variable.expression; + variableNodeWithSpan = $async$self._async_evaluate0$_expressionNode$1(t6); + t6 = t6.accept$1($async$self); + if (!t5._is(t6)) { + t7 = new A._Future($.Zone__current, t4); + t7._state = 8; + t7._resultOrListeners = t6; + t6 = t7; + } + $async$temp1 = newValues; + $async$temp2 = variable.name; + $async$temp3 = A; + $async$goto = 6; + return A._asyncAwait(t6, $async$_async_evaluate0$_addForwardConfiguration$2); + case 6: + // returning from await. + $async$temp1.$indexSet(0, $async$temp2, new $async$temp3.ConfiguredValue0($async$self._async_evaluate0$_withoutSlash$2($async$result, variableNodeWithSpan), variable.span, variableNodeWithSpan)); + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + if (configuration instanceof A.ExplicitConfiguration0 || t1.get$isEmpty(t1)) { + $async$returnValue = new A.ExplicitConfiguration0(node, newValues, null); + // goto return + $async$goto = 1; + break; + } else { + $async$returnValue = new A.Configuration0(newValues, null); + // goto return + $async$goto = 1; + break; + } + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_addForwardConfiguration$2, $async$completer); + }, + _async_evaluate0$_registerCommentsForModule$1(module) { + var _this = this, _s5_ = "_root", + t1 = _this._async_evaluate0$__root; + if (t1 == null) + return; + if (_this._async_evaluate0$_assertInModule$2(t1, _s5_).children.get$length(0) === 0 || !module.get$transitivelyContainsCss()) + return; + t1 = _this._async_evaluate0$_preModuleComments; + if (t1 == null) + t1 = _this._async_evaluate0$_preModuleComments = A.LinkedHashMap_LinkedHashMap$_empty(type$.Module_AsyncCallable_2, type$.List_CssComment_2); + J.addAll$1$ax(t1.putIfAbsent$2(module, new A._EvaluateVisitor__registerCommentsForModule_closure2()), new A.UnmodifiableListView(J.cast$1$0$ax(_this._async_evaluate0$_assertInModule$2(_this._async_evaluate0$__root, _s5_).children._collection$_source, type$.CssComment_2), type$.UnmodifiableListView_CssComment_2)); + _this._async_evaluate0$_assertInModule$2(_this._async_evaluate0$__root, _s5_).clearChildren$0(); + _this._async_evaluate0$__endOfImports = 0; + }, + _async_evaluate0$_removeUsedConfiguration$3$except(upstream, downstream, except) { + var t1, t2, t3, t4, _i, $name; + for (t1 = upstream._configuration0$_values, t2 = J.toList$0$ax(t1.get$keys(t1)), t3 = t2.length, t4 = downstream._configuration0$_values, _i = 0; _i < t2.length; t2.length === t3 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + $name = t2[_i]; + if (except.contains$1(0, $name)) + continue; + if (!t4.containsKey$1($name)) + if (!t1.get$isEmpty(t1)) + t1.remove$1(0, $name); + } + }, + _async_evaluate0$_assertConfigurationIsEmpty$2$nameInError(configuration, nameInError) { + var t1, _0_0, $name, value; + if (!(configuration instanceof A.ExplicitConfiguration0)) + return; + t1 = configuration._configuration0$_values; + if (t1.get$isEmpty(t1)) + return; + t1 = A.MapExtensions_get_pairs0(new A.UnmodifiableMapView(t1, type$.UnmodifiableMapView_String_ConfiguredValue_2), type$.String, type$.ConfiguredValue_2); + _0_0 = t1.get$first(t1); + $name = _0_0._0; + value = _0_0._1; + t1 = nameInError ? "$" + $name + string$.x20was_n : string$.This_v; + throw A.wrapException(this._async_evaluate0$_exception$2(t1, value.configurationSpan)); + }, + _async_evaluate0$_assertConfigurationIsEmpty$1(configuration) { + return this._async_evaluate0$_assertConfigurationIsEmpty$2$nameInError(configuration, false); + }, + visitFunctionRule$1(_, node) { + return this.visitFunctionRule$body$_EvaluateVisitor0(0, node); + }, + visitFunctionRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, t1, t2, t3, t4, index, t5; + var $async$visitFunctionRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self._async_evaluate0$_environment; + t2 = t1.closure$0(); + t3 = $async$self._async_evaluate0$_inDependency; + t4 = t1._async_environment0$_functions; + index = t4.length - 1; + t5 = node.name; + t1._async_environment0$_functionIndices.$indexSet(0, t5, index); + t4[index].$indexSet(0, t5, new A.UserDefinedCallable0(node, t2, t3, type$.UserDefinedCallable_AsyncEnvironment_2)); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitFunctionRule$1, $async$completer); + }, + visitIfRule$1(_, node) { + return this.visitIfRule$body$_EvaluateVisitor0(0, node); + }, + visitIfRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, t1, t2, _i, clauseToCheck, clause; + var $async$visitIfRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + clause = node.lastClause; + t1 = node.clauses, t2 = t1.length, _i = 0; + case 3: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 5; + break; + } + clauseToCheck = t1[_i]; + $async$goto = 6; + return A._asyncAwait(clauseToCheck.expression.accept$1($async$self), $async$visitIfRule$1); + case 6: + // returning from await. + if ($async$result.get$isTruthy()) { + clause = clauseToCheck; + // goto after for + $async$goto = 5; + break; + } + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + t1 = A.NullableExtension_andThen0(clause, new A._EvaluateVisitor_visitIfRule_closure2($async$self)); + $async$goto = 7; + return A._asyncAwait(type$.Future_nullable_Value_2._is(t1) ? t1 : A._Future$value(t1, type$.nullable_Value_2), $async$visitIfRule$1); + case 7: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitIfRule$1, $async$completer); + }, + visitImportRule$1(_, node) { + return this.visitImportRule$body$_EvaluateVisitor0(0, node); + }, + visitImportRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, t1, t2, t3, _i, $import; + var $async$visitImportRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = node.imports, t2 = t1.length, t3 = type$.StaticImport_2, _i = 0; + case 3: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 5; + break; + } + $import = t1[_i]; + $async$goto = $import instanceof A.DynamicImport0 ? 6 : 8; + break; + case 6: + // then + $async$goto = 9; + return A._asyncAwait($async$self._async_evaluate0$_visitDynamicImport$1($import), $async$visitImportRule$1); + case 9: + // returning from await. + // goto join + $async$goto = 7; + break; + case 8: + // else + $async$goto = 10; + return A._asyncAwait($async$self._async_evaluate0$_visitStaticImport$1(t3._as($import)), $async$visitImportRule$1); + case 10: + // returning from await. + case 7: + // join + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitImportRule$1, $async$completer); + }, + _async_evaluate0$_visitDynamicImport$1($import) { + return this._async_evaluate0$_withStackFrame$1$3("@import", $import, new A._EvaluateVisitor__visitDynamicImport_closure2(this, $import), type$.void); + }, + _async_evaluate0$_loadStylesheet$4$baseUrl$forImport(url, span, baseUrl, forImport) { + return this._loadStylesheet$body$_EvaluateVisitor0(url, span, baseUrl, forImport); + }, + _async_evaluate0$_loadStylesheet$3$baseUrl(url, span, baseUrl) { + return this._async_evaluate0$_loadStylesheet$4$baseUrl$forImport(url, span, baseUrl, false); + }, + _async_evaluate0$_loadStylesheet$3$forImport(url, span, forImport) { + return this._async_evaluate0$_loadStylesheet$4$baseUrl$forImport(url, span, null, forImport); + }, + _loadStylesheet$body$_EvaluateVisitor0(url, span, baseUrl, forImport) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_3_Stylesheet_and_nullable_AsyncImporter_importer_and_bool_isDependency_2), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$next = [], $async$self = this, _0_0, importCache, _1_0, importer, canonicalUrl, originalUrl, isDependency, _2_0, stylesheet, _3_0, result, error, stackTrace, error0, stackTrace0, t1, t2, exception, $async$exception; + var $async$_async_evaluate0$_loadStylesheet$4$baseUrl$forImport = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + baseUrl = baseUrl; + $async$handler = 4; + $async$self._async_evaluate0$_importSpan = span; + _0_0 = $async$self._async_evaluate0$_importCache; + importCache = null; + $async$goto = _0_0 != null ? 7 : 8; + break; + case 7: + // then + importCache = _0_0; + if (baseUrl == null) + baseUrl = $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__stylesheet, "_stylesheet").span.file.url; + $async$goto = 9; + return A._asyncAwait(J.canonicalize$4$baseImporter$baseUrl$forImport$x(importCache, A.Uri_parse(url), $async$self._async_evaluate0$_importer, baseUrl, forImport), $async$_async_evaluate0$_loadStylesheet$4$baseUrl$forImport); + case 9: + // returning from await. + _1_0 = $async$result; + importer = null; + canonicalUrl = null; + originalUrl = null; + $async$goto = type$.Record_3_nullable_Object_and_nullable_Object_and_nullable_Object_originalUrl._is(_1_0) ? 10 : 11; + break; + case 10: + // then + importer = _1_0._0; + canonicalUrl = _1_0._1; + originalUrl = _1_0._2; + if (canonicalUrl.get$scheme() === "") + A.WarnForDeprecation_warnForDeprecation0($async$self._async_evaluate0$_logger, B.Deprecation_Ord, "Importer " + A.S(importer) + " canonicalized " + url + " to " + A.S(canonicalUrl) + string$.x2e_Rela, null, null); + $async$self._async_evaluate0$_loadedUrls.add$1(0, canonicalUrl); + isDependency = $async$self._async_evaluate0$_inDependency || !J.$eq$(importer, $async$self._async_evaluate0$_importer); + $async$goto = 12; + return A._asyncAwait(importCache.importCanonical$3$originalUrl(importer, canonicalUrl, originalUrl), $async$_async_evaluate0$_loadStylesheet$4$baseUrl$forImport); + case 12: + // returning from await. + _2_0 = $async$result; + stylesheet = null; + if (_2_0 != null) { + stylesheet = _2_0; + t1 = stylesheet; + t2 = importer; + $async$returnValue = new A._Record_3_importer_isDependency(t1, t2, isDependency); + $async$next = [1]; + // goto finally + $async$goto = 5; + break; + } + case 11: + // join + case 8: + // join + $async$goto = $async$self._async_evaluate0$_nodeImporter != null ? 13 : 14; + break; + case 13: + // then + t1 = baseUrl; + $async$goto = 15; + return A._asyncAwait($async$self._async_evaluate0$_importLikeNode$3(url, t1 == null ? $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__stylesheet, "_stylesheet").span.file.url : t1, forImport), $async$_async_evaluate0$_loadStylesheet$4$baseUrl$forImport); + case 15: + // returning from await. + _3_0 = $async$result; + result = null; + if (_3_0 != null) { + result = _3_0; + t1 = $async$self._async_evaluate0$_loadedUrls; + A.NullableExtension_andThen0(result._0.span.file.url, t1.get$add(t1)); + t1 = result; + $async$returnValue = t1; + $async$next = [1]; + // goto finally + $async$goto = 5; + break; + } + case 14: + // join + t1 = B.JSString_methods.startsWith$1(url, "package:"); + if (t1) + throw A.wrapException(string$.x22packa); + else + throw A.wrapException("Can't find stylesheet to import."); + $async$next.push(6); + // goto finally + $async$goto = 5; + break; + case 4: + // catch + $async$handler = 3; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (t1 instanceof A.SassException0) + throw $async$exception; + else if (t1 instanceof A.ArgumentError) { + error = t1; + stackTrace = A.getTraceFromException($async$exception); + A.throwWithTrace0($async$self._async_evaluate0$_exception$1(J.toString$0$(error)), error, stackTrace); + } else { + error0 = t1; + stackTrace0 = A.getTraceFromException($async$exception); + A.throwWithTrace0($async$self._async_evaluate0$_exception$1($async$self._async_evaluate0$_getErrorMessage$1(error0)), error0, stackTrace0); + } + $async$next.push(6); + // goto finally + $async$goto = 5; + break; + case 3: + // uncaught + $async$next = [2]; + case 5: + // finally + $async$handler = 2; + $async$self._async_evaluate0$_importSpan = null; + // goto the next finally handler + $async$goto = $async$next.pop(); + break; + case 6: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_loadStylesheet$4$baseUrl$forImport, $async$completer); + }, + _async_evaluate0$_importLikeNode$3(originalUrl, previous, forImport) { + return this._importLikeNode$body$_EvaluateVisitor(originalUrl, previous, forImport); + }, + _importLikeNode$body$_EvaluateVisitor(originalUrl, previous, forImport) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Record_3_Stylesheet_and_nullable_AsyncImporter_importer_and_bool_isDependency), + $async$returnValue, $async$self = this, isDependency, url, t1, result; + var $async$_async_evaluate0$_importLikeNode$3 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self._async_evaluate0$_nodeImporter; + result = t1.loadRelative$3(originalUrl, previous, forImport); + $async$goto = result != null ? 3 : 5; + break; + case 3: + // then + isDependency = $async$self._async_evaluate0$_inDependency; + // goto join + $async$goto = 4; + break; + case 5: + // else + $async$goto = 6; + return A._asyncAwait(t1.loadAsync$3(originalUrl, previous, forImport), $async$_async_evaluate0$_importLikeNode$3); + case 6: + // returning from await. + result = $async$result; + if (result == null) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + isDependency = true; + case 4: + // join + url = result._1; + t1 = B.JSString_methods.startsWith$1(url, "file") ? A.Syntax_forPath0(url) : B.Syntax_SCSS_scss0; + $async$returnValue = new A._Record_3_importer_isDependency(A.Stylesheet_Stylesheet$parse0(result._0, t1, url), null, isDependency); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_importLikeNode$3, $async$completer); + }, + _async_evaluate0$_visitStaticImport$1($import) { + return this._visitStaticImport$body$_EvaluateVisitor0($import); + }, + _visitStaticImport$body$_EvaluateVisitor0($import) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1, t2, node, $async$temp1, $async$temp2; + var $async$_async_evaluate0$_visitStaticImport$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 2; + return A._asyncAwait($async$self._async_evaluate0$_interpolationToValue$1($import.url), $async$_async_evaluate0$_visitStaticImport$1); + case 2: + // returning from await. + t1 = $async$result; + t2 = A.NullableExtension_andThen0($import.modifiers, $async$self.get$_async_evaluate0$_interpolationToValue()); + $async$temp1 = A; + $async$temp2 = t1; + $async$goto = 3; + return A._asyncAwait(type$.Future_nullable_CssValue_String_2._is(t2) ? t2 : A._Future$value(t2, type$.nullable_CssValue_String_2), $async$_async_evaluate0$_visitStaticImport$1); + case 3: + // returning from await. + node = new $async$temp1.ModifiableCssImport0($async$temp2, $async$result, $import.span); + if ($async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent") !== $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__root, "_root")) + $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent").addChild$1(node); + else if ($async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__endOfImports, "_endOfImports") === J.get$length$asx($async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__root, "_root").children._collection$_source)) { + $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__root, "_root").addChild$1(node); + $async$self._async_evaluate0$__endOfImports = $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__endOfImports, "_endOfImports") + 1; + } else { + t1 = $async$self._async_evaluate0$_outOfOrderImports; + (t1 == null ? $async$self._async_evaluate0$_outOfOrderImports = A._setArrayType([], type$.JSArray_ModifiableCssImport_2) : t1).push(node); + } + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_visitStaticImport$1, $async$completer); + }, + _async_evaluate0$_applyMixin$5(mixin, contentCallable, $arguments, nodeWithSpan, nodeWithSpanWithoutContent) { + return this._applyMixin$body$_EvaluateVisitor0(mixin, contentCallable, $arguments, nodeWithSpan, nodeWithSpanWithoutContent); + }, + _applyMixin$body$_EvaluateVisitor0(mixin, contentCallable, $arguments, nodeWithSpan, nodeWithSpanWithoutContent) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1, _0_0, t2, _1_8; + var $async$_async_evaluate0$_applyMixin$5 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if (mixin == null) + throw A.wrapException($async$self._async_evaluate0$_exception$2("Undefined mixin.", nodeWithSpan.get$span(nodeWithSpan))); + t1 = type$.AsyncBuiltInCallable_2._is(mixin); + $async$goto = t1 && !mixin.get$acceptsContent() && contentCallable != null ? 3 : 4; + break; + case 3: + // then + $async$goto = 5; + return A._asyncAwait($async$self._async_evaluate0$_evaluateArguments$1($arguments), $async$_async_evaluate0$_applyMixin$5); + case 5: + // returning from await. + t1 = $async$result._values; + _0_0 = mixin.callbackFor$2(J.get$length$asx(t1[2]), new A.MapKeySet(t1[0], type$.MapKeySet_String)); + throw A.wrapException(A.MultiSpanSassRuntimeException$0("Mixin doesn't accept a content block.", nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent), "invocation", A.LinkedHashMap_LinkedHashMap$_literal([_0_0._0.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), $async$self._async_evaluate0$_stackTrace$1(nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent)), null)); + case 4: + // join + $async$goto = t1 ? 6 : 7; + break; + case 6: + // then + $async$goto = 8; + return A._asyncAwait($async$self._async_evaluate0$_environment.withContent$2(contentCallable, new A._EvaluateVisitor__applyMixin_closure5($async$self, $arguments, mixin, nodeWithSpanWithoutContent)), $async$_async_evaluate0$_applyMixin$5); + case 8: + // returning from await. + // goto break $label0$0 + $async$goto = 2; + break; + case 7: + // join + t1 = type$.UserDefinedCallable_AsyncEnvironment_2._is(mixin); + t2 = false; + if (t1) { + _1_8 = mixin.declaration; + if (_1_8 instanceof A.MixinRule0) + t2 = !type$.MixinRule_2._as(_1_8).get$hasContent() && contentCallable != null; + } + if (t2) + throw A.wrapException(A.MultiSpanSassRuntimeException$0("Mixin doesn't accept a content block.", nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent), "invocation", A.LinkedHashMap_LinkedHashMap$_literal([mixin.declaration.parameters.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), $async$self._async_evaluate0$_stackTrace$1(nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent)), null)); + $async$goto = t1 ? 9 : 10; + break; + case 9: + // then + $async$goto = 11; + return A._asyncAwait($async$self._async_evaluate0$_runUserDefinedCallable$1$4($arguments, mixin, nodeWithSpanWithoutContent, new A._EvaluateVisitor__applyMixin_closure6($async$self, contentCallable, mixin, nodeWithSpanWithoutContent), type$.Null), $async$_async_evaluate0$_applyMixin$5); + case 11: + // returning from await. + // goto break $label0$0 + $async$goto = 2; + break; + case 10: + // join + throw A.wrapException(A.UnsupportedError$("Unknown callable type " + mixin.toString$0(0) + ".")); + case 2: + // break $label0$0 + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_applyMixin$5, $async$completer); + }, + visitIncludeRule$1(_, node) { + return this.visitIncludeRule$body$_EvaluateVisitor0(0, node); + }, + visitIncludeRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, mixin; + var $async$visitIncludeRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + mixin = $async$self._async_evaluate0$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitIncludeRule_closure8($async$self, node)); + if (B.JSString_methods.startsWith$1(node.originalName, "--") && mixin instanceof A.UserDefinedCallable0 && !B.JSString_methods.startsWith$1(mixin.declaration.originalName, "--")) + $async$self._async_evaluate0$_warn$3(string$.Sassx20_m, node.get$nameSpan(), B.Deprecation_d4j); + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_applyMixin$5(mixin, A.NullableExtension_andThen0(node.content, new A._EvaluateVisitor_visitIncludeRule_closure9($async$self)), node.$arguments, node, new A._FakeAstNode0(new A._EvaluateVisitor_visitIncludeRule_closure10(node))), $async$visitIncludeRule$1); + case 3: + // returning from await. + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitIncludeRule$1, $async$completer); + }, + visitMixinRule$1(_, node) { + return this.visitMixinRule$body$_EvaluateVisitor0(0, node); + }, + visitMixinRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, t1, t2, t3, t4, index, t5; + var $async$visitMixinRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self._async_evaluate0$_environment; + t2 = t1.closure$0(); + t3 = $async$self._async_evaluate0$_inDependency; + t4 = t1._async_environment0$_mixins; + index = t4.length - 1; + t5 = node.name; + t1._async_environment0$_mixinIndices.$indexSet(0, t5, index); + t4[index].$indexSet(0, t5, new A.UserDefinedCallable0(node, t2, t3, type$.UserDefinedCallable_AsyncEnvironment_2)); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitMixinRule$1, $async$completer); + }, + visitLoudComment$1(_, node) { + return this.visitLoudComment$body$_EvaluateVisitor0(0, node); + }, + visitLoudComment$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, t1, text; + var $async$visitLoudComment$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate0$_inFunction) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + if ($async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent") === $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__root, "_root") && $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__endOfImports, "_endOfImports") === J.get$length$asx($async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__root, "_root").children._collection$_source)) + $async$self._async_evaluate0$__endOfImports = $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__endOfImports, "_endOfImports") + 1; + t1 = node.text; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_performInterpolation$1(t1), $async$visitLoudComment$1); + case 3: + // returning from await. + text = $async$result; + if (!B.JSString_methods.endsWith$1(text, "*/")) + text += " */"; + $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent").addChild$1(new A.ModifiableCssComment0(text, t1.span)); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitLoudComment$1, $async$completer); + }, + visitMediaRule$1(_, node) { + return this.visitMediaRule$body$_EvaluateVisitor0(0, node); + }, + visitMediaRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, queries, mergedQueries, t1, mergedSources, t2, t3; + var $async$visitMediaRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate0$_declarationName != null) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Media_, node.span)); + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_visitMediaQueries$1(node.query), $async$visitMediaRule$1); + case 3: + // returning from await. + queries = $async$result; + mergedQueries = A.NullableExtension_andThen0($async$self._async_evaluate0$_mediaQueries, new A._EvaluateVisitor_visitMediaRule_closure8($async$self, queries)); + t1 = mergedQueries == null; + if (!t1 && J.get$isEmpty$asx(mergedQueries)) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + if (t1) + mergedSources = B.Set_empty5; + else { + t2 = $async$self._async_evaluate0$_mediaQuerySources; + t2.toString; + t2 = A.LinkedHashSet_LinkedHashSet$of(t2, type$.CssMediaQuery_2); + t3 = $async$self._async_evaluate0$_mediaQueries; + t3.toString; + t2.addAll$1(0, t3); + t2.addAll$1(0, queries); + mergedSources = t2; + } + t1 = t1 ? queries : mergedQueries; + $async$goto = 4; + return A._asyncAwait($async$self._async_evaluate0$_withParent$2$4$scopeWhen$through(A.ModifiableCssMediaRule$0(t1, node.span), new A._EvaluateVisitor_visitMediaRule_closure9($async$self, mergedQueries, queries, mergedSources, node), node.hasDeclarations, new A._EvaluateVisitor_visitMediaRule_closure10(mergedSources), type$.ModifiableCssMediaRule_2, type$.Null), $async$visitMediaRule$1); + case 4: + // returning from await. + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitMediaRule$1, $async$completer); + }, + _async_evaluate0$_visitMediaQueries$1(interpolation) { + return this._visitMediaQueries$body$_EvaluateVisitor0(interpolation); + }, + _visitMediaQueries$body$_EvaluateVisitor0(interpolation) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.List_CssMediaQuery_2), + $async$returnValue, $async$self = this, _0_0, resolved, map; + var $async$_async_evaluate0$_visitMediaQueries$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_performInterpolationWithMap$2$warnForColor(interpolation, true), $async$_async_evaluate0$_visitMediaQueries$1); + case 3: + // returning from await. + _0_0 = $async$result; + resolved = _0_0._0; + map = _0_0._1; + $async$returnValue = new A.MediaQueryParser0(A.SpanScanner$(resolved, null), map).parse$0(0); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_visitMediaQueries$1, $async$completer); + }, + _async_evaluate0$_mergeMediaQueries$2(queries1, queries2) { + var t1, t2, t3, t4, _0_0, t5, result, + queries = A._setArrayType([], type$.JSArray_CssMediaQuery_2); + for (t1 = J.get$iterator$ax(queries1), t2 = J.getInterceptor$ax(queries2); t1.moveNext$0();) { + t3 = t1.get$current(t1); + for (t4 = t2.get$iterator(queries2); t4.moveNext$0();) { + _0_0 = t3.merge$1(t4.get$current(t4)); + if (B._SingletonCssMediaQueryMergeResult_00 === _0_0) + continue; + if (B._SingletonCssMediaQueryMergeResult_10 === _0_0) + return null; + t5 = _0_0 instanceof A.MediaQuerySuccessfulMergeResult0; + result = t5 ? _0_0 : null; + if (t5) + queries.push(result.query); + } + } + return queries; + }, + visitReturnRule$1(_, node) { + return this.visitReturnRule$body$_EvaluateVisitor0(0, node); + }, + visitReturnRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$self = this, t1, t2; + var $async$visitReturnRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = node.expression; + t2 = t1.accept$1($async$self); + $async$goto = 3; + return A._asyncAwait(type$.Future_Value_2._is(t2) ? t2 : A._Future$value(t2, type$.Value_2), $async$visitReturnRule$1); + case 3: + // returning from await. + $async$returnValue = $async$self._async_evaluate0$_withoutSlash$2($async$result, t1); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitReturnRule$1, $async$completer); + }, + visitSilentComment$1(_, node) { + return this.visitSilentComment$body$_EvaluateVisitor0(0, node); + }, + visitSilentComment$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue; + var $async$visitSilentComment$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitSilentComment$1, $async$completer); + }, + visitStyleRule$1(_, node) { + return this.visitStyleRule$body$_EvaluateVisitor0(0, node); + }, + visitStyleRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, t1, _0_0, selectorText, selectorMap, parsedSelector, nest, t2, _i, _1_0, first, t3, rule, oldAtRootExcludingStyleRule; + var $async$visitStyleRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate0$_declarationName != null) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Style_n, node.span)); + else if ($async$self._async_evaluate0$_inKeyframes && $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent") instanceof A.ModifiableCssKeyframeBlock0) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Style_k, node.span)); + t1 = node.selector; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_performInterpolationWithMap$2$warnForColor(t1, true), $async$visitStyleRule$1); + case 3: + // returning from await. + _0_0 = $async$result; + selectorText = _0_0._0; + selectorMap = _0_0._1; + $async$goto = $async$self._async_evaluate0$_inKeyframes ? 4 : 5; + break; + case 4: + // then + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate0$_withParent$2$4$scopeWhen$through(A.ModifiableCssKeyframeBlock$0(new A.CssValue0(A.List_List$unmodifiable(new A.KeyframeSelectorParser0(A.SpanScanner$(selectorText, null), selectorMap).parse$0(0), type$.String), t1.span, type$.CssValue_List_String_2), node.span), new A._EvaluateVisitor_visitStyleRule_closure11($async$self, node), node.hasDeclarations, new A._EvaluateVisitor_visitStyleRule_closure12(), type$.ModifiableCssKeyframeBlock_2, type$.Null), $async$visitStyleRule$1); + case 6: + // returning from await. + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 5: + // join + parsedSelector = A.SelectorList_SelectorList$parse0(selectorText, true, selectorMap, $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__stylesheet, "_stylesheet").plainCss); + t1 = $async$self._async_evaluate0$_atRootExcludingStyleRule ? null : $async$self._async_evaluate0$_styleRuleIgnoringAtRoot; + t1 = t1 == null ? null : t1.fromPlainCss; + nest = t1 !== true; + if (nest) { + if ($async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__stylesheet, "_stylesheet").plainCss) + for (t1 = parsedSelector.components, t2 = t1.length, _i = 0; _i < t2; ++_i) { + _1_0 = t1[_i].leadingCombinators; + if (_1_0.length >= 1) { + first = _1_0[0]; + t3 = $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__stylesheet, "_stylesheet").plainCss; + } else { + first = null; + t3 = false; + } + if (t3) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Top_lel, first.span)); + } + t1 = $async$self._async_evaluate0$_styleRuleIgnoringAtRoot; + t1 = t1 == null ? null : t1.originalSelector; + parsedSelector = parsedSelector.nestWithin$3$implicitParent$preserveParentSelectors(t1, !$async$self._async_evaluate0$_atRootExcludingStyleRule, $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__stylesheet, "_stylesheet").plainCss); + } + rule = A.ModifiableCssStyleRule$0($async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__extensionStore, "_extensionStore").addSelector$2(parsedSelector, $async$self._async_evaluate0$_mediaQueries), node.span, $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__stylesheet, "_stylesheet").plainCss, parsedSelector); + oldAtRootExcludingStyleRule = $async$self._async_evaluate0$_atRootExcludingStyleRule; + t1 = $async$self._async_evaluate0$_atRootExcludingStyleRule = false; + t2 = nest ? new A._EvaluateVisitor_visitStyleRule_closure13() : null; + $async$goto = 7; + return A._asyncAwait($async$self._async_evaluate0$_withParent$2$4$scopeWhen$through(rule, new A._EvaluateVisitor_visitStyleRule_closure14($async$self, rule, node), node.hasDeclarations, t2, type$.ModifiableCssStyleRule_2, type$.Null), $async$visitStyleRule$1); + case 7: + // returning from await. + $async$self._async_evaluate0$_atRootExcludingStyleRule = oldAtRootExcludingStyleRule; + $async$self._async_evaluate0$_warnForBogusCombinators$1(rule); + if (($async$self._async_evaluate0$_atRootExcludingStyleRule ? null : $async$self._async_evaluate0$_styleRuleIgnoringAtRoot) == null) { + t1 = $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent").children; + t1 = !t1.get$isEmpty(t1); + } + if (t1) { + t1 = $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent").children; + t1.get$last(t1).isGroupEnd = true; + } + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitStyleRule$1, $async$completer); + }, + _async_evaluate0$_warnForBogusCombinators$1(rule) { + var t1, t2, t3, t4, t5, _i, complex, visitor, t6, t7, t8, t9, _this = this, _null = null; + if (!rule.accept$1(B._IsInvisibleVisitor_false_false0)) + for (t1 = rule._style_rule0$_selector._box0$_inner.value.components, t2 = t1.length, t3 = type$.SourceSpan, t4 = type$.String, t5 = rule.children, _i = 0; _i < t2; ++_i) { + complex = t1[_i]; + if (!complex.accept$1(B._IsBogusVisitor_true0)) + continue; + if (complex.accept$1(B.C__IsUselessVisitor0)) { + visitor = A._SerializeVisitor$0(_null, true, _null, _null, true, false, _null, true); + complex.accept$1(visitor); + _this._async_evaluate0$_warn$3('The selector "' + B.JSString_methods.trim$0(visitor._serialize0$_buffer.toString$0(0)) + string$.x22x20is_ix20, A.SpanExtensions_trimRight0(complex.span), B.Deprecation_SHb); + } else if (complex.leadingCombinators.length !== 0) { + if (!_this._async_evaluate0$_assertInModule$2(_this._async_evaluate0$__stylesheet, "_stylesheet").plainCss) { + visitor = A._SerializeVisitor$0(_null, true, _null, _null, true, false, _null, true); + complex.accept$1(visitor); + _this._async_evaluate0$_warn$3('The selector "' + B.JSString_methods.trim$0(visitor._serialize0$_buffer.toString$0(0)) + string$.x22x20is_ix0a, A.SpanExtensions_trimRight0(complex.span), B.Deprecation_SHb); + } + } else { + visitor = A._SerializeVisitor$0(_null, true, _null, _null, true, false, _null, true); + complex.accept$1(visitor); + t6 = B.JSString_methods.trim$0(visitor._serialize0$_buffer.toString$0(0)); + t7 = complex.accept$1(B._IsBogusVisitor_false0) ? string$.x20It_wi : ""; + t8 = A.SpanExtensions_trimRight0(complex.span); + if (t5.get$length(0) === 0) + A.throwExpression(A.IterableElementError_noElement()); + t9 = J.get$span$z(t5.$index(0, 0)); + _this._async_evaluate0$_warn$3('The selector "' + t6 + string$.x22x20is_o + t7 + string$.x0aThis_, new A.MultiSpan0(t8, "invalid selector", A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_literal([t9, "this is not a style rule" + (t5.every$1(t5, new A._EvaluateVisitor__warnForBogusCombinators_closure2()) ? "\n(try converting to a //-style comment)" : "")], t3, t4), t3, t4)), B.Deprecation_SHb); + } + } + }, + visitSupportsRule$1(_, node) { + return this.visitSupportsRule$body$_EvaluateVisitor0(0, node); + }, + visitSupportsRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, t1, $async$temp1, $async$temp2; + var $async$visitSupportsRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate0$_declarationName != null) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Suppor, node.span)); + t1 = node.condition; + $async$temp1 = A; + $async$temp2 = A; + $async$goto = 4; + return A._asyncAwait($async$self._async_evaluate0$_visitSupportsCondition$1(t1), $async$visitSupportsRule$1); + case 4: + // returning from await. + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_withParent$2$4$scopeWhen$through($async$temp1.ModifiableCssSupportsRule$0(new $async$temp2.CssValue0($async$result, t1.get$span(t1), type$.CssValue_String_2), node.span), new A._EvaluateVisitor_visitSupportsRule_closure5($async$self, node), node.hasDeclarations, new A._EvaluateVisitor_visitSupportsRule_closure6(), type$.ModifiableCssSupportsRule_2, type$.Null), $async$visitSupportsRule$1); + case 3: + // returning from await. + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitSupportsRule$1, $async$completer); + }, + _async_evaluate0$_visitSupportsCondition$1(condition) { + return this._visitSupportsCondition$body$_EvaluateVisitor0(condition); + }, + _visitSupportsCondition$body$_EvaluateVisitor0(condition) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.String), + $async$returnValue, $async$self = this, t1, $async$temp1, $async$temp2; + var $async$_async_evaluate0$_visitSupportsCondition$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = condition instanceof A.SupportsOperation0 ? 4 : 5; + break; + case 4: + // then + t1 = condition.operator; + $async$temp1 = A; + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate0$_parenthesize$2(condition.left, t1), $async$_async_evaluate0$_visitSupportsCondition$1); + case 6: + // returning from await. + $async$temp1 = $async$temp1.S($async$result) + " " + t1 + " "; + $async$temp2 = A; + $async$goto = 7; + return A._asyncAwait($async$self._async_evaluate0$_parenthesize$2(condition.right, t1), $async$_async_evaluate0$_visitSupportsCondition$1); + case 7: + // returning from await. + t1 = $async$temp1 + $async$temp2.S($async$result); + // goto break $label0$0 + $async$goto = 3; + break; + case 5: + // join + $async$goto = condition instanceof A.SupportsNegation0 ? 8 : 9; + break; + case 8: + // then + $async$temp1 = A; + $async$goto = 10; + return A._asyncAwait($async$self._async_evaluate0$_parenthesize$1(condition.condition), $async$_async_evaluate0$_visitSupportsCondition$1); + case 10: + // returning from await. + t1 = "not " + $async$temp1.S($async$result); + // goto break $label0$0 + $async$goto = 3; + break; + case 9: + // join + $async$goto = condition instanceof A.SupportsInterpolation0 ? 11 : 12; + break; + case 11: + // then + $async$goto = 13; + return A._asyncAwait($async$self._async_evaluate0$_evaluateToCss$2$quote(condition.expression, false), $async$_async_evaluate0$_visitSupportsCondition$1); + case 13: + // returning from await. + t1 = $async$result; + // goto break $label0$0 + $async$goto = 3; + break; + case 12: + // join + t1 = {}; + t1.declaration = null; + $async$goto = condition instanceof A.SupportsDeclaration0 ? 14 : 15; + break; + case 14: + // then + t1.declaration = condition; + $async$goto = 16; + return A._asyncAwait($async$self._async_evaluate0$_withSupportsDeclaration$1$1(new A._EvaluateVisitor__visitSupportsCondition_closure2(t1, $async$self), type$.String), $async$_async_evaluate0$_visitSupportsCondition$1); + case 16: + // returning from await. + t1 = $async$result; + // goto break $label0$0 + $async$goto = 3; + break; + case 15: + // join + $async$goto = condition instanceof A.SupportsFunction0 ? 17 : 18; + break; + case 17: + // then + $async$temp1 = A; + $async$goto = 19; + return A._asyncAwait($async$self._async_evaluate0$_performInterpolation$1(condition.name), $async$_async_evaluate0$_visitSupportsCondition$1); + case 19: + // returning from await. + $async$temp1 = $async$temp1.S($async$result) + "("; + $async$temp2 = A; + $async$goto = 20; + return A._asyncAwait($async$self._async_evaluate0$_performInterpolation$1(condition.$arguments), $async$_async_evaluate0$_visitSupportsCondition$1); + case 20: + // returning from await. + t1 = $async$temp1 + $async$temp2.S($async$result) + ")"; + // goto break $label0$0 + $async$goto = 3; + break; + case 18: + // join + $async$goto = condition instanceof A.SupportsAnything0 ? 21 : 22; + break; + case 21: + // then + $async$temp1 = A; + $async$goto = 23; + return A._asyncAwait($async$self._async_evaluate0$_performInterpolation$1(condition.contents), $async$_async_evaluate0$_visitSupportsCondition$1); + case 23: + // returning from await. + t1 = "(" + $async$temp1.S($async$result) + ")"; + // goto break $label0$0 + $async$goto = 3; + break; + case 22: + // join + t1 = A.throwExpression(A.ArgumentError$("Unknown supports condition type " + A.getRuntimeTypeOfDartObject(condition).toString$0(0) + ".", null)); + case 3: + // break $label0$0 + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_visitSupportsCondition$1, $async$completer); + }, + _async_evaluate0$_withSupportsDeclaration$1$1(callback, $T) { + return this._withSupportsDeclaration$body$_EvaluateVisitor0(callback, $T, $T); + }, + _withSupportsDeclaration$body$_EvaluateVisitor0(callback, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$next = [], $async$self = this, t1, oldInSupportsDeclaration; + var $async$_async_evaluate0$_withSupportsDeclaration$1$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + oldInSupportsDeclaration = $async$self._async_evaluate0$_inSupportsDeclaration; + $async$self._async_evaluate0$_inSupportsDeclaration = true; + $async$handler = 3; + t1 = callback.call$0(); + $async$goto = 6; + return A._asyncAwait($T._eval$1("Future<0>")._is(t1) ? t1 : A._Future$value(t1, $T), $async$_async_evaluate0$_withSupportsDeclaration$1$1); + case 6: + // returning from await. + t1 = $async$result; + $async$returnValue = t1; + $async$next = [1]; + // goto finally + $async$goto = 4; + break; + $async$next.push(5); + // goto finally + $async$goto = 4; + break; + case 3: + // uncaught + $async$next = [2]; + case 4: + // finally + $async$handler = 2; + $async$self._async_evaluate0$_inSupportsDeclaration = oldInSupportsDeclaration; + // goto the next finally handler + $async$goto = $async$next.pop(); + break; + case 5: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_withSupportsDeclaration$1$1, $async$completer); + }, + _async_evaluate0$_parenthesize$2(condition, operator) { + return this._parenthesize$body$_EvaluateVisitor0(condition, operator); + }, + _async_evaluate0$_parenthesize$1(condition) { + return this._async_evaluate0$_parenthesize$2(condition, null); + }, + _parenthesize$body$_EvaluateVisitor0(condition, operator) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.String), + $async$returnValue, $async$self = this, t1, $async$temp1; + var $async$_async_evaluate0$_parenthesize$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if (!(condition instanceof A.SupportsNegation0)) + if (condition instanceof A.SupportsOperation0) + t1 = operator == null || operator !== condition.operator; + else + t1 = false; + else + t1 = true; + $async$goto = t1 ? 3 : 4; + break; + case 3: + // then + $async$temp1 = A; + $async$goto = 5; + return A._asyncAwait($async$self._async_evaluate0$_visitSupportsCondition$1(condition), $async$_async_evaluate0$_parenthesize$2); + case 5: + // returning from await. + $async$returnValue = "(" + $async$temp1.S($async$result) + ")"; + // goto return + $async$goto = 1; + break; + case 4: + // join + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate0$_visitSupportsCondition$1(condition), $async$_async_evaluate0$_parenthesize$2); + case 6: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_parenthesize$2, $async$completer); + }, + visitVariableDeclaration$1(_, node) { + return this.visitVariableDeclaration$body$_EvaluateVisitor0(0, node); + }, + visitVariableDeclaration$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, t1, _0_0, t2, value, $async$temp1, $async$temp2, $async$temp3; + var $async$visitVariableDeclaration$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if (node.isGuarded) { + if (node.namespace == null && $async$self._async_evaluate0$_environment._async_environment0$_variables.length === 1) { + t1 = $async$self._async_evaluate0$_configuration._configuration0$_values; + _0_0 = t1.get$isEmpty(t1) ? null : t1.remove$1(0, node.name); + t1 = {}; + t1.override = null; + if (_0_0 != null) { + t1.override = _0_0; + t2 = !_0_0.value.$eq(0, B.C__SassNull0); + } else + t2 = false; + if (t2) { + $async$self._async_evaluate0$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitVariableDeclaration_closure8(t1, $async$self, node)); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + } + value = $async$self._async_evaluate0$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitVariableDeclaration_closure9($async$self, node)); + if (value != null && !value.$eq(0, B.C__SassNull0)) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + } + if (node.isGlobal && !$async$self._async_evaluate0$_environment.globalVariableExists$1(node.name)) { + t1 = $async$self._async_evaluate0$_environment._async_environment0$_variables.length === 1 ? string$.As_of_S : string$.As_of_R + A.declarationName0(node.span) + ": null` at the stylesheet root."; + $async$self._async_evaluate0$_warn$3(t1, node.span, B.Deprecation_mSy); + } + t1 = node.expression; + t2 = t1.accept$1($async$self); + $async$temp1 = node; + $async$temp2 = A; + $async$temp3 = node; + $async$goto = 3; + return A._asyncAwait(type$.Future_Value_2._is(t2) ? t2 : A._Future$value(t2, type$.Value_2), $async$visitVariableDeclaration$1); + case 3: + // returning from await. + $async$self._async_evaluate0$_addExceptionSpan$2($async$temp1, new $async$temp2._EvaluateVisitor_visitVariableDeclaration_closure10($async$self, $async$temp3, $async$self._async_evaluate0$_withoutSlash$2($async$result, t1))); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitVariableDeclaration$1, $async$completer); + }, + visitUseRule$1(_, node) { + return this.visitUseRule$body$_EvaluateVisitor0(0, node); + }, + visitUseRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, values, t3, t4, _i, variable, t5, variableNodeWithSpan, t6, configuration, t1, t2, $async$temp1, $async$temp2, $async$temp3; + var $async$visitUseRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = node.configuration; + t2 = t1.length; + $async$goto = t2 !== 0 ? 3 : 5; + break; + case 3: + // then + values = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.ConfiguredValue_2); + t3 = type$._Future_Value_2, t4 = type$.Future_Value_2, _i = 0; + case 6: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 8; + break; + } + variable = t1[_i]; + t5 = variable.expression; + variableNodeWithSpan = $async$self._async_evaluate0$_expressionNode$1(t5); + t5 = t5.accept$1($async$self); + if (!t4._is(t5)) { + t6 = new A._Future($.Zone__current, t3); + t6._state = 8; + t6._resultOrListeners = t5; + t5 = t6; + } + $async$temp1 = values; + $async$temp2 = variable.name; + $async$temp3 = A; + $async$goto = 9; + return A._asyncAwait(t5, $async$visitUseRule$1); + case 9: + // returning from await. + $async$temp1.$indexSet(0, $async$temp2, new $async$temp3.ConfiguredValue0($async$self._async_evaluate0$_withoutSlash$2($async$result, variableNodeWithSpan), variable.span, variableNodeWithSpan)); + case 7: + // for update + ++_i; + // goto for condition + $async$goto = 6; + break; + case 8: + // after for + configuration = new A.ExplicitConfiguration0(node, values, null); + // goto join + $async$goto = 4; + break; + case 5: + // else + configuration = B.Configuration_Map_empty_null0; + case 4: + // join + $async$goto = 10; + return A._asyncAwait($async$self._async_evaluate0$_loadModule$5$configuration(node.url, "@use", node, new A._EvaluateVisitor_visitUseRule_closure2($async$self, node), configuration), $async$visitUseRule$1); + case 10: + // returning from await. + $async$self._async_evaluate0$_assertConfigurationIsEmpty$1(configuration); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitUseRule$1, $async$completer); + }, + visitWarnRule$1(_, node) { + return this.visitWarnRule$body$_EvaluateVisitor0(0, node); + }, + visitWarnRule$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, value, t1, t2; + var $async$visitWarnRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_addExceptionSpanAsync$1$2(node, new A._EvaluateVisitor_visitWarnRule_closure2($async$self, node), type$.Value_2), $async$visitWarnRule$1); + case 3: + // returning from await. + value = $async$result; + t1 = value instanceof A.SassString0 ? value._string0$_text : $async$self._async_evaluate0$_serialize$2(value, node.expression); + t2 = $async$self._async_evaluate0$_stackTrace$1(node.span); + $async$self._async_evaluate0$_logger.internalWarn$4$deprecation$span$trace(t1, null, null, t2); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitWarnRule$1, $async$completer); + }, + visitWhileRule$1(_, node) { + return this._async_evaluate0$_environment.scope$1$3$semiGlobal$when(new A._EvaluateVisitor_visitWhileRule_closure2(this, node), true, node.hasDeclarations, type$.nullable_Value_2); + }, + visitBinaryOperationExpression$1(_, node) { + var t1, _this = this; + if (_this._async_evaluate0$_assertInModule$2(_this._async_evaluate0$__stylesheet, "_stylesheet").plainCss) { + t1 = node.operator; + t1 = t1 !== B.BinaryOperator_Kyq0 && t1 !== B.BinaryOperator_Mh50; + } else + t1 = false; + if (t1) + throw A.wrapException(_this._async_evaluate0$_exception$2("Operators aren't allowed in plain CSS.", node.get$operatorSpan())); + return _this._async_evaluate0$_addExceptionSpanAsync$1$2(node, new A._EvaluateVisitor_visitBinaryOperationExpression_closure2(_this, node), type$.Value_2); + }, + _async_evaluate0$_slash$3(left, right, node) { + var t2, _1_1, + result = left.dividedBy$1(right), + _1_2_isSet = left instanceof A.SassNumber0, + _1_2 = null, right0 = null, + t1 = false; + if (_1_2_isSet) { + t2 = type$.SassNumber_2; + t2._as(left); + if (right instanceof A.SassNumber0) { + t2._as(right); + t1 = node.allowsSlash && this._async_evaluate0$_operandAllowsSlash$1(node.left) && this._async_evaluate0$_operandAllowsSlash$1(node.right); + right0 = right; + _1_2 = right0; + } else + _1_2 = right; + _1_1 = left; + } else { + _1_1 = left; + left = null; + } + if (t1) + return type$.SassNumber_2._as(result).withSlash$2(left, right0); + if (_1_1 instanceof A.SassNumber0) + t1 = (_1_2_isSet ? _1_2 : right) instanceof A.SassNumber0; + else + t1 = false; + if (t1) { + this._async_evaluate0$_warn$3(string$.Using__o + A.S(new A._EvaluateVisitor__slash_recommendation2().call$1(node)) + " or " + A.expressionToCalc0(node).toString$0(0) + string$.x0a_Morex20, node.get$span(0), B.Deprecation_FyB); + return result; + } + return result; + }, + _async_evaluate0$_operandAllowsSlash$1(node) { + var t1; + if (node instanceof A.FunctionExpression0) + if (node.namespace == null) { + t1 = node.name; + t1 = B.Set_Pr3yj.contains$1(0, t1.toLowerCase()) && this._async_evaluate0$_environment.getFunction$1(t1) == null; + } else + t1 = false; + else + t1 = true; + return t1; + }, + visitValueExpression$1(_, node) { + return this.visitValueExpression$body$_EvaluateVisitor0(0, node); + }, + visitValueExpression$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue; + var $async$visitValueExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$returnValue = node.value; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitValueExpression$1, $async$completer); + }, + visitVariableExpression$1(_, node) { + return this.visitVariableExpression$body$_EvaluateVisitor0(0, node); + }, + visitVariableExpression$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$self = this, result; + var $async$visitVariableExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + result = $async$self._async_evaluate0$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitVariableExpression_closure2($async$self, node)); + if (result != null) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + throw A.wrapException($async$self._async_evaluate0$_exception$2("Undefined variable.", node.span)); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitVariableExpression$1, $async$completer); + }, + visitUnaryOperationExpression$1(_, node) { + return this.visitUnaryOperationExpression$body$_EvaluateVisitor0(0, node); + }, + visitUnaryOperationExpression$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$self = this, $async$temp1, $async$temp2, $async$temp3; + var $async$visitUnaryOperationExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$temp1 = node; + $async$temp2 = A; + $async$temp3 = node; + $async$goto = 3; + return A._asyncAwait(node.operand.accept$1($async$self), $async$visitUnaryOperationExpression$1); + case 3: + // returning from await. + $async$returnValue = $async$self._async_evaluate0$_addExceptionSpan$2($async$temp1, new $async$temp2._EvaluateVisitor_visitUnaryOperationExpression_closure2($async$temp3, $async$result)); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitUnaryOperationExpression$1, $async$completer); + }, + visitBooleanExpression$1(_, node) { + return this.visitBooleanExpression$body$_EvaluateVisitor0(0, node); + }, + visitBooleanExpression$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassBoolean_2), + $async$returnValue; + var $async$visitBooleanExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$returnValue = node.value ? B.SassBoolean_true0 : B.SassBoolean_false0; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitBooleanExpression$1, $async$completer); + }, + visitIfExpression$1(_, node) { + return this.visitIfExpression$body$_EvaluateVisitor0(0, node); + }, + visitIfExpression$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$self = this, condition, t1, ifTrue, ifFalse, result, _0_0, positional, named; + var $async$visitIfExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_evaluateMacroArguments$1(node), $async$visitIfExpression$1); + case 3: + // returning from await. + _0_0 = $async$result; + positional = _0_0._0; + named = _0_0._1; + $async$self._async_evaluate0$_verifyArguments$4(J.get$length$asx(positional), named, $.$get$IfExpression_declaration0(), node); + condition = A.ListExtensions_elementAtOrNull(positional, 0); + if (condition == null) { + t1 = named.$index(0, "condition"); + t1.toString; + condition = t1; + } + ifTrue = A.ListExtensions_elementAtOrNull(positional, 1); + if (ifTrue == null) { + t1 = named.$index(0, "if-true"); + t1.toString; + ifTrue = t1; + } + ifFalse = A.ListExtensions_elementAtOrNull(positional, 2); + if (ifFalse == null) { + t1 = named.$index(0, "if-false"); + t1.toString; + ifFalse = t1; + } + $async$goto = 4; + return A._asyncAwait(condition.accept$1($async$self), $async$visitIfExpression$1); + case 4: + // returning from await. + result = $async$result.get$isTruthy() ? ifTrue : ifFalse; + t1 = result.accept$1($async$self); + $async$goto = 5; + return A._asyncAwait(type$.Future_Value_2._is(t1) ? t1 : A._Future$value(t1, type$.Value_2), $async$visitIfExpression$1); + case 5: + // returning from await. + $async$returnValue = $async$self._async_evaluate0$_withoutSlash$2($async$result, $async$self._async_evaluate0$_expressionNode$1(result)); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitIfExpression$1, $async$completer); + }, + visitNullExpression$1(_, node) { + return this.visitNullExpression$body$_EvaluateVisitor0(0, node); + }, + visitNullExpression$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue; + var $async$visitNullExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$returnValue = B.C__SassNull0; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitNullExpression$1, $async$completer); + }, + visitNumberExpression$1(_, node) { + return this.visitNumberExpression$body$_EvaluateVisitor0(0, node); + }, + visitNumberExpression$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassNumber_2), + $async$returnValue; + var $async$visitNumberExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$returnValue = A.SassNumber_SassNumber0(node.value, node.unit); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitNumberExpression$1, $async$completer); + }, + visitParenthesizedExpression$1(_, node) { + var _this = this; + return _this._async_evaluate0$_assertInModule$2(_this._async_evaluate0$__stylesheet, "_stylesheet").plainCss ? A.throwExpression(_this._async_evaluate0$_exception$2("Parentheses aren't allowed in plain CSS.", node.span)) : node.expression.accept$1(_this); + }, + visitColorExpression$1(_, node) { + return this.visitColorExpression$body$_EvaluateVisitor0(0, node); + }, + visitColorExpression$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassColor_2), + $async$returnValue; + var $async$visitColorExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$returnValue = node.value; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitColorExpression$1, $async$completer); + }, + visitListExpression$1(_, node) { + return this.visitListExpression$body$_EvaluateVisitor0(0, node); + }, + visitListExpression$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassList_2), + $async$returnValue, $async$self = this, $async$temp1; + var $async$visitListExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$temp1 = A; + $async$goto = 3; + return A._asyncAwait(A.mapAsync0(node.contents, new A._EvaluateVisitor_visitListExpression_closure2($async$self), type$.Expression_2, type$.Value_2), $async$visitListExpression$1); + case 3: + // returning from await. + $async$returnValue = $async$temp1.SassList$0($async$result, node.separator, node.hasBrackets); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitListExpression$1, $async$completer); + }, + visitMapExpression$1(_, node) { + return this.visitMapExpression$body$_EvaluateVisitor0(0, node); + }, + visitMapExpression$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassMap_2), + $async$returnValue, $async$self = this, t2, t3, _i, t4, key, keyValue, valueValue, oldValueSpan, t1, map, keyNodes; + var $async$visitMapExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = type$.Value_2; + map = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + keyNodes = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.AstNode_2); + t2 = node.pairs, t3 = t2.length, _i = 0; + case 3: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 5; + break; + } + t4 = t2[_i]; + key = t4._0; + $async$goto = 6; + return A._asyncAwait(key.accept$1($async$self), $async$visitMapExpression$1); + case 6: + // returning from await. + keyValue = $async$result; + $async$goto = 7; + return A._asyncAwait(t4._1.accept$1($async$self), $async$visitMapExpression$1); + case 7: + // returning from await. + valueValue = $async$result; + if (map.containsKey$1(keyValue)) { + t1 = keyNodes.$index(0, keyValue); + oldValueSpan = t1 == null ? null : t1.get$span(t1); + t1 = key.get$span(key); + t2 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + if (oldValueSpan != null) + t2.$indexSet(0, oldValueSpan, "first key"); + throw A.wrapException(A.MultiSpanSassRuntimeException$0("Duplicate key.", t1, "second key", t2, $async$self._async_evaluate0$_stackTrace$1(key.get$span(key)), null)); + } + map.$indexSet(0, keyValue, valueValue); + keyNodes.$indexSet(0, keyValue, key); + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $async$returnValue = new A.SassMap0(A.ConstantMap_ConstantMap$from(map, t1, t1)); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitMapExpression$1, $async$completer); + }, + visitFunctionExpression$1(_, node) { + return this.visitFunctionExpression$body$_EvaluateVisitor0(0, node); + }, + visitFunctionExpression$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$self = this, t2, _0_0, t3, t4, $name, oldInFunction, result, t1, $function; + var $async$visitFunctionExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = {}; + $function = $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__stylesheet, "_stylesheet").plainCss ? null : $async$self._async_evaluate0$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitFunctionExpression_closure8($async$self, node)); + t1.$function = $function; + $async$goto = $function == null ? 3 : 5; + break; + case 3: + // then + if (node.namespace != null) + throw A.wrapException($async$self._async_evaluate0$_exception$2("Undefined function.", node.span)); + t2 = node.name; + _0_0 = t2.toLowerCase(); + t3 = false; + if ("min" === _0_0 || "max" === _0_0 || "round" === _0_0 || "abs" === _0_0) { + t3 = node.$arguments; + t4 = t3.named; + t3 = t4.get$isEmpty(t4) && t3.rest == null && B.JSArray_methods.every$1(t3.positional, new A._EvaluateVisitor_visitFunctionExpression_closure9()); + $name = _0_0; + } else + $name = null; + $async$goto = t3 ? 6 : 7; + break; + case 6: + // then + $async$goto = 8; + return A._asyncAwait($async$self._async_evaluate0$_visitCalculation$2$inLegacySassFunction(node, $name), $async$visitFunctionExpression$1); + case 8: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + case 7: + // join + $async$goto = "calc" === _0_0 || "clamp" === _0_0 || "hypot" === _0_0 || "sin" === _0_0 || "cos" === _0_0 || "tan" === _0_0 || "asin" === _0_0 || "acos" === _0_0 || "atan" === _0_0 || "sqrt" === _0_0 || "exp" === _0_0 || "sign" === _0_0 || "mod" === _0_0 || "rem" === _0_0 || "atan2" === _0_0 || "pow" === _0_0 || "log" === _0_0 || "calc-size" === _0_0 ? 9 : 10; + break; + case 9: + // then + $async$goto = 11; + return A._asyncAwait($async$self._async_evaluate0$_visitCalculation$1(node), $async$visitFunctionExpression$1); + case 11: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + case 10: + // join + $function = $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__stylesheet, "_stylesheet").plainCss ? null : $async$self._async_evaluate0$_builtInFunctions.$index(0, t2); + t2 = t1.$function = $function == null ? new A.PlainCssCallable0(node.originalName) : $function; + // goto join + $async$goto = 4; + break; + case 5: + // else + t2 = $function; + case 4: + // join + if (B.JSString_methods.startsWith$1(node.originalName, "--") && t2 instanceof A.UserDefinedCallable0 && !B.JSString_methods.startsWith$1(t2.declaration.originalName, "--")) + $async$self._async_evaluate0$_warn$3(string$.Sassx20_f_, node.get$nameSpan(), B.Deprecation_d4j); + oldInFunction = $async$self._async_evaluate0$_inFunction; + $async$self._async_evaluate0$_inFunction = true; + $async$goto = 12; + return A._asyncAwait($async$self._async_evaluate0$_addErrorSpan$1$2(node, new A._EvaluateVisitor_visitFunctionExpression_closure10(t1, $async$self, node), type$.Value_2), $async$visitFunctionExpression$1); + case 12: + // returning from await. + result = $async$result; + $async$self._async_evaluate0$_inFunction = oldInFunction; + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitFunctionExpression$1, $async$completer); + }, + _async_evaluate0$_visitCalculation$2$inLegacySassFunction(node, inLegacySassFunction) { + return this._visitCalculation$body$_EvaluateVisitor0(node, inLegacySassFunction); + }, + _async_evaluate0$_visitCalculation$1(node) { + return this._async_evaluate0$_visitCalculation$2$inLegacySassFunction(node, null); + }, + _visitCalculation$body$_EvaluateVisitor0(node, inLegacySassFunction) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$next = [], $async$self = this, $arguments, oldCallableNode, t1, _0_0, error, stackTrace, t4, _i, exception, t2, t3, $async$temp1; + var $async$_async_evaluate0$_visitCalculation$2$inLegacySassFunction = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t2 = node.$arguments; + t3 = t2.named; + if (t3.get$isNotEmpty(t3)) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Keywor, node.span)); + else if (t2.rest != null) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Rest_a, node.span)); + $async$self._async_evaluate0$_checkCalculationArguments$1(node); + t3 = A._setArrayType([], type$.JSArray_Object); + t2 = t2.positional, t4 = t2.length, _i = 0; + case 3: + // for condition + if (!(_i < t4)) { + // goto after for + $async$goto = 5; + break; + } + $async$temp1 = t3; + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate0$_visitCalculationExpression$2$inLegacySassFunction(t2[_i], inLegacySassFunction), $async$_async_evaluate0$_visitCalculation$2$inLegacySassFunction); + case 6: + // returning from await. + $async$temp1.push($async$result); + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $arguments = t3; + if ($async$self._async_evaluate0$_inSupportsDeclaration) { + $async$returnValue = new A.SassCalculation0(node.name, A.List_List$unmodifiable($arguments, type$.Object)); + // goto return + $async$goto = 1; + break; + } + oldCallableNode = $async$self._async_evaluate0$_callableNode; + $async$self._async_evaluate0$_callableNode = node; + try { + t1 = null; + t3 = node.name; + _0_0 = t3.toLowerCase(); + $label0$0: { + if ("calc" === _0_0) { + t1 = A.SassCalculation_calc0(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("sqrt" === _0_0) { + t1 = A.SassCalculation__singleArgument0("sqrt", J.$index$asx($arguments, 0), A.number2__sqrt$closure(), true); + break $label0$0; + } + if ("sin" === _0_0) { + t1 = A.SassCalculation__singleArgument0("sin", J.$index$asx($arguments, 0), A.number2__sin$closure(), false); + break $label0$0; + } + if ("cos" === _0_0) { + t1 = A.SassCalculation__singleArgument0("cos", J.$index$asx($arguments, 0), A.number2__cos$closure(), false); + break $label0$0; + } + if ("tan" === _0_0) { + t1 = A.SassCalculation__singleArgument0("tan", J.$index$asx($arguments, 0), A.number2__tan$closure(), false); + break $label0$0; + } + if ("asin" === _0_0) { + t1 = A.SassCalculation__singleArgument0("asin", J.$index$asx($arguments, 0), A.number2__asin$closure(), true); + break $label0$0; + } + if ("acos" === _0_0) { + t1 = A.SassCalculation__singleArgument0("acos", J.$index$asx($arguments, 0), A.number2__acos$closure(), true); + break $label0$0; + } + if ("atan" === _0_0) { + t1 = A.SassCalculation__singleArgument0("atan", J.$index$asx($arguments, 0), A.number2__atan$closure(), true); + break $label0$0; + } + if ("abs" === _0_0) { + t1 = A.SassCalculation_abs0(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("exp" === _0_0) { + t1 = A.SassCalculation_exp0(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("sign" === _0_0) { + t1 = A.SassCalculation_sign0(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("min" === _0_0) { + t1 = A.SassCalculation_min0($arguments); + break $label0$0; + } + if ("max" === _0_0) { + t1 = A.SassCalculation_max0($arguments); + break $label0$0; + } + if ("hypot" === _0_0) { + t1 = A.SassCalculation_hypot0($arguments); + break $label0$0; + } + if ("pow" === _0_0) { + t1 = A.SassCalculation_pow0(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("atan2" === _0_0) { + t1 = A.SassCalculation_atan20(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("log" === _0_0) { + t1 = A.SassCalculation_log0(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("mod" === _0_0) { + t1 = A.SassCalculation_mod0(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("rem" === _0_0) { + t1 = A.SassCalculation_rem0(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("round" === _0_0) { + t1 = A.SassCalculation_roundInternal0(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1), A.ListExtensions_elementAtOrNull($arguments, 2), inLegacySassFunction, node.span, new A._EvaluateVisitor__visitCalculation_closure2($async$self, node)); + break $label0$0; + } + if ("clamp" === _0_0) { + t1 = A.SassCalculation_clamp0(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1), A.ListExtensions_elementAtOrNull($arguments, 2)); + break $label0$0; + } + if ("calc-size" === _0_0) { + t1 = A.SassCalculation_calcSize0(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + t3 = A.UnsupportedError$('Unknown calculation name "' + t3 + '".'); + t1 = A.throwExpression(t3); + } + t1 = t1; + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassScriptException0) { + error = t1; + stackTrace = A.getTraceFromException(exception); + if (B.JSString_methods.contains$1(error.message, "compatible")) + $async$self._async_evaluate0$_verifyCompatibleNumbers$2($arguments, t2); + A.throwWithTrace0($async$self._async_evaluate0$_exception$2(error.message, node.span), error, stackTrace); + } else + throw exception; + } finally { + $async$self._async_evaluate0$_callableNode = oldCallableNode; + } + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_visitCalculation$2$inLegacySassFunction, $async$completer); + }, + _async_evaluate0$_checkCalculationArguments$1(node) { + var t1, _0_0, + check = new A._EvaluateVisitor__checkCalculationArguments_check2(this, node); + $label0$0: { + t1 = node.name; + _0_0 = t1.toLowerCase(); + if ("calc" === _0_0 || "sqrt" === _0_0 || "sin" === _0_0 || "cos" === _0_0 || "tan" === _0_0 || "asin" === _0_0 || "acos" === _0_0 || "atan" === _0_0 || "abs" === _0_0 || "exp" === _0_0 || "sign" === _0_0) { + check.call$1(1); + break $label0$0; + } + if ("min" === _0_0 || "max" === _0_0 || "hypot" === _0_0) { + check.call$0(); + break $label0$0; + } + if ("pow" === _0_0 || "atan2" === _0_0 || "log" === _0_0 || "mod" === _0_0 || "rem" === _0_0 || "calc-size" === _0_0) { + check.call$1(2); + break $label0$0; + } + if ("round" === _0_0 || "clamp" === _0_0) { + check.call$1(3); + break $label0$0; + } + throw A.wrapException(A.UnsupportedError$('Unknown calculation name "' + t1 + '".')); + } + }, + _async_evaluate0$_verifyCompatibleNumbers$2(args, nodesWithSpans) { + var i, t1, _0_0, arg, t2, number1, j, number2, t3, t4, t5, t6; + for (i = 0; t1 = args.length, i < t1; ++i) { + _0_0 = args[i]; + if (_0_0 instanceof A.SassNumber0) { + t1 = _0_0.get$hasComplexUnits(); + arg = _0_0; + } else { + arg = null; + t1 = false; + } + if (t1) { + t1 = A.S(arg); + t2 = nodesWithSpans[i]; + throw A.wrapException(this._async_evaluate0$_exception$2("Number " + t1 + " isn't compatible with CSS calculations.", t2.get$span(t2))); + } + } + for (i = 0; i < t1 - 1; ++i) { + number1 = args[i]; + if (!(number1 instanceof A.SassNumber0)) + continue; + for (j = i + 1; t1 = args.length, j < t1; ++j) { + number2 = args[j]; + if (!(number2 instanceof A.SassNumber0)) + continue; + if (number1.hasPossiblyCompatibleUnits$1(number2)) + continue; + t1 = number1.toString$0(0); + t2 = number2.toString$0(0); + t3 = nodesWithSpans[i]; + t3 = t3.get$span(t3); + t4 = number1.toString$0(0); + t5 = nodesWithSpans[j]; + t5 = A.LinkedHashMap_LinkedHashMap$_literal([t5.get$span(t5), number2.toString$0(0)], type$.FileSpan, type$.String); + t6 = nodesWithSpans[i]; + throw A.wrapException(A.MultiSpanSassRuntimeException$0(t1 + " and " + t2 + " are incompatible.", t3, t4, t5, this._async_evaluate0$_stackTrace$1(t6.get$span(t6)), null)); + } + } + }, + _async_evaluate0$_visitCalculationExpression$2$inLegacySassFunction(node, inLegacySassFunction) { + return this._visitCalculationExpression$body$_EvaluateVisitor0(node, inLegacySassFunction); + }, + _visitCalculationExpression$body$_EvaluateVisitor0(node, inLegacySassFunction) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Object), + $async$returnValue, $async$self = this, result, t2, _0_0, _box_0, _1_0, t3, _i, i, t1, inner, $async$temp1; + var $async$_async_evaluate0$_visitCalculationExpression$2$inLegacySassFunction = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = node instanceof A.ParenthesizedExpression0; + inner = t1 ? node.expression : null; + $async$goto = t1 ? 3 : 4; + break; + case 3: + // then + $async$goto = 5; + return A._asyncAwait($async$self._async_evaluate0$_visitCalculationExpression$2$inLegacySassFunction(inner, inLegacySassFunction), $async$_async_evaluate0$_visitCalculationExpression$2$inLegacySassFunction); + case 5: + // returning from await. + result = $async$result; + $async$returnValue = result instanceof A.SassString0 ? new A.SassString0("(" + result._string0$_text + ")", false) : result; + // goto return + $async$goto = 1; + break; + case 4: + // join + $async$goto = node instanceof A.StringExpression0 && node.accept$1(B.C_IsCalculationSafeVisitor0) ? 6 : 7; + break; + case 6: + // then + t1 = node.text; + t2 = t1.get$asPlain(); + _0_0 = t2 == null ? null : t2.toLowerCase(); + if ("pi" === _0_0) { + t1 = A.SassNumber_SassNumber0(3.141592653589793, null); + // goto break $label0$0 + $async$goto = 8; + break; + } + if ("e" === _0_0) { + t1 = A.SassNumber_SassNumber0(2.718281828459045, null); + // goto break $label0$0 + $async$goto = 8; + break; + } + if ("infinity" === _0_0) { + t1 = A.SassNumber_SassNumber0(1 / 0, null); + // goto break $label0$0 + $async$goto = 8; + break; + } + if ("-infinity" === _0_0) { + t1 = A.SassNumber_SassNumber0(-1 / 0, null); + // goto break $label0$0 + $async$goto = 8; + break; + } + if ("nan" === _0_0) { + t1 = A.SassNumber_SassNumber0(0 / 0, null); + // goto break $label0$0 + $async$goto = 8; + break; + } + $async$temp1 = A; + $async$goto = 9; + return A._asyncAwait($async$self._async_evaluate0$_performInterpolation$1(t1), $async$_async_evaluate0$_visitCalculationExpression$2$inLegacySassFunction); + case 9: + // returning from await. + t1 = new $async$temp1.SassString0($async$result, false); + // goto break $label0$0 + $async$goto = 8; + break; + case 8: + // break $label0$0 + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + case 7: + // join + _box_0 = {}; + _box_0.right = _box_0.left = _box_0.operator = null; + t1 = node instanceof A.BinaryOperationExpression0; + if (t1) { + _box_0.operator = node.operator; + _box_0.left = node.left; + _box_0.right = node.right; + } + $async$goto = t1 ? 10 : 11; + break; + case 10: + // then + $async$self._async_evaluate0$_checkWhitespaceAroundCalculationOperator$1(node); + $async$goto = 12; + return A._asyncAwait($async$self._async_evaluate0$_addExceptionSpanAsync$1$2(node, new A._EvaluateVisitor__visitCalculationExpression_closure2(_box_0, $async$self, node, inLegacySassFunction), type$.Object), $async$_async_evaluate0$_visitCalculationExpression$2$inLegacySassFunction); + case 12: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + case 11: + // join + $async$goto = node instanceof A.NumberExpression0 || node instanceof A.VariableExpression0 || node instanceof A.FunctionExpression0 || node instanceof A.IfExpression0 ? 13 : 14; + break; + case 13: + // then + $async$goto = 15; + return A._asyncAwait(node.accept$1($async$self), $async$_async_evaluate0$_visitCalculationExpression$2$inLegacySassFunction); + case 15: + // returning from await. + _1_0 = $async$result; + $label1$1: { + if (_1_0 instanceof A.SassNumber0) { + t1 = _1_0; + break $label1$1; + } + if (_1_0 instanceof A.SassCalculation0) { + t1 = _1_0; + break $label1$1; + } + if (_1_0 instanceof A.SassString0) { + t1 = !_1_0._string0$_hasQuotes; + result = _1_0; + } else { + result = null; + t1 = false; + } + if (t1) { + t1 = result; + break $label1$1; + } + t1 = A.throwExpression($async$self._async_evaluate0$_exception$2("Value " + _1_0.toString$0(0) + " can't be used in a calculation.", node.get$span(node))); + } + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + case 14: + // join + $async$goto = node instanceof A.ListExpression0 && !node.hasBrackets && B.ListSeparator_qSL0 === node.separator && node.contents.length >= 2 ? 16 : 17; + break; + case 16: + // then + t1 = A._setArrayType([], type$.JSArray_Object); + t2 = node.contents, t3 = t2.length, _i = 0; + case 18: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 20; + break; + } + $async$temp1 = t1; + $async$goto = 21; + return A._asyncAwait($async$self._async_evaluate0$_visitCalculationExpression$2$inLegacySassFunction(t2[_i], inLegacySassFunction), $async$_async_evaluate0$_visitCalculationExpression$2$inLegacySassFunction); + case 21: + // returning from await. + $async$temp1.push($async$result); + case 19: + // for update + ++_i; + // goto for condition + $async$goto = 18; + break; + case 20: + // after for + $async$self._async_evaluate0$_checkAdjacentCalculationValues$2(t1, node); + for (i = 0; i < t1.length; ++i) { + t3 = t1[i]; + if (t3 instanceof A.CalculationOperation0 && t2[i] instanceof A.ParenthesizedExpression0) + t1[i] = new A.SassString0("(" + A.S(t3) + ")", false); + } + $async$returnValue = new A.SassString0(B.JSArray_methods.join$1(t1, " "), false); + // goto return + $async$goto = 1; + break; + case 17: + // join + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.This_e, node.get$span(node))); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_visitCalculationExpression$2$inLegacySassFunction, $async$completer); + }, + _async_evaluate0$_checkWhitespaceAroundCalculationOperator$1(node) { + var t2, t3, t4, textBetweenOperands, first, last, + t1 = node.operator; + if (t1 !== B.BinaryOperator_Swh0 && t1 !== B.BinaryOperator_QG10) + return; + t1 = node.left; + t2 = t1.get$span(t1); + t2 = t2.get$file(t2); + t3 = node.right; + t4 = t3.get$span(t3); + if (t2 !== t4.get$file(t4)) + return; + t2 = t1.get$span(t1); + t2 = t2.get$end(t2); + t4 = t3.get$span(t3); + if (t2.offset >= t4.get$start(t4).offset) + return; + t2 = t1.get$span(t1); + t2 = t2.get$file(t2); + t1 = t1.get$span(t1); + t1 = t1.get$end(t1); + t3 = t3.get$span(t3); + textBetweenOperands = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t2._decodedChars, t1.offset, t3.get$start(t3).offset), 0, null); + first = textBetweenOperands.charCodeAt(0); + last = textBetweenOperands.charCodeAt(textBetweenOperands.length - 1); + if (first === 32 || first === 9 || first === 10 || first === 13 || first === 12 || first === 47) + t1 = !(last === 32 || last === 9 || last === 10 || last === 13 || last === 12 || last === 47); + else + t1 = true; + if (t1) + throw A.wrapException(this._async_evaluate0$_exception$2(string$.x22x2b__an, node.get$operatorSpan())); + }, + _async_evaluate0$_binaryOperatorToCalculationOperator$2(operator, node) { + var t1; + $label0$0: { + if (B.BinaryOperator_Swh0 === operator) { + t1 = B.CalculationOperator_F7i0; + break $label0$0; + } + if (B.BinaryOperator_QG10 === operator) { + t1 = B.CalculationOperator_oum0; + break $label0$0; + } + if (B.BinaryOperator_tht0 === operator) { + t1 = B.CalculationOperator_kkN0; + break $label0$0; + } + if (B.BinaryOperator_Mh50 === operator) { + t1 = B.CalculationOperator_bo50; + break $label0$0; + } + t1 = A.throwExpression(this._async_evaluate0$_exception$2(string$.This_o, node.get$operatorSpan())); + } + return t1; + }, + _async_evaluate0$_checkAdjacentCalculationValues$2(elements, node) { + var t1, i, t2, previous, current, previousNode, currentNode, _0_2; + for (t1 = elements.length, i = 1; i < t1; ++i) { + t2 = i - 1; + previous = elements[t2]; + current = elements[i]; + if (previous instanceof A.SassString0 || current instanceof A.SassString0) + continue; + t1 = node.contents; + previousNode = t1[t2]; + currentNode = t1[i]; + if (currentNode instanceof A.UnaryOperationExpression0) { + _0_2 = currentNode.operator; + if (B.UnaryOperator_UCP0 !== _0_2) + t1 = B.UnaryOperator_Rbl0 === _0_2; + else + t1 = true; + } else + t1 = false; + if (!t1) + t1 = currentNode instanceof A.NumberExpression0 && currentNode.value < 0; + else + t1 = true; + if (t1) + throw A.wrapException(this._async_evaluate0$_exception$2(string$.x22x2b__an, A.FileSpanExtension_subspan(currentNode.get$span(currentNode), 0, 1))); + else + throw A.wrapException(this._async_evaluate0$_exception$2("Missing math operator.", previousNode.get$span(previousNode).expand$1(0, currentNode.get$span(currentNode)))); + } + }, + visitInterpolatedFunctionExpression$1(_, node) { + return this.visitInterpolatedFunctionExpression$body$_EvaluateVisitor0(0, node); + }, + visitInterpolatedFunctionExpression$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$self = this, result, t1, oldInFunction; + var $async$visitInterpolatedFunctionExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_performInterpolation$1(node.name), $async$visitInterpolatedFunctionExpression$1); + case 3: + // returning from await. + t1 = $async$result; + oldInFunction = $async$self._async_evaluate0$_inFunction; + $async$self._async_evaluate0$_inFunction = true; + $async$goto = 4; + return A._asyncAwait($async$self._async_evaluate0$_addErrorSpan$1$2(node, new A._EvaluateVisitor_visitInterpolatedFunctionExpression_closure2($async$self, node, new A.PlainCssCallable0(t1)), type$.Value_2), $async$visitInterpolatedFunctionExpression$1); + case 4: + // returning from await. + result = $async$result; + $async$self._async_evaluate0$_inFunction = oldInFunction; + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitInterpolatedFunctionExpression$1, $async$completer); + }, + _async_evaluate0$_runUserDefinedCallable$1$4($arguments, callable, nodeWithSpan, run, $V) { + return this._runUserDefinedCallable$body$_EvaluateVisitor0($arguments, callable, nodeWithSpan, run, $V, $V); + }, + _runUserDefinedCallable$body$_EvaluateVisitor0($arguments, callable, nodeWithSpan, run, $V, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$self = this, oldCallable, oldInDependency, result, evaluated, $name; + var $async$_async_evaluate0$_runUserDefinedCallable$1$4 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_evaluateArguments$1($arguments), $async$_async_evaluate0$_runUserDefinedCallable$1$4); + case 3: + // returning from await. + evaluated = $async$result; + $name = callable.declaration.name; + if ($name !== "@content") + $name += "()"; + oldCallable = $async$self._async_evaluate0$_currentCallable; + oldInDependency = $async$self._async_evaluate0$_inDependency; + $async$self._async_evaluate0$_currentCallable = callable; + $async$self._async_evaluate0$_inDependency = callable.inDependency; + $async$goto = 4; + return A._asyncAwait($async$self._async_evaluate0$_withStackFrame$1$3($name, nodeWithSpan, new A._EvaluateVisitor__runUserDefinedCallable_closure2($async$self, callable, evaluated, nodeWithSpan, run, $V), $V), $async$_async_evaluate0$_runUserDefinedCallable$1$4); + case 4: + // returning from await. + result = $async$result; + $async$self._async_evaluate0$_currentCallable = oldCallable; + $async$self._async_evaluate0$_inDependency = oldInDependency; + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_runUserDefinedCallable$1$4, $async$completer); + }, + _async_evaluate0$_runFunctionCallable$3($arguments, callable, nodeWithSpan) { + return this._runFunctionCallable$body$_EvaluateVisitor0($arguments, callable, nodeWithSpan); + }, + _runFunctionCallable$body$_EvaluateVisitor0($arguments, callable, nodeWithSpan) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$self = this, buffer, first, argument, restArg, rest, error, t1, t2, _i, t3, t4, exception, $async$exception, $async$temp1; + var $async$_async_evaluate0$_runFunctionCallable$3 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = type$.AsyncBuiltInCallable_2._is(callable) ? 3 : 5; + break; + case 3: + // then + $async$goto = 6; + return A._asyncAwait($async$self._async_evaluate0$_runBuiltInCallable$3($arguments, callable, nodeWithSpan), $async$_async_evaluate0$_runFunctionCallable$3); + case 6: + // returning from await. + $async$returnValue = $async$self._async_evaluate0$_withoutSlash$2($async$result, nodeWithSpan); + // goto return + $async$goto = 1; + break; + // goto join + $async$goto = 4; + break; + case 5: + // else + $async$goto = type$.UserDefinedCallable_AsyncEnvironment_2._is(callable) ? 7 : 9; + break; + case 7: + // then + $async$goto = 10; + return A._asyncAwait($async$self._async_evaluate0$_runUserDefinedCallable$1$4($arguments, callable, nodeWithSpan, new A._EvaluateVisitor__runFunctionCallable_closure2($async$self, callable), type$.Value_2), $async$_async_evaluate0$_runFunctionCallable$3); + case 10: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + // goto join + $async$goto = 8; + break; + case 9: + // else + $async$goto = callable instanceof A.PlainCssCallable0 ? 11 : 13; + break; + case 11: + // then + t1 = $arguments.named; + if (t1.get$isNotEmpty(t1) || $arguments.keywordRest != null) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Plain_, nodeWithSpan.get$span(nodeWithSpan))); + buffer = new A.StringBuffer(callable.name + "("); + $async$handler = 15; + first = true; + t1 = $arguments.positional, t2 = t1.length, _i = 0; + case 18: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 20; + break; + } + argument = t1[_i]; + if (first) + first = false; + else + buffer._contents += ", "; + t3 = buffer; + $async$temp1 = A; + $async$goto = 21; + return A._asyncAwait($async$self._async_evaluate0$_evaluateToCss$1(argument), $async$_async_evaluate0$_runFunctionCallable$3); + case 21: + // returning from await. + t4 = $async$temp1.S($async$result); + t3._contents += t4; + case 19: + // for update + ++_i; + // goto for condition + $async$goto = 18; + break; + case 20: + // after for + restArg = $arguments.rest; + $async$goto = restArg != null ? 22 : 23; + break; + case 22: + // then + $async$goto = 24; + return A._asyncAwait(restArg.accept$1($async$self), $async$_async_evaluate0$_runFunctionCallable$3); + case 24: + // returning from await. + rest = $async$result; + if (!first) + buffer._contents += ", "; + t1 = buffer; + t2 = $async$self._async_evaluate0$_serialize$2(rest, restArg); + t1._contents += t2; + case 23: + // join + $async$handler = 2; + // goto after finally + $async$goto = 17; + break; + case 15: + // catch + $async$handler = 14; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (type$.SassRuntimeException_2._is(t1)) { + error = t1; + if (!B.JSString_methods.endsWith$1(error._span_exception$_message, "isn't a valid CSS value.")) + throw $async$exception; + throw A.wrapException(A.MultiSpanSassRuntimeException$0(error._span_exception$_message, J.get$span$z(error), "value", A.LinkedHashMap_LinkedHashMap$_literal([nodeWithSpan.get$span(nodeWithSpan), "unknown function treated as plain CSS"], type$.FileSpan, type$.String), J.get$trace$z(error), null)); + } else + throw $async$exception; + // goto after finally + $async$goto = 17; + break; + case 14: + // uncaught + // goto rethrow + $async$goto = 2; + break; + case 17: + // after finally + t1 = buffer; + t2 = A.Primitives_stringFromCharCode(41); + t1._contents += t2; + t2 = buffer._contents; + $async$returnValue = new A.SassString0(t2.charCodeAt(0) == 0 ? t2 : t2, false); + // goto return + $async$goto = 1; + break; + // goto join + $async$goto = 12; + break; + case 13: + // else + throw A.wrapException(A.ArgumentError$("Unknown callable type " + J.get$runtimeType$(callable).toString$0(0) + ".", null)); + case 12: + // join + case 8: + // join + case 4: + // join + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_runFunctionCallable$3, $async$completer); + }, + _async_evaluate0$_runBuiltInCallable$3($arguments, callable, nodeWithSpan) { + return this._runBuiltInCallable$body$_EvaluateVisitor0($arguments, callable, nodeWithSpan); + }, + _runBuiltInCallable$body$_EvaluateVisitor0($arguments, callable, nodeWithSpan) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$self = this, result, error, stackTrace, namedSet, _0_0, parameters, i, t1, t2, t3, parameter, t4, t5, t6, t7, rest, argumentList, exception, _box_0, evaluated, oldCallableNode, $async$exception; + var $async$_async_evaluate0$_runBuiltInCallable$3 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + _box_0 = {}; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_evaluateArguments$1($arguments), $async$_async_evaluate0$_runBuiltInCallable$3); + case 3: + // returning from await. + evaluated = $async$result; + oldCallableNode = $async$self._async_evaluate0$_callableNode; + $async$self._async_evaluate0$_callableNode = nodeWithSpan; + namedSet = new A.MapKeySet(evaluated._values[0], type$.MapKeySet_String); + _box_0.callback = _box_0.overload = null; + _0_0 = callable.callbackFor$2(J.get$length$asx(evaluated._values[2]), namedSet); + _box_0.overload = _0_0._0; + _box_0.callback = _0_0._1; + $async$self._async_evaluate0$_addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__runBuiltInCallable_closure8(_box_0, evaluated, namedSet)); + parameters = _box_0.overload.parameters; + i = J.get$length$asx(evaluated._values[2]), t1 = parameters.length, t2 = type$._Future_Value_2, t3 = type$.Future_Value_2; + case 4: + // for condition + if (!(i < t1)) { + // goto after for + $async$goto = 6; + break; + } + parameter = parameters[i]; + t4 = evaluated._values[2]; + t5 = evaluated._values[0].remove$1(0, parameter.name); + $async$goto = t5 == null ? 7 : 8; + break; + case 7: + // then + t5 = parameter.defaultValue; + t6 = t5.accept$1($async$self); + if (!t3._is(t6)) { + t7 = new A._Future($.Zone__current, t2); + t7._state = 8; + t7._resultOrListeners = t6; + t6 = t7; + } + $async$goto = 9; + return A._asyncAwait(t6, $async$_async_evaluate0$_runBuiltInCallable$3); + case 9: + // returning from await. + t5 = $async$self._async_evaluate0$_withoutSlash$2($async$result, t5); + case 8: + // join + J.add$1$ax(t4, t5); + case 5: + // for update + ++i; + // goto for condition + $async$goto = 4; + break; + case 6: + // after for + if (_box_0.overload.restParameter != null) { + if (J.get$length$asx(evaluated._values[2]) > t1) { + rest = J.sublist$1$ax(evaluated._values[2], t1); + J.removeRange$2$ax(evaluated._values[2], t1, J.get$length$asx(evaluated._values[2])); + } else + rest = B.List_empty20; + t1 = evaluated._values[0]; + argumentList = A.SassArgumentList$0(rest, t1, evaluated._values[4] === B.ListSeparator_undecided_null_undecided0 ? B.ListSeparator_qVN0 : evaluated._values[4]); + J.add$1$ax(evaluated._values[2], argumentList); + } else + argumentList = null; + result = null; + $async$handler = 11; + $async$goto = 14; + return A._asyncAwait($async$self._async_evaluate0$_addExceptionSpanAsync$1$2(nodeWithSpan, new A._EvaluateVisitor__runBuiltInCallable_closure9(_box_0, evaluated), type$.Value_2), $async$_async_evaluate0$_runBuiltInCallable$3); + case 14: + // returning from await. + result = $async$result; + $async$handler = 2; + // goto after finally + $async$goto = 13; + break; + case 11: + // catch + $async$handler = 10; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (t1 instanceof A.SassException0) + throw $async$exception; + else { + error = t1; + stackTrace = A.getTraceFromException($async$exception); + A.throwWithTrace0($async$self._async_evaluate0$_exception$2($async$self._async_evaluate0$_getErrorMessage$1(error), nodeWithSpan.get$span(nodeWithSpan)), error, stackTrace); + } + // goto after finally + $async$goto = 13; + break; + case 10: + // uncaught + // goto rethrow + $async$goto = 2; + break; + case 13: + // after finally + $async$self._async_evaluate0$_callableNode = oldCallableNode; + if (argumentList == null) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + t1 = evaluated._values[0]; + if (t1.get$isEmpty(t1)) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + if (argumentList._argument_list$_wereKeywordsAccessed) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + t1 = evaluated._values[0]; + t1 = A.pluralize0("parameter", J.get$length$asx(t1.get$keys(t1)), null); + t2 = evaluated._values[0]; + throw A.wrapException(A.MultiSpanSassRuntimeException$0("No " + t1 + " named " + A.toSentence0(J.map$1$1$ax(t2.get$keys(t2), new A._EvaluateVisitor__runBuiltInCallable_closure10(), type$.Object), "or") + ".", nodeWithSpan.get$span(nodeWithSpan), "invocation", A.LinkedHashMap_LinkedHashMap$_literal([_box_0.overload.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), $async$self._async_evaluate0$_stackTrace$1(nodeWithSpan.get$span(nodeWithSpan)), null)); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_runBuiltInCallable$3, $async$completer); + }, + _async_evaluate0$_evaluateArguments$1($arguments) { + return this._evaluateArguments$body$_EvaluateVisitor0($arguments); + }, + _evaluateArguments$body$_EvaluateVisitor0($arguments) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_5_Map_String_Value_named_and_Map_String_AstNode_namedNodes_and_List_Value_positional_and_List_AstNode_positionalNodes_and_ListSeparator_separator_2), + $async$returnValue, $async$self = this, t1, t2, t3, t4, _i, expression, nodeForSpan, t5, t6, named, namedNodes, $name, value, t7, restArgs, rest, restNodeForSpan, separator, keywordRestArgs, keywordRest, keywordRestNodeForSpan, positional, positionalNodes, $async$temp1, $async$temp2; + var $async$_async_evaluate0$_evaluateArguments$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + positional = A._setArrayType([], type$.JSArray_Value_2); + positionalNodes = A._setArrayType([], type$.JSArray_AstNode_2); + t1 = $arguments.positional, t2 = t1.length, t3 = type$._Future_Value_2, t4 = type$.Future_Value_2, _i = 0; + case 3: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 5; + break; + } + expression = t1[_i]; + nodeForSpan = $async$self._async_evaluate0$_expressionNode$1(expression); + t5 = expression.accept$1($async$self); + if (!t4._is(t5)) { + t6 = new A._Future($.Zone__current, t3); + t6._state = 8; + t6._resultOrListeners = t5; + t5 = t6; + } + $async$temp1 = positional; + $async$goto = 6; + return A._asyncAwait(t5, $async$_async_evaluate0$_evaluateArguments$1); + case 6: + // returning from await. + $async$temp1.push($async$self._async_evaluate0$_withoutSlash$2($async$result, nodeForSpan)); + positionalNodes.push(nodeForSpan); + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + t1 = type$.String; + named = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Value_2); + t2 = type$.AstNode_2; + namedNodes = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + t5 = A.MapExtensions_get_pairs0($arguments.named, t1, type$.Expression_2), t5 = t5.get$iterator(t5); + case 7: + // for condition + if (!t5.moveNext$0()) { + // goto after for + $async$goto = 8; + break; + } + t6 = t5.get$current(t5); + $name = t6._0; + value = t6._1; + nodeForSpan = $async$self._async_evaluate0$_expressionNode$1(value); + t6 = value.accept$1($async$self); + if (!t4._is(t6)) { + t7 = new A._Future($.Zone__current, t3); + t7._state = 8; + t7._resultOrListeners = t6; + t6 = t7; + } + $async$temp1 = named; + $async$temp2 = $name; + $async$goto = 9; + return A._asyncAwait(t6, $async$_async_evaluate0$_evaluateArguments$1); + case 9: + // returning from await. + $async$temp1.$indexSet(0, $async$temp2, $async$self._async_evaluate0$_withoutSlash$2($async$result, nodeForSpan)); + namedNodes.$indexSet(0, $name, nodeForSpan); + // goto for condition + $async$goto = 7; + break; + case 8: + // after for + restArgs = $arguments.rest; + if (restArgs == null) { + $async$returnValue = new A._Record_5_named_namedNodes_positional_positionalNodes_separator([named, namedNodes, positional, positionalNodes, B.ListSeparator_undecided_null_undecided0]); + // goto return + $async$goto = 1; + break; + } + $async$goto = 10; + return A._asyncAwait(restArgs.accept$1($async$self), $async$_async_evaluate0$_evaluateArguments$1); + case 10: + // returning from await. + rest = $async$result; + restNodeForSpan = $async$self._async_evaluate0$_expressionNode$1(restArgs); + if (rest instanceof A.SassMap0) { + $async$self._async_evaluate0$_addRestMap$4(named, rest, restArgs, new A._EvaluateVisitor__evaluateArguments_closure11()); + t3 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t4 = rest._map0$_contents, t4 = J.get$iterator$ax(t4.get$keys(t4)), t5 = type$.SassString_2; t4.moveNext$0();) + t3.$indexSet(0, t5._as(t4.get$current(t4))._string0$_text, restNodeForSpan); + namedNodes.addAll$1(0, t3); + separator = B.ListSeparator_undecided_null_undecided0; + } else if (rest instanceof A.SassList0) { + t3 = rest._list1$_contents; + B.JSArray_methods.addAll$1(positional, new A.MappedListIterable(t3, new A._EvaluateVisitor__evaluateArguments_closure12($async$self, restNodeForSpan), A._arrayInstanceType(t3)._eval$1("MappedListIterable<1,Value0>"))); + B.JSArray_methods.addAll$1(positionalNodes, A.List_List$filled(t3.length, restNodeForSpan, false, t2)); + separator = rest._list1$_separator; + if (rest instanceof A.SassArgumentList0) { + rest._argument_list$_wereKeywordsAccessed = true; + rest._argument_list$_keywords.forEach$1(0, new A._EvaluateVisitor__evaluateArguments_closure13($async$self, named, restNodeForSpan, namedNodes)); + } + } else { + positional.push($async$self._async_evaluate0$_withoutSlash$2(rest, restNodeForSpan)); + positionalNodes.push(restNodeForSpan); + separator = B.ListSeparator_undecided_null_undecided0; + } + keywordRestArgs = $arguments.keywordRest; + if (keywordRestArgs == null) { + $async$returnValue = new A._Record_5_named_namedNodes_positional_positionalNodes_separator([named, namedNodes, positional, positionalNodes, separator]); + // goto return + $async$goto = 1; + break; + } + $async$goto = 11; + return A._asyncAwait(keywordRestArgs.accept$1($async$self), $async$_async_evaluate0$_evaluateArguments$1); + case 11: + // returning from await. + keywordRest = $async$result; + keywordRestNodeForSpan = $async$self._async_evaluate0$_expressionNode$1(keywordRestArgs); + if (keywordRest instanceof A.SassMap0) { + $async$self._async_evaluate0$_addRestMap$4(named, keywordRest, keywordRestArgs, new A._EvaluateVisitor__evaluateArguments_closure14()); + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t2 = keywordRest._map0$_contents, t2 = J.get$iterator$ax(t2.get$keys(t2)), t3 = type$.SassString_2; t2.moveNext$0();) + t1.$indexSet(0, t3._as(t2.get$current(t2))._string0$_text, keywordRestNodeForSpan); + namedNodes.addAll$1(0, t1); + $async$returnValue = new A._Record_5_named_namedNodes_positional_positionalNodes_separator([named, namedNodes, positional, positionalNodes, separator]); + // goto return + $async$goto = 1; + break; + } else + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Variabs + keywordRest.toString$0(0) + ").", keywordRestArgs.get$span(keywordRestArgs))); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_evaluateArguments$1, $async$completer); + }, + _async_evaluate0$_evaluateMacroArguments$1(invocation) { + return this._evaluateMacroArguments$body$_EvaluateVisitor0(invocation); + }, + _evaluateMacroArguments$body$_EvaluateVisitor0(invocation) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_2_List_Expression_and_Map_String_Expression_2), + $async$returnValue, $async$self = this, t2, positional, named, rest, restNodeForSpan, keywordRestArgs_, keywordRest, keywordRestNodeForSpan, t1, restArgs_; + var $async$_async_evaluate0$_evaluateMacroArguments$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = invocation.$arguments; + restArgs_ = t1.rest; + if (restArgs_ == null) { + $async$returnValue = new A._Record_2(t1.positional, t1.named); + // goto return + $async$goto = 1; + break; + } + t2 = t1.positional; + positional = A._setArrayType(t2.slice(0), A._arrayInstanceType(t2)); + named = A.LinkedHashMap_LinkedHashMap$of(t1.named, type$.String, type$.Expression_2); + $async$goto = 3; + return A._asyncAwait(restArgs_.accept$1($async$self), $async$_async_evaluate0$_evaluateMacroArguments$1); + case 3: + // returning from await. + rest = $async$result; + restNodeForSpan = $async$self._async_evaluate0$_expressionNode$1(restArgs_); + if (rest instanceof A.SassMap0) + $async$self._async_evaluate0$_addRestMap$4(named, rest, invocation, new A._EvaluateVisitor__evaluateMacroArguments_closure11(restArgs_)); + else if (rest instanceof A.SassList0) { + t2 = rest._list1$_contents; + B.JSArray_methods.addAll$1(positional, new A.MappedListIterable(t2, new A._EvaluateVisitor__evaluateMacroArguments_closure12($async$self, restNodeForSpan, restArgs_), A._arrayInstanceType(t2)._eval$1("MappedListIterable<1,Expression0>"))); + if (rest instanceof A.SassArgumentList0) { + rest._argument_list$_wereKeywordsAccessed = true; + rest._argument_list$_keywords.forEach$1(0, new A._EvaluateVisitor__evaluateMacroArguments_closure13($async$self, named, restNodeForSpan, restArgs_)); + } + } else + positional.push(new A.ValueExpression0($async$self._async_evaluate0$_withoutSlash$2(rest, restNodeForSpan), restArgs_.get$span(restArgs_))); + keywordRestArgs_ = t1.keywordRest; + if (keywordRestArgs_ == null) { + $async$returnValue = new A._Record_2(positional, named); + // goto return + $async$goto = 1; + break; + } + $async$goto = 4; + return A._asyncAwait(keywordRestArgs_.accept$1($async$self), $async$_async_evaluate0$_evaluateMacroArguments$1); + case 4: + // returning from await. + keywordRest = $async$result; + keywordRestNodeForSpan = $async$self._async_evaluate0$_expressionNode$1(keywordRestArgs_); + if (keywordRest instanceof A.SassMap0) { + $async$self._async_evaluate0$_addRestMap$4(named, keywordRest, invocation, new A._EvaluateVisitor__evaluateMacroArguments_closure14($async$self, keywordRestNodeForSpan, keywordRestArgs_)); + $async$returnValue = new A._Record_2(positional, named); + // goto return + $async$goto = 1; + break; + } else + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Variabs + keywordRest.toString$0(0) + ").", keywordRestArgs_.get$span(keywordRestArgs_))); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_evaluateMacroArguments$1, $async$completer); + }, + _async_evaluate0$_addRestMap$1$4(values, map, nodeWithSpan, convert) { + map._map0$_contents.forEach$1(0, new A._EvaluateVisitor__addRestMap_closure2(this, values, convert, this._async_evaluate0$_expressionNode$1(nodeWithSpan), map, nodeWithSpan)); + }, + _async_evaluate0$_addRestMap$4(values, map, nodeWithSpan, convert) { + return this._async_evaluate0$_addRestMap$1$4(values, map, nodeWithSpan, convert, type$.dynamic); + }, + _async_evaluate0$_verifyArguments$4(positional, named, parameters, nodeWithSpan) { + return this._async_evaluate0$_addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__verifyArguments_closure2(parameters, positional, named)); + }, + visitSelectorExpression$1(_, node) { + return this.visitSelectorExpression$body$_EvaluateVisitor0(0, node); + }, + visitSelectorExpression$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$self = this, t1; + var $async$visitSelectorExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self._async_evaluate0$_styleRuleIgnoringAtRoot; + t1 = t1 == null ? null : t1.originalSelector.get$asSassList(); + $async$returnValue = t1 == null ? B.C__SassNull0 : t1; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitSelectorExpression$1, $async$completer); + }, + visitStringExpression$1(_, node) { + return this.visitStringExpression$body$_EvaluateVisitor0(0, node); + }, + visitStringExpression$body$_EvaluateVisitor0(_, node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassString_2), + $async$returnValue, $async$self = this, t1, t2, t3, _i, value, t4, _0_0, text, oldInSupportsDeclaration; + var $async$visitStringExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + oldInSupportsDeclaration = $async$self._async_evaluate0$_inSupportsDeclaration; + $async$self._async_evaluate0$_inSupportsDeclaration = false; + t1 = A._setArrayType([], type$.JSArray_String); + t2 = node.text.contents, t3 = t2.length, _i = 0; + case 3: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 5; + break; + } + value = t2[_i]; + if (typeof value == "string") { + t4 = value; + // goto break $label0$0 + $async$goto = 6; + break; + } + $async$goto = value instanceof A.Expression0 ? 7 : 8; + break; + case 7: + // then + $async$goto = 9; + return A._asyncAwait(value.accept$1($async$self), $async$visitStringExpression$1); + case 9: + // returning from await. + _0_0 = $async$result; + $label1$1: { + if (_0_0 instanceof A.SassString0) { + text = _0_0._string0$_text; + t4 = text; + break $label1$1; + } + t4 = $async$self._async_evaluate0$_serialize$3$quote(_0_0, value, false); + break $label1$1; + } + // goto break $label0$0 + $async$goto = 6; + break; + case 8: + // join + t4 = A.throwExpression(A.UnsupportedError$("Unknown interpolation value " + A.S(value))); + case 6: + // break $label0$0 + t1.push(t4); + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + t1 = B.JSArray_methods.join$0(t1); + $async$self._async_evaluate0$_inSupportsDeclaration = oldInSupportsDeclaration; + $async$returnValue = new A.SassString0(t1, node.hasQuotes); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitStringExpression$1, $async$completer); + }, + visitSupportsExpression$1(_, expression) { + return this.visitSupportsExpression$body$_EvaluateVisitor0(0, expression); + }, + visitSupportsExpression$body$_EvaluateVisitor0(_, expression) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassString_2), + $async$returnValue, $async$self = this, $async$temp1; + var $async$visitSupportsExpression$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$temp1 = A; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_visitSupportsCondition$1(expression.condition), $async$visitSupportsExpression$1); + case 3: + // returning from await. + $async$returnValue = new $async$temp1.SassString0($async$result, false); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitSupportsExpression$1, $async$completer); + }, + visitCssAtRule$1(node) { + return this.visitCssAtRule$body$_EvaluateVisitor0(node); + }, + visitCssAtRule$body$_EvaluateVisitor0(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$returnValue, $async$self = this, wasInKeyframes, wasInUnknownAtRule, t1; + var $async$visitCssAtRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate0$_declarationName != null) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.At_rul, node.span)); + if (node.isChildless) { + $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent").addChild$1(A.ModifiableCssAtRule$0(node.name, node.span, true, node.value)); + // goto return + $async$goto = 1; + break; + } + wasInKeyframes = $async$self._async_evaluate0$_inKeyframes; + wasInUnknownAtRule = $async$self._async_evaluate0$_inUnknownAtRule; + t1 = node.name; + if (A.unvendor0(t1.value) === "keyframes") + $async$self._async_evaluate0$_inKeyframes = true; + else + $async$self._async_evaluate0$_inUnknownAtRule = true; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_withParent$2$4$scopeWhen$through(A.ModifiableCssAtRule$0(t1, node.span, false, node.value), new A._EvaluateVisitor_visitCssAtRule_closure5($async$self, node), false, new A._EvaluateVisitor_visitCssAtRule_closure6(), type$.ModifiableCssAtRule_2, type$.Null), $async$visitCssAtRule$1); + case 3: + // returning from await. + $async$self._async_evaluate0$_inUnknownAtRule = wasInUnknownAtRule; + $async$self._async_evaluate0$_inKeyframes = wasInKeyframes; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssAtRule$1, $async$completer); + }, + visitCssComment$1(node) { + return this.visitCssComment$body$_EvaluateVisitor0(node); + }, + visitCssComment$body$_EvaluateVisitor0(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this; + var $async$visitCssComment$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent") === $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__root, "_root") && $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__endOfImports, "_endOfImports") === J.get$length$asx($async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__root, "_root").children._collection$_source)) + $async$self._async_evaluate0$__endOfImports = $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__endOfImports, "_endOfImports") + 1; + $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent").addChild$1(new A.ModifiableCssComment0(node.text, node.span)); + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssComment$1, $async$completer); + }, + visitCssDeclaration$1(node) { + return this.visitCssDeclaration$body$_EvaluateVisitor0(node); + }, + visitCssDeclaration$body$_EvaluateVisitor0(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this; + var $async$visitCssDeclaration$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent").addChild$1(A.ModifiableCssDeclaration$0(node.name, node.value, node.span, null, node.parsedAsCustomProperty, null, node.valueSpanForMap)); + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssDeclaration$1, $async$completer); + }, + visitCssImport$1(node) { + return this.visitCssImport$body$_EvaluateVisitor0(node); + }, + visitCssImport$body$_EvaluateVisitor0(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1, modifiableNode; + var $async$visitCssImport$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + modifiableNode = new A.ModifiableCssImport0(node.url, node.modifiers, node.span); + if ($async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent") !== $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__root, "_root")) + $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent").addChild$1(modifiableNode); + else if ($async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__endOfImports, "_endOfImports") === J.get$length$asx($async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__root, "_root").children._collection$_source)) { + $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__root, "_root").addChild$1(modifiableNode); + $async$self._async_evaluate0$__endOfImports = $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__endOfImports, "_endOfImports") + 1; + } else { + t1 = $async$self._async_evaluate0$_outOfOrderImports; + (t1 == null ? $async$self._async_evaluate0$_outOfOrderImports = A._setArrayType([], type$.JSArray_ModifiableCssImport_2) : t1).push(modifiableNode); + } + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssImport$1, $async$completer); + }, + visitCssKeyframeBlock$1(node) { + return this.visitCssKeyframeBlock$body$_EvaluateVisitor0(node); + }, + visitCssKeyframeBlock$body$_EvaluateVisitor0(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this; + var $async$visitCssKeyframeBlock$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 2; + return A._asyncAwait($async$self._async_evaluate0$_withParent$2$4$scopeWhen$through(A.ModifiableCssKeyframeBlock$0(node.selector, node.span), new A._EvaluateVisitor_visitCssKeyframeBlock_closure5($async$self, node), false, new A._EvaluateVisitor_visitCssKeyframeBlock_closure6(), type$.ModifiableCssKeyframeBlock_2, type$.Null), $async$visitCssKeyframeBlock$1); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssKeyframeBlock$1, $async$completer); + }, + visitCssMediaRule$1(node) { + return this.visitCssMediaRule$body$_EvaluateVisitor0(node); + }, + visitCssMediaRule$body$_EvaluateVisitor0(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$returnValue, $async$self = this, mergedQueries, t1, mergedSources, t2, t3; + var $async$visitCssMediaRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate0$_declarationName != null) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Media_, node.span)); + mergedQueries = A.NullableExtension_andThen0($async$self._async_evaluate0$_mediaQueries, new A._EvaluateVisitor_visitCssMediaRule_closure8($async$self, node)); + t1 = mergedQueries == null; + if (!t1 && J.get$isEmpty$asx(mergedQueries)) { + // goto return + $async$goto = 1; + break; + } + if (t1) + mergedSources = B.Set_empty5; + else { + t2 = $async$self._async_evaluate0$_mediaQuerySources; + t2.toString; + t2 = A.LinkedHashSet_LinkedHashSet$of(t2, type$.CssMediaQuery_2); + t3 = $async$self._async_evaluate0$_mediaQueries; + t3.toString; + t2.addAll$1(0, t3); + t2.addAll$1(0, node.queries); + mergedSources = t2; + } + t1 = t1 ? node.queries : mergedQueries; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_withParent$2$4$scopeWhen$through(A.ModifiableCssMediaRule$0(t1, node.span), new A._EvaluateVisitor_visitCssMediaRule_closure9($async$self, mergedQueries, node, mergedSources), false, new A._EvaluateVisitor_visitCssMediaRule_closure10(mergedSources), type$.ModifiableCssMediaRule_2, type$.Null), $async$visitCssMediaRule$1); + case 3: + // returning from await. + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssMediaRule$1, $async$completer); + }, + visitCssStyleRule$1(node) { + return this.visitCssStyleRule$body$_EvaluateVisitor0(node); + }, + visitCssStyleRule$body$_EvaluateVisitor0(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1, styleRule, t2, nest, t3, originalSelector, rule, oldAtRootExcludingStyleRule, _0_1, lastChild; + var $async$visitCssStyleRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate0$_declarationName != null) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Style_n, node.span)); + else if ($async$self._async_evaluate0$_inKeyframes && $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent") instanceof A.ModifiableCssKeyframeBlock0) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Style_k, node.span)); + t1 = $async$self._async_evaluate0$_atRootExcludingStyleRule; + styleRule = t1 ? null : $async$self._async_evaluate0$_styleRuleIgnoringAtRoot; + t2 = t1 ? null : $async$self._async_evaluate0$_styleRuleIgnoringAtRoot; + t2 = t2 == null ? null : t2.fromPlainCss; + nest = t2 !== true; + t2 = node._style_rule0$_selector._box0$_inner; + if (nest) { + t2 = t2.value; + t3 = styleRule == null ? null : styleRule.originalSelector; + originalSelector = t2.nestWithin$3$implicitParent$preserveParentSelectors(t3, !t1, node.fromPlainCss); + } else + originalSelector = t2.value; + rule = A.ModifiableCssStyleRule$0($async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__extensionStore, "_extensionStore").addSelector$2(originalSelector, $async$self._async_evaluate0$_mediaQueries), node.span, node.fromPlainCss, originalSelector); + oldAtRootExcludingStyleRule = $async$self._async_evaluate0$_atRootExcludingStyleRule; + $async$self._async_evaluate0$_atRootExcludingStyleRule = false; + t1 = nest ? new A._EvaluateVisitor_visitCssStyleRule_closure5() : null; + $async$goto = 2; + return A._asyncAwait($async$self._async_evaluate0$_withParent$2$4$scopeWhen$through(rule, new A._EvaluateVisitor_visitCssStyleRule_closure6($async$self, rule, node), false, t1, type$.ModifiableCssStyleRule_2, type$.Null), $async$visitCssStyleRule$1); + case 2: + // returning from await. + $async$self._async_evaluate0$_atRootExcludingStyleRule = oldAtRootExcludingStyleRule; + t1 = $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent").children._collection$_source; + t2 = J.getInterceptor$asx(t1); + _0_1 = t2.get$length(t1); + if (_0_1 >= 1) { + lastChild = t2.elementAt$1(t1, _0_1 - 1); + t1 = styleRule == null; + } else { + lastChild = null; + t1 = false; + } + if (t1) + lastChild.isGroupEnd = true; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssStyleRule$1, $async$completer); + }, + visitCssStylesheet$1(node) { + return this.visitCssStylesheet$body$_EvaluateVisitor0(node); + }, + visitCssStylesheet$body$_EvaluateVisitor0(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1; + var $async$visitCssStylesheet$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = J.get$iterator$ax(node.get$children(node)); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + $async$goto = 4; + return A._asyncAwait(t1.get$current(t1).accept$1($async$self), $async$visitCssStylesheet$1); + case 4: + // returning from await. + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssStylesheet$1, $async$completer); + }, + visitCssSupportsRule$1(node) { + return this.visitCssSupportsRule$body$_EvaluateVisitor0(node); + }, + visitCssSupportsRule$body$_EvaluateVisitor0(node) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this; + var $async$visitCssSupportsRule$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if ($async$self._async_evaluate0$_declarationName != null) + throw A.wrapException($async$self._async_evaluate0$_exception$2(string$.Suppor, node.span)); + $async$goto = 2; + return A._asyncAwait($async$self._async_evaluate0$_withParent$2$4$scopeWhen$through(A.ModifiableCssSupportsRule$0(node.condition, node.span), new A._EvaluateVisitor_visitCssSupportsRule_closure5($async$self, node), false, new A._EvaluateVisitor_visitCssSupportsRule_closure6(), type$.ModifiableCssSupportsRule_2, type$.Null), $async$visitCssSupportsRule$1); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$visitCssSupportsRule$1, $async$completer); + }, + _async_evaluate0$_handleReturn$1$2(list, callback) { + return this._handleReturn$body$_EvaluateVisitor0(list, callback); + }, + _async_evaluate0$_handleReturn$2(list, callback) { + return this._async_evaluate0$_handleReturn$1$2(list, callback, type$.dynamic); + }, + _handleReturn$body$_EvaluateVisitor0(list, callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, t1, _i, _0_0; + var $async$_async_evaluate0$_handleReturn$1$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = list.length, _i = 0; + case 3: + // for condition + if (!(_i < list.length)) { + // goto after for + $async$goto = 5; + break; + } + $async$goto = 6; + return A._asyncAwait(callback.call$1(list[_i]), $async$_async_evaluate0$_handleReturn$1$2); + case 6: + // returning from await. + _0_0 = $async$result; + if (_0_0 != null) { + $async$returnValue = _0_0; + // goto return + $async$goto = 1; + break; + } + case 4: + // for update + list.length === t1 || (0, A.throwConcurrentModificationError)(list), ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_handleReturn$1$2, $async$completer); + }, + _async_evaluate0$_withEnvironment$1$2(environment, callback, $T) { + return this._withEnvironment$body$_EvaluateVisitor0(environment, callback, $T, $T); + }, + _withEnvironment$body$_EvaluateVisitor0(environment, callback, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$self = this, result, oldEnvironment; + var $async$_async_evaluate0$_withEnvironment$1$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + oldEnvironment = $async$self._async_evaluate0$_environment; + $async$self._async_evaluate0$_environment = environment; + $async$goto = 3; + return A._asyncAwait(callback.call$0(), $async$_async_evaluate0$_withEnvironment$1$2); + case 3: + // returning from await. + result = $async$result; + $async$self._async_evaluate0$_environment = oldEnvironment; + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_withEnvironment$1$2, $async$completer); + }, + _async_evaluate0$_interpolationToValue$3$trim$warnForColor(interpolation, trim, warnForColor) { + return this._interpolationToValue$body$_EvaluateVisitor0(interpolation, trim, warnForColor); + }, + _async_evaluate0$_interpolationToValue$1(interpolation) { + return this._async_evaluate0$_interpolationToValue$3$trim$warnForColor(interpolation, false, false); + }, + _async_evaluate0$_interpolationToValue$2$warnForColor(interpolation, warnForColor) { + return this._async_evaluate0$_interpolationToValue$3$trim$warnForColor(interpolation, false, warnForColor); + }, + _interpolationToValue$body$_EvaluateVisitor0(interpolation, trim, warnForColor) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.CssValue_String_2), + $async$returnValue, $async$self = this, result, t1; + var $async$_async_evaluate0$_interpolationToValue$3$trim$warnForColor = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_performInterpolation$2$warnForColor(interpolation, warnForColor), $async$_async_evaluate0$_interpolationToValue$3$trim$warnForColor); + case 3: + // returning from await. + result = $async$result; + t1 = trim ? A.trimAscii0(result, true) : result; + $async$returnValue = new A.CssValue0(t1, interpolation.span, type$.CssValue_String_2); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_interpolationToValue$3$trim$warnForColor, $async$completer); + }, + _async_evaluate0$_performInterpolation$2$warnForColor(interpolation, warnForColor) { + return this._performInterpolation$body$_EvaluateVisitor0(interpolation, warnForColor); + }, + _async_evaluate0$_performInterpolation$1(interpolation) { + return this._async_evaluate0$_performInterpolation$2$warnForColor(interpolation, false); + }, + _performInterpolation$body$_EvaluateVisitor0(interpolation, warnForColor) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.String), + $async$returnValue, $async$self = this; + var $async$_async_evaluate0$_performInterpolation$2$warnForColor = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_performInterpolationHelper$3$sourceMap$warnForColor(interpolation, false, warnForColor), $async$_async_evaluate0$_performInterpolation$2$warnForColor); + case 3: + // returning from await. + $async$returnValue = $async$result._0; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_performInterpolation$2$warnForColor, $async$completer); + }, + _async_evaluate0$_performInterpolationWithMap$2$warnForColor(interpolation, warnForColor) { + return this._performInterpolationWithMap$body$_EvaluateVisitor0(interpolation, true); + }, + _performInterpolationWithMap$body$_EvaluateVisitor0(interpolation, warnForColor) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_2_String_and_InterpolationMap_2), + $async$returnValue, $async$self = this, _0_0, result, map; + var $async$_async_evaluate0$_performInterpolationWithMap$2$warnForColor = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_performInterpolationHelper$3$sourceMap$warnForColor(interpolation, true, true), $async$_async_evaluate0$_performInterpolationWithMap$2$warnForColor); + case 3: + // returning from await. + _0_0 = $async$result; + result = _0_0._0; + map = _0_0._1; + map.toString; + $async$returnValue = new A._Record_2(result, map); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_performInterpolationWithMap$2$warnForColor, $async$completer); + }, + _async_evaluate0$_performInterpolationHelper$3$sourceMap$warnForColor(interpolation, sourceMap, warnForColor) { + return this._performInterpolationHelper$body$_EvaluateVisitor0(interpolation, sourceMap, warnForColor); + }, + _performInterpolationHelper$body$_EvaluateVisitor0(interpolation, sourceMap, warnForColor) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_2_String_and_nullable_InterpolationMap_2), + $async$returnValue, $async$self = this, t1, t2, t3, t4, t5, t6, first, _i, t7, value, result, result0, t8, targetLocations, oldInSupportsDeclaration; + var $async$_async_evaluate0$_performInterpolationHelper$3$sourceMap$warnForColor = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + targetLocations = sourceMap ? A._setArrayType([], type$.JSArray_SourceLocation) : null; + oldInSupportsDeclaration = $async$self._async_evaluate0$_inSupportsDeclaration; + $async$self._async_evaluate0$_inSupportsDeclaration = false; + t1 = interpolation.contents, t2 = t1.length, t3 = type$.Expression_2, t4 = targetLocations == null, t5 = interpolation.span, t6 = type$.Object, first = true, _i = 0, t7 = ""; + case 3: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 5; + break; + } + value = t1[_i]; + if (!first) + if (!t4) + targetLocations.push(A.SourceLocation$(t7.length, null, null, null)); + if (typeof value == "string") { + t7 += value; + // goto for update + $async$goto = 4; + break; + } + t3._as(value); + $async$goto = 6; + return A._asyncAwait(value.accept$1($async$self), $async$_async_evaluate0$_performInterpolationHelper$3$sourceMap$warnForColor); + case 6: + // returning from await. + result = $async$result; + if (warnForColor && $.$get$namesByColor0().containsKey$1(result)) { + result0 = A.List_List$from([""], false, t6); + result0.$flags = 3; + t8 = $.$get$namesByColor0(); + $async$self._async_evaluate0$_warn$2(string$.You_pr + A.S(t8.$index(0, result)) + string$.x20in_in + result.toString$0(0) + string$.x2c_whicw + A.S(t8.$index(0, result)) + string$.x22x29__If + new A.BinaryOperationExpression0(B.BinaryOperator_Swh0, new A.StringExpression0(new A.Interpolation0(result0, B.List_null, t5), true), value, false).toString$0(0) + "'.", value.get$span(value)); + } + t7 += $async$self._async_evaluate0$_serialize$3$quote(result, value, false); + case 4: + // for update + ++_i, first = false; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $async$self._async_evaluate0$_inSupportsDeclaration = oldInSupportsDeclaration; + $async$returnValue = new A._Record_2(t7.charCodeAt(0) == 0 ? t7 : t7, A.NullableExtension_andThen0(targetLocations, new A._EvaluateVisitor__performInterpolationHelper_closure2(interpolation))); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_performInterpolationHelper$3$sourceMap$warnForColor, $async$completer); + }, + _async_evaluate0$_evaluateToCss$2$quote(expression, quote) { + return this._evaluateToCss$body$_EvaluateVisitor0(expression, quote); + }, + _async_evaluate0$_evaluateToCss$1(expression) { + return this._async_evaluate0$_evaluateToCss$2$quote(expression, true); + }, + _evaluateToCss$body$_EvaluateVisitor0(expression, quote) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.String), + $async$returnValue, $async$self = this, t1; + var $async$_async_evaluate0$_evaluateToCss$2$quote = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = expression.accept$1($async$self); + $async$goto = 3; + return A._asyncAwait(type$.Future_Value_2._is(t1) ? t1 : A._Future$value(t1, type$.Value_2), $async$_async_evaluate0$_evaluateToCss$2$quote); + case 3: + // returning from await. + $async$returnValue = $async$self._async_evaluate0$_serialize$3$quote($async$result, expression, quote); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_evaluateToCss$2$quote, $async$completer); + }, + _async_evaluate0$_serialize$3$quote(value, nodeWithSpan, quote) { + return this._async_evaluate0$_addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__serialize_closure2(value, quote)); + }, + _async_evaluate0$_serialize$2(value, nodeWithSpan) { + return this._async_evaluate0$_serialize$3$quote(value, nodeWithSpan, true); + }, + _async_evaluate0$_expressionNode$1(expression) { + var t1; + if (expression instanceof A.VariableExpression0) { + t1 = this._async_evaluate0$_addExceptionSpan$2(expression, new A._EvaluateVisitor__expressionNode_closure2(this, expression)); + return t1 == null ? expression : t1; + } else + return expression; + }, + _async_evaluate0$_withParent$2$4$scopeWhen$through(node, callback, scopeWhen, through, $S, $T) { + return this._withParent$body$_EvaluateVisitor0(node, callback, scopeWhen, through, $S, $T, $T); + }, + _async_evaluate0$_withParent$2$2(node, callback, $S, $T) { + return this._async_evaluate0$_withParent$2$4$scopeWhen$through(node, callback, true, null, $S, $T); + }, + _async_evaluate0$_withParent$2$3$scopeWhen(node, callback, scopeWhen, $S, $T) { + return this._async_evaluate0$_withParent$2$4$scopeWhen$through(node, callback, scopeWhen, null, $S, $T); + }, + _withParent$body$_EvaluateVisitor0(node, callback, scopeWhen, through, $S, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$self = this, oldParent, result; + var $async$_async_evaluate0$_withParent$2$4$scopeWhen$through = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$self._async_evaluate0$_addChild$2$through(node, through); + oldParent = $async$self._async_evaluate0$_assertInModule$2($async$self._async_evaluate0$__parent, "__parent"); + $async$self._async_evaluate0$__parent = node; + $async$goto = 3; + return A._asyncAwait($async$self._async_evaluate0$_environment.scope$1$2$when(callback, scopeWhen, $T), $async$_async_evaluate0$_withParent$2$4$scopeWhen$through); + case 3: + // returning from await. + result = $async$result; + $async$self._async_evaluate0$__parent = oldParent; + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_withParent$2$4$scopeWhen$through, $async$completer); + }, + _async_evaluate0$_addChild$2$through(node, through) { + var _0_0, grandparent, t1, + $parent = this._async_evaluate0$_assertInModule$2(this._async_evaluate0$__parent, "__parent"); + if (through != null) { + for (; through.call$1($parent); $parent = _0_0) { + _0_0 = $parent._node$_parent; + if (_0_0 == null) + throw A.wrapException(A.ArgumentError$(string$.throug + node.toString$0(0) + ".", null)); + } + if ($parent.get$hasFollowingSibling()) { + grandparent = $parent._node$_parent; + t1 = grandparent.children; + if ($parent.equalsIgnoringChildren$1(t1.get$last(t1))) + $parent = type$.ModifiableCssParentNode_2._as(t1.get$last(t1)); + else { + $parent = $parent.copyWithoutChildren$0(); + grandparent.addChild$1($parent); + } + } + } + $parent.addChild$1(node); + }, + _async_evaluate0$_addChild$1(node) { + return this._async_evaluate0$_addChild$2$through(node, null); + }, + _async_evaluate0$_withStyleRule$1$2(rule, callback, $T) { + return this._withStyleRule$body$_EvaluateVisitor0(rule, callback, $T, $T); + }, + _withStyleRule$body$_EvaluateVisitor0(rule, callback, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$self = this, result, oldRule; + var $async$_async_evaluate0$_withStyleRule$1$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + oldRule = $async$self._async_evaluate0$_styleRuleIgnoringAtRoot; + $async$self._async_evaluate0$_styleRuleIgnoringAtRoot = rule; + $async$goto = 3; + return A._asyncAwait(callback.call$0(), $async$_async_evaluate0$_withStyleRule$1$2); + case 3: + // returning from await. + result = $async$result; + $async$self._async_evaluate0$_styleRuleIgnoringAtRoot = oldRule; + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_withStyleRule$1$2, $async$completer); + }, + _async_evaluate0$_withMediaQueries$1$3(queries, sources, callback, $T) { + return this._withMediaQueries$body$_EvaluateVisitor0(queries, sources, callback, $T, $T); + }, + _withMediaQueries$body$_EvaluateVisitor0(queries, sources, callback, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$self = this, result, oldMediaQueries, oldSources; + var $async$_async_evaluate0$_withMediaQueries$1$3 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + oldMediaQueries = $async$self._async_evaluate0$_mediaQueries; + oldSources = $async$self._async_evaluate0$_mediaQuerySources; + $async$self._async_evaluate0$_mediaQueries = queries; + $async$self._async_evaluate0$_mediaQuerySources = sources; + $async$goto = 3; + return A._asyncAwait(callback.call$0(), $async$_async_evaluate0$_withMediaQueries$1$3); + case 3: + // returning from await. + result = $async$result; + $async$self._async_evaluate0$_mediaQueries = oldMediaQueries; + $async$self._async_evaluate0$_mediaQuerySources = oldSources; + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_withMediaQueries$1$3, $async$completer); + }, + _async_evaluate0$_withStackFrame$1$3(member, nodeWithSpan, callback, $T) { + return this._withStackFrame$body$_EvaluateVisitor0(member, nodeWithSpan, callback, $T, $T); + }, + _withStackFrame$body$_EvaluateVisitor0(member, nodeWithSpan, callback, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$self = this, oldMember, result, t1; + var $async$_async_evaluate0$_withStackFrame$1$3 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self._async_evaluate0$_stack; + t1.push(new A._Record_2($async$self._async_evaluate0$_member, nodeWithSpan)); + oldMember = $async$self._async_evaluate0$_member; + $async$self._async_evaluate0$_member = member; + $async$goto = 3; + return A._asyncAwait(callback.call$0(), $async$_async_evaluate0$_withStackFrame$1$3); + case 3: + // returning from await. + result = $async$result; + $async$self._async_evaluate0$_member = oldMember; + t1.pop(); + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_withStackFrame$1$3, $async$completer); + }, + _async_evaluate0$_withoutSlash$2(value, nodeForSpan) { + var t1; + if (value instanceof A.SassNumber0) + t1 = value.asSlash != null; + else + t1 = false; + if (t1) + this._async_evaluate0$_warn$3(string$.Using__i + A.S(new A._EvaluateVisitor__withoutSlash_recommendation2().call$1(value)) + string$.x0a_Morex20, nodeForSpan.get$span(nodeForSpan), B.Deprecation_FyB); + return value.withoutSlash$0(); + }, + _async_evaluate0$_stackFrame$2(member, span) { + return A.frameForSpan0(span, member, A.NullableExtension_andThen0(span.get$sourceUrl(span), new A._EvaluateVisitor__stackFrame_closure2(this))); + }, + _async_evaluate0$_stackTrace$1(span) { + var t2, t3, _i, t4, nodeWithSpan, _this = this, + t1 = A._setArrayType([], type$.JSArray_Frame); + for (t2 = _this._async_evaluate0$_stack, t3 = t2.length, _i = 0; _i < t2.length; t2.length === t3 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + t4 = t2[_i]; + nodeWithSpan = t4._1; + t1.push(_this._async_evaluate0$_stackFrame$2(t4._0, nodeWithSpan.get$span(nodeWithSpan))); + } + if (span != null) + t1.push(_this._async_evaluate0$_stackFrame$2(_this._async_evaluate0$_member, span)); + return A.Trace$(new A.ReversedListIterable(t1, type$.ReversedListIterable_Frame), null); + }, + _async_evaluate0$_stackTrace$0() { + return this._async_evaluate0$_stackTrace$1(null); + }, + _async_evaluate0$_warn$3(message, span, deprecation) { + var trace, t1, _this = this; + if (_this._async_evaluate0$_quietDeps && _this._async_evaluate0$_inDependency) + return; + if (!_this._async_evaluate0$_warningsEmitted.add$1(0, new A._Record_2(message, span))) + return; + trace = _this._async_evaluate0$_stackTrace$1(span); + t1 = _this._async_evaluate0$_logger; + if (deprecation == null) + t1.internalWarn$4$deprecation$span$trace(message, null, span, trace); + else + A.WarnForDeprecation_warnForDeprecation0(t1, deprecation, message, span, trace); + }, + _async_evaluate0$_warn$2(message, span) { + return this._async_evaluate0$_warn$3(message, span, null); + }, + _async_evaluate0$_exception$2(message, span) { + var t1, t2; + if (span == null) { + t1 = B.JSArray_methods.get$last(this._async_evaluate0$_stack)._1; + t1 = t1.get$span(t1); + } else + t1 = span; + t2 = this._async_evaluate0$_stackTrace$1(span); + return new A.SassRuntimeException0(t2, B.Set_empty, message, t1); + }, + _async_evaluate0$_exception$1(message) { + return this._async_evaluate0$_exception$2(message, null); + }, + _async_evaluate0$_multiSpanException$3(message, primaryLabel, secondaryLabels) { + var t1 = B.JSArray_methods.get$last(this._async_evaluate0$_stack)._1; + return A.MultiSpanSassRuntimeException$0(message, t1.get$span(t1), primaryLabel, secondaryLabels, this._async_evaluate0$_stackTrace$0(), null); + }, + _async_evaluate0$_addExceptionSpan$1$2(nodeWithSpan, callback) { + var error, stackTrace, t1, exception, + addStackFrame = true; + try { + t1 = callback.call$0(); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassScriptException0) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = error.withSpan$1(nodeWithSpan.get$span(nodeWithSpan)); + A.throwWithTrace0(t1.withTrace$1(this._async_evaluate0$_stackTrace$1(addStackFrame ? nodeWithSpan.get$span(nodeWithSpan) : null)), error, stackTrace); + } else + throw exception; + } + }, + _async_evaluate0$_addExceptionSpan$2(nodeWithSpan, callback) { + return this._async_evaluate0$_addExceptionSpan$1$2(nodeWithSpan, callback, type$.dynamic); + }, + _async_evaluate0$_addExceptionSpanAsync$1$3$addStackFrame(nodeWithSpan, callback, addStackFrame, $T) { + return this._addExceptionSpanAsync$body$_EvaluateVisitor0(nodeWithSpan, callback, addStackFrame, $T, $T); + }, + _async_evaluate0$_addExceptionSpanAsync$1$2(nodeWithSpan, callback, $T) { + return this._async_evaluate0$_addExceptionSpanAsync$1$3$addStackFrame(nodeWithSpan, callback, true, $T); + }, + _addExceptionSpanAsync$body$_EvaluateVisitor0(nodeWithSpan, callback, addStackFrame, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$self = this, error, stackTrace, t1, exception, $async$exception; + var $async$_async_evaluate0$_addExceptionSpanAsync$1$3$addStackFrame = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$handler = 4; + t1 = callback.call$0(); + $async$goto = 7; + return A._asyncAwait($T._eval$1("Future<0>")._is(t1) ? t1 : A._Future$value(t1, $T), $async$_async_evaluate0$_addExceptionSpanAsync$1$3$addStackFrame); + case 7: + // returning from await. + t1 = $async$result; + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + $async$handler = 2; + // goto after finally + $async$goto = 6; + break; + case 4: + // catch + $async$handler = 3; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (t1 instanceof A.SassScriptException0) { + error = t1; + stackTrace = A.getTraceFromException($async$exception); + t1 = error.withSpan$1(nodeWithSpan.get$span(nodeWithSpan)); + A.throwWithTrace0(t1.withTrace$1($async$self._async_evaluate0$_stackTrace$1(addStackFrame ? nodeWithSpan.get$span(nodeWithSpan) : null)), error, stackTrace); + } else + throw $async$exception; + // goto after finally + $async$goto = 6; + break; + case 3: + // uncaught + // goto rethrow + $async$goto = 2; + break; + case 6: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_addExceptionSpanAsync$1$3$addStackFrame, $async$completer); + }, + _async_evaluate0$_addExceptionTrace$1$1(callback, $T) { + return this._addExceptionTrace$body$_EvaluateVisitor0(callback, $T, $T); + }, + _addExceptionTrace$body$_EvaluateVisitor0(callback, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$self = this, error, stackTrace, t1, exception, t2, $async$exception; + var $async$_async_evaluate0$_addExceptionTrace$1$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$handler = 4; + t1 = callback.call$0(); + $async$goto = 7; + return A._asyncAwait($T._eval$1("Future<0>")._is(t1) ? t1 : A._Future$value(t1, $T), $async$_async_evaluate0$_addExceptionTrace$1$1); + case 7: + // returning from await. + t1 = $async$result; + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + $async$handler = 2; + // goto after finally + $async$goto = 6; + break; + case 4: + // catch + $async$handler = 3; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (type$.SassRuntimeException_2._is(t1)) + throw $async$exception; + else if (t1 instanceof A.SassException0) { + error = t1; + stackTrace = A.getTraceFromException($async$exception); + t1 = error; + t2 = J.getInterceptor$z(t1); + A.throwWithTrace0(error.withTrace$1($async$self._async_evaluate0$_stackTrace$1(A.SourceSpanException.prototype.get$span.call(t2, t1))), error, stackTrace); + } else + throw $async$exception; + // goto after finally + $async$goto = 6; + break; + case 3: + // uncaught + // goto rethrow + $async$goto = 2; + break; + case 6: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_addExceptionTrace$1$1, $async$completer); + }, + _async_evaluate0$_addErrorSpan$1$2(nodeWithSpan, callback, $T) { + return this._addErrorSpan$body$_EvaluateVisitor0(nodeWithSpan, callback, $T, $T); + }, + _addErrorSpan$body$_EvaluateVisitor0(nodeWithSpan, callback, $T, $async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$handler = 2, $async$errorStack = [], $async$self = this, error, stackTrace, t1, exception, t2, t3, $async$exception; + var $async$_async_evaluate0$_addErrorSpan$1$2 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$handler = 4; + $async$goto = 7; + return A._asyncAwait(callback.call$0(), $async$_async_evaluate0$_addErrorSpan$1$2); + case 7: + // returning from await. + t1 = $async$result; + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + $async$handler = 2; + // goto after finally + $async$goto = 6; + break; + case 4: + // catch + $async$handler = 3; + $async$exception = $async$errorStack.pop(); + t1 = A.unwrapException($async$exception); + if (type$.SassRuntimeException_2._is(t1)) { + error = t1; + stackTrace = A.getTraceFromException($async$exception); + if (!B.JSString_methods.startsWith$1(J.get$span$z(error).get$text(), "@error")) + throw $async$exception; + t1 = error._span_exception$_message; + t2 = nodeWithSpan.get$span(nodeWithSpan); + t3 = $async$self._async_evaluate0$_stackTrace$0(); + A.throwWithTrace0(new A.SassRuntimeException0(t3, B.Set_empty, t1, t2), error, stackTrace); + } else + throw $async$exception; + // goto after finally + $async$goto = 6; + break; + case 3: + // uncaught + // goto rethrow + $async$goto = 2; + break; + case 6: + // after finally + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + case 2: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$_async_evaluate0$_addErrorSpan$1$2, $async$completer); + }, + _async_evaluate0$_getErrorMessage$1(error) { + var t1, exception; + if (type$.Error._is(error)) + return error.toString$0(0); + try { + t1 = A._asString(J.get$message$x(error)); + return t1; + } catch (exception) { + t1 = J.toString$0$(error); + return t1; + } + }, + $isExpressionVisitor: 1, + $isStatementVisitor: 1 + }; + A._EvaluateVisitor_closure38.prototype = { + call$1($arguments) { + var module, t2, + t1 = J.getInterceptor$asx($arguments), + variable = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this._async_evaluate0$_environment; + t2 = A.stringReplaceAllUnchecked(variable._string0$_text, "_", "-"); + return t1.globalVariableExists$2$namespace(t2, module == null ? null : module._string0$_text) ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._EvaluateVisitor_closure39.prototype = { + call$1($arguments) { + var variable = J.$index$asx($arguments, 0).assertString$1("name"), + t1 = this.$this._async_evaluate0$_environment; + return t1.getVariable$1(A.stringReplaceAllUnchecked(variable._string0$_text, "_", "-")) != null ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._EvaluateVisitor_closure40.prototype = { + call$1($arguments) { + var module, t2, t3, t4, + t1 = J.getInterceptor$asx($arguments), + variable = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this; + t2 = t1._async_evaluate0$_environment; + t3 = variable._string0$_text; + t4 = A.stringReplaceAllUnchecked(t3, "_", "-"); + return t2.getFunction$2$namespace(t4, module == null ? null : module._string0$_text) != null || t1._async_evaluate0$_builtInFunctions.containsKey$1(t3) ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._EvaluateVisitor_closure41.prototype = { + call$1($arguments) { + var module, t2, + t1 = J.getInterceptor$asx($arguments), + variable = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this._async_evaluate0$_environment; + t2 = A.stringReplaceAllUnchecked(variable._string0$_text, "_", "-"); + return t1.getMixin$2$namespace(t2, module == null ? null : module._string0$_text) != null ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._EvaluateVisitor_closure42.prototype = { + call$1($arguments) { + var t1 = this.$this._async_evaluate0$_environment; + if (!t1._async_environment0$_inMixin) + throw A.wrapException(A.SassScriptException$0(string$.conten, null)); + return t1._async_environment0$_content != null ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._EvaluateVisitor_closure43.prototype = { + call$1($arguments) { + var t2, t3, t4, + t1 = J.$index$asx($arguments, 0).assertString$1("module")._string0$_text, + module = this.$this._async_evaluate0$_environment._async_environment0$_modules.$index(0, t1); + if (module == null) + throw A.wrapException('There is no module with namespace "' + t1 + '".'); + t1 = type$.Value_2; + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t3 = A.MapExtensions_get_pairs0(module.get$variables(), type$.String, t1), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t2.$indexSet(0, new A.SassString0(t4._0, true), t4._1); + } + return new A.SassMap0(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 37 + }; + A._EvaluateVisitor_closure44.prototype = { + call$1($arguments) { + var t2, t3, t4, + t1 = J.$index$asx($arguments, 0).assertString$1("module")._string0$_text, + module = this.$this._async_evaluate0$_environment._async_environment0$_modules.$index(0, t1); + if (module == null) + throw A.wrapException('There is no module with namespace "' + t1 + '".'); + t1 = type$.Value_2; + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t3 = A.MapExtensions_get_pairs0(module.get$functions(module), type$.String, type$.AsyncCallable_2), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t2.$indexSet(0, new A.SassString0(t4._0, true), new A.SassFunction0(t4._1)); + } + return new A.SassMap0(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 37 + }; + A._EvaluateVisitor_closure45.prototype = { + call$1($arguments) { + var t2, t3, t4, + t1 = J.$index$asx($arguments, 0).assertString$1("module")._string0$_text, + module = this.$this._async_evaluate0$_environment._async_environment0$_modules.$index(0, t1); + if (module == null) + throw A.wrapException('There is no module with namespace "' + t1 + '".'); + t1 = type$.Value_2; + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t3 = A.MapExtensions_get_pairs0(module.get$mixins(), type$.String, type$.AsyncCallable_2), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t2.$indexSet(0, new A.SassString0(t4._0, true), new A.SassMixin0(t4._1)); + } + return new A.SassMap0(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 37 + }; + A._EvaluateVisitor_closure46.prototype = { + call$1($arguments) { + var module, t2, callable, + t1 = J.getInterceptor$asx($arguments), + $name = t1.$index($arguments, 0).assertString$1("name"), + css = t1.$index($arguments, 1).get$isTruthy(); + t1 = t1.$index($arguments, 2).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + if (css) { + if (module != null) + throw A.wrapException(string$.x24css_a); + return new A.SassFunction0(new A.PlainCssCallable0($name._string0$_text)); + } + t1 = this.$this; + t2 = t1._async_evaluate0$_callableNode; + t2.toString; + callable = t1._async_evaluate0$_addExceptionSpan$2(t2, new A._EvaluateVisitor__closure14(t1, $name, module)); + if (callable == null) + throw A.wrapException("Function not found: " + $name.toString$0(0)); + return new A.SassFunction0(callable); + }, + $signature: 205 + }; + A._EvaluateVisitor__closure14.prototype = { + call$0() { + var local, + normalizedName = A.stringReplaceAllUnchecked(this.name._string0$_text, "_", "-"), + t1 = this.module, + namespace = t1 == null ? null : t1._string0$_text; + t1 = this.$this; + local = t1._async_evaluate0$_environment.getFunction$2$namespace(normalizedName, namespace); + if (local != null || namespace != null) + return local; + return t1._async_evaluate0$_builtInFunctions.$index(0, normalizedName); + }, + $signature: 97 + }; + A._EvaluateVisitor_closure47.prototype = { + call$1($arguments) { + var module, t2, callable, + t1 = J.getInterceptor$asx($arguments), + $name = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this; + t2 = t1._async_evaluate0$_callableNode; + t2.toString; + callable = t1._async_evaluate0$_addExceptionSpan$2(t2, new A._EvaluateVisitor__closure13(t1, $name, module)); + if (callable == null) + throw A.wrapException("Mixin not found: " + $name.toString$0(0)); + return new A.SassMixin0(callable); + }, + $signature: 206 + }; + A._EvaluateVisitor__closure13.prototype = { + call$0() { + var t1 = this.$this._async_evaluate0$_environment, + t2 = A.stringReplaceAllUnchecked(this.name._string0$_text, "_", "-"), + t3 = this.module; + return t1.getMixin$2$namespace(t2, t3 == null ? null : t3._string0$_text); + }, + $signature: 97 + }; + A._EvaluateVisitor_closure48.prototype = { + call$1($arguments) { + return this.$call$body$_EvaluateVisitor_closure4($arguments); + }, + $call$body$_EvaluateVisitor_closure4($arguments) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$self = this, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, invocation, callableNode, t1, $function, args; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = J.getInterceptor$asx($arguments); + $function = t1.$index($arguments, 0); + args = type$.SassArgumentList_2._as(t1.$index($arguments, 1)); + t1 = $async$self.$this; + t2 = t1._async_evaluate0$_callableNode; + t2.toString; + t3 = A._setArrayType([], type$.JSArray_Expression_2); + t4 = type$.String; + t5 = type$.Expression_2; + t6 = t2.get$span(t2); + t7 = t2.get$span(t2); + args._argument_list$_wereKeywordsAccessed = true; + t8 = args._argument_list$_keywords; + if (t8.get$isEmpty(t8)) + t2 = null; + else { + t9 = type$.Value_2; + t10 = A.LinkedHashMap_LinkedHashMap$_empty(t9, t9); + args._argument_list$_wereKeywordsAccessed = true; + t8 = A.MapExtensions_get_pairs0(t8, t4, t9); + t8 = t8.get$iterator(t8); + for (; t8.moveNext$0();) { + t11 = t8.get$current(t8); + t10.$indexSet(0, new A.SassString0(t11._0, false), t11._1); + } + t2 = new A.ValueExpression0(new A.SassMap0(A.ConstantMap_ConstantMap$from(t10, t9, t9)), t2.get$span(t2)); + } + invocation = new A.ArgumentList0(A.List_List$unmodifiable(t3, t5), A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_empty(t4, t5), t4, t5), new A.ValueExpression0(args, t7), t2, t6); + $async$goto = $function instanceof A.SassString0 ? 3 : 4; + break; + case 3: + // then + A.warnForDeprecation0(string$.Passina + $function.toString$0(0) + "))", B.Deprecation_aM0); + callableNode = t1._async_evaluate0$_callableNode; + t2 = $function._string0$_text; + t3 = callableNode.get$span(callableNode); + t1 = t1.visitFunctionExpression$1(0, new A.FunctionExpression0(null, A.stringReplaceAllUnchecked(t2, "_", "-"), t2, invocation, t3)); + $async$goto = 5; + return A._asyncAwait(type$.Future_Value_2._is(t1) ? t1 : A._Future$value(t1, type$.Value_2), $async$call$1); + case 5: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + case 4: + // join + t2 = $function.assertFunction$1("function"); + t3 = t1._async_evaluate0$_callableNode; + t3.toString; + $async$goto = 6; + return A._asyncAwait(t1._async_evaluate0$_runFunctionCallable$3(invocation, t2.callable, t3), $async$call$1); + case 6: + // returning from await. + t3 = $async$result; + $async$returnValue = t3; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 86 + }; + A._EvaluateVisitor_closure49.prototype = { + call$1($arguments) { + return this.$call$body$_EvaluateVisitor_closure3($arguments); + }, + $call$body$_EvaluateVisitor_closure3($arguments) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, withMap, t2, values, configuration, t3, t1, url; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = J.getInterceptor$asx($arguments); + url = A.Uri_parse(t1.$index($arguments, 0).assertString$1("url")._string0$_text); + t1 = t1.$index($arguments, 1).get$realNull(); + withMap = t1 == null ? null : t1.assertMap$1("with")._map0$_contents; + t1 = $async$self.$this; + t2 = t1._async_evaluate0$_callableNode; + t2.toString; + if (withMap != null) { + values = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.ConfiguredValue_2); + withMap.forEach$1(0, new A._EvaluateVisitor__closure11(values, t2.get$span(t2), t2)); + configuration = new A.ExplicitConfiguration0(t2, values, null); + } else + configuration = B.Configuration_Map_empty_null0; + t3 = t2.get$span(t2); + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate0$_loadModule$7$baseUrl$configuration$namesInErrors(url, "load-css()", t2, new A._EvaluateVisitor__closure12(t1), t3.get$sourceUrl(t3), configuration, true), $async$call$1); + case 2: + // returning from await. + t1._async_evaluate0$_assertConfigurationIsEmpty$2$nameInError(configuration, true); + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 207 + }; + A._EvaluateVisitor__closure11.prototype = { + call$2(variable, value) { + var t1 = variable.assertString$1("with key"), + $name = A.stringReplaceAllUnchecked(t1._string0$_text, "_", "-"); + t1 = this.values; + if (t1.containsKey$1($name)) + throw A.wrapException("The variable $" + $name + " was configured twice."); + t1.$indexSet(0, $name, new A.ConfiguredValue0(value, this.span, this.callableNode)); + }, + $signature: 98 + }; + A._EvaluateVisitor__closure12.prototype = { + call$2(module, _) { + var t1 = this.$this; + return t1._async_evaluate0$_combineCss$2$clone(module, true).accept$1(t1); + }, + $signature: 327 + }; + A._EvaluateVisitor_closure50.prototype = { + call$1($arguments) { + return this.$call$body$_EvaluateVisitor_closure2($arguments); + }, + $call$body$_EvaluateVisitor_closure2($arguments) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, callableNode, t2, t3, t4, t5, t1, mixin, args; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = J.getInterceptor$asx($arguments); + mixin = t1.$index($arguments, 0); + args = type$.SassArgumentList_2._as(t1.$index($arguments, 1)); + t1 = $async$self.$this; + callableNode = t1._async_evaluate0$_callableNode; + t2 = callableNode.get$span(callableNode); + t3 = callableNode.get$span(callableNode); + t4 = type$.Expression_2; + t5 = A.List_List$unmodifiable(B.List_empty21, t4); + t4 = A.ConstantMap_ConstantMap$from(B.Map_empty14, type$.String, t4); + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate0$_applyMixin$5(mixin.assertMixin$1("mixin").callable, t1._async_evaluate0$_environment._async_environment0$_content, new A.ArgumentList0(t5, t4, new A.ValueExpression0(args, t3), null, t2), callableNode, callableNode), $async$call$1); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 207 + }; + A._EvaluateVisitor_run_closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet_2), + $async$returnValue, $async$self = this, module, t2, t1, _0_0, url; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node; + _0_0 = t1.span.file.url; + url = null; + if (_0_0 != null) { + url = _0_0; + t2 = $async$self.$this; + t2._async_evaluate0$_activeModules.$indexSet(0, url, null); + if (!(t2._async_evaluate0$_nodeImporter != null && J.toString$0$(url) === "stdin")) + t2._async_evaluate0$_loadedUrls.add$1(0, url); + } + t2 = $async$self.$this; + $async$goto = 3; + return A._asyncAwait(t2._async_evaluate0$_addExceptionTrace$1$1(new A._EvaluateVisitor_run__closure2(t2, $async$self.importer, t1), type$.Module_AsyncCallable_2), $async$call$0); + case 3: + // returning from await. + module = $async$result; + $async$returnValue = new A._Record_2_loadedUrls_stylesheet(t2._async_evaluate0$_loadedUrls, t2._async_evaluate0$_combineCss$1(module)); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 328 + }; + A._EvaluateVisitor_run__closure2.prototype = { + call$0() { + return this.$this._async_evaluate0$_execute$2(this.importer, this.node); + }, + $signature: 329 + }; + A._EvaluateVisitor__loadModule_closure5.prototype = { + call$0() { + return this.callback.call$2(this._box_0.builtInModule, false); + }, + $signature: 0 + }; + A._EvaluateVisitor__loadModule_closure6.prototype = { + call$0() { + return this.$call$body$_EvaluateVisitor__loadModule_closure0(); + }, + $call$body$_EvaluateVisitor__loadModule_closure0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$handler = 1, $async$errorStack = [], $async$next = [], $async$self = this, canonicalUrl, oldInDependency, isDependency, t4, message, t1, stylesheet, importer, t2, t3, _1_0, $async$temp1; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = {}; + stylesheet = null; + importer = null; + t2 = $async$self.$this; + t3 = $async$self.nodeWithSpan; + $async$goto = 2; + return A._asyncAwait(t2._async_evaluate0$_loadStylesheet$3$baseUrl($async$self.url.toString$0(0), t3.get$span(t3), $async$self.baseUrl), $async$call$0); + case 2: + // returning from await. + _1_0 = $async$result; + stylesheet = _1_0._0; + importer = _1_0._1; + isDependency = _1_0._2; + canonicalUrl = stylesheet.span.file.url; + if (canonicalUrl != null) { + t4 = t2._async_evaluate0$_activeModules; + if (t4.containsKey$1(canonicalUrl)) { + if ($async$self.namesInErrors) { + t1 = canonicalUrl; + t3 = $.$get$context(); + t1.toString; + message = "Module loop: " + t3.prettyUri$1(t1) + " is already being loaded."; + } else + message = string$.Modulel; + t1 = A.NullableExtension_andThen0(t4.$index(0, canonicalUrl), new A._EvaluateVisitor__loadModule__closure5(t2, message)); + throw A.wrapException(t1 == null ? t2._async_evaluate0$_exception$1(message) : t1); + } else + t4.$indexSet(0, canonicalUrl, t3); + } + t4 = t2._async_evaluate0$_modules.containsKey$1(canonicalUrl); + oldInDependency = t2._async_evaluate0$_inDependency; + t2._async_evaluate0$_inDependency = isDependency; + t1.module = null; + $async$handler = 3; + $async$temp1 = t1; + $async$goto = 6; + return A._asyncAwait(t2._async_evaluate0$_execute$5$configuration$namesInErrors$nodeWithSpan(importer, stylesheet, $async$self.configuration, $async$self.namesInErrors, t3), $async$call$0); + case 6: + // returning from await. + $async$temp1.module = $async$result; + $async$next.push(5); + // goto finally + $async$goto = 4; + break; + case 3: + // uncaught + $async$next = [1]; + case 4: + // finally + $async$handler = 1; + t2._async_evaluate0$_activeModules.remove$1(0, canonicalUrl); + t2._async_evaluate0$_inDependency = oldInDependency; + // goto the next finally handler + $async$goto = $async$next.pop(); + break; + case 5: + // after finally + $async$goto = 7; + return A._asyncAwait(t2._async_evaluate0$_addExceptionSpanAsync$1$3$addStackFrame(t3, new A._EvaluateVisitor__loadModule__closure6(t1, $async$self.callback, !t4), false, type$.void), $async$call$0); + case 7: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + case 1: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor__loadModule__closure5.prototype = { + call$1(previousLoad) { + return this.$this._async_evaluate0$_multiSpanException$3(this.message, "new load", A.LinkedHashMap_LinkedHashMap$_literal([previousLoad.get$span(previousLoad), "original load"], type$.FileSpan, type$.String)); + }, + $signature: 99 + }; + A._EvaluateVisitor__loadModule__closure6.prototype = { + call$0() { + return this.callback.call$2(this._box_1.module, this.firstLoad); + }, + $signature: 0 + }; + A._EvaluateVisitor__execute_closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t3, t4, t5, t6, t1, oldImporter, oldStylesheet, oldRoot, oldPreModuleComments, oldParent, oldEndOfImports, oldOutOfOrderImports, oldExtensionStore, t2, oldStyleRule, oldMediaQueries, oldDeclarationName, oldInUnknownAtRule, oldInKeyframes, oldConfiguration; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + oldImporter = t1._async_evaluate0$_importer; + oldStylesheet = t1._async_evaluate0$__stylesheet; + oldRoot = t1._async_evaluate0$__root; + oldPreModuleComments = t1._async_evaluate0$_preModuleComments; + oldParent = t1._async_evaluate0$__parent; + oldEndOfImports = t1._async_evaluate0$__endOfImports; + oldOutOfOrderImports = t1._async_evaluate0$_outOfOrderImports; + oldExtensionStore = t1._async_evaluate0$__extensionStore; + t2 = t1._async_evaluate0$_atRootExcludingStyleRule; + oldStyleRule = t2 ? null : t1._async_evaluate0$_styleRuleIgnoringAtRoot; + oldMediaQueries = t1._async_evaluate0$_mediaQueries; + oldDeclarationName = t1._async_evaluate0$_declarationName; + oldInUnknownAtRule = t1._async_evaluate0$_inUnknownAtRule; + oldInKeyframes = t1._async_evaluate0$_inKeyframes; + oldConfiguration = t1._async_evaluate0$_configuration; + t1._async_evaluate0$_importer = $async$self.importer; + t3 = t1._async_evaluate0$__stylesheet = $async$self.stylesheet; + t4 = t3.span; + t5 = t1._async_evaluate0$__parent = t1._async_evaluate0$__root = A.ModifiableCssStylesheet$0(t4); + t1._async_evaluate0$__endOfImports = 0; + t1._async_evaluate0$_outOfOrderImports = null; + t1._async_evaluate0$__extensionStore = $async$self.extensionStore; + t1._async_evaluate0$_declarationName = t1._async_evaluate0$_mediaQueries = t1._async_evaluate0$_styleRuleIgnoringAtRoot = null; + t1._async_evaluate0$_inKeyframes = t1._async_evaluate0$_atRootExcludingStyleRule = t1._async_evaluate0$_inUnknownAtRule = false; + t6 = $async$self.configuration; + if (t6 != null) + t1._async_evaluate0$_configuration = t6; + $async$goto = 2; + return A._asyncAwait(t1.visitStylesheet$1(0, t3), $async$call$0); + case 2: + // returning from await. + t3 = t1._async_evaluate0$_outOfOrderImports == null ? t5 : new A.CssStylesheet0(new A.UnmodifiableListView(t1._async_evaluate0$_addOutOfOrderImports$0(), type$.UnmodifiableListView_CssNode_2), t4); + $async$self.css.__late_helper$_value = t3; + $async$self.preModuleComments.__late_helper$_value = t1._async_evaluate0$_preModuleComments; + t1._async_evaluate0$_importer = oldImporter; + t1._async_evaluate0$__stylesheet = oldStylesheet; + t1._async_evaluate0$__root = oldRoot; + t1._async_evaluate0$_preModuleComments = oldPreModuleComments; + t1._async_evaluate0$__parent = oldParent; + t1._async_evaluate0$__endOfImports = oldEndOfImports; + t1._async_evaluate0$_outOfOrderImports = oldOutOfOrderImports; + t1._async_evaluate0$__extensionStore = oldExtensionStore; + t1._async_evaluate0$_styleRuleIgnoringAtRoot = oldStyleRule; + t1._async_evaluate0$_mediaQueries = oldMediaQueries; + t1._async_evaluate0$_declarationName = oldDeclarationName; + t1._async_evaluate0$_inUnknownAtRule = oldInUnknownAtRule; + t1._async_evaluate0$_atRootExcludingStyleRule = t2; + t1._async_evaluate0$_inKeyframes = oldInKeyframes; + t1._async_evaluate0$_configuration = oldConfiguration; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor__combineCss_closure5.prototype = { + call$1(module) { + return module.get$transitivelyContainsCss(); + }, + $signature: 116 + }; + A._EvaluateVisitor__combineCss_closure6.prototype = { + call$1(target) { + return !this.selectors.contains$1(0, target); + }, + $signature: 14 + }; + A._EvaluateVisitor__combineCss_visitModule2.prototype = { + call$1(module) { + var t1, t2, t3, t4, _i, upstream, _1_0, statements, index, _this = this; + if (!_this.seen.add$1(0, module)) + return; + if (_this.clone) + module = module.cloneCss$0(); + for (t1 = module.get$upstream(), t2 = t1.length, t3 = _this.css, t4 = _this.imports, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + upstream = t1[_i]; + if (upstream.get$transitivelyContainsCss()) { + _1_0 = module.get$preModuleComments().$index(0, upstream); + if (_1_0 != null) + B.JSArray_methods.addAll$1(t3.length === 0 ? t4 : t3, _1_0); + _this.call$1(upstream); + } + } + _this.sorted.addFirst$1(module); + t1 = module.get$css(module); + statements = t1.get$children(t1); + index = _this.$this._async_evaluate0$_indexAfterImports$1(statements); + t1 = J.getInterceptor$ax(statements); + B.JSArray_methods.addAll$1(t4, t1.getRange$2(statements, 0, index)); + B.JSArray_methods.addAll$1(t3, t1.getRange$2(statements, index, t1.get$length(statements))); + }, + $signature: 331 + }; + A._EvaluateVisitor__extendModules_closure5.prototype = { + call$1(target) { + return !this.originalSelectors.contains$1(0, target); + }, + $signature: 14 + }; + A._EvaluateVisitor__extendModules_closure6.prototype = { + call$0() { + return A._setArrayType([], type$.JSArray_ExtensionStore_2); + }, + $signature: 209 + }; + A._EvaluateVisitor_visitAtRootRule_closure5.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitAtRootRule_closure6.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 32 + }; + A._EvaluateVisitor__scopeForAtRoot_closure17.prototype = { + call$1(callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, oldParent; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + oldParent = t1._async_evaluate0$_assertInModule$2(t1._async_evaluate0$__parent, "__parent"); + t1._async_evaluate0$__parent = $async$self.newParent; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate0$_environment.scope$1$2$when(callback, $async$self.node.hasDeclarations, type$.void), $async$call$1); + case 2: + // returning from await. + t1._async_evaluate0$__parent = oldParent; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 40 + }; + A._EvaluateVisitor__scopeForAtRoot_closure18.prototype = { + call$1(callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, oldAtRootExcludingStyleRule; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + oldAtRootExcludingStyleRule = t1._async_evaluate0$_atRootExcludingStyleRule; + t1._async_evaluate0$_atRootExcludingStyleRule = true; + $async$goto = 2; + return A._asyncAwait($async$self.innerScope.call$1(callback), $async$call$1); + case 2: + // returning from await. + t1._async_evaluate0$_atRootExcludingStyleRule = oldAtRootExcludingStyleRule; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 40 + }; + A._EvaluateVisitor__scopeForAtRoot_closure19.prototype = { + call$1(callback) { + return this.$this._async_evaluate0$_withMediaQueries$1$3(null, null, new A._EvaluateVisitor__scopeForAtRoot__closure2(this.innerScope, callback), type$.Null); + }, + $signature: 40 + }; + A._EvaluateVisitor__scopeForAtRoot__closure2.prototype = { + call$0() { + return this.innerScope.call$1(this.callback); + }, + $signature: 2 + }; + A._EvaluateVisitor__scopeForAtRoot_closure20.prototype = { + call$1(callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, wasInKeyframes; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + wasInKeyframes = t1._async_evaluate0$_inKeyframes; + t1._async_evaluate0$_inKeyframes = false; + $async$goto = 2; + return A._asyncAwait($async$self.innerScope.call$1(callback), $async$call$1); + case 2: + // returning from await. + t1._async_evaluate0$_inKeyframes = wasInKeyframes; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 40 + }; + A._EvaluateVisitor__scopeForAtRoot_closure21.prototype = { + call$1($parent) { + return $parent instanceof A.ModifiableCssAtRule0; + }, + $signature: 210 + }; + A._EvaluateVisitor__scopeForAtRoot_closure22.prototype = { + call$1(callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, wasInUnknownAtRule; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + wasInUnknownAtRule = t1._async_evaluate0$_inUnknownAtRule; + t1._async_evaluate0$_inUnknownAtRule = false; + $async$goto = 2; + return A._asyncAwait($async$self.innerScope.call$1(callback), $async$call$1); + case 2: + // returning from await. + t1._async_evaluate0$_inUnknownAtRule = wasInUnknownAtRule; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 40 + }; + A._EvaluateVisitor_visitContentRule_closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$returnValue, $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.content.declaration.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 3: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 5; + break; + } + $async$goto = 6; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 6: + // returning from await. + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitDeclaration_closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self._box_0.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitEachRule_closure8.prototype = { + call$1(value) { + var t1 = this.$this, + t2 = this.nodeWithSpan; + return t1._async_evaluate0$_environment.setLocalVariable$3(this._box_0.variable, t1._async_evaluate0$_withoutSlash$2(value, t2), t2); + }, + $signature: 66 + }; + A._EvaluateVisitor_visitEachRule_closure9.prototype = { + call$1(value) { + return this.$this._async_evaluate0$_setMultipleVariables$3(this._box_1.variables, value, this.nodeWithSpan); + }, + $signature: 66 + }; + A._EvaluateVisitor_visitEachRule_closure10.prototype = { + call$0() { + var _this = this, + t1 = _this.$this; + return t1._async_evaluate0$_handleReturn$2(_this.list.get$asList(), new A._EvaluateVisitor_visitEachRule__closure2(t1, _this.setVariables, _this.node)); + }, + $signature: 74 + }; + A._EvaluateVisitor_visitEachRule__closure2.prototype = { + call$1(element) { + var t1; + this.setVariables.call$1(element); + t1 = this.$this; + return t1._async_evaluate0$_handleReturn$2(this.node.children, new A._EvaluateVisitor_visitEachRule___closure2(t1)); + }, + $signature: 336 + }; + A._EvaluateVisitor_visitEachRule___closure2.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 88 + }; + A._EvaluateVisitor_visitAtRule_closure8.prototype = { + call$1(value) { + return this.$this._async_evaluate0$_interpolationToValue$3$trim$warnForColor(value, true, true); + }, + $signature: 338 + }; + A._EvaluateVisitor_visitAtRule_closure9.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t2, t3, _i, t1, styleRule; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + styleRule = t1._async_evaluate0$_atRootExcludingStyleRule ? null : t1._async_evaluate0$_styleRuleIgnoringAtRoot; + $async$goto = styleRule == null || t1._async_evaluate0$_inKeyframes || J.$eq$($async$self.name.value, "font-face") ? 2 : 4; + break; + case 2: + // then + t2 = $async$self.children, t3 = t2.length, _i = 0; + case 5: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 7; + break; + } + $async$goto = 8; + return A._asyncAwait(t2[_i].accept$1(t1), $async$call$0); + case 8: + // returning from await. + case 6: + // for update + ++_i; + // goto for condition + $async$goto = 5; + break; + case 7: + // after for + // goto join + $async$goto = 3; + break; + case 4: + // else + $async$goto = 9; + return A._asyncAwait(t1._async_evaluate0$_withParent$2$3$scopeWhen(A.ModifiableCssStyleRule$0(styleRule._style_rule0$_selector, styleRule.span, false, styleRule.originalSelector), new A._EvaluateVisitor_visitAtRule__closure2(t1, $async$self.children), false, type$.ModifiableCssStyleRule_2, type$.Null), $async$call$0); + case 9: + // returning from await. + case 3: + // join + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitAtRule__closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitAtRule_closure10.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitForRule_closure14.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassNumber_2), + $async$returnValue, $async$self = this; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self.node.from.accept$1($async$self.$this), $async$call$0); + case 3: + // returning from await. + $async$returnValue = $async$result.assertNumber$0(); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 213 + }; + A._EvaluateVisitor_visitForRule_closure15.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.SassNumber_2), + $async$returnValue, $async$self = this; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait($async$self.node.to.accept$1($async$self.$this), $async$call$0); + case 3: + // returning from await. + $async$returnValue = $async$result.assertNumber$0(); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 213 + }; + A._EvaluateVisitor_visitForRule_closure16.prototype = { + call$0() { + return this.fromNumber.assertInt$0(); + }, + $signature: 10 + }; + A._EvaluateVisitor_visitForRule_closure17.prototype = { + call$0() { + var t1 = this.fromNumber; + return this.toNumber.coerce$2(t1.get$numeratorUnits(t1), t1.get$denominatorUnits(t1)).assertInt$0(); + }, + $signature: 10 + }; + A._EvaluateVisitor_visitForRule_closure18.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, i, t3, t4, t5, t6, t7, t8, _0_0, t1, t2, nodeWithSpan; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + t2 = $async$self.node; + nodeWithSpan = t1._async_evaluate0$_expressionNode$1(t2.from); + i = $async$self.from, t3 = $async$self._box_0, t4 = $async$self.direction, t5 = t2.variable, t6 = $async$self.fromNumber, t2 = t2.children; + case 3: + // for condition + if (!(i !== t3.to)) { + // goto after for + $async$goto = 5; + break; + } + t7 = t1._async_evaluate0$_environment; + t8 = t6.get$numeratorUnits(t6); + t7.setLocalVariable$3(t5, A.SassNumber_SassNumber$withUnits0(i, t6.get$denominatorUnits(t6), t8), nodeWithSpan); + $async$goto = 6; + return A._asyncAwait(t1._async_evaluate0$_handleReturn$2(t2, new A._EvaluateVisitor_visitForRule__closure2(t1)), $async$call$0); + case 6: + // returning from await. + _0_0 = $async$result; + if (_0_0 != null) { + $async$returnValue = _0_0; + // goto return + $async$goto = 1; + break; + } + case 4: + // for update + i += t4; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 74 + }; + A._EvaluateVisitor_visitForRule__closure2.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 88 + }; + A._EvaluateVisitor_visitForwardRule_closure5.prototype = { + call$2(module, firstLoad) { + if (firstLoad) + this.$this._async_evaluate0$_registerCommentsForModule$1(module); + this.$this._async_evaluate0$_environment.forwardModule$2(module, this.node); + }, + $signature: 114 + }; + A._EvaluateVisitor_visitForwardRule_closure6.prototype = { + call$2(module, firstLoad) { + if (firstLoad) + this.$this._async_evaluate0$_registerCommentsForModule$1(module); + this.$this._async_evaluate0$_environment.forwardModule$2(module, this.node); + }, + $signature: 114 + }; + A._EvaluateVisitor__registerCommentsForModule_closure2.prototype = { + call$0() { + return A._setArrayType([], type$.JSArray_CssComment_2); + }, + $signature: 214 + }; + A._EvaluateVisitor_visitIfRule_closure2.prototype = { + call$1(clause) { + var t1 = this.$this; + return t1._async_evaluate0$_environment.scope$1$3$semiGlobal$when(new A._EvaluateVisitor_visitIfRule__closure2(t1, clause), true, clause.hasDeclarations, type$.nullable_Value_2); + }, + $signature: 343 + }; + A._EvaluateVisitor_visitIfRule__closure2.prototype = { + call$0() { + var t1 = this.$this; + return t1._async_evaluate0$_handleReturn$2(this.clause.children, new A._EvaluateVisitor_visitIfRule___closure2(t1)); + }, + $signature: 74 + }; + A._EvaluateVisitor_visitIfRule___closure2.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 88 + }; + A._EvaluateVisitor__visitDynamicImport_closure2.prototype = { + call$0() { + return this.$call$body$_EvaluateVisitor__visitDynamicImport_closure0(); + }, + $call$body$_EvaluateVisitor__visitDynamicImport_closure0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$returnValue, $async$self = this, t1, t2, _0_0, stylesheet, importer, isDependency, url, t3, oldImporter, oldStylesheet, oldInDependency, loadsUserDefinedModules, children, t4, t5, t6, t7, t8, t9, t10, environment, module, visitor, _box_0; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + _box_0 = {}; + _box_0.isDependency = _box_0.importer = _box_0.stylesheet = null; + t1 = $async$self.$this; + t2 = $async$self.$import; + $async$goto = 3; + return A._asyncAwait(t1._async_evaluate0$_loadStylesheet$3$forImport(t2.urlString, t2.span, true), $async$call$0); + case 3: + // returning from await. + _0_0 = $async$result; + stylesheet = _box_0.stylesheet = _0_0._0; + importer = _0_0._1; + _box_0.importer = importer; + isDependency = _0_0._2; + _box_0.isDependency = isDependency; + url = stylesheet.span.file.url; + if (url != null) { + t3 = t1._async_evaluate0$_activeModules; + if (t3.containsKey$1(url)) { + t2 = A.NullableExtension_andThen0(t3.$index(0, url), new A._EvaluateVisitor__visitDynamicImport__closure11(t1)); + throw A.wrapException(t2 == null ? t1._async_evaluate0$_exception$1("This file is already being loaded.") : t2); + } + t3.$indexSet(0, url, t2); + } + t2 = stylesheet._stylesheet1$_uses; + t3 = type$.UnmodifiableListView_UseRule_2; + $async$goto = new A.UnmodifiableListView(t2, t3).get$length(0) === 0 && new A.UnmodifiableListView(stylesheet._stylesheet1$_forwards, type$.UnmodifiableListView_ForwardRule_2).get$length(0) === 0 ? 4 : 5; + break; + case 4: + // then + oldImporter = t1._async_evaluate0$_importer; + oldStylesheet = t1._async_evaluate0$_assertInModule$2(t1._async_evaluate0$__stylesheet, "_stylesheet"); + oldInDependency = t1._async_evaluate0$_inDependency; + t1._async_evaluate0$_importer = importer; + t1._async_evaluate0$__stylesheet = stylesheet; + t1._async_evaluate0$_inDependency = isDependency; + $async$goto = 6; + return A._asyncAwait(t1.visitStylesheet$1(0, stylesheet), $async$call$0); + case 6: + // returning from await. + t1._async_evaluate0$_importer = oldImporter; + t1._async_evaluate0$__stylesheet = oldStylesheet; + t1._async_evaluate0$_inDependency = oldInDependency; + t1._async_evaluate0$_activeModules.remove$1(0, url); + // goto return + $async$goto = 1; + break; + case 5: + // join + t2 = new A.UnmodifiableListView(t2, t3); + if (!t2.any$1(t2, new A._EvaluateVisitor__visitDynamicImport__closure12())) { + t2 = new A.UnmodifiableListView(stylesheet._stylesheet1$_forwards, type$.UnmodifiableListView_ForwardRule_2); + loadsUserDefinedModules = t2.any$1(t2, new A._EvaluateVisitor__visitDynamicImport__closure13()); + } else + loadsUserDefinedModules = true; + children = A._Cell$(); + t2 = t1._async_evaluate0$_environment; + t3 = type$.String; + t4 = type$.Module_AsyncCallable_2; + t5 = type$.AstNode_2; + t6 = A._setArrayType([], type$.JSArray_Module_AsyncCallable_2); + t7 = t2._async_environment0$_variables; + t7 = A._setArrayType(t7.slice(0), A._arrayInstanceType(t7)); + t8 = t2._async_environment0$_variableNodes; + t8 = A._setArrayType(t8.slice(0), A._arrayInstanceType(t8)); + t9 = t2._async_environment0$_functions; + t9 = A._setArrayType(t9.slice(0), A._arrayInstanceType(t9)); + t10 = t2._async_environment0$_mixins; + t10 = A._setArrayType(t10.slice(0), A._arrayInstanceType(t10)); + environment = A.AsyncEnvironment$_0(A.LinkedHashMap_LinkedHashMap$_empty(t3, t4), A.LinkedHashMap_LinkedHashMap$_empty(t3, t5), A.LinkedHashMap_LinkedHashMap$_empty(t4, t5), t2._async_environment0$_importedModules, null, null, t6, t7, t8, t9, t10, t2._async_environment0$_content); + $async$goto = 7; + return A._asyncAwait(t1._async_evaluate0$_withEnvironment$1$2(environment, new A._EvaluateVisitor__visitDynamicImport__closure14(_box_0, t1, loadsUserDefinedModules, environment, children), type$.Null), $async$call$0); + case 7: + // returning from await. + module = environment.toDummyModule$0(); + t1._async_evaluate0$_environment.importForwards$1(module); + $async$goto = loadsUserDefinedModules ? 8 : 9; + break; + case 8: + // then + $async$goto = module.transitivelyContainsCss ? 10 : 11; + break; + case 10: + // then + $async$goto = 12; + return A._asyncAwait(t1._async_evaluate0$_combineCss$2$clone(module, module.transitivelyContainsExtensions).accept$1(t1), $async$call$0); + case 12: + // returning from await. + case 11: + // join + visitor = new A._ImportedCssVisitor2(t1); + for (t2 = J.get$iterator$ax(children._readLocal$0()); t2.moveNext$0();) + t2.get$current(t2).accept$1(visitor); + case 9: + // join + t1._async_evaluate0$_activeModules.remove$1(0, url); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 32 + }; + A._EvaluateVisitor__visitDynamicImport__closure11.prototype = { + call$1(previousLoad) { + return this.$this._async_evaluate0$_multiSpanException$3("This file is already being loaded.", "new load", A.LinkedHashMap_LinkedHashMap$_literal([previousLoad.get$span(previousLoad), "original load"], type$.FileSpan, type$.String)); + }, + $signature: 99 + }; + A._EvaluateVisitor__visitDynamicImport__closure12.prototype = { + call$1(rule) { + return rule.url.get$scheme() !== "sass"; + }, + $signature: 215 + }; + A._EvaluateVisitor__visitDynamicImport__closure13.prototype = { + call$1(rule) { + return rule.url.get$scheme() !== "sass"; + }, + $signature: 216 + }; + A._EvaluateVisitor__visitDynamicImport__closure14.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t3, t4, t1, oldImporter, oldStylesheet, oldRoot, oldParent, oldEndOfImports, oldOutOfOrderImports, oldConfiguration, oldInDependency, t2; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + oldImporter = t1._async_evaluate0$_importer; + oldStylesheet = t1._async_evaluate0$_assertInModule$2(t1._async_evaluate0$__stylesheet, "_stylesheet"); + oldRoot = t1._async_evaluate0$_assertInModule$2(t1._async_evaluate0$__root, "_root"); + oldParent = t1._async_evaluate0$_assertInModule$2(t1._async_evaluate0$__parent, "__parent"); + oldEndOfImports = t1._async_evaluate0$_assertInModule$2(t1._async_evaluate0$__endOfImports, "_endOfImports"); + oldOutOfOrderImports = t1._async_evaluate0$_outOfOrderImports; + oldConfiguration = t1._async_evaluate0$_configuration; + oldInDependency = t1._async_evaluate0$_inDependency; + t2 = $async$self._box_0; + t1._async_evaluate0$_importer = t2.importer; + t3 = t2.stylesheet; + t1._async_evaluate0$__stylesheet = t3; + t4 = $async$self.loadsUserDefinedModules; + if (t4) { + t3 = A.ModifiableCssStylesheet$0(t3.span); + t1._async_evaluate0$__root = t3; + t1._async_evaluate0$__parent = t1._async_evaluate0$_assertInModule$2(t3, "_root"); + t1._async_evaluate0$__endOfImports = 0; + t1._async_evaluate0$_outOfOrderImports = null; + } + t1._async_evaluate0$_inDependency = t2.isDependency; + t3 = new A.UnmodifiableListView(t2.stylesheet._stylesheet1$_forwards, type$.UnmodifiableListView_ForwardRule_2); + if (!t3.get$isEmpty(t3)) + t1._async_evaluate0$_configuration = $async$self.environment.toImplicitConfiguration$0(); + $async$goto = 2; + return A._asyncAwait(t1.visitStylesheet$1(0, t2.stylesheet), $async$call$0); + case 2: + // returning from await. + t2 = t4 ? t1._async_evaluate0$_addOutOfOrderImports$0() : A._setArrayType([], type$.JSArray_ModifiableCssNode_2); + $async$self.children.__late_helper$_value = t2; + t1._async_evaluate0$_importer = oldImporter; + t1._async_evaluate0$__stylesheet = oldStylesheet; + if (t4) { + t1._async_evaluate0$__root = oldRoot; + t1._async_evaluate0$__parent = oldParent; + t1._async_evaluate0$__endOfImports = oldEndOfImports; + t1._async_evaluate0$_outOfOrderImports = oldOutOfOrderImports; + } + t1._async_evaluate0$_configuration = oldConfiguration; + t1._async_evaluate0$_inDependency = oldInDependency; + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor__applyMixin_closure5.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate0$_environment.asMixin$1(new A._EvaluateVisitor__applyMixin__closure6(t1, $async$self.$arguments, $async$self.mixin, $async$self.nodeWithSpanWithoutContent)), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 32 + }; + A._EvaluateVisitor__applyMixin__closure6.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 2; + return A._asyncAwait($async$self.$this._async_evaluate0$_runBuiltInCallable$3($async$self.$arguments, $async$self.mixin, $async$self.nodeWithSpanWithoutContent), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 32 + }; + A._EvaluateVisitor__applyMixin_closure6.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate0$_environment.withContent$2($async$self.contentCallable, new A._EvaluateVisitor__applyMixin__closure5(t1, $async$self.mixin, $async$self.nodeWithSpanWithoutContent)), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor__applyMixin__closure5.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate0$_environment.asMixin$1(new A._EvaluateVisitor__applyMixin___closure2(t1, $async$self.mixin, $async$self.nodeWithSpanWithoutContent)), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 32 + }; + A._EvaluateVisitor__applyMixin___closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, t1, t2, t3, t4, t5, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.mixin.declaration.children, t2 = t1.length, t3 = $async$self.$this, t4 = $async$self.nodeWithSpanWithoutContent, t5 = type$.nullable_Value_2, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t3._async_evaluate0$_addErrorSpan$1$2(t4, new A._EvaluateVisitor__applyMixin____closure2(t3, t1[_i]), t5), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 32 + }; + A._EvaluateVisitor__applyMixin____closure2.prototype = { + call$0() { + return this.statement.accept$1(this.$this); + }, + $signature: 74 + }; + A._EvaluateVisitor_visitIncludeRule_closure8.prototype = { + call$0() { + var t1 = this.node; + return this.$this._async_evaluate0$_environment.getMixin$2$namespace(t1.name, t1.namespace); + }, + $signature: 97 + }; + A._EvaluateVisitor_visitIncludeRule_closure9.prototype = { + call$1($content) { + var t1 = this.$this; + return new A.UserDefinedCallable0($content, t1._async_evaluate0$_environment.closure$0(), t1._async_evaluate0$_inDependency, type$.UserDefinedCallable_AsyncEnvironment_2); + }, + $signature: 346 + }; + A._EvaluateVisitor_visitIncludeRule_closure10.prototype = { + call$0() { + return this.node.get$spanWithoutContent(); + }, + $signature: 29 + }; + A._EvaluateVisitor_visitMediaRule_closure8.prototype = { + call$1(mediaQueries) { + return this.$this._async_evaluate0$_mergeMediaQueries$2(mediaQueries, this.queries); + }, + $signature: 104 + }; + A._EvaluateVisitor_visitMediaRule_closure9.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + t2 = $async$self.mergedQueries; + if (t2 == null) + t2 = $async$self.queries; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate0$_withMediaQueries$1$3(t2, $async$self.mergedSources, new A._EvaluateVisitor_visitMediaRule__closure2(t1, $async$self.node), type$.Null), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitMediaRule__closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t2, t3, _i, t1, _0_0; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + _0_0 = t1._async_evaluate0$_atRootExcludingStyleRule ? null : t1._async_evaluate0$_styleRuleIgnoringAtRoot; + $async$goto = _0_0 != null ? 2 : 4; + break; + case 2: + // then + $async$goto = 5; + return A._asyncAwait(t1._async_evaluate0$_withParent$2$3$scopeWhen(A.ModifiableCssStyleRule$0(_0_0._style_rule0$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitMediaRule___closure2(t1, $async$self.node), false, type$.ModifiableCssStyleRule_2, type$.Null), $async$call$0); + case 5: + // returning from await. + // goto join + $async$goto = 3; + break; + case 4: + // else + t2 = $async$self.node.children, t3 = t2.length, _i = 0; + case 6: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 8; + break; + } + $async$goto = 9; + return A._asyncAwait(t2[_i].accept$1(t1), $async$call$0); + case 9: + // returning from await. + case 7: + // for update + ++_i; + // goto for condition + $async$goto = 6; + break; + case 8: + // after for + case 3: + // join + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitMediaRule___closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitMediaRule_closure10.prototype = { + call$1(node) { + var t1; + if (!(node instanceof A.ModifiableCssStyleRule0)) { + t1 = this.mergedSources; + t1 = t1.get$isNotEmpty(t1) && node instanceof A.ModifiableCssMediaRule0 && B.JSArray_methods.every$1(node.queries, t1.get$contains(t1)); + } else + t1 = true; + return t1; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitStyleRule_closure11.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitStyleRule_closure12.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitStyleRule_closure14.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate0$_withStyleRule$1$2($async$self.rule, new A._EvaluateVisitor_visitStyleRule__closure2(t1, $async$self.node), type$.Null), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitStyleRule__closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitStyleRule_closure13.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor__warnForBogusCombinators_closure2.prototype = { + call$1(child) { + return child instanceof A.ModifiableCssComment0; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitSupportsRule_closure5.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t2, t3, _i, t1, _0_0; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + _0_0 = t1._async_evaluate0$_atRootExcludingStyleRule ? null : t1._async_evaluate0$_styleRuleIgnoringAtRoot; + $async$goto = _0_0 != null ? 2 : 4; + break; + case 2: + // then + $async$goto = 5; + return A._asyncAwait(t1._async_evaluate0$_withParent$2$2(A.ModifiableCssStyleRule$0(_0_0._style_rule0$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitSupportsRule__closure2(t1, $async$self.node), type$.ModifiableCssStyleRule_2, type$.Null), $async$call$0); + case 5: + // returning from await. + // goto join + $async$goto = 3; + break; + case 4: + // else + t2 = $async$self.node.children, t3 = t2.length, _i = 0; + case 6: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 8; + break; + } + $async$goto = 9; + return A._asyncAwait(t2[_i].accept$1(t1), $async$call$0); + case 9: + // returning from await. + case 7: + // for update + ++_i; + // goto for condition + $async$goto = 6; + break; + case 8: + // after for + case 3: + // join + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitSupportsRule__closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, _i; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.length, t3 = $async$self.$this, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 5; + return A._asyncAwait(t1[_i].accept$1(t3), $async$call$0); + case 5: + // returning from await. + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitSupportsRule_closure6.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor__visitSupportsCondition_closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.String), + $async$returnValue, $async$self = this, t1, t2, t3, t4, $async$temp1, $async$temp2; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + t2 = $async$self._box_0; + $async$temp1 = A; + $async$goto = 3; + return A._asyncAwait(t1._async_evaluate0$_evaluateToCss$1(t2.declaration.name), $async$call$0); + case 3: + // returning from await. + t3 = $async$temp1.S($async$result); + t4 = t2.declaration.get$isCustomProperty() ? "" : " "; + $async$temp1 = "(" + t3 + ":" + t4; + $async$temp2 = A; + $async$goto = 4; + return A._asyncAwait(t1._async_evaluate0$_evaluateToCss$1(t2.declaration.value), $async$call$0); + case 4: + // returning from await. + $async$returnValue = $async$temp1 + $async$temp2.S($async$result) + ")"; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 181 + }; + A._EvaluateVisitor_visitVariableDeclaration_closure8.prototype = { + call$0() { + var t1 = this.$this._async_evaluate0$_environment, + t2 = this._box_0.override; + t1.setVariable$4$global(this.node.name, t2.value, t2.assignmentNode, true); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitVariableDeclaration_closure9.prototype = { + call$0() { + var t1 = this.node; + return this.$this._async_evaluate0$_environment.getVariable$2$namespace(t1.name, t1.namespace); + }, + $signature: 44 + }; + A._EvaluateVisitor_visitVariableDeclaration_closure10.prototype = { + call$0() { + var t1 = this.$this, + t2 = this.node; + t1._async_evaluate0$_environment.setVariable$5$global$namespace(t2.name, this.value, t1._async_evaluate0$_expressionNode$1(t2.expression), t2.isGlobal, t2.namespace); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitUseRule_closure2.prototype = { + call$2(module, firstLoad) { + var t1, t2, t3, _0_0, t4, t5, span; + if (firstLoad) + this.$this._async_evaluate0$_registerCommentsForModule$1(module); + t1 = this.$this._async_evaluate0$_environment; + t2 = this.node; + t3 = t2.namespace; + if (t3 == null) { + t1._async_environment0$_globalModules.$indexSet(0, module, t2); + t1._async_environment0$_allModules.push(module); + _0_0 = A.IterableExtension_firstWhereOrNull(J.get$keys$z(B.JSArray_methods.get$first(t1._async_environment0$_variables)), module.get$variables().get$containsKey()); + if (_0_0 != null) + A.throwExpression(A.SassScriptException$0(string$.This_ma + _0_0 + '".', null)); + } else { + t4 = t1._async_environment0$_modules; + if (t4.containsKey$1(t3)) { + t5 = t1._async_environment0$_namespaceNodes.$index(0, t3); + span = t5 == null ? null : t5.span; + t5 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + if (span != null) + t5.$indexSet(0, span, "original @use"); + A.throwExpression(A.MultiSpanSassScriptException$0(string$.There_ + t3 + '".', "new @use", t5)); + } + t4.$indexSet(0, t3, module); + t1._async_environment0$_namespaceNodes.$indexSet(0, t3, t2); + t1._async_environment0$_allModules.push(module); + } + }, + $signature: 114 + }; + A._EvaluateVisitor_visitWarnRule_closure2.prototype = { + call$0() { + return this.node.expression.accept$1(this.$this); + }, + $signature: 78 + }; + A._EvaluateVisitor_visitWhileRule_closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Value_2), + $async$returnValue, $async$self = this, t1, t2, t3, _0_0; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node, t2 = t1.condition, t3 = $async$self.$this, t1 = t1.children; + case 3: + // for condition + $async$goto = 5; + return A._asyncAwait(t2.accept$1(t3), $async$call$0); + case 5: + // returning from await. + if (!$async$result.get$isTruthy()) { + // goto after for + $async$goto = 4; + break; + } + $async$goto = 6; + return A._asyncAwait(t3._async_evaluate0$_handleReturn$2(t1, new A._EvaluateVisitor_visitWhileRule__closure2(t3)), $async$call$0); + case 6: + // returning from await. + _0_0 = $async$result; + if (_0_0 != null) { + $async$returnValue = _0_0; + // goto return + $async$goto = 1; + break; + } + // goto for condition + $async$goto = 3; + break; + case 4: + // after for + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 74 + }; + A._EvaluateVisitor_visitWhileRule__closure2.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 88 + }; + A._EvaluateVisitor_visitBinaryOperationExpression_closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$self = this, t3, t1, t2, left, $async$temp1, $async$temp2; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node; + t2 = $async$self.$this; + $async$goto = 3; + return A._asyncAwait(t1.left.accept$1(t2), $async$call$0); + case 3: + // returning from await. + left = $async$result; + case 4: + // switch + switch (t1.operator) { + case B.BinaryOperator_Kyq0: + // goto case + $async$goto = 6; + break; + case B.BinaryOperator_tKu0: + // goto case + $async$goto = 7; + break; + case B.BinaryOperator_uke0: + // goto case + $async$goto = 8; + break; + case B.BinaryOperator_r840: + // goto case + $async$goto = 9; + break; + case B.BinaryOperator_qGq0: + // goto case + $async$goto = 10; + break; + case B.BinaryOperator_o8O0: + // goto case + $async$goto = 11; + break; + case B.BinaryOperator_JiR0: + // goto case + $async$goto = 12; + break; + case B.BinaryOperator_qHy0: + // goto case + $async$goto = 13; + break; + case B.BinaryOperator_FPG0: + // goto case + $async$goto = 14; + break; + case B.BinaryOperator_Swh0: + // goto case + $async$goto = 15; + break; + case B.BinaryOperator_QG10: + // goto case + $async$goto = 16; + break; + case B.BinaryOperator_tht0: + // goto case + $async$goto = 17; + break; + case B.BinaryOperator_Mh50: + // goto case + $async$goto = 18; + break; + case B.BinaryOperator_s7T0: + // goto case + $async$goto = 19; + break; + default: + // goto default + $async$goto = 20; + break; + } + break; + case 6: + // case + t1 = t1.right.accept$1(t2); + $async$goto = 21; + return A._asyncAwait(type$.Future_Value_2._is(t1) ? t1 : A._Future$value(t1, type$.Value_2), $async$call$0); + case 21: + // returning from await. + t1 = $async$result; + t1 = new A.SassString0(A.serializeValue0(left, false, true) + "=" + A.serializeValue0(t1, false, true), false); + // goto after switch + $async$goto = 5; + break; + case 7: + // case + $async$goto = left.get$isTruthy() ? 22 : 24; + break; + case 22: + // then + t1 = left; + // goto join + $async$goto = 23; + break; + case 24: + // else + t1 = t1.right.accept$1(t2); + $async$goto = 25; + return A._asyncAwait(type$.Future_Value_2._is(t1) ? t1 : A._Future$value(t1, type$.Value_2), $async$call$0); + case 25: + // returning from await. + t1 = $async$result; + case 23: + // join + // goto after switch + $async$goto = 5; + break; + case 8: + // case + $async$goto = left.get$isTruthy() ? 26 : 28; + break; + case 26: + // then + t1 = t1.right.accept$1(t2); + $async$goto = 29; + return A._asyncAwait(type$.Future_Value_2._is(t1) ? t1 : A._Future$value(t1, type$.Value_2), $async$call$0); + case 29: + // returning from await. + t1 = $async$result; + // goto join + $async$goto = 27; + break; + case 28: + // else + t1 = left; + case 27: + // join + // goto after switch + $async$goto = 5; + break; + case 9: + // case + $async$temp1 = left; + $async$goto = 30; + return A._asyncAwait(t1.right.accept$1(t2), $async$call$0); + case 30: + // returning from await. + t1 = $async$temp1.$eq(0, $async$result) ? B.SassBoolean_true0 : B.SassBoolean_false0; + // goto after switch + $async$goto = 5; + break; + case 10: + // case + $async$temp1 = left; + $async$goto = 31; + return A._asyncAwait(t1.right.accept$1(t2), $async$call$0); + case 31: + // returning from await. + t1 = !$async$temp1.$eq(0, $async$result) ? B.SassBoolean_true0 : B.SassBoolean_false0; + // goto after switch + $async$goto = 5; + break; + case 11: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 32; + return A._asyncAwait(type$.Future_Value_2._is(t1) ? t1 : A._Future$value(t1, type$.Value_2), $async$call$0); + case 32: + // returning from await. + t1 = $async$temp1.greaterThan$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 12: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 33; + return A._asyncAwait(type$.Future_Value_2._is(t1) ? t1 : A._Future$value(t1, type$.Value_2), $async$call$0); + case 33: + // returning from await. + t1 = $async$temp1.greaterThanOrEquals$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 13: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 34; + return A._asyncAwait(type$.Future_Value_2._is(t1) ? t1 : A._Future$value(t1, type$.Value_2), $async$call$0); + case 34: + // returning from await. + t1 = $async$temp1.lessThan$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 14: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 35; + return A._asyncAwait(type$.Future_Value_2._is(t1) ? t1 : A._Future$value(t1, type$.Value_2), $async$call$0); + case 35: + // returning from await. + t1 = $async$temp1.lessThanOrEquals$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 15: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 36; + return A._asyncAwait(type$.Future_Value_2._is(t1) ? t1 : A._Future$value(t1, type$.Value_2), $async$call$0); + case 36: + // returning from await. + t1 = $async$temp1.plus$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 16: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 37; + return A._asyncAwait(type$.Future_Value_2._is(t1) ? t1 : A._Future$value(t1, type$.Value_2), $async$call$0); + case 37: + // returning from await. + t1 = $async$temp1.minus$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 17: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 38; + return A._asyncAwait(type$.Future_Value_2._is(t1) ? t1 : A._Future$value(t1, type$.Value_2), $async$call$0); + case 38: + // returning from await. + t1 = $async$temp1.times$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 18: + // case + t3 = t1.right.accept$1(t2); + $async$temp1 = t2; + $async$temp2 = left; + $async$goto = 39; + return A._asyncAwait(type$.Future_Value_2._is(t3) ? t3 : A._Future$value(t3, type$.Value_2), $async$call$0); + case 39: + // returning from await. + t1 = $async$temp1._async_evaluate0$_slash$3($async$temp2, $async$result, t1); + // goto after switch + $async$goto = 5; + break; + case 19: + // case + t1 = t1.right.accept$1(t2); + $async$temp1 = left; + $async$goto = 40; + return A._asyncAwait(type$.Future_Value_2._is(t1) ? t1 : A._Future$value(t1, type$.Value_2), $async$call$0); + case 40: + // returning from await. + t1 = $async$temp1.modulo$1($async$result); + // goto after switch + $async$goto = 5; + break; + case 20: + // default + t1 = null; + case 5: + // after switch + $async$returnValue = t1; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 78 + }; + A._EvaluateVisitor__slash_recommendation2.prototype = { + call$1(expression) { + var t1; + $label0$0: { + if (expression instanceof A.BinaryOperationExpression0 && B.BinaryOperator_Mh50 === expression.operator) { + t1 = "math.div(" + A.S(this.call$1(expression.left)) + ", " + A.S(this.call$1(expression.right)) + ")"; + break $label0$0; + } + if (expression instanceof A.ParenthesizedExpression0) { + t1 = expression.expression.toString$0(0); + break $label0$0; + } + t1 = expression.toString$0(0); + break $label0$0; + } + return t1; + }, + $signature: 113 + }; + A._EvaluateVisitor_visitVariableExpression_closure2.prototype = { + call$0() { + var t1 = this.node; + return this.$this._async_evaluate0$_environment.getVariable$2$namespace(t1.name, t1.namespace); + }, + $signature: 44 + }; + A._EvaluateVisitor_visitUnaryOperationExpression_closure2.prototype = { + call$0() { + var t1, _this = this; + switch (_this.node.operator) { + case B.UnaryOperator_Rbl0: + t1 = _this.operand.unaryPlus$0(); + break; + case B.UnaryOperator_UCP0: + t1 = _this.operand.unaryMinus$0(); + break; + case B.UnaryOperator_lZV0: + t1 = new A.SassString0("/" + A.serializeValue0(_this.operand, false, true), false); + break; + case B.UnaryOperator_not_not_not0: + t1 = _this.operand.unaryNot$0(); + break; + default: + t1 = null; + } + return t1; + }, + $signature: 49 + }; + A._EvaluateVisitor_visitListExpression_closure2.prototype = { + call$1(expression) { + return expression.accept$1(this.$this); + }, + $signature: 352 + }; + A._EvaluateVisitor_visitFunctionExpression_closure8.prototype = { + call$0() { + var t1 = this.node; + return this.$this._async_evaluate0$_environment.getFunction$2$namespace(t1.name, t1.namespace); + }, + $signature: 97 + }; + A._EvaluateVisitor_visitFunctionExpression_closure9.prototype = { + call$1(argument) { + return argument.accept$1(B.C_IsCalculationSafeVisitor0); + }, + $signature: 140 + }; + A._EvaluateVisitor_visitFunctionExpression_closure10.prototype = { + call$0() { + var t1 = this.node; + return this.$this._async_evaluate0$_runFunctionCallable$3(t1.$arguments, this._box_0.$function, t1); + }, + $signature: 78 + }; + A._EvaluateVisitor__visitCalculation_closure2.prototype = { + call$2(message, deprecation) { + return this.$this._async_evaluate0$_warn$3(message, this.node.span, deprecation); + }, + call$1(message) { + return this.call$2(message, null); + }, + $signature: 110 + }; + A._EvaluateVisitor__checkCalculationArguments_check2.prototype = { + call$1(maxArgs) { + var t1 = this.node, + t2 = t1.$arguments.positional.length; + if (t2 === 0) + throw A.wrapException(this.$this._async_evaluate0$_exception$2("Missing argument.", t1.span)); + else if (maxArgs != null && t2 > maxArgs) + throw A.wrapException(this.$this._async_evaluate0$_exception$2("Only " + A.S(maxArgs) + " " + A.pluralize0("argument", maxArgs, null) + " allowed, but " + t2 + " " + A.pluralize0("was", t2, "were") + " passed.", t1.span)); + }, + call$0() { + return this.call$1(null); + }, + $signature: 106 + }; + A._EvaluateVisitor__visitCalculationExpression_closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Object), + $async$returnValue, $async$self = this, t1, t2, t3, t4, $async$temp1, $async$temp2, $async$temp3; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + t2 = $async$self._box_0; + t3 = $async$self.node; + t4 = $async$self.inLegacySassFunction; + $async$temp1 = A; + $async$temp2 = t1._async_evaluate0$_binaryOperatorToCalculationOperator$2(t2.operator, t3); + $async$goto = 3; + return A._asyncAwait(t1._async_evaluate0$_visitCalculationExpression$2$inLegacySassFunction(t2.left, t4), $async$call$0); + case 3: + // returning from await. + $async$temp3 = $async$result; + $async$goto = 4; + return A._asyncAwait(t1._async_evaluate0$_visitCalculationExpression$2$inLegacySassFunction(t2.right, t4), $async$call$0); + case 4: + // returning from await. + $async$returnValue = $async$temp1.SassCalculation_operateInternal0($async$temp2, $async$temp3, $async$result, t4, !t1._async_evaluate0$_inSupportsDeclaration, new A._EvaluateVisitor__visitCalculationExpression__closure2(t1, t3)); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 183 + }; + A._EvaluateVisitor__visitCalculationExpression__closure2.prototype = { + call$2(message, deprecation) { + return this.$this._async_evaluate0$_warn$3(message, this.node.get$span(0), deprecation); + }, + call$1(message) { + return this.call$2(message, null); + }, + $signature: 110 + }; + A._EvaluateVisitor_visitInterpolatedFunctionExpression_closure2.prototype = { + call$0() { + var t1 = this.node; + return this.$this._async_evaluate0$_runFunctionCallable$3(t1.$arguments, this.$function, t1); + }, + $signature: 78 + }; + A._EvaluateVisitor__runUserDefinedCallable_closure2.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this.callable, + t3 = _this.V; + return t1._async_evaluate0$_withEnvironment$1$2(t2.environment.closure$0(), new A._EvaluateVisitor__runUserDefinedCallable__closure2(t1, _this.evaluated, t2, _this.nodeWithSpan, _this.run, t3), t3); + }, + $signature() { + return this.V._eval$1("Future<0>()"); + } + }; + A._EvaluateVisitor__runUserDefinedCallable__closure2.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this.V; + return t1._async_evaluate0$_environment.scope$1$1(new A._EvaluateVisitor__runUserDefinedCallable___closure2(t1, _this.evaluated, _this.callable, _this.nodeWithSpan, _this.run, t2), t2); + }, + $signature() { + return this.V._eval$1("Future<0>()"); + } + }; + A._EvaluateVisitor__runUserDefinedCallable___closure2.prototype = { + call$0() { + return this.$call$body$_EvaluateVisitor__runUserDefinedCallable___closure0(this.V); + }, + $call$body$_EvaluateVisitor__runUserDefinedCallable___closure0($async$type) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter($async$type), + $async$returnValue, $async$self = this, parameters, t5, minLength, i, parameter, t6, value, t7, t8, restParameter, rest, argumentList, result, parameterWord, t1, t2, t3, t4, $async$temp1; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + t2 = $async$self.evaluated._values; + t3 = $async$self.callable.declaration.parameters; + t4 = $async$self.nodeWithSpan; + t1._async_evaluate0$_verifyArguments$4(J.get$length$asx(t2[2]), t2[0], t3, t4); + parameters = t3.parameters; + t5 = parameters.length; + minLength = Math.min(J.get$length$asx(t2[2]), t5); + for (i = 0; i < minLength; ++i) + t1._async_evaluate0$_environment.setLocalVariable$3(parameters[i].name, J.$index$asx(t2[2], i), J.$index$asx(t2[3], i)); + i = J.get$length$asx(t2[2]); + case 3: + // for condition + if (!(i < t5)) { + // goto after for + $async$goto = 5; + break; + } + parameter = parameters[i]; + t6 = parameter.name; + value = t2[0].remove$1(0, t6); + $async$goto = value == null ? 6 : 7; + break; + case 6: + // then + t7 = parameter.defaultValue; + $async$temp1 = t1; + $async$goto = 8; + return A._asyncAwait(t7.accept$1(t1), $async$call$0); + case 8: + // returning from await. + value = $async$temp1._async_evaluate0$_withoutSlash$2($async$result, t1._async_evaluate0$_expressionNode$1(t7)); + case 7: + // join + t7 = t1._async_evaluate0$_environment; + t8 = t2[1].$index(0, t6); + if (t8 == null) { + t8 = parameter.defaultValue; + t8.toString; + t8 = t1._async_evaluate0$_expressionNode$1(t8); + } + t7.setLocalVariable$3(t6, value, t8); + case 4: + // for update + ++i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + restParameter = t3.restParameter; + if (restParameter != null) { + rest = J.get$length$asx(t2[2]) > t5 ? J.sublist$1$ax(t2[2], t5) : B.List_empty20; + t5 = t2[0]; + t6 = t2[4]; + argumentList = A.SassArgumentList$0(rest, t5, t6 === B.ListSeparator_undecided_null_undecided0 ? B.ListSeparator_qVN0 : t6); + t1._async_evaluate0$_environment.setLocalVariable$3(restParameter, argumentList, t4); + } else + argumentList = null; + $async$goto = 9; + return A._asyncAwait($async$self.run.call$0(), $async$call$0); + case 9: + // returning from await. + result = $async$result; + if (argumentList == null) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + t5 = t2[0]; + if (t5.get$isEmpty(t5)) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + if (argumentList._argument_list$_wereKeywordsAccessed) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + t5 = t2[0]; + parameterWord = A.pluralize0("parameter", J.get$length$asx(t5.get$keys(t5)), null); + t2 = t2[0]; + throw A.wrapException(A.MultiSpanSassRuntimeException$0("No " + parameterWord + " named " + A.toSentence0(J.map$1$1$ax(t2.get$keys(t2), new A._EvaluateVisitor__runUserDefinedCallable____closure2(), type$.Object), "or") + ".", t4.get$span(t4), "invocation", A.LinkedHashMap_LinkedHashMap$_literal([t3.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), t1._async_evaluate0$_stackTrace$1(t4.get$span(t4)), null)); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature() { + return this.V._eval$1("Future<0>()"); + } + }; + A._EvaluateVisitor__runUserDefinedCallable____closure2.prototype = { + call$1($name) { + return "$" + $name; + }, + $signature: 6 + }; + A._EvaluateVisitor__runFunctionCallable_closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$self = this, t1, t2, t3, t4, _i, $returnValue; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.callable.declaration, t2 = t1.children, t3 = t2.length, t4 = $async$self.$this, _i = 0; + case 3: + // for condition + if (!(_i < t3)) { + // goto after for + $async$goto = 5; + break; + } + $async$goto = 6; + return A._asyncAwait(t2[_i].accept$1(t4), $async$call$0); + case 6: + // returning from await. + $returnValue = $async$result; + if ($returnValue instanceof A.Value0) { + $async$returnValue = $returnValue; + // goto return + $async$goto = 1; + break; + } + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + throw A.wrapException(t4._async_evaluate0$_exception$2("Function finished without @return.", t1.span)); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 78 + }; + A._EvaluateVisitor__runBuiltInCallable_closure8.prototype = { + call$0() { + return this._box_0.overload.verify$2(J.get$length$asx(this.evaluated._values[2]), this.namedSet); + }, + $signature: 0 + }; + A._EvaluateVisitor__runBuiltInCallable_closure9.prototype = { + call$0() { + return this._box_0.callback.call$1(this.evaluated._values[2]); + }, + $signature: 355 + }; + A._EvaluateVisitor__runBuiltInCallable_closure10.prototype = { + call$1($name) { + return "$" + $name; + }, + $signature: 6 + }; + A._EvaluateVisitor__evaluateArguments_closure11.prototype = { + call$1(value) { + return value; + }, + $signature: 43 + }; + A._EvaluateVisitor__evaluateArguments_closure12.prototype = { + call$1(value) { + return this.$this._async_evaluate0$_withoutSlash$2(value, this.restNodeForSpan); + }, + $signature: 43 + }; + A._EvaluateVisitor__evaluateArguments_closure13.prototype = { + call$2(key, value) { + var _this = this, + t1 = _this.restNodeForSpan; + _this.named.$indexSet(0, key, _this.$this._async_evaluate0$_withoutSlash$2(value, t1)); + _this.namedNodes.$indexSet(0, key, t1); + }, + $signature: 109 + }; + A._EvaluateVisitor__evaluateArguments_closure14.prototype = { + call$1(value) { + return value; + }, + $signature: 43 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure11.prototype = { + call$1(value) { + var t1 = this.restArgs; + return new A.ValueExpression0(value, t1.get$span(t1)); + }, + $signature: 65 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure12.prototype = { + call$1(value) { + var t1 = this.restArgs; + return new A.ValueExpression0(this.$this._async_evaluate0$_withoutSlash$2(value, this.restNodeForSpan), t1.get$span(t1)); + }, + $signature: 65 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure13.prototype = { + call$2(key, value) { + var _this = this, + t1 = _this.restArgs; + _this.named.$indexSet(0, key, new A.ValueExpression0(_this.$this._async_evaluate0$_withoutSlash$2(value, _this.restNodeForSpan), t1.get$span(t1))); + }, + $signature: 109 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure14.prototype = { + call$1(value) { + var t1 = this.keywordRestArgs; + return new A.ValueExpression0(this.$this._async_evaluate0$_withoutSlash$2(value, this.keywordRestNodeForSpan), t1.get$span(t1)); + }, + $signature: 65 + }; + A._EvaluateVisitor__addRestMap_closure2.prototype = { + call$2(key, value) { + var t2, _this = this, + t1 = _this.$this; + if (key instanceof A.SassString0) + _this.values.$indexSet(0, key._string0$_text, _this.convert.call$1(t1._async_evaluate0$_withoutSlash$2(value, _this.expressionNode))); + else { + t2 = _this.nodeWithSpan; + throw A.wrapException(t1._async_evaluate0$_exception$2(string$.Variab_ + key.toString$0(0) + " is not a string in " + _this.map.toString$0(0) + ".", t2.get$span(t2))); + } + }, + $signature: 98 + }; + A._EvaluateVisitor__verifyArguments_closure2.prototype = { + call$0() { + return this.parameters.verify$2(this.positional, new A.MapKeySet(this.named, type$.MapKeySet_String)); + }, + $signature: 0 + }; + A._EvaluateVisitor_visitCssAtRule_closure5.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, t4; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = $async$self.$this, t2 = t2._eval$1("ListBase.E"); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + t4 = t1.__internal$_current; + $async$goto = 4; + return A._asyncAwait((t4 == null ? t2._as(t4) : t4).accept$1(t3), $async$call$0); + case 4: + // returning from await. + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssAtRule_closure6.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitCssKeyframeBlock_closure5.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, t4; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = $async$self.$this, t2 = t2._eval$1("ListBase.E"); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + t4 = t1.__internal$_current; + $async$goto = 4; + return A._asyncAwait((t4 == null ? t2._as(t4) : t4).accept$1(t3), $async$call$0); + case 4: + // returning from await. + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssKeyframeBlock_closure6.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitCssMediaRule_closure8.prototype = { + call$1(mediaQueries) { + return this.$this._async_evaluate0$_mergeMediaQueries$2(mediaQueries, this.node.queries); + }, + $signature: 104 + }; + A._EvaluateVisitor_visitCssMediaRule_closure9.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + t2 = $async$self.mergedQueries; + if (t2 == null) + t2 = $async$self.node.queries; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate0$_withMediaQueries$1$3(t2, $async$self.mergedSources, new A._EvaluateVisitor_visitCssMediaRule__closure2(t1, $async$self.node), type$.Null), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssMediaRule__closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t2, t3, t4, t1, _0_0; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + _0_0 = t1._async_evaluate0$_atRootExcludingStyleRule ? null : t1._async_evaluate0$_styleRuleIgnoringAtRoot; + $async$goto = _0_0 != null ? 2 : 4; + break; + case 2: + // then + $async$goto = 5; + return A._asyncAwait(t1._async_evaluate0$_withParent$2$3$scopeWhen(A.ModifiableCssStyleRule$0(_0_0._style_rule0$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitCssMediaRule___closure2(t1, $async$self.node), false, type$.ModifiableCssStyleRule_2, type$.Null), $async$call$0); + case 5: + // returning from await. + // goto join + $async$goto = 3; + break; + case 4: + // else + t2 = $async$self.node.children, t3 = t2.$ti, t2 = new A.ListIterator(t2, t2.get$length(0), t3._eval$1("ListIterator")), t3 = t3._eval$1("ListBase.E"); + case 6: + // for condition + if (!t2.moveNext$0()) { + // goto after for + $async$goto = 7; + break; + } + t4 = t2.__internal$_current; + $async$goto = 8; + return A._asyncAwait((t4 == null ? t3._as(t4) : t4).accept$1(t1), $async$call$0); + case 8: + // returning from await. + // goto for condition + $async$goto = 6; + break; + case 7: + // after for + case 3: + // join + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssMediaRule___closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, t4; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = $async$self.$this, t2 = t2._eval$1("ListBase.E"); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + t4 = t1.__internal$_current; + $async$goto = 4; + return A._asyncAwait((t4 == null ? t2._as(t4) : t4).accept$1(t3), $async$call$0); + case 4: + // returning from await. + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssMediaRule_closure10.prototype = { + call$1(node) { + var t1; + if (!(node instanceof A.ModifiableCssStyleRule0)) { + t1 = this.mergedSources; + t1 = t1.get$isNotEmpty(t1) && node instanceof A.ModifiableCssMediaRule0 && B.JSArray_methods.every$1(node.queries, t1.get$contains(t1)); + } else + t1 = true; + return t1; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitCssStyleRule_closure6.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + $async$goto = 2; + return A._asyncAwait(t1._async_evaluate0$_withStyleRule$1$2($async$self.rule, new A._EvaluateVisitor_visitCssStyleRule__closure2(t1, $async$self.node), type$.Null), $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssStyleRule__closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, t4; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = $async$self.$this, t2 = t2._eval$1("ListBase.E"); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + t4 = t1.__internal$_current; + $async$goto = 4; + return A._asyncAwait((t4 == null ? t2._as(t4) : t4).accept$1(t3), $async$call$0); + case 4: + // returning from await. + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssStyleRule_closure5.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitCssSupportsRule_closure5.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t2, t3, t4, t1, _0_0; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + _0_0 = t1._async_evaluate0$_atRootExcludingStyleRule ? null : t1._async_evaluate0$_styleRuleIgnoringAtRoot; + $async$goto = _0_0 != null ? 2 : 4; + break; + case 2: + // then + $async$goto = 5; + return A._asyncAwait(t1._async_evaluate0$_withParent$2$2(A.ModifiableCssStyleRule$0(_0_0._style_rule0$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitCssSupportsRule__closure2(t1, $async$self.node), type$.ModifiableCssStyleRule_2, type$.Null), $async$call$0); + case 5: + // returning from await. + // goto join + $async$goto = 3; + break; + case 4: + // else + t2 = $async$self.node.children, t3 = t2.$ti, t2 = new A.ListIterator(t2, t2.get$length(0), t3._eval$1("ListIterator")), t3 = t3._eval$1("ListBase.E"); + case 6: + // for condition + if (!t2.moveNext$0()) { + // goto after for + $async$goto = 7; + break; + } + t4 = t2.__internal$_current; + $async$goto = 8; + return A._asyncAwait((t4 == null ? t3._as(t4) : t4).accept$1(t1), $async$call$0); + case 8: + // returning from await. + // goto for condition + $async$goto = 6; + break; + case 7: + // after for + case 3: + // join + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssSupportsRule__closure2.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1, t2, t3, t4; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = $async$self.$this, t2 = t2._eval$1("ListBase.E"); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + t4 = t1.__internal$_current; + $async$goto = 4; + return A._asyncAwait((t4 == null ? t2._as(t4) : t4).accept$1(t3), $async$call$0); + case 4: + // returning from await. + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A._EvaluateVisitor_visitCssSupportsRule_closure6.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor__performInterpolationHelper_closure2.prototype = { + call$1(targetLocations) { + return A.InterpolationMap$0(this.interpolation, targetLocations); + }, + $signature: 218 + }; + A._EvaluateVisitor__serialize_closure2.prototype = { + call$0() { + return A.serializeValue0(this.value, false, this.quote); + }, + $signature: 26 + }; + A._EvaluateVisitor__expressionNode_closure2.prototype = { + call$0() { + var t1 = this.expression; + return this.$this._async_evaluate0$_environment.getVariableNode$2$namespace(t1.name, t1.namespace); + }, + $signature: 219 + }; + A._EvaluateVisitor__withoutSlash_recommendation2.prototype = { + call$1(number) { + var before, after, t1, + _1_0 = number.asSlash; + $label0$0: { + if (type$.Record_2_nullable_Object_and_nullable_Object._is(_1_0)) { + before = _1_0._0; + after = _1_0._1; + t1 = "math.div(" + A.S(this.call$1(before)) + ", " + A.S(this.call$1(after)) + ")"; + break $label0$0; + } + t1 = A.serializeValue0(number, true, true); + break $label0$0; + } + return t1; + }, + $signature: 220 + }; + A._EvaluateVisitor__stackFrame_closure2.prototype = { + call$1(url) { + var t1 = this.$this._async_evaluate0$_importCache; + t1 = t1 == null ? null : t1.humanize$1(url); + return t1 == null ? url : t1; + }, + $signature: 50 + }; + A._ImportedCssVisitor2.prototype = { + visitCssAtRule$1(node) { + var t1 = node.isChildless ? null : new A._ImportedCssVisitor_visitCssAtRule_closure2(); + this._async_evaluate0$_visitor._async_evaluate0$_addChild$2$through(node, t1); + }, + visitCssComment$1(node) { + return this._async_evaluate0$_visitor._async_evaluate0$_addChild$1(node); + }, + visitCssDeclaration$1(node) { + }, + visitCssImport$1(node) { + var t2, + _s13_ = "_endOfImports", + t1 = this._async_evaluate0$_visitor; + if (t1._async_evaluate0$_assertInModule$2(t1._async_evaluate0$__parent, "__parent") !== t1._async_evaluate0$_assertInModule$2(t1._async_evaluate0$__root, "_root")) + t1._async_evaluate0$_addChild$1(node); + else if (t1._async_evaluate0$_assertInModule$2(t1._async_evaluate0$__endOfImports, _s13_) === J.get$length$asx(t1._async_evaluate0$_assertInModule$2(t1._async_evaluate0$__root, "_root").children._collection$_source)) { + t1._async_evaluate0$_addChild$1(node); + t1._async_evaluate0$__endOfImports = t1._async_evaluate0$_assertInModule$2(t1._async_evaluate0$__endOfImports, _s13_) + 1; + } else { + t2 = t1._async_evaluate0$_outOfOrderImports; + (t2 == null ? t1._async_evaluate0$_outOfOrderImports = A._setArrayType([], type$.JSArray_ModifiableCssImport_2) : t2).push(node); + } + }, + visitCssKeyframeBlock$1(node) { + }, + visitCssMediaRule$1(node) { + var t1 = this._async_evaluate0$_visitor, + mediaQueries = t1._async_evaluate0$_mediaQueries; + t1._async_evaluate0$_addChild$2$through(node, new A._ImportedCssVisitor_visitCssMediaRule_closure2(mediaQueries == null || t1._async_evaluate0$_mergeMediaQueries$2(mediaQueries, node.queries) != null)); + }, + visitCssStyleRule$1(node) { + return this._async_evaluate0$_visitor._async_evaluate0$_addChild$2$through(node, new A._ImportedCssVisitor_visitCssStyleRule_closure2()); + }, + visitCssStylesheet$1(node) { + var t1, t2, t3; + for (t1 = node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t3 = t1.__internal$_current; + (t3 == null ? t2._as(t3) : t3).accept$1(this); + } + }, + visitCssSupportsRule$1(node) { + return this._async_evaluate0$_visitor._async_evaluate0$_addChild$2$through(node, new A._ImportedCssVisitor_visitCssSupportsRule_closure2()); + } + }; + A._ImportedCssVisitor_visitCssAtRule_closure2.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._ImportedCssVisitor_visitCssMediaRule_closure2.prototype = { + call$1(node) { + var t1; + if (!(node instanceof A.ModifiableCssStyleRule0)) + t1 = this.hasBeenMerged && node instanceof A.ModifiableCssMediaRule0; + else + t1 = true; + return t1; + }, + $signature: 7 + }; + A._ImportedCssVisitor_visitCssStyleRule_closure2.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._ImportedCssVisitor_visitCssSupportsRule_closure2.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluationContext2.prototype = { + get$currentCallableSpan() { + var _0_0 = this._async_evaluate0$_visitor._async_evaluate0$_callableNode; + if (_0_0 != null) + return _0_0.get$span(_0_0); + throw A.wrapException(A.StateError$(string$.No_Sasc)); + }, + warn$2(_, message, deprecation) { + var t1 = this._async_evaluate0$_visitor, + t2 = t1._async_evaluate0$_importSpan; + if (t2 == null) { + t2 = t1._async_evaluate0$_callableNode; + t2 = t2 == null ? null : t2.get$span(t2); + } + t1._async_evaluate0$_warn$3(message, t2 == null ? this._async_evaluate0$_defaultWarnNodeWithSpan.span : t2, deprecation); + }, + $isEvaluationContext0: 1 + }; + A.JSToDartAsyncFileImporter.prototype = { + canonicalize$1(_, url) { + return this.canonicalize$body$JSToDartAsyncFileImporter(0, url); + }, + canonicalize$body$JSToDartAsyncFileImporter(_, url) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Uri), + $async$returnValue, $async$self = this, result, t1, resultUrl; + var $async$canonicalize$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if (url.get$scheme() === "file") { + $async$returnValue = $.$get$FilesystemImporter_cwd0().canonicalize$1(0, url); + // goto return + $async$goto = 1; + break; + } + result = A.wrapJSExceptions(new A.JSToDartAsyncFileImporter_canonicalize_closure($async$self, url)); + $async$goto = result != null && result instanceof self.Promise ? 3 : 4; + break; + case 3: + // then + $async$goto = 5; + return A._asyncAwait(A.promiseToFuture0(type$.Promise._as(result), type$.nullable_Object), $async$canonicalize$1); + case 5: + // returning from await. + result = $async$result; + case 4: + // join + if (result == null) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + t1 = self.URL; + if (!(result instanceof t1)) + A.jsThrow(new self.Error(string$.The_fie)); + resultUrl = A.Uri_parse(J.toString$0$(type$.JSUrl._as(result))); + if (resultUrl.get$scheme() !== "file") + A.jsThrow(new self.Error(string$.The_fiu + url.toString$0(0) + '".')); + $async$returnValue = $.$get$FilesystemImporter_cwd0().canonicalize$1(0, resultUrl); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$canonicalize$1, $async$completer); + }, + load$1(_, url) { + return $.$get$FilesystemImporter_cwd0().load$1(0, url); + }, + isNonCanonicalScheme$1(scheme) { + return scheme !== "file"; + } + }; + A.JSToDartAsyncFileImporter_canonicalize_closure.prototype = { + call$0() { + return this.$this._findFileUrl.call$2(this.url.toString$0(0), A.canonicalizeContext0()); + }, + $signature: 36 + }; + A.AsyncImportCache0.prototype = { + canonicalize$4$baseImporter$baseUrl$forImport(_, url, baseImporter, baseUrl, forImport) { + return this.canonicalize$body$AsyncImportCache0(0, url, baseImporter, baseUrl, forImport); + }, + canonicalize$body$AsyncImportCache0(_, url, baseImporter, baseUrl, forImport) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_2), + $async$returnValue, $async$self = this, t1, resolvedUrl, key, relativeResult, t2, t3, t4, t5, t6, cacheable, i, importer, perImporterKey, t7, _1_0, _1_2_isSet, result, _1_2, _2_0, _2_1, _2_5_isSet, _2_5, _2_3, _2_3_isSet, j; + var $async$canonicalize$4$baseImporter$baseUrl$forImport = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + if (A.isBrowser()) + t1 = (baseImporter == null || baseImporter instanceof A.NoOpImporter0) && $async$self._async_import_cache0$_importers.length === 0; + else + t1 = false; + if (t1) + throw A.wrapException(string$.Custom); + $async$goto = baseImporter != null && url.get$scheme() === "" ? 3 : 4; + break; + case 3: + // then + resolvedUrl = baseUrl == null ? null : baseUrl.resolveUri$1(url); + if (resolvedUrl == null) + resolvedUrl = url; + key = new A._Record_3_forImport(baseImporter, resolvedUrl, forImport); + $async$goto = 5; + return A._asyncAwait(A.putIfAbsentAsync0($async$self._async_import_cache0$_perImporterCanonicalizeCache, key, new A.AsyncImportCache_canonicalize_closure0($async$self, baseImporter, resolvedUrl, baseUrl, forImport, key, url), type$.Record_3_AsyncImporter_and_Uri_and_bool_forImport_2, type$.nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_2), $async$canonicalize$4$baseImporter$baseUrl$forImport); + case 5: + // returning from await. + relativeResult = $async$result; + if (relativeResult != null) { + $async$returnValue = relativeResult; + // goto return + $async$goto = 1; + break; + } + case 4: + // join + key = new A._Record_2_forImport(url, forImport); + t1 = $async$self._async_import_cache0$_canonicalizeCache; + if (t1.containsKey$1(key)) { + $async$returnValue = t1.$index(0, key); + // goto return + $async$goto = 1; + break; + } + t2 = $async$self._async_import_cache0$_importers, t3 = type$.Record_1_nullable_Object, t4 = $async$self._async_import_cache0$_perImporterCanonicalizeCache, t5 = type$.nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_2, t6 = type$.Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_2, cacheable = true, i = 0; + case 6: + // for condition + if (!(i < t2.length)) { + // goto after for + $async$goto = 8; + break; + } + importer = t2[i]; + perImporterKey = new A._Record_3_forImport(importer, url, forImport); + if (t4.containsKey$1(perImporterKey)) { + t7 = t4.$index(0, perImporterKey); + _1_0 = new A._Record_1(t7 == null ? t5._as(t7) : t7); + } else + _1_0 = null; + _1_2_isSet = t3._is(_1_0); + result = null; + if (_1_2_isSet) { + _1_2 = _1_0._0; + t7 = _1_2 != null; + if (t7) { + t6._as(_1_2); + result = _1_2; + } + } else { + _1_2 = null; + t7 = false; + } + if (t7) { + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + if (_1_2_isSet) + t7 = _1_2 == null; + else + t7 = false; + if (t7) { + // goto for update + $async$goto = 7; + break; + } + $async$goto = 10; + return A._asyncAwait($async$self._async_import_cache0$_canonicalize$4(importer, url, baseUrl, forImport), $async$canonicalize$4$baseImporter$baseUrl$forImport); + case 10: + // returning from await. + _2_0 = $async$result; + _2_1 = _2_0._0; + _2_5_isSet = _2_1 != null; + _2_5 = null; + _2_3 = null; + t7 = false; + if (_2_5_isSet) { + result = _2_1 == null ? t6._as(_2_1) : _2_1; + _2_3 = _2_0._1; + t7 = _2_3; + _2_5 = t7; + t7 = t7 && cacheable; + } else + result = null; + if (t7) { + t1.$indexSet(0, key, result); + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + } + if (_2_5_isSet) { + t7 = _2_5; + _2_3_isSet = _2_5_isSet; + } else { + _2_3 = _2_0._1; + t7 = _2_3; + _2_3_isSet = true; + } + t7 = t7 && !cacheable; + if (t7) { + t4.$indexSet(0, perImporterKey, _2_1); + if (_2_1 != null) { + $async$returnValue = _2_1; + // goto return + $async$goto = 1; + break; + } + // goto break $label0$1 + $async$goto = 9; + break; + } + t7 = false === (_2_3_isSet ? _2_3 : _2_0._1); + if (t7) { + if (cacheable) { + for (j = 0; j < i; ++j) + t4.$indexSet(0, new A._Record_3_forImport(t2[j], url, forImport), null); + cacheable = false; + } + if (_2_1 != null) { + $async$returnValue = _2_1; + // goto return + $async$goto = 1; + break; + } + } + case 9: + // break $label0$1 + case 7: + // for update + ++i; + // goto for condition + $async$goto = 6; + break; + case 8: + // after for + if (cacheable) + t1.$indexSet(0, key, null); + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$canonicalize$4$baseImporter$baseUrl$forImport, $async$completer); + }, + _async_import_cache0$_canonicalize$4(importer, url, baseUrl, forImport) { + return this._canonicalize$body$AsyncImportCache0(importer, url, baseUrl, forImport); + }, + _canonicalize$body$AsyncImportCache0(importer, url, baseUrl, forImport) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Record_2_nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_and_bool_2), + $async$returnValue, t1, passContainingUrl, canonicalizeContext, result, cacheable; + var $async$_async_import_cache0$_canonicalize$4 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = baseUrl != null ? 3 : 5; + break; + case 3: + // then + $async$goto = url.get$scheme() !== "" ? 6 : 8; + break; + case 6: + // then + t1 = A._Future$value(importer.isNonCanonicalScheme$1(url.get$scheme()), type$.bool); + $async$goto = 9; + return A._asyncAwait(t1, $async$_async_import_cache0$_canonicalize$4); + case 9: + // returning from await. + t1 = $async$result; + passContainingUrl = t1; + // goto join + $async$goto = 7; + break; + case 8: + // else + passContainingUrl = true; + case 7: + // join + // goto join + $async$goto = 4; + break; + case 5: + // else + passContainingUrl = false; + case 4: + // join + canonicalizeContext = new A.CanonicalizeContext0(forImport, passContainingUrl ? baseUrl : null); + t1 = type$.nullable_Object; + t1 = A.runZoned(new A.AsyncImportCache__canonicalize_closure0(importer, url), A.LinkedHashMap_LinkedHashMap$_literal([B.Symbol__canonicalizeContext, canonicalizeContext], t1, t1), type$.FutureOr_nullable_Uri); + $async$goto = 10; + return A._asyncAwait(type$.Future_nullable_Uri._is(t1) ? t1 : A._Future$value(t1, type$.nullable_Uri), $async$_async_import_cache0$_canonicalize$4); + case 10: + // returning from await. + result = $async$result; + cacheable = !passContainingUrl || !canonicalizeContext._canonicalize_context$_wasContainingUrlAccessed; + if (result == null) { + $async$returnValue = new A._Record_2(null, cacheable); + // goto return + $async$goto = 1; + break; + } + $async$goto = result.get$scheme() !== "" ? 11 : 13; + break; + case 11: + // then + t1 = A._Future$value(importer.isNonCanonicalScheme$1(result.get$scheme()), type$.bool); + $async$goto = 14; + return A._asyncAwait(t1, $async$_async_import_cache0$_canonicalize$4); + case 14: + // returning from await. + t1 = $async$result; + // goto join + $async$goto = 12; + break; + case 13: + // else + t1 = false; + case 12: + // join + if (t1) + throw A.wrapException("Importer " + importer.toString$0(0) + " canonicalized " + url.toString$0(0) + " to " + result.toString$0(0) + string$.x2c_whicu); + $async$returnValue = new A._Record_2(new A._Record_3_originalUrl(importer, result, url), cacheable); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_async_import_cache0$_canonicalize$4, $async$completer); + }, + importCanonical$3$originalUrl(importer, canonicalUrl, originalUrl) { + return this.importCanonical$body$AsyncImportCache0(importer, canonicalUrl, originalUrl); + }, + importCanonical$body$AsyncImportCache0(importer, canonicalUrl, originalUrl) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Stylesheet_2), + $async$returnValue, $async$self = this; + var $async$importCanonical$3$originalUrl = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$goto = 3; + return A._asyncAwait(A.putIfAbsentAsync0($async$self._async_import_cache0$_importCache, canonicalUrl, new A.AsyncImportCache_importCanonical_closure0($async$self, importer, canonicalUrl, originalUrl), type$.Uri, type$.nullable_Stylesheet_2), $async$importCanonical$3$originalUrl); + case 3: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$importCanonical$3$originalUrl, $async$completer); + }, + humanize$1(canonicalUrl) { + var t1 = this._async_import_cache0$_canonicalizeCache, + t2 = type$.NonNullsIterable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_2; + t2 = A.NullableExtension_andThen0(A.minBy(new A.MappedIterable(new A.WhereIterable(new A.NonNullsIterable(new A.LinkedHashMapValuesIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapValuesIterable<2>")), t2), new A.AsyncImportCache_humanize_closure3(canonicalUrl), t2._eval$1("WhereIterable")), new A.AsyncImportCache_humanize_closure4(), t2._eval$1("MappedIterable")), new A.AsyncImportCache_humanize_closure5()), new A.AsyncImportCache_humanize_closure6(canonicalUrl)); + return t2 == null ? canonicalUrl : t2; + }, + sourceMapUrl$1(_, canonicalUrl) { + var t1 = this._async_import_cache0$_resultsCache.$index(0, canonicalUrl); + t1 = t1 == null ? null : t1.get$sourceMapUrl(0); + return t1 == null ? canonicalUrl : t1; + } + }; + A.AsyncImportCache_canonicalize_closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_2), + $async$returnValue, $async$self = this, t1, t2, _0_0, result; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.$this; + t2 = $async$self.baseUrl; + $async$goto = 3; + return A._asyncAwait(t1._async_import_cache0$_canonicalize$4($async$self.baseImporter, $async$self.resolvedUrl, t2, $async$self.forImport), $async$call$0); + case 3: + // returning from await. + _0_0 = $async$result; + result = _0_0._0; + _0_0._1; + if (t2 != null) + t1._async_import_cache0$_nonCanonicalRelativeUrls.$indexSet(0, $async$self.key, $async$self.url); + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 362 + }; + A.AsyncImportCache__canonicalize_closure0.prototype = { + call$0() { + return this.importer.canonicalize$1(0, this.url); + }, + $signature: 182 + }; + A.AsyncImportCache_importCanonical_closure0.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Stylesheet_2), + $async$returnValue, $async$self = this, t1, t2, t3, result; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = Date.now(); + t2 = $async$self.canonicalUrl; + t3 = $async$self.importer.load$1(0, t2); + $async$goto = 3; + return A._asyncAwait(type$.Future_nullable_ImporterResult._is(t3) ? t3 : A._Future$value(t3, type$.nullable_ImporterResult_2), $async$call$0); + case 3: + // returning from await. + result = $async$result; + if (result == null) { + $async$returnValue = null; + // goto return + $async$goto = 1; + break; + } + t3 = $async$self.$this; + t3._async_import_cache0$_loadTimes.$indexSet(0, t2, new A.DateTime(t1, 0, false)); + t3._async_import_cache0$_resultsCache.$indexSet(0, t2, result); + t3 = result.contents; + t1 = result.syntax; + t2 = $async$self.originalUrl.resolveUri$1(t2); + $async$returnValue = A.Stylesheet_Stylesheet$parse0(t3, t1, t2); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 363 + }; + A.AsyncImportCache_humanize_closure3.prototype = { + call$1(result) { + return result._1.$eq(0, this.canonicalUrl); + }, + $signature: 364 + }; + A.AsyncImportCache_humanize_closure4.prototype = { + call$1(result) { + return result._2; + }, + $signature: 365 + }; + A.AsyncImportCache_humanize_closure5.prototype = { + call$1(url) { + return url.get$path(url).length; + }, + $signature: 80 + }; + A.AsyncImportCache_humanize_closure6.prototype = { + call$1(url) { + var t1 = $.$get$url(), + t2 = this.canonicalUrl; + return url.resolve$1(0, A.ParsedPath_ParsedPath$parse(t2.get$path(t2), t1.style).get$basename()); + }, + $signature: 50 + }; + A.AtRootQueryParser0.prototype = { + parse$0(_) { + return this.wrapSpanFormatException$1(new A.AtRootQueryParser_parse_closure0(this)); + } + }; + A.AtRootQueryParser_parse_closure0.prototype = { + call$0() { + var include, atRules, + t1 = this.$this, + t2 = t1.scanner; + t2.expectChar$1(40); + t1.whitespace$1$consumeNewlines(true); + include = t1.scanIdentifier$1("with"); + if (!include) + t1.expectIdentifier$2$name("without", '"with" or "without"'); + t1.whitespace$1$consumeNewlines(true); + t2.expectChar$1(58); + t1.whitespace$1$consumeNewlines(true); + atRules = A.LinkedHashSet_LinkedHashSet$_empty(type$.String); + do { + atRules.add$1(0, t1.identifier$0().toLowerCase()); + t1.whitespace$1$consumeNewlines(true); + } while (t1.lookingAtIdentifier$0()); + t2.expectChar$1(41); + t2.expectDone$0(); + return new A.AtRootQuery0(include, atRules, atRules.contains$1(0, "all"), atRules.contains$1(0, "rule")); + }, + $signature: 366 + }; + A.AtRootQuery0.prototype = { + excludes$1(node) { + var t1, _this = this; + if (_this._at_root_query0$_all) + return !_this.include; + $label0$0: { + if (node instanceof A.ModifiableCssStyleRule0) { + t1 = _this._at_root_query0$_rule !== _this.include; + break $label0$0; + } + if (node instanceof A.ModifiableCssMediaRule0) { + t1 = _this.excludesName$1("media"); + break $label0$0; + } + if (node instanceof A.ModifiableCssSupportsRule0) { + t1 = _this.excludesName$1("supports"); + break $label0$0; + } + if (node instanceof A.ModifiableCssAtRule0) { + t1 = _this.excludesName$1(node.name.value.toLowerCase()); + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + excludesName$1($name) { + var t1 = this._at_root_query0$_all || this.names.contains$1(0, $name); + return t1 !== this.include; + } + }; + A.AtRootRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitAtRootRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var buffer = new A.StringBuffer("@at-root "), + t1 = this.query; + if (t1 != null) + buffer._contents = "@at-root " + (t1.toString$0(0) + " "); + t1 = this.children; + return buffer.toString$0(0) + " {" + (t1 && B.JSArray_methods).join$1(t1, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.ModifiableCssAtRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitCssAtRule$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + equalsIgnoringChildren$1(other) { + var t1, t2; + if (other instanceof A.ModifiableCssAtRule0) { + t1 = this.name; + t2 = other.name; + t1 = t1.$ti._is(t2) && J.$eq$(t2.value, t1.value) && J.$eq$(this.value, other.value) && this.isChildless === other.isChildless; + } else + t1 = false; + return t1; + }, + copyWithoutChildren$0() { + var _this = this; + return A.ModifiableCssAtRule$0(_this.name, _this.span, _this.isChildless, _this.value); + }, + addChild$1(child) { + this.super$ModifiableCssParentNode$addChild0(child); + }, + get$isChildless() { + return this.isChildless; + }, + get$span(receiver) { + return this.span; + } + }; + A.AtRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitAtRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var children, + t1 = "@" + this.name.toString$0(0), + buffer = new A.StringBuffer(t1), + t2 = this.value; + if (t2 != null) + buffer._contents = t1 + (" " + t2.toString$0(0)); + children = this.children; + return children == null ? buffer.toString$0(0) + ";" : buffer.toString$0(0) + " {" + B.JSArray_methods.join$1(children, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.AttributeSelector0.prototype = { + accept$1$1(visitor) { + return visitor.visitAttributeSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + $eq(_, other) { + var _this = this; + if (other == null) + return false; + return other instanceof A.AttributeSelector0 && other.name.$eq(0, _this.name) && other.op == _this.op && other.value == _this.value && other.modifier == _this.modifier; + }, + get$hashCode(_) { + var _this = this, + t1 = _this.name; + return (B.JSString_methods.get$hashCode(t1.name) ^ J.get$hashCode$(t1.namespace) ^ J.get$hashCode$(_this.op) ^ J.get$hashCode$(_this.value) ^ J.get$hashCode$(_this.modifier)) >>> 0; + } + }; + A.AttributeOperator0.prototype = { + _enumToString$0() { + return "AttributeOperator." + this._name; + }, + toString$0(_) { + return this._attribute0$_text; + } + }; + A.BinaryOperationExpression0.prototype = { + get$span(_) { + var right, + left = this.left; + for (; left instanceof A.BinaryOperationExpression0;) + left = left.left; + right = this.right; + for (; right instanceof A.BinaryOperationExpression0;) + right = right.right; + return left.get$span(left).expand$1(0, right.get$span(right)); + }, + get$operatorSpan() { + var t3, t4, + t1 = this.left, + t2 = t1.get$span(t1); + t2 = t2.get$file(t2); + t3 = this.right; + t4 = t3.get$span(t3); + if (t2 === t4.get$file(t4)) { + t2 = t1.get$span(t1); + t2 = t2.get$end(t2); + t4 = t3.get$span(t3); + t4 = t2.offset < t4.get$start(t4).offset; + t2 = t4; + } else + t2 = false; + if (t2) { + t2 = t1.get$span(t1); + t2 = t2.get$file(t2); + t1 = t1.get$span(t1); + t1 = t1.get$end(t1); + t3 = t3.get$span(t3); + t3 = A.SpanExtensions_trimRight0(A.SpanExtensions_trimLeft0(t2.span$2(0, t1.offset, t3.get$start(t3).offset))); + t1 = t3; + } else + t1 = this.get$span(0); + return t1; + }, + accept$1$1(visitor) { + return visitor.visitBinaryOperationExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1, t2, right, t3, operator, _this = this, + _0_0 = _this.left; + $label0$0: { + if (_0_0 instanceof A.BinaryOperationExpression0) { + t1 = _0_0.operator.precedence < _this.operator.precedence; + break $label0$0; + } + if (_0_0 instanceof A.ListExpression0 && !_0_0.hasBrackets && _0_0.contents.length >= 2) { + t1 = true; + break $label0$0; + } + t1 = false; + break $label0$0; + } + t2 = t1 ? "" + A.Primitives_stringFromCharCode(40) : ""; + t2 += _0_0.toString$0(0); + t1 = t1 ? t2 + A.Primitives_stringFromCharCode(41) : t2; + t2 = _this.operator; + t1 = t1 + A.Primitives_stringFromCharCode(32) + t2.operator + A.Primitives_stringFromCharCode(32); + right = _this.right; + $label1$1: { + t3 = false; + if (right instanceof A.BinaryOperationExpression0) { + operator = right.operator; + if (operator.precedence <= t2.precedence) { + t3 = !(operator === t2 && operator.isAssociative); + t2 = t3; + } else + t2 = t3; + break $label1$1; + } + if (right instanceof A.ListExpression0 && !right.hasBrackets && right.contents.length >= 2) { + t2 = true; + break $label1$1; + } + t2 = t3; + break $label1$1; + } + if (t2) + t1 += A.Primitives_stringFromCharCode(40); + t1 += right.toString$0(0); + if (t2) + t1 += A.Primitives_stringFromCharCode(41); + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + }; + A.BinaryOperator0.prototype = { + _enumToString$0() { + return "BinaryOperator." + this._name; + }, + toString$0(_) { + return this.name; + } + }; + A.BooleanExpression0.prototype = { + accept$1$1(visitor) { + return visitor.visitBooleanExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return String(this.value); + }, + get$span(receiver) { + return this.span; + } + }; + A.booleanClass_closure.prototype = { + call$0() { + var t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.SassBoolean", new A.booleanClass__closure())); + A.JSClassExtension_injectSuperclass(t1._as(B.SassBoolean_true0.constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.booleanClass__closure.prototype = { + call$2($self, _) { + A.jsThrow(new self.Error("new sass.SassBoolean() isn't allowed.\nUse sass.sassTrue or sass.sassFalse instead.")); + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 221 + }; + A.legacyBooleanClass_closure.prototype = { + call$0() { + var t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.types.Boolean", new A.legacyBooleanClass__closure())); + J.get$$prototype$x(jsClass).getValue = A.allowInteropCaptureThisNamed("getValue", new A.legacyBooleanClass__closure0()); + jsClass.TRUE = B.SassBoolean_true0; + jsClass.FALSE = B.SassBoolean_false0; + A.JSClassExtension_injectSuperclass(t1._as(B.SassBoolean_true0.constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.legacyBooleanClass__closure.prototype = { + call$2(_, __) { + throw A.wrapException("new sass.types.Boolean() isn't allowed.\nUse sass.types.Boolean.TRUE or sass.types.Boolean.FALSE instead."); + }, + call$1(_) { + return this.call$2(_, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 222 + }; + A.legacyBooleanClass__closure0.prototype = { + call$1($self) { + return $self === B.SassBoolean_true0; + }, + $signature: 77 + }; + A.SassBoolean0.prototype = { + get$isTruthy() { + return this.value; + }, + accept$1$1(visitor) { + return visitor._serialize0$_buffer.write$1(0, String(this.value)); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + assertBoolean$1($name) { + return this; + }, + unaryNot$0() { + return this.value ? B.SassBoolean_false0 : B.SassBoolean_true0; + } + }; + A.Box0.prototype = { + $eq(_, other) { + if (other == null) + return false; + return this.$ti._is(other) && other._box0$_inner === this._box0$_inner; + }, + get$hashCode(_) { + return A.Primitives_objectHashCode(this._box0$_inner); + } + }; + A.ModifiableBox0.prototype = {}; + A.BuiltInCallable0.prototype = { + callbackFor$2(positional, names) { + var t1, t2, fuzzyMatch, minMismatchDistance, _i, overload, t3, mismatchDistance, t4; + for (t1 = this._built_in$_overloads, t2 = t1.length, fuzzyMatch = null, minMismatchDistance = null, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + overload = t1[_i]; + t3 = overload._0; + if (t3.matches$2(positional, names)) + return overload; + mismatchDistance = t3.parameters.length - positional; + if (minMismatchDistance != null) { + t3 = Math.abs(mismatchDistance); + t4 = Math.abs(minMismatchDistance); + if (t3 > t4) + continue; + if (t3 === t4 && mismatchDistance < 0) + continue; + } + minMismatchDistance = mismatchDistance; + fuzzyMatch = overload; + } + if (fuzzyMatch != null) + return fuzzyMatch; + throw A.wrapException(A.StateError$("BuiltInCallable " + this.name + " may not have empty overloads.")); + }, + withName$1($name) { + return new A.BuiltInCallable0($name, this._built_in$_overloads, this.acceptsContent); + }, + withDeprecationWarning$2(module, newName) { + var t2, t3, _i, t4, t5, _this = this, + t1 = A._setArrayType([], type$.JSArray_Record_2_ParameterList_and_Value_Function_List_Value_2); + for (t2 = _this._built_in$_overloads, t3 = t2.length, _i = 0; _i < t2.length; t2.length === t3 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + t4 = {}; + t5 = t2[_i]; + t4.$function = null; + t4.$function = t5._1; + t1.push(new A._Record_2(t5._0, new A.BuiltInCallable_withDeprecationWarning_closure0(t4, _this, module, newName))); + } + return new A.BuiltInCallable0(_this.name, t1, _this.acceptsContent); + }, + withDeprecationWarning$1(module) { + return this.withDeprecationWarning$2(module, null); + }, + $isAsyncCallable0: 1, + $isAsyncBuiltInCallable0: 1, + $isCallable: 1, + get$name(receiver) { + return this.name; + }, + get$acceptsContent() { + return this.acceptsContent; + } + }; + A.BuiltInCallable$mixin_closure0.prototype = { + call$1($arguments) { + this.callback.call$1($arguments); + return B.C__SassNull0; + }, + $signature: 3 + }; + A.BuiltInCallable_withDeprecationWarning_closure0.prototype = { + call$1(args) { + var _this = this, + t1 = _this.newName; + if (t1 == null) + t1 = _this.$this.name; + A.warnForDeprecation0(string$.Global + _this.module + "." + t1 + string$.x20inste, B.Deprecation_ZDV); + return _this._box_0.$function.call$1(args); + }, + $signature: 3 + }; + A.BuiltInModule0.prototype = { + get$upstream() { + return B.List_empty19; + }, + get$variableNodes() { + return B.Map_empty13; + }, + get$extensionStore() { + return B.C_EmptyExtensionStore0; + }, + get$css(_) { + return new A.CssStylesheet0(B.List_empty17, A.SourceFile$decoded(B.List_empty4, this.url).span$2(0, 0, 0)); + }, + get$preModuleComments() { + return B.Map_empty12; + }, + get$transitivelyContainsCss() { + return false; + }, + get$transitivelyContainsExtensions() { + return false; + }, + setVariable$3($name, value, nodeWithSpan) { + if (!this.variables.containsKey$1($name)) + throw A.wrapException(A.SassScriptException$0("Undefined variable.", null)); + throw A.wrapException(A.SassScriptException$0("Cannot modify built-in variable.", null)); + }, + variableIdentity$1($name) { + return this; + }, + cloneCss$0() { + return this; + }, + $isModule1: 1, + get$url(receiver) { + return this.url; + }, + get$functions(receiver) { + return this.functions; + }, + get$mixins() { + return this.mixins; + }, + get$variables() { + return this.variables; + } + }; + A.calculationClass_closure.prototype = { + call$0() { + var t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.SassCalculation", new A.calculationClass__closure())), + t2 = type$.String, + t3 = type$.Function; + A.LinkedHashMap_LinkedHashMap$_literal(["calc", new A.calculationClass__closure0(), "min", new A.calculationClass__closure1(), "max", new A.calculationClass__closure2(), "clamp", new A.calculationClass__closure3()], t2, t3).forEach$1(0, A.JSClassExtension_get_defineStaticMethod(jsClass)); + A.LinkedHashMap_LinkedHashMap$_literal(["assertCalculation", new A.calculationClass__closure4()], t2, t3).forEach$1(0, A.JSClassExtension_get_defineMethod(jsClass)); + A.LinkedHashMap_LinkedHashMap$_literal(["arguments", new A.calculationClass__closure5()], t2, t3).forEach$1(0, A.JSClassExtension_get_defineGetter(jsClass)); + A.JSClassExtension_injectSuperclass(t1._as(new A.SassCalculation0("calc", A.List_List$unmodifiable(A._setArrayType([A.SassNumber_SassNumber0(1, null)], type$.JSArray_Object), type$.Object)).constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.calculationClass__closure.prototype = { + call$2($self, _) { + A.jsThrow0(new self.Error("new sass.SassCalculation() isn't allowed")); + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 221 + }; + A.calculationClass__closure0.prototype = { + call$1(argument) { + A._assertCalculationValue(argument); + return new A.SassCalculation0("calc", A.List_List$unmodifiable(A._setArrayType([argument], type$.JSArray_Object), type$.Object)); + }, + $signature: 115 + }; + A.calculationClass__closure1.prototype = { + call$1($arguments) { + var t1 = self.immutable.isOrderedMap($arguments) ? J.toArray$0$x(type$.ImmutableList_2._as($arguments)) : type$.List_dynamic._as($arguments), + t2 = type$.Object, + argList = J.cast$1$0$ax(t1, t2); + argList.forEach$1(argList, A.calculation1___assertCalculationValue$closure()); + return new A.SassCalculation0("min", A.List_List$unmodifiable(argList, t2)); + }, + $signature: 115 + }; + A.calculationClass__closure2.prototype = { + call$1($arguments) { + var t1 = self.immutable.isOrderedMap($arguments) ? J.toArray$0$x(type$.ImmutableList_2._as($arguments)) : type$.List_dynamic._as($arguments), + t2 = type$.Object, + argList = J.cast$1$0$ax(t1, t2); + argList.forEach$1(argList, A.calculation1___assertCalculationValue$closure()); + return new A.SassCalculation0("max", A.List_List$unmodifiable(argList, t2)); + }, + $signature: 115 + }; + A.calculationClass__closure3.prototype = { + call$3(min, value, max) { + var t1; + if (!(value == null && !A._isValidClampArg(min))) + t1 = max == null && !B.JSArray_methods.any$1([min, value], A.calculation1___isValidClampArg$closure()); + else + t1 = true; + if (t1) + A.jsThrow0(new self.Error("Expected at least one SassString or CalculationInterpolation in `" + new A.NonNullsIterable([min, value, max], type$.NonNullsIterable_Object).toString$0(0) + "`")); + t1 = type$.NonNullsIterable_Object; + new A.NonNullsIterable([min, value, max], t1).forEach$1(0, A.calculation1___assertCalculationValue$closure()); + return new A.SassCalculation0("clamp", A.List_List$unmodifiable(new A.NonNullsIterable([min, value, max], t1), type$.Object)); + }, + call$1(min) { + return this.call$3(min, null, null); + }, + call$2(min, value) { + return this.call$3(min, value, null); + }, + "call*": "call$3", + $requiredArgCount: 1, + $defaultValues() { + return [null, null]; + }, + $signature: 371 + }; + A.calculationClass__closure4.prototype = { + call$2($self, $name) { + return $self; + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 372 + }; + A.calculationClass__closure5.prototype = { + call$1($self) { + return new self.immutable.List($self.$arguments); + }, + $signature: 373 + }; + A.calculationOperationClass_closure.prototype = { + call$0() { + var _null = null, + t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.CalculationOperation", new A.calculationOperationClass__closure())), + t2 = type$.String, + t3 = type$.Function; + A.LinkedHashMap_LinkedHashMap$_literal(["equals", new A.calculationOperationClass__closure0(), "hashCode", new A.calculationOperationClass__closure1()], t2, t3).forEach$1(0, A.JSClassExtension_get_defineMethod(jsClass)); + A.LinkedHashMap_LinkedHashMap$_literal(["operator", new A.calculationOperationClass__closure2(), "left", new A.calculationOperationClass__closure3(), "right", new A.calculationOperationClass__closure4()], t2, t3).forEach$1(0, A.JSClassExtension_get_defineGetter(jsClass)); + A.JSClassExtension_injectSuperclass(t1._as(A.SassCalculation_operateInternal0(B.CalculationOperator_F7i0, A.SassNumber_SassNumber0(1, _null), A.SassNumber_SassNumber0(1, _null), _null, false, _null).constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.calculationOperationClass__closure.prototype = { + call$4($self, strOperator, left, right) { + var operator = A.IterableExtension_firstWhereOrNull(B.List_g9w, new A.calculationOperationClass___closure(strOperator)); + if (operator == null) + A.jsThrow0(new self.Error("Invalid operator: " + strOperator)); + A._assertCalculationValue(left); + A._assertCalculationValue(right); + return A.SassCalculation_operateInternal0(operator, left, right, null, false, null); + }, + "call*": "call$4", + $requiredArgCount: 4, + $signature: 374 + }; + A.calculationOperationClass___closure.prototype = { + call$1(value) { + return value.operator === this.strOperator; + }, + $signature: 375 + }; + A.calculationOperationClass__closure0.prototype = { + call$2($self, other) { + return $self.$eq(0, other); + }, + $signature: 376 + }; + A.calculationOperationClass__closure1.prototype = { + call$1($self) { + return $self.get$hashCode(0); + }, + $signature: 377 + }; + A.calculationOperationClass__closure2.prototype = { + call$1($self) { + return $self._calculation0$_operator.operator; + }, + $signature: 378 + }; + A.calculationOperationClass__closure3.prototype = { + call$1($self) { + return $self._calculation0$_left; + }, + $signature: 223 + }; + A.calculationOperationClass__closure4.prototype = { + call$1($self) { + return $self._calculation0$_right; + }, + $signature: 223 + }; + A.calculationInterpolationClass_closure.prototype = { + call$0() { + var t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.CalculationInterpolation", new A.calculationInterpolationClass__closure())), + t2 = type$.String, + t3 = type$.Function; + A.LinkedHashMap_LinkedHashMap$_literal(["equals", new A.calculationInterpolationClass__closure0(), "hashCode", new A.calculationInterpolationClass__closure1()], t2, t3).forEach$1(0, A.JSClassExtension_get_defineMethod(jsClass)); + A.LinkedHashMap_LinkedHashMap$_literal(["value", new A.calculationInterpolationClass__closure2()], t2, t3).forEach$1(0, A.JSClassExtension_get_defineGetter(jsClass)); + A.JSClassExtension_injectSuperclass(t1._as(new A.CalculationInterpolation("").constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.calculationInterpolationClass__closure.prototype = { + call$2($self, value) { + return new A.CalculationInterpolation(value); + }, + $signature: 380 + }; + A.calculationInterpolationClass__closure0.prototype = { + call$2($self, other) { + return other instanceof A.CalculationInterpolation && $self._calculation0$_value === other._calculation0$_value; + }, + $signature: 381 + }; + A.calculationInterpolationClass__closure1.prototype = { + call$1($self) { + return B.JSString_methods.get$hashCode($self._calculation0$_value); + }, + $signature: 382 + }; + A.calculationInterpolationClass__closure2.prototype = { + call$1($self) { + return $self._calculation0$_value; + }, + $signature: 383 + }; + A.SassCalculation0.prototype = { + get$isSpecialNumber() { + return true; + }, + accept$1$1(visitor) { + return visitor.visitCalculation$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + assertCalculation$1($name) { + return this; + }, + plus$1(other) { + if (other instanceof A.SassString0) + return this.super$Value$plus0(other); + throw A.wrapException(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " + " + other.toString$0(0) + '".', null)); + }, + minus$1(other) { + return A.throwExpression(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " - " + other.toString$0(0) + '".', null)); + }, + unaryPlus$0() { + return A.throwExpression(A.SassScriptException$0('Undefined operation "+' + this.toString$0(0) + '".', null)); + }, + unaryMinus$0() { + return A.throwExpression(A.SassScriptException$0('Undefined operation "-' + this.toString$0(0) + '".', null)); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.SassCalculation0 && this.name === other.name && B.C_ListEquality.equals$2(0, this.$arguments, other.$arguments); + }, + get$hashCode(_) { + return B.JSString_methods.get$hashCode(this.name) ^ B.C_ListEquality0.hash$1(this.$arguments); + } + }; + A.SassCalculation__verifyLength_closure0.prototype = { + call$1(arg) { + return arg instanceof A.SassString0; + }, + $signature: 77 + }; + A.CalculationOperation0.prototype = { + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.CalculationOperation0 && this._calculation0$_operator === other._calculation0$_operator && J.$eq$(this._calculation0$_left, other._calculation0$_left) && J.$eq$(this._calculation0$_right, other._calculation0$_right); + }, + get$hashCode(_) { + return (A.Primitives_objectHashCode(this._calculation0$_operator) ^ J.get$hashCode$(this._calculation0$_left) ^ J.get$hashCode$(this._calculation0$_right)) >>> 0; + }, + toString$0(_) { + var parenthesized = A.serializeValue0(new A.SassCalculation0("", A._setArrayType([this], type$.JSArray_Object)), true, true); + return B.JSString_methods.substring$2(parenthesized, 1, parenthesized.length - 1); + } + }; + A.CalculationOperator0.prototype = { + _enumToString$0() { + return "CalculationOperator." + this._name; + }, + toString$0(_) { + return this.name; + } + }; + A.CalculationInterpolation.prototype = { + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.CalculationInterpolation && this._calculation0$_value === other._calculation0$_value; + }, + get$hashCode(_) { + return B.JSString_methods.get$hashCode(this._calculation0$_value); + }, + toString$0(_) { + return this._calculation0$_value; + } + }; + A.CallableDeclaration0.prototype = { + get$span(receiver) { + return this.span; + } + }; + A.updateCanonicalizeContextPrototype_closure.prototype = { + call$1($self) { + return $self._canonicalize_context$_fromImport; + }, + $signature: 384 + }; + A.updateCanonicalizeContextPrototype_closure0.prototype = { + call$1($self) { + $self._canonicalize_context$_wasContainingUrlAccessed = true; + return A.NullableExtension_andThen0($self._canonicalize_context$_containingUrl, A.utils3__dartToJSUrl$closure()); + }, + $signature: 385 + }; + A.CanonicalizeContext0.prototype = { + withFromImport$1$2(fromImport, callback) { + var t1, + oldFromImport = this._canonicalize_context$_fromImport; + this._canonicalize_context$_fromImport = true; + try { + t1 = callback.call$0(); + return t1; + } finally { + this._canonicalize_context$_fromImport = oldFromImport; + } + }, + withFromImport$2(fromImport, callback) { + return this.withFromImport$1$2(fromImport, callback, type$.dynamic); + } + }; + A.ColorChannel0.prototype = { + isAnalogous$1(other) { + var _0_6_isSet, t1, _0_60, t2, _0_6_isSet0, + _0_1 = this.name, + _0_6 = other.name; + $label0$0: { + if ("red" !== _0_1) + _0_6_isSet = "x" === _0_1; + else + _0_6_isSet = true; + if (_0_6_isSet) { + if ("red" !== _0_6) + t1 = "x" === _0_6; + else + t1 = true; + _0_60 = _0_6; + } else { + _0_60 = null; + t1 = false; + } + t2 = true; + if (!t1) { + if ("green" !== _0_1) + t1 = "y" === _0_1; + else + t1 = true; + if (t1) { + _0_6_isSet0 = true; + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t1; + } + if ("green" !== t1) { + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t1; + } + t1 = "y" === t1; + } else + t1 = true; + } else + t1 = false; + if (!t1) { + if ("blue" !== _0_1) + t1 = "z" === _0_1; + else + t1 = true; + if (t1) { + _0_6_isSet0 = true; + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t1; + } + if ("blue" !== t1) { + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t1; + } + t1 = "z" === t1; + } else + t1 = true; + } else + t1 = false; + if (!t1) { + if ("chroma" !== _0_1) + t1 = "saturation" === _0_1; + else + t1 = true; + if (t1) { + _0_6_isSet0 = true; + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t1; + } + if ("chroma" !== t1) { + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_6_isSet = _0_6_isSet0; + _0_60 = t1; + } + t1 = "saturation" === t1; + } else + t1 = true; + } else + t1 = false; + if (!t1) { + if ("lightness" === _0_1) { + if (_0_6_isSet) + t1 = _0_60; + else { + t1 = _0_6; + _0_60 = t1; + _0_6_isSet = true; + } + t1 = "lightness" === t1; + } else + t1 = false; + if (!t1) + if ("hue" === _0_1) + t1 = "hue" === (_0_6_isSet ? _0_60 : _0_6); + else + t1 = false; + else + t1 = t2; + } else + t1 = t2; + } else + t1 = t2; + } else + t1 = t2; + } else + t1 = t2; + if (t1) + break $label0$0; + break $label0$0; + } + return t1; + } + }; + A.LinearChannel0.prototype = {}; + A.Chokidar0.prototype = {}; + A.ChokidarOptions0.prototype = {}; + A.ChokidarWatcher0.prototype = {}; + A.ClassSelector0.prototype = { + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.ClassSelector0 && other.name === this.name; + }, + accept$1$1(visitor) { + return visitor.visitClassSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + addSuffix$1(suffix) { + return new A.ClassSelector0(this.name + suffix, this.span); + }, + get$hashCode(_) { + return B.JSString_methods.get$hashCode(this.name); + } + }; + A.ClipGamutMap0.prototype = { + map$1(_, color) { + var t1 = color._color0$_space, + t2 = t1._space$_channels; + return A.SassColor_SassColor$forSpaceInternal0(t1, this._clip$_clampChannel$2(color.channel0OrNull, t2[0]), this._clip$_clampChannel$2(color.channel1OrNull, t2[1]), this._clip$_clampChannel$2(color.channel2OrNull, t2[2]), color.alphaOrNull); + }, + _clip$_clampChannel$2(value, channel) { + var t1, min; + if (value == null) + t1 = null; + else + $label0$0: { + if (channel instanceof A.LinearChannel0) { + min = channel.min; + t1 = isNaN(value) ? min : B.JSNumber_methods.clamp$2(value, min, channel.max); + break $label0$0; + } + t1 = value; + break $label0$0; + } + return t1; + } + }; + A._CloneCssVisitor0.prototype = { + visitCssAtRule$1(node) { + var t1 = node.isChildless, + rule = A.ModifiableCssAtRule$0(node.name, node.span, t1, node.value); + return t1 ? rule : this._clone_css$_visitChildren$2(rule, node); + }, + visitCssComment$1(node) { + return new A.ModifiableCssComment0(node.text, node.span); + }, + visitCssDeclaration$1(node) { + return A.ModifiableCssDeclaration$0(node.name, node.value, node.span, null, node.parsedAsCustomProperty, null, node.valueSpanForMap); + }, + visitCssImport$1(node) { + return new A.ModifiableCssImport0(node.url, node.modifiers, node.span); + }, + visitCssKeyframeBlock$1(node) { + return this._clone_css$_visitChildren$2(A.ModifiableCssKeyframeBlock$0(node.selector, node.span), node); + }, + visitCssMediaRule$1(node) { + return this._clone_css$_visitChildren$2(A.ModifiableCssMediaRule$0(node.queries, node.span), node); + }, + visitCssStyleRule$1(node) { + var _0_0 = this._clone_css$_oldToNewSelectors.$index(0, node._style_rule0$_selector._box0$_inner.value); + if (_0_0 != null) + return this._clone_css$_visitChildren$2(A.ModifiableCssStyleRule$0(_0_0, node.span, false, node.originalSelector), node); + else + throw A.wrapException(A.StateError$(string$.The_Ex)); + }, + visitCssStylesheet$1(node) { + return this._clone_css$_visitChildren$2(A.ModifiableCssStylesheet$0(node.get$span(node)), node); + }, + visitCssSupportsRule$1(node) { + return this._clone_css$_visitChildren$2(A.ModifiableCssSupportsRule$0(node.condition, node.span), node); + }, + _clone_css$_visitChildren$1$2(newParent, oldParent) { + var t1, t2, newChild; + for (t1 = J.get$iterator$ax(oldParent.get$children(oldParent)); t1.moveNext$0();) { + t2 = t1.get$current(t1); + newChild = t2.accept$1(this); + newChild.isGroupEnd = t2.get$isGroupEnd(); + newParent.addChild$1(newChild); + } + return newParent; + }, + _clone_css$_visitChildren$2(newParent, oldParent) { + return this._clone_css$_visitChildren$1$2(newParent, oldParent, type$.ModifiableCssParentNode_2); + } + }; + A.ColorExpression0.prototype = { + accept$1$1(visitor) { + return visitor.visitColorExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return A.serializeValue0(this.value, true, true); + }, + get$span(receiver) { + return this.span; + } + }; + A.global_closure44.prototype = { + call$1(color) { + return B.JSNumber_methods.round$0(color._color0$_legacyChannel$2(B.RgbColorSpace_i0P0, "red")); + }, + $signature: 39 + }; + A.global_closure45.prototype = { + call$1(color) { + return B.JSNumber_methods.round$0(color._color0$_legacyChannel$2(B.RgbColorSpace_i0P0, "green")); + }, + $signature: 39 + }; + A.global_closure46.prototype = { + call$1(color) { + return B.JSNumber_methods.round$0(color._color0$_legacyChannel$2(B.RgbColorSpace_i0P0, "blue")); + }, + $signature: 39 + }; + A.global_closure47.prototype = { + call$1($arguments) { + return A._rgb0("rgb", $arguments); + }, + $signature: 3 + }; + A.global_closure48.prototype = { + call$1($arguments) { + return A._rgb0("rgb", $arguments); + }, + $signature: 3 + }; + A.global_closure49.prototype = { + call$1($arguments) { + return A._rgbTwoArg0("rgb", $arguments); + }, + $signature: 3 + }; + A.global_closure50.prototype = { + call$1($arguments) { + return A._parseChannels0("rgb", J.$index$asx($arguments, 0), "channels", B.RgbColorSpace_i0P0); + }, + $signature: 3 + }; + A.global_closure51.prototype = { + call$1($arguments) { + return A._rgb0("rgba", $arguments); + }, + $signature: 3 + }; + A.global_closure52.prototype = { + call$1($arguments) { + return A._rgb0("rgba", $arguments); + }, + $signature: 3 + }; + A.global_closure53.prototype = { + call$1($arguments) { + return A._rgbTwoArg0("rgba", $arguments); + }, + $signature: 3 + }; + A.global_closure54.prototype = { + call$1($arguments) { + return A._parseChannels0("rgba", J.$index$asx($arguments, 0), "channels", B.RgbColorSpace_i0P0); + }, + $signature: 3 + }; + A.global_closure55.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + if (!(t1.$index($arguments, 0) instanceof A.SassNumber0) && !t1.$index($arguments, 0).get$isSpecialNumber()) + A.warnForDeprecation0(string$.Globalci, B.Deprecation_ZDV); + return A._invert0($arguments, true); + }, + $signature: 3 + }; + A.global_closure56.prototype = { + call$1(color) { + return color._color0$_legacyChannel$2(B.HslColorSpace_JQ20, "hue"); + }, + $signature: 31 + }; + A.global_closure57.prototype = { + call$1(color) { + return color._color0$_legacyChannel$2(B.HslColorSpace_JQ20, "saturation"); + }, + $signature: 31 + }; + A.global_closure58.prototype = { + call$1(color) { + return color._color0$_legacyChannel$2(B.HslColorSpace_JQ20, "lightness"); + }, + $signature: 31 + }; + A.global_closure59.prototype = { + call$1($arguments) { + return A._hsl0("hsl", $arguments); + }, + $signature: 3 + }; + A.global_closure60.prototype = { + call$1($arguments) { + return A._hsl0("hsl", $arguments); + }, + $signature: 3 + }; + A.global_closure61.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0).get$isVar() || t1.$index($arguments, 1).get$isVar()) + return A._functionString0("hsl", $arguments); + else + throw A.wrapException(A.SassScriptException$0("Missing argument $lightness.", null)); + }, + $signature: 18 + }; + A.global_closure62.prototype = { + call$1($arguments) { + return A._parseChannels0("hsl", J.$index$asx($arguments, 0), "channels", B.HslColorSpace_JQ20); + }, + $signature: 3 + }; + A.global_closure63.prototype = { + call$1($arguments) { + return A._hsl0("hsla", $arguments); + }, + $signature: 3 + }; + A.global_closure64.prototype = { + call$1($arguments) { + return A._hsl0("hsla", $arguments); + }, + $signature: 3 + }; + A.global_closure65.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0).get$isVar() || t1.$index($arguments, 1).get$isVar()) + return A._functionString0("hsla", $arguments); + else + throw A.wrapException(A.SassScriptException$0("Missing argument $lightness.", null)); + }, + $signature: 18 + }; + A.global_closure66.prototype = { + call$1($arguments) { + return A._parseChannels0("hsla", J.$index$asx($arguments, 0), "channels", B.HslColorSpace_JQ20); + }, + $signature: 3 + }; + A.global_closure67.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0) instanceof A.SassNumber0 || t1.$index($arguments, 0).get$isSpecialNumber()) + return A._functionString0("grayscale", $arguments); + else { + A.warnForDeprecation0(string$.Globalcg, B.Deprecation_ZDV); + return A._grayscale0(t1.$index($arguments, 0)); + } + }, + $signature: 3 + }; + A.global_closure68.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + degrees = A._angleValue0(t1.$index($arguments, 1), "degrees"); + if (!color._color0$_space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0(string$.adjusto, null)); + A.warnForDeprecation0(string$.adjustd + A.SassNumber_SassNumber0(degrees, "deg").toString$0(0) + string$.x29x0a_Mor_, B.Deprecation_fdF); + return color.changeHsl$1$hue(color._color0$_legacyChannel$2(B.HslColorSpace_JQ20, "hue") + degrees); + }, + $signature: 23 + }; + A.global_closure69.prototype = { + call$1($arguments) { + var result, + _s9_ = "lightness", + t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + amount = t1.$index($arguments, 1).assertNumber$1("amount"); + if (!color._color0$_space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0(string$.lighte, null)); + t1 = color._color0$_legacyChannel$2(B.HslColorSpace_JQ20, _s9_) + amount.valueInRange$3(0, 100, "amount"); + result = color.changeHsl$1$lightness(isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 100)); + A.warnForDeprecation0("lighten() is deprecated. " + A._suggestScaleAndAdjust0(color, amount._number1$_value, _s9_) + string$.x0a_Morex3ac, B.Deprecation_fdF); + return result; + }, + $signature: 23 + }; + A.global_closure70.prototype = { + call$1($arguments) { + var result, + _s9_ = "lightness", + t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + amount = t1.$index($arguments, 1).assertNumber$1("amount"); + if (!color._color0$_space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0(string$.darken, null)); + t1 = color._color0$_legacyChannel$2(B.HslColorSpace_JQ20, _s9_) - amount.valueInRange$3(0, 100, "amount"); + result = color.changeHsl$1$lightness(isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 100)); + A.warnForDeprecation0("darken() is deprecated. " + A._suggestScaleAndAdjust0(color, -amount._number1$_value, _s9_) + string$.x0a_Morex3ac, B.Deprecation_fdF); + return result; + }, + $signature: 23 + }; + A.global_closure71.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0) instanceof A.SassNumber0 || t1.$index($arguments, 0).get$isSpecialNumber()) + return A._functionString0("saturate", $arguments); + return new A.SassString0("saturate(" + A.serializeValue0(t1.$index($arguments, 0).assertNumber$1("amount"), false, true) + ")", false); + }, + $signature: 18 + }; + A.global_closure72.prototype = { + call$1($arguments) { + var t1, color, amount, result, + _s10_ = "saturation"; + A.warnForDeprecation0(string$.Globalcad, B.Deprecation_ZDV); + t1 = J.getInterceptor$asx($arguments); + color = t1.$index($arguments, 0).assertColor$1("color"); + amount = t1.$index($arguments, 1).assertNumber$1("amount"); + if (!color._color0$_space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0(string$.satura, null)); + t1 = color._color0$_legacyChannel$2(B.HslColorSpace_JQ20, _s10_) + amount.valueInRange$3(0, 100, "amount"); + result = color.changeHsl$1$saturation(isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 100)); + A.warnForDeprecation0("saturate() is deprecated. " + A._suggestScaleAndAdjust0(color, amount._number1$_value, _s10_) + string$.x0a_Morex3ac, B.Deprecation_fdF); + return result; + }, + $signature: 23 + }; + A.global_closure73.prototype = { + call$1($arguments) { + var result, + _s10_ = "saturation", + t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + amount = t1.$index($arguments, 1).assertNumber$1("amount"); + if (!color._color0$_space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0(string$.desatu, null)); + t1 = color._color0$_legacyChannel$2(B.HslColorSpace_JQ20, _s10_) - amount.valueInRange$3(0, 100, "amount"); + result = color.changeHsl$1$saturation(isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 100)); + A.warnForDeprecation0("desaturate() is deprecated. " + A._suggestScaleAndAdjust0(color, -amount._number1$_value, _s10_) + string$.x0a_Morex3ac, B.Deprecation_fdF); + return result; + }, + $signature: 23 + }; + A.global_closure74.prototype = { + call$1($arguments) { + return A._opacify0("opacify", $arguments); + }, + $signature: 23 + }; + A.global_closure75.prototype = { + call$1($arguments) { + return A._opacify0("fade-in", $arguments); + }, + $signature: 23 + }; + A.global_closure76.prototype = { + call$1($arguments) { + return A._transparentize0("transparentize", $arguments); + }, + $signature: 23 + }; + A.global_closure77.prototype = { + call$1($arguments) { + return A._transparentize0("fade-out", $arguments); + }, + $signature: 23 + }; + A.global_closure78.prototype = { + call$1($arguments) { + var _0_0 = J.$index$asx($arguments, 0), + t1 = false; + if (_0_0 instanceof A.SassString0) + if (!_0_0._string0$_hasQuotes) + t1 = B.JSString_methods.contains$1(_0_0._string0$_text, $.$get$_microsoftFilterStart0()); + if (t1) + return A._functionString0("alpha", $arguments); + if (_0_0 instanceof A.SassColor0 && !_0_0._color0$_space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0(string$.alpha_, null)); + A.warnForDeprecation0(string$.Globalcal, B.Deprecation_ZDV); + t1 = _0_0.assertColor$1("color").alphaOrNull; + return A.SassNumber_SassNumber0(t1 == null ? 0 : t1, null); + }, + $signature: 3 + }; + A.global_closure79.prototype = { + call$1($arguments) { + var t1, + argList = J.$index$asx($arguments, 0).get$asList(); + if (argList.length !== 0 && B.JSArray_methods.every$1(argList, new A.global__closure0())) + return A._functionString0("alpha", $arguments); + t1 = argList.length; + if (t1 === 0) + throw A.wrapException(A.SassScriptException$0("Missing argument $color.", null)); + else + throw A.wrapException(A.SassScriptException$0("Only 1 argument allowed, but " + t1 + " were passed.", null)); + }, + $signature: 18 + }; + A.global__closure0.prototype = { + call$1(argument) { + return argument instanceof A.SassString0 && !argument._string0$_hasQuotes && B.JSString_methods.contains$1(argument._string0$_text, $.$get$_microsoftFilterStart0()); + }, + $signature: 54 + }; + A.global_closure80.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0) instanceof A.SassNumber0 || t1.$index($arguments, 0).get$isSpecialNumber()) + return A._functionString0("opacity", $arguments); + A.warnForDeprecation0(string$.Globalco, B.Deprecation_ZDV); + t1 = t1.$index($arguments, 0).assertColor$1("color").alphaOrNull; + return A.SassNumber_SassNumber0(t1 == null ? 0 : t1, null); + }, + $signature: 3 + }; + A.global_closure81.prototype = { + call$1($arguments) { + return A._parseChannels0("color", J.$index$asx($arguments, 0), "description", null); + }, + $signature: 3 + }; + A.global_closure82.prototype = { + call$1($arguments) { + return A._parseChannels0("hwb", J.$index$asx($arguments, 0), "channels", B.HwbColorSpace_guQ0); + }, + $signature: 3 + }; + A.global_closure83.prototype = { + call$1($arguments) { + return A._parseChannels0("lab", J.$index$asx($arguments, 0), "channels", B.LabColorSpace_2nT0); + }, + $signature: 3 + }; + A.global_closure84.prototype = { + call$1($arguments) { + return A._parseChannels0("lch", J.$index$asx($arguments, 0), "channels", B.LchColorSpace_Bpv0); + }, + $signature: 3 + }; + A.global_closure85.prototype = { + call$1($arguments) { + return A._parseChannels0("oklab", J.$index$asx($arguments, 0), "channels", B.OklabColorSpace_5400); + }, + $signature: 3 + }; + A.global_closure86.prototype = { + call$1($arguments) { + return A._parseChannels0("oklch", J.$index$asx($arguments, 0), "channels", B.OklchColorSpace_9Gj0); + }, + $signature: 3 + }; + A.module_closure27.prototype = { + call$1(color) { + return B.JSNumber_methods.round$0(color._color0$_legacyChannel$2(B.RgbColorSpace_i0P0, "red")); + }, + $signature: 39 + }; + A.module_closure28.prototype = { + call$1(color) { + return B.JSNumber_methods.round$0(color._color0$_legacyChannel$2(B.RgbColorSpace_i0P0, "green")); + }, + $signature: 39 + }; + A.module_closure29.prototype = { + call$1(color) { + return B.JSNumber_methods.round$0(color._color0$_legacyChannel$2(B.RgbColorSpace_i0P0, "blue")); + }, + $signature: 39 + }; + A.module_closure30.prototype = { + call$1($arguments) { + var result = A._invert0($arguments, false); + if (result instanceof A.SassString0) + A.warnForDeprecation0("Passing a number (" + J.$index$asx($arguments, 0).toString$0(0) + string$.x29x20to_ci + result.toString$0(0), B.Deprecation_Kry); + return result; + }, + $signature: 3 + }; + A.module_closure31.prototype = { + call$1(color) { + return color._color0$_legacyChannel$2(B.HslColorSpace_JQ20, "hue"); + }, + $signature: 31 + }; + A.module_closure32.prototype = { + call$1(color) { + return color._color0$_legacyChannel$2(B.HslColorSpace_JQ20, "saturation"); + }, + $signature: 31 + }; + A.module_closure33.prototype = { + call$1(color) { + return color._color0$_legacyChannel$2(B.HslColorSpace_JQ20, "lightness"); + }, + $signature: 31 + }; + A.module_closure34.prototype = { + call$1($arguments) { + var result, + t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0) instanceof A.SassNumber0) { + result = A._functionString0("grayscale", t1.take$1($arguments, 1)); + A.warnForDeprecation0("Passing a number (" + t1.$index($arguments, 0).toString$0(0) + string$.x29x20to_cg + result.toString$0(0), B.Deprecation_Kry); + return result; + } + return A._grayscale0(t1.$index($arguments, 0)); + }, + $signature: 3 + }; + A.module_closure35.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + t2 = type$.JSArray_Value_2; + return A._parseChannels0("hwb", A.SassList$0(A._setArrayType([A.SassList$0(A._setArrayType([t1.$index($arguments, 0), t1.$index($arguments, 1), t1.$index($arguments, 2)], t2), B.ListSeparator_qSL0, false), t1.$index($arguments, 3)], t2), B.ListSeparator_bRz0, false), null, B.HwbColorSpace_guQ0); + }, + $signature: 3 + }; + A.module_closure36.prototype = { + call$1($arguments) { + return A._parseChannels0("hwb", J.$index$asx($arguments, 0), "channels", B.HwbColorSpace_guQ0); + }, + $signature: 3 + }; + A.module_closure37.prototype = { + call$1(color) { + return color._color0$_legacyChannel$2(B.HwbColorSpace_guQ0, "whiteness"); + }, + $signature: 31 + }; + A.module_closure38.prototype = { + call$1(color) { + return color._color0$_legacyChannel$2(B.HwbColorSpace_guQ0, "blackness"); + }, + $signature: 31 + }; + A.module_closure39.prototype = { + call$1($arguments) { + var result, + _0_0 = J.$index$asx($arguments, 0), + t1 = false; + if (_0_0 instanceof A.SassString0) + if (!_0_0._string0$_hasQuotes) + t1 = B.JSString_methods.contains$1(_0_0._string0$_text, $.$get$_microsoftFilterStart0()); + if (t1) { + result = A._functionString0("alpha", $arguments); + A.warnForDeprecation0(string$.Using_c + result.toString$0(0), B.Deprecation_Kry); + return result; + } + if (_0_0 instanceof A.SassColor0 && !_0_0._color0$_space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0(string$.color_a, null)); + t1 = _0_0.assertColor$1("color").alphaOrNull; + return A.SassNumber_SassNumber0(t1 == null ? 0 : t1, null); + }, + $signature: 3 + }; + A.module_closure40.prototype = { + call$1($arguments) { + var result, + t1 = J.getInterceptor$asx($arguments); + if (B.JSArray_methods.every$1(t1.$index($arguments, 0).get$asList(), new A.module__closure6())) { + result = A._functionString0("alpha", $arguments); + A.warnForDeprecation0(string$.Using_c + result.toString$0(0), B.Deprecation_Kry); + return result; + } + throw A.wrapException(A.SassScriptException$0("Only 1 argument allowed, but " + t1.get$length($arguments) + " were passed.", null)); + }, + $signature: 18 + }; + A.module__closure6.prototype = { + call$1(argument) { + return argument instanceof A.SassString0 && !argument._string0$_hasQuotes && B.JSString_methods.contains$1(argument._string0$_text, $.$get$_microsoftFilterStart0()); + }, + $signature: 54 + }; + A.module_closure41.prototype = { + call$1($arguments) { + var result, + t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0) instanceof A.SassNumber0) { + result = A._functionString0("opacity", $arguments); + A.warnForDeprecation0("Passing a number (" + t1.$index($arguments, 0).toString$0(0) + string$.x20to_co + result.toString$0(0), B.Deprecation_Kry); + return result; + } + t1 = t1.$index($arguments, 0).assertColor$1("color").alphaOrNull; + return A.SassNumber_SassNumber0(t1 == null ? 0 : t1, null); + }, + $signature: 3 + }; + A.module_closure42.prototype = { + call$1($arguments) { + return new A.SassString0(J.get$first$ax($arguments).assertColor$1("color")._color0$_space.name, false); + }, + $signature: 18 + }; + A.module_closure43.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return A._colorInSpace0(t1.$index($arguments, 0), t1.$index($arguments, 1), false); + }, + $signature: 23 + }; + A.module_closure44.prototype = { + call$1($arguments) { + return J.$index$asx($arguments, 0).assertColor$1("color")._color0$_space.get$isLegacyInternal() ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A.module_closure45.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return t1.$index($arguments, 0).assertColor$1("color").isChannelMissing$3$channelName$colorName(A._channelName0(t1.$index($arguments, 1)), "channel", "color") ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A.module_closure46.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return A._colorInSpace0(t1.$index($arguments, 0), t1.$index($arguments, 1), true).get$isInGamut() ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A.module_closure47.prototype = { + call$1($arguments) { + var space, method, _s5_ = "space", _s6_ = "method", + t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + t2 = t1.$index($arguments, 1); + if (t2.$eq(0, B.C__SassNull0)) + space = color._color0$_space; + else { + t2 = t2.assertString$1(_s5_); + t2.assertUnquoted$1(_s5_); + space = A.ColorSpace_fromName0(t2._string0$_text, _s5_); + } + if (t1.$index($arguments, 2).$eq(0, B.C__SassNull0)) + throw A.wrapException(A.SassScriptException$0(string$.color_t, _s6_)); + t1 = t1.$index($arguments, 2).assertString$1(_s6_); + t1.assertUnquoted$1(_s6_); + method = A.GamutMapMethod_GamutMapMethod$fromName0(t1._string0$_text); + if (!space.get$isBoundedInternal()) + return color; + t1 = color.toSpace$1(space); + t1 = t1.get$isInGamut() ? t1 : method.map$1(0, t1); + return t1.toSpace$2$legacyMissing(color._color0$_space, false); + }, + $signature: 23 + }; + A.module_closure48.prototype = { + call$1($arguments) { + var channelIndex, channelInfo, channelValue, unit, + t1 = J.getInterceptor$asx($arguments), + color = A._colorInSpace0(t1.$index($arguments, 0), t1.$index($arguments, 2), true), + channelName = A._channelName0(t1.$index($arguments, 1)); + if (channelName === "alpha") { + t1 = color.alphaOrNull; + return A.SassNumber_SassNumber0(t1 == null ? 0 : t1, null); + } + t1 = color._color0$_space._space$_channels; + channelIndex = B.JSArray_methods.indexWhere$1(t1, new A.module__closure5(channelName)); + if (channelIndex === -1) + throw A.wrapException(A.SassScriptException$0("Color " + color.toString$0(0) + " has no channel named " + channelName + ".", "channel")); + channelInfo = t1[channelIndex]; + channelValue = color.get$channels()[channelIndex]; + unit = channelInfo.associatedUnit; + return A.SassNumber_SassNumber0(unit === "%" ? channelValue * 100 / type$.LinearChannel_2._as(channelInfo).max : channelValue, unit); + }, + $signature: 22 + }; + A.module__closure5.prototype = { + call$1(channel) { + return channel.name === this.channelName; + }, + $signature: 70 + }; + A.module_closure49.prototype = { + call$1($arguments) { + var t2, t3, + t1 = J.getInterceptor$asx($arguments), + color1 = t1.$index($arguments, 0).assertColor$1("color1"), + color2 = t1.$index($arguments, 1).assertColor$1("color2"); + t1 = new A.module_closure_toXyzNoMissing0(); + if (color1._color0$_space === color2._color0$_space) { + t1 = color1.channel0OrNull; + t2 = false; + if (t1 == null) + t1 = 0; + t3 = color2.channel0OrNull; + if (A.fuzzyEquals0(t1, t3 == null ? 0 : t3)) { + t1 = color1.channel1OrNull; + if (t1 == null) + t1 = 0; + t3 = color2.channel1OrNull; + if (A.fuzzyEquals0(t1, t3 == null ? 0 : t3)) { + t1 = color1.channel2OrNull; + if (t1 == null) + t1 = 0; + t3 = color2.channel2OrNull; + if (A.fuzzyEquals0(t1, t3 == null ? 0 : t3)) { + t1 = color1.alphaOrNull; + if (t1 == null) + t1 = 0; + t2 = color2.alphaOrNull; + t1 = A.fuzzyEquals0(t1, t2 == null ? 0 : t2); + } else + t1 = t2; + } else + t1 = t2; + } else + t1 = t2; + } else + t1 = J.$eq$(t1.call$1(color1), t1.call$1(color2)); + return t1 ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A.module_closure_toXyzNoMissing0.prototype = { + call$1(color) { + var _1_1, _1_3, t1, _1_7, channel0, _1_8, channel1, _1_9, channel2, _1_10, alpha, _null = null; + $label0$0: { + _1_1 = color._color0$_space; + _1_3 = B.XyzD65ColorSpace_WiJ0 === _1_1; + t1 = _1_3; + if (t1) + t1 = !(color.channel0OrNull == null || color.channel1OrNull == null || color.channel2OrNull == null || color.alphaOrNull == null); + else + t1 = false; + if (t1) { + t1 = color; + break $label0$0; + } + if (_1_3) { + _1_7 = color.channel0OrNull; + if (_1_7 == null) + _1_7 = 0; + channel0 = _1_7; + _1_8 = color.channel1OrNull; + if (_1_8 == null) + _1_8 = 0; + channel1 = _1_8; + _1_9 = color.channel2OrNull; + if (_1_9 == null) + _1_9 = 0; + channel2 = _1_9; + _1_10 = color.alphaOrNull; + if (_1_10 == null) + _1_10 = 0; + alpha = _1_10; + t1 = A.SassColor$_forSpace0(B.XyzD65ColorSpace_WiJ0, channel0, channel1, channel2, alpha, _null); + break $label0$0; + } + _1_7 = color.channel0OrNull; + if (_1_7 == null) + _1_7 = 0; + channel0 = _1_7; + _1_8 = color.channel1OrNull; + if (_1_8 == null) + _1_8 = 0; + channel1 = _1_8; + _1_9 = color.channel2OrNull; + if (_1_9 == null) + _1_9 = 0; + channel2 = _1_9; + _1_10 = color.alphaOrNull; + if (_1_10 == null) + _1_10 = 0; + alpha = _1_10; + t1 = _1_1.convert$5(B.XyzD65ColorSpace_WiJ0, channel0, channel1, channel2, alpha); + break $label0$0; + } + return t1; + }, + $signature: 393 + }; + A.module_closure50.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return A._colorInSpace0(t1.$index($arguments, 0), t1.$index($arguments, 2), true).isChannelPowerless$3$channelName$colorName(A._channelName0(t1.$index($arguments, 1)), "channel", "color") ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._mix_closure0.prototype = { + call$1($arguments) { + var _s6_ = "weight", + _s41_ = string$.To_usem, + _s29_ = ", you must provide a $method.", + t1 = J.getInterceptor$asx($arguments), + color1 = t1.$index($arguments, 0).assertColor$1("color1"), + color2 = t1.$index($arguments, 1).assertColor$1("color2"), + weight = t1.$index($arguments, 2).assertNumber$1(_s6_); + if (!t1.$index($arguments, 3).$eq(0, B.C__SassNull0)) + return color1.interpolate$4$legacyMissing$weight(color2, A.InterpolationMethod_InterpolationMethod$fromValue0(t1.$index($arguments, 3), "method"), false, weight.valueInRangeWithUnit$4(0, 100, _s6_, "%") / 100); + A._checkPercent0(weight, _s6_); + if (!color1._color0$_space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0(_s41_ + color1.toString$0(0) + _s29_, "color1")); + else if (!color2._color0$_space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0(_s41_ + color2.toString$0(0) + _s29_, "color2")); + return A._mixLegacy0(color1, color2, weight); + }, + $signature: 23 + }; + A._complement_closure0.prototype = { + call$1($arguments) { + var space, t3, colorInSpace, t4, t5, t6, _s5_ = "space", + t1 = J.getInterceptor$asx($arguments), + color = t1.$index($arguments, 0).assertColor$1("color"), + t2 = color._color0$_space; + if (t2.get$isLegacyInternal() && t1.$index($arguments, 1).$eq(0, B.C__SassNull0)) + space = B.HslColorSpace_JQ20; + else { + t3 = t1.$index($arguments, 1).assertString$1(_s5_); + t3.assertUnquoted$1(_s5_); + space = A.ColorSpace_fromName0(t3._string0$_text, _s5_); + } + if (!space.get$isPolarInternal()) + throw A.wrapException(A.SassScriptException$0("Color space " + space.toString$0(0) + " doesn't have a hue channel.", _s5_)); + colorInSpace = color.toSpace$2$legacyMissing(space, !t1.$index($arguments, 1).$eq(0, B.C__SassNull0)); + t1 = space._space$_channels; + t3 = colorInSpace.channel0OrNull; + t4 = colorInSpace.channel1OrNull; + t5 = colorInSpace.channel2OrNull; + t6 = colorInSpace.alphaOrNull; + return (space.get$isLegacyInternal() ? A.SassColor_SassColor$forSpaceInternal0(space, A._adjustChannel0(colorInSpace, t1[0], t3, A.SassNumber_SassNumber0(180, null)), t4, t5, t6) : A.SassColor_SassColor$forSpaceInternal0(space, t3, t4, A._adjustChannel0(colorInSpace, t1[2], t5, A.SassNumber_SassNumber0(180, null)), t6)).toSpace$2$legacyMissing(t2, false); + }, + $signature: 23 + }; + A._adjust_closure0.prototype = { + call$1($arguments) { + return A._updateComponents0($arguments, true, false, false); + }, + $signature: 23 + }; + A._scale_closure0.prototype = { + call$1($arguments) { + return A._updateComponents0($arguments, false, false, true); + }, + $signature: 23 + }; + A._change_closure0.prototype = { + call$1($arguments) { + return A._updateComponents0($arguments, false, true, false); + }, + $signature: 23 + }; + A._ieHexStr_closure0.prototype = { + call$1($arguments) { + var t1, t2, t3, t4, t5, + color = J.$index$asx($arguments, 0).assertColor$1("color").toSpace$1(B.RgbColorSpace_i0P0); + color = color.get$isInGamut() ? color : B.LocalMindeGamutMap_A2x0.map$1(0, color); + t1 = new A._ieHexStr_closure_hexString0(); + t2 = color.alphaOrNull; + t2 = A.S(t1.call$1((t2 == null ? 0 : t2) * 255)); + t3 = color.channel0OrNull; + t3 = A.S(t1.call$1(t3 == null ? 0 : t3)); + t4 = color.channel1OrNull; + t4 = A.S(t1.call$1(t4 == null ? 0 : t4)); + t5 = color.channel2OrNull; + return new A.SassString0("#" + t2 + t3 + t4 + A.S(t1.call$1(t5 == null ? 0 : t5)), false); + }, + $signature: 18 + }; + A._ieHexStr_closure_hexString0.prototype = { + call$1(component) { + return B.JSString_methods.padLeft$2(B.JSInt_methods.toRadixString$1(A.fuzzyRound0(component), 16), 2, "0").toUpperCase(); + }, + $signature: 229 + }; + A._updateComponents_closure1.prototype = { + call$1(space) { + return this.originalColor.toSpace$2$legacyMissing(space, false); + }, + $signature: 394 + }; + A._updateComponents_closure2.prototype = { + call$1(info) { + return this._box_0.name === info.name; + }, + $signature: 70 + }; + A._changeColor_closure0.prototype = { + call$0() { + var t1 = this.alphaArg; + A.warnForDeprecation0("$alpha: Passing a unit other than % (" + A.S(t1) + string$.x29x20is_d + t1.unitSuggestion$1("alpha") + string$.x0a_See_, B.Deprecation_vn5); + return t1.valueInRange$3(0, 1, "alpha"); + }, + $signature: 238 + }; + A._adjustColor_closure0.prototype = { + call$1(alpha) { + return isNaN(alpha) ? 0 : B.JSNumber_methods.clamp$2(alpha, 0, 1); + }, + $signature: 16 + }; + A._functionString_closure0.prototype = { + call$1(argument) { + return A.serializeValue0(argument, false, true); + }, + $signature: 225 + }; + A._removedColorFunction_closure0.prototype = { + call$1($arguments) { + var t1 = this.name, + t2 = J.getInterceptor$asx($arguments), + t3 = t2.$index($arguments, 0).toString$0(0), + t4 = this.negative ? "-" : ""; + throw A.wrapException(A.SassScriptException$0("The function " + t1 + string$.x28__isn + t3 + ", $" + this.argument + ": " + t4 + t2.$index($arguments, 1).toString$0(0) + string$.x29x0a_Moro + t1, null)); + }, + $signature: 396 + }; + A._rgb_closure0.prototype = { + call$1(alpha) { + var t1 = A._percentageOrUnitless0(alpha.assertNumber$1("alpha"), 1, "alpha"); + return isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 1); + }, + $signature: 226 + }; + A._hsl_closure0.prototype = { + call$1(alpha) { + var t1 = A._percentageOrUnitless0(alpha.assertNumber$1("alpha"), 1, "alpha"); + return isNaN(t1) ? 0 : B.JSNumber_methods.clamp$2(t1, 0, 1); + }, + $signature: 226 + }; + A._parseChannels_closure1.prototype = { + call$1($name) { + return $name + " channel"; + }, + $signature: 6 + }; + A._parseChannels_closure2.prototype = { + call$1(channel) { + return channel.get$isSpecialNumber(); + }, + $signature: 54 + }; + A._colorFromChannels_closure1.prototype = { + call$1(channel0) { + return A._angleValue0(channel0, "hue"); + }, + $signature: 89 + }; + A._colorFromChannels_closure2.prototype = { + call$1(channel0) { + return A._angleValue0(channel0, "hue"); + }, + $signature: 89 + }; + A._channelFromValue_closure0.prototype = { + call$1(value) { + var t1, _0_8, t2, _0_5, _0_8_isSet, upperClamped, t3, + _0_0 = this.channel; + $label0$0: { + t1 = _0_0 instanceof A.LinearChannel0; + if (t1 && _0_0.requiresPercent && !value.hasUnit$1("%")) + A.throwExpression(A.SassScriptException$0("Expected " + value.toString$0(0) + ' to have unit "%".', _0_0.name)); + _0_8 = null; + t2 = false; + if (t1) { + _0_5 = _0_0.lowerClamped; + _0_8_isSet = !_0_5; + if (_0_8_isSet) { + _0_8 = _0_0.upperClamped; + t2 = !_0_8; + } + } else { + _0_5 = null; + _0_8_isSet = false; + } + if (t2) { + t1 = A._percentageOrUnitless0(value, _0_0.max, _0_0.name); + break $label0$0; + } + if (t1 && !this.clamp) { + t1 = A._percentageOrUnitless0(value, _0_0.max, _0_0.name); + break $label0$0; + } + if (t1) { + upperClamped = _0_8_isSet ? _0_8 : _0_0.upperClamped; + t1 = _0_0.max; + t2 = A._percentageOrUnitless0(value, t1, _0_0.name); + t3 = _0_5 ? _0_0.min : -1 / 0; + t1 = upperClamped ? t1 : 1 / 0; + t1 = isNaN(t2) ? t3 : B.JSNumber_methods.clamp$2(t2, t3, t1); + break $label0$0; + } + t1 = B.JSNumber_methods.$mod(value.coerceValueToUnit$2("deg", _0_0.name), 360); + break $label0$0; + } + return t1; + }, + $signature: 89 + }; + A._channelFunction_closure0.prototype = { + call$1($arguments) { + var _this = this, + result = A.SassNumber_SassNumber0(_this.getter.call$1(J.get$first$ax($arguments).assertColor$1("color")), _this.unit), + t1 = _this.global ? "" : "color.", + t2 = _this.name; + A.warnForDeprecation0(t1 + t2 + string$.x28__is_d + t2 + '", $space: ' + _this.space.toString$0(0) + string$.x29x0a_Mor_, B.Deprecation_fdF); + return result; + }, + $signature: 22 + }; + A._suggestScaleAndAdjust_closure0.prototype = { + call$1(channel) { + return channel.name === this.channelName; + }, + $signature: 70 + }; + A.colorClass_closure.prototype = { + call$0() { + var t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.SassColor", new A.colorClass__closure())), + t2 = type$.String, + t3 = type$.Function; + A.LinkedHashMap_LinkedHashMap$_literal(["equals", new A.colorClass__closure0(), "hashCode", new A.colorClass__closure1(), "toSpace", new A.colorClass__closure2(), "isInGamut", new A.colorClass__closure3(), "toGamut", new A.colorClass__closure4(), "channel", new A.colorClass__closure5(), "isChannelMissing", new A.colorClass__closure6(), "isChannelPowerless", new A.colorClass__closure7(), "change", new A.colorClass__closure8(), "interpolate", new A.colorClass__closure9()], t2, t3).forEach$1(0, A.JSClassExtension_get_defineMethod(jsClass)); + A.LinkedHashMap_LinkedHashMap$_literal(["red", new A.colorClass__closure10(), "green", new A.colorClass__closure11(), "blue", new A.colorClass__closure12(), "hue", new A.colorClass__closure13(), "saturation", new A.colorClass__closure14(), "lightness", new A.colorClass__closure15(), "whiteness", new A.colorClass__closure16(), "blackness", new A.colorClass__closure17(), "alpha", new A.colorClass__closure18(), "space", new A.colorClass__closure19(), "isLegacy", new A.colorClass__closure20(), "channelsOrNull", new A.colorClass__closure21(), "channels", new A.colorClass__closure22()], t2, t3).forEach$1(0, A.JSClassExtension_get_defineGetter(jsClass)); + A.JSClassExtension_injectSuperclass(t1._as(A.SassColor_SassColor$rgbInternal0(0, 0, 0, 1, null).constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.colorClass__closure.prototype = { + call$2($self, options) { + var t1, t2, t3, t4, _null = null; + switch (A._constructionSpace(options)) { + case B.RgbColorSpace_i0P0: + A._checkNullAlphaDeprecation(options); + t1 = J.getInterceptor$x(options); + t2 = t1.get$red(options); + t3 = t1.get$green(options); + t4 = t1.get$blue(options); + t1 = t1.get$alpha(options); + return A.SassColor_SassColor$rgbInternal0(t2, t3, t4, A._asBool($.$get$_isUndefined().call$1(t1)) ? 1 : t1, _null); + case B.HslColorSpace_JQ20: + A._checkNullAlphaDeprecation(options); + t1 = J.getInterceptor$x(options); + t2 = t1.get$hue(options); + t3 = t1.get$saturation(options); + t4 = t1.get$lightness(options); + t1 = t1.get$alpha(options); + return A.SassColor_SassColor$hsl0(t2, t3, t4, A._asBool($.$get$_isUndefined().call$1(t1)) ? 1 : t1); + case B.HwbColorSpace_guQ0: + A._checkNullAlphaDeprecation(options); + t1 = J.getInterceptor$x(options); + t2 = t1.get$hue(options); + t3 = t1.get$whiteness(options); + t4 = t1.get$blackness(options); + t1 = t1.get$alpha(options); + return A.SassColor_SassColor$hwb0(t2, t3, t4, A._asBool($.$get$_isUndefined().call$1(t1)) ? 1 : t1); + case B.LabColorSpace_2nT0: + t1 = J.getInterceptor$x(options); + t2 = t1.get$lightness(options); + t3 = t1.get$a(options); + t4 = t1.get$b(options); + t1 = t1.get$alpha(options); + return A.SassColor$_forSpace0(B.LabColorSpace_2nT0, t2, t3, t4, A._asBool($.$get$_isUndefined().call$1(t1)) ? 1 : t1, _null); + case B.OklabColorSpace_5400: + t1 = J.getInterceptor$x(options); + t2 = t1.get$lightness(options); + t3 = t1.get$a(options); + t4 = t1.get$b(options); + t1 = t1.get$alpha(options); + return A.SassColor$_forSpace0(B.OklabColorSpace_5400, t2, t3, t4, A._asBool($.$get$_isUndefined().call$1(t1)) ? 1 : t1, _null); + case B.LchColorSpace_Bpv0: + t1 = J.getInterceptor$x(options); + t2 = t1.get$lightness(options); + t3 = t1.get$chroma(options); + t4 = t1.get$hue(options); + t1 = t1.get$alpha(options); + return A.SassColor_SassColor$forSpaceInternal0(B.LchColorSpace_Bpv0, t2, t3, t4, A._asBool($.$get$_isUndefined().call$1(t1)) ? 1 : t1); + case B.OklchColorSpace_9Gj0: + t1 = J.getInterceptor$x(options); + t2 = t1.get$lightness(options); + t3 = t1.get$chroma(options); + t4 = t1.get$hue(options); + t1 = t1.get$alpha(options); + return A.SassColor_SassColor$forSpaceInternal0(B.OklchColorSpace_9Gj0, t2, t3, t4, A._asBool($.$get$_isUndefined().call$1(t1)) ? 1 : t1); + case B.SrgbColorSpace_thf0: + t1 = J.getInterceptor$x(options); + t2 = t1.get$red(options); + t3 = t1.get$green(options); + t4 = t1.get$blue(options); + t1 = t1.get$alpha(options); + return A.SassColor$_forSpace0(B.SrgbColorSpace_thf0, t2, t3, t4, A._asBool($.$get$_isUndefined().call$1(t1)) ? 1 : t1, _null); + case B.SrgbLinearColorSpace_kUj0: + t1 = J.getInterceptor$x(options); + t2 = t1.get$red(options); + t3 = t1.get$green(options); + t4 = t1.get$blue(options); + t1 = t1.get$alpha(options); + return A.SassColor$_forSpace0(B.SrgbLinearColorSpace_kUj0, t2, t3, t4, A._asBool($.$get$_isUndefined().call$1(t1)) ? 1 : t1, _null); + case B.DisplayP3ColorSpace_MmT0: + t1 = J.getInterceptor$x(options); + t2 = t1.get$red(options); + t3 = t1.get$green(options); + t4 = t1.get$blue(options); + t1 = t1.get$alpha(options); + return A.SassColor$_forSpace0(B.DisplayP3ColorSpace_MmT0, t2, t3, t4, A._asBool($.$get$_isUndefined().call$1(t1)) ? 1 : t1, _null); + case B.A98RgbColorSpace_lf20: + t1 = J.getInterceptor$x(options); + t2 = t1.get$red(options); + t3 = t1.get$green(options); + t4 = t1.get$blue(options); + t1 = t1.get$alpha(options); + return A.SassColor$_forSpace0(B.A98RgbColorSpace_lf20, t2, t3, t4, A._asBool($.$get$_isUndefined().call$1(t1)) ? 1 : t1, _null); + case B.ProphotoRgbColorSpace_BDz0: + t1 = J.getInterceptor$x(options); + t2 = t1.get$red(options); + t3 = t1.get$green(options); + t4 = t1.get$blue(options); + t1 = t1.get$alpha(options); + return A.SassColor$_forSpace0(B.ProphotoRgbColorSpace_BDz0, t2, t3, t4, A._asBool($.$get$_isUndefined().call$1(t1)) ? 1 : t1, _null); + case B.Rec2020ColorSpace_6oo0: + t1 = J.getInterceptor$x(options); + t2 = t1.get$red(options); + t3 = t1.get$green(options); + t4 = t1.get$blue(options); + t1 = t1.get$alpha(options); + return A.SassColor$_forSpace0(B.Rec2020ColorSpace_6oo0, t2, t3, t4, A._asBool($.$get$_isUndefined().call$1(t1)) ? 1 : t1, _null); + case B.XyzD50ColorSpace_2OB0: + t1 = J.getInterceptor$x(options); + t2 = t1.get$x(options); + t3 = t1.get$y(options); + t4 = t1.get$z(options); + t1 = t1.get$alpha(options); + return A.SassColor$_forSpace0(B.XyzD50ColorSpace_2OB0, t2, t3, t4, A._asBool($.$get$_isUndefined().call$1(t1)) ? 1 : t1, _null); + case B.XyzD65ColorSpace_WiJ0: + t1 = J.getInterceptor$x(options); + t2 = t1.get$x(options); + t3 = t1.get$y(options); + t4 = t1.get$z(options); + t1 = t1.get$alpha(options); + return A.SassColor$_forSpace0(B.XyzD65ColorSpace_WiJ0, t2, t3, t4, A._asBool($.$get$_isUndefined().call$1(t1)) ? 1 : t1, _null); + default: + throw A.wrapException("Unreachable"); + } + }, + $signature: 399 + }; + A.colorClass__closure0.prototype = { + call$2($self, other) { + return $self.$eq(0, other); + }, + $signature: 400 + }; + A.colorClass__closure1.prototype = { + call$1($self) { + return $self.get$hashCode(0); + }, + $signature: 39 + }; + A.colorClass__closure2.prototype = { + call$2($self, space) { + return A._toSpace($self, space); + }, + $signature: 401 + }; + A.colorClass__closure3.prototype = { + call$2($self, space) { + return A._toSpace($self, space).get$isInGamut(); + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 402 + }; + A.colorClass__closure4.prototype = { + call$2($self, options) { + var t1 = J.getInterceptor$x(options), + t2 = A._toSpace($self, t1.get$space(options)); + t1 = A.GamutMapMethod_GamutMapMethod$fromName0(t1.get$method(options)); + t1 = t2.get$isInGamut() ? t2 : t1.map$1(0, t2); + return t1.toSpace$1($self._color0$_space); + }, + $signature: 403 + }; + A.colorClass__closure5.prototype = { + call$3($self, channel, options) { + return A._toSpace($self, options == null ? null : J.get$space$x(options)).channel$1(0, channel); + }, + call$2($self, channel) { + return this.call$3($self, channel, null); + }, + "call*": "call$3", + $requiredArgCount: 2, + $defaultValues() { + return [null]; + }, + $signature: 404 + }; + A.colorClass__closure6.prototype = { + call$2($self, channel) { + return $self.isChannelMissing$1(channel); + }, + $signature: 405 + }; + A.colorClass__closure7.prototype = { + call$3($self, channel, options) { + return A._toSpace($self, options == null ? null : J.get$space$x(options)).isChannelPowerless$1(channel); + }, + call$2($self, channel) { + return this.call$3($self, channel, null); + }, + "call*": "call$3", + $requiredArgCount: 2, + $defaultValues() { + return [null]; + }, + $signature: 406 + }; + A.colorClass__closure8.prototype = { + call$2($self, options) { + var t3, space, t4, t5, t6, color, changedValue, _0_2, changedColor, _0_4, _0_6, _null = null, + _s9_ = "whiteness", + _s9_0 = "blackness", + _s3_ = "hue", + _s10_ = "saturation", + _s9_1 = "lightness", + _s3_0 = "red", _s5_ = "green", _s4_ = "blue", _s5_0 = "alpha", + _s106_ = string$.Passin_, + _s105_ = "Passing `hue: null` without setting `space` is deprecated.\nMore info: https://sass-lang.com/d/color-4-api", + t1 = J.getInterceptor$x(options), + t2 = t1.get$space(options) == null, + spaceSetExplicitly = !t2; + if (spaceSetExplicitly) { + t3 = t1.get$space(options); + t3.toString; + space = A.ColorSpace_fromName0(t3, _null); + } else + space = $self._color0$_space; + t3 = $self._color0$_space; + if (t3.get$isLegacyInternal() && t2) { + if ("whiteness" in options || "blackness" in options) + space = B.HwbColorSpace_guQ0; + else if ("hue" in options && t3 === B.HwbColorSpace_guQ0) + space = B.HwbColorSpace_guQ0; + else if ("hue" in options || "saturation" in options || "lightness" in options) + space = B.HslColorSpace_JQ20; + else if ("red" in options || "green" in options || "blue" in options) + space = B.RgbColorSpace_i0P0; + if (space !== t3) + A.warnForDeprecationFromApi("Changing a channel not in this color's space without explicitly specifying the `space` option is deprecated.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + } + for (t2 = J.get$iterator$ax(self.Object.keys(options)), t4 = space._space$_channels, t5 = type$.JSArray_String; t2.moveNext$0();) { + t6 = t2.get$current(t2); + if (B.JSArray_methods.contains$1(A._setArrayType(["alpha", "space"], t5), t6)) + continue; + if (!B.JSArray_methods.any$1(t4, new A.colorClass___closure(t6))) + A.jsThrow(new self.Error("`" + t6 + "` is not a valid channel in `" + space.toString$0(0) + "`.")); + } + color = $self.toSpace$1(space); + changedValue = new A.colorClass__closure_changedValue(color, options); + $label0$2: { + _0_2 = B.HslColorSpace_JQ20 === space; + if (_0_2 && spaceSetExplicitly) { + changedColor = A.SassColor_SassColor$hsl0(changedValue.call$1(_s3_), changedValue.call$1(_s10_), changedValue.call$1(_s9_1), changedValue.call$1(_s5_0)); + break $label0$2; + } + if (_0_2) { + t2 = t1.get$hue(options); + t4 = $.$get$_isNull(); + if (A._asBool(t4.call$1(t2))) + A.warnForDeprecationFromApi(_s105_, B.Deprecation_FD1); + else if (A._asBool(t4.call$1(t1.get$saturation(options)))) + A.warnForDeprecationFromApi("Passing `saturation: null` without setting `space` is deprecated.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + else if (A._asBool(t4.call$1(t1.get$lightness(options)))) + A.warnForDeprecationFromApi("Passing `lightness: null` without setting `space` is deprecated.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + if (A._asBool(t4.call$1(t1.get$alpha(options)))) + A.warnForDeprecationFromApi(_s106_, B.Deprecation_l0m); + t2 = t1.get$hue(options); + if (t2 == null) + t2 = color.channel$1(0, _s3_); + t4 = t1.get$saturation(options); + if (t4 == null) + t4 = color.channel$1(0, _s10_); + t5 = t1.get$lightness(options); + if (t5 == null) + t5 = color.channel$1(0, _s9_1); + t1 = t1.get$alpha(options); + changedColor = A.SassColor_SassColor$hsl0(t2, t4, t5, t1 == null ? color.channel$1(0, _s5_0) : t1); + break $label0$2; + } + _0_4 = B.HwbColorSpace_guQ0 === space; + if (_0_4 && spaceSetExplicitly) { + changedColor = A.SassColor_SassColor$hwb0(changedValue.call$1(_s3_), changedValue.call$1(_s9_), changedValue.call$1(_s9_0), changedValue.call$1(_s5_0)); + break $label0$2; + } + if (_0_4) { + t2 = t1.get$hue(options); + t4 = $.$get$_isNull(); + if (A._asBool(t4.call$1(t2))) + A.warnForDeprecationFromApi(_s105_, B.Deprecation_FD1); + else if (A._asBool(t4.call$1(t1.get$whiteness(options)))) + A.warnForDeprecationFromApi("Passing `whiteness: null` without setting `space` is deprecated.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + else if (A._asBool(t4.call$1(t1.get$blackness(options)))) + A.warnForDeprecationFromApi("Passing `blackness: null` without setting `space` is deprecated.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + if (A._asBool(t4.call$1(t1.get$alpha(options)))) + A.warnForDeprecationFromApi(_s106_, B.Deprecation_l0m); + t2 = t1.get$hue(options); + if (t2 == null) + t2 = color.channel$1(0, _s3_); + t4 = t1.get$whiteness(options); + if (t4 == null) + t4 = color.channel$1(0, _s9_); + t5 = t1.get$blackness(options); + if (t5 == null) + t5 = color.channel$1(0, _s9_0); + t1 = t1.get$alpha(options); + changedColor = A.SassColor_SassColor$hwb0(t2, t4, t5, t1 == null ? color.channel$1(0, _s5_0) : t1); + break $label0$2; + } + _0_6 = B.RgbColorSpace_i0P0 === space; + if (_0_6 && spaceSetExplicitly) { + changedColor = A.SassColor_SassColor$rgbInternal0(changedValue.call$1(_s3_0), changedValue.call$1(_s5_), changedValue.call$1(_s4_), changedValue.call$1(_s5_0), _null); + break $label0$2; + } + if (_0_6) { + t2 = t1.get$red(options); + t4 = $.$get$_isNull(); + if (A._asBool(t4.call$1(t2))) + A.warnForDeprecationFromApi("Passing `red: null` without setting `space` is deprecated.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + else if (A._asBool(t4.call$1(t1.get$green(options)))) + A.warnForDeprecationFromApi("Passing `green: null` without setting `space` is deprecated.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + else if (A._asBool(t4.call$1(t1.get$blue(options)))) + A.warnForDeprecationFromApi("Passing `blue: null` without setting `space` is deprecated.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + if (A._asBool(t4.call$1(t1.get$alpha(options)))) + A.warnForDeprecationFromApi(_s106_, B.Deprecation_l0m); + t2 = t1.get$red(options); + if (t2 == null) + t2 = color.channel$1(0, _s3_0); + t4 = t1.get$green(options); + if (t4 == null) + t4 = color.channel$1(0, _s5_); + t5 = t1.get$blue(options); + if (t5 == null) + t5 = color.channel$1(0, _s4_); + t1 = t1.get$alpha(options); + changedColor = A.SassColor_SassColor$rgbInternal0(t2, t4, t5, t1 == null ? color.channel$1(0, _s5_0) : t1, _null); + break $label0$2; + } + if (B.LabColorSpace_2nT0 === space) { + changedColor = A.SassColor$_forSpace0(B.LabColorSpace_2nT0, changedValue.call$1(_s9_1), changedValue.call$1("a"), changedValue.call$1("b"), changedValue.call$1(_s5_0), _null); + break $label0$2; + } + if (B.OklabColorSpace_5400 === space) { + changedColor = A.SassColor$_forSpace0(B.OklabColorSpace_5400, changedValue.call$1(_s9_1), changedValue.call$1("a"), changedValue.call$1("b"), changedValue.call$1(_s5_0), _null); + break $label0$2; + } + if (B.LchColorSpace_Bpv0 === space) { + changedColor = A.SassColor_SassColor$forSpaceInternal0(B.LchColorSpace_Bpv0, changedValue.call$1(_s9_1), changedValue.call$1("chroma"), changedValue.call$1(_s3_), changedValue.call$1(_s5_0)); + break $label0$2; + } + if (B.OklchColorSpace_9Gj0 === space) { + changedColor = A.SassColor_SassColor$forSpaceInternal0(B.OklchColorSpace_9Gj0, changedValue.call$1(_s9_1), changedValue.call$1("chroma"), changedValue.call$1(_s3_), changedValue.call$1(_s5_0)); + break $label0$2; + } + if (B.A98RgbColorSpace_lf20 === space) { + changedColor = A.SassColor$_forSpace0(B.A98RgbColorSpace_lf20, changedValue.call$1(_s3_0), changedValue.call$1(_s5_), changedValue.call$1(_s4_), changedValue.call$1(_s5_0), _null); + break $label0$2; + } + if (B.DisplayP3ColorSpace_MmT0 === space) { + changedColor = A.SassColor$_forSpace0(B.DisplayP3ColorSpace_MmT0, changedValue.call$1(_s3_0), changedValue.call$1(_s5_), changedValue.call$1(_s4_), changedValue.call$1(_s5_0), _null); + break $label0$2; + } + if (B.ProphotoRgbColorSpace_BDz0 === space) { + changedColor = A.SassColor$_forSpace0(B.ProphotoRgbColorSpace_BDz0, changedValue.call$1(_s3_0), changedValue.call$1(_s5_), changedValue.call$1(_s4_), changedValue.call$1(_s5_0), _null); + break $label0$2; + } + if (B.Rec2020ColorSpace_6oo0 === space) { + changedColor = A.SassColor$_forSpace0(B.Rec2020ColorSpace_6oo0, changedValue.call$1(_s3_0), changedValue.call$1(_s5_), changedValue.call$1(_s4_), changedValue.call$1(_s5_0), _null); + break $label0$2; + } + if (B.SrgbColorSpace_thf0 === space) { + changedColor = A.SassColor$_forSpace0(B.SrgbColorSpace_thf0, changedValue.call$1(_s3_0), changedValue.call$1(_s5_), changedValue.call$1(_s4_), changedValue.call$1(_s5_0), _null); + break $label0$2; + } + if (B.SrgbLinearColorSpace_kUj0 === space) { + changedColor = A.SassColor$_forSpace0(B.SrgbLinearColorSpace_kUj0, changedValue.call$1(_s3_0), changedValue.call$1(_s5_), changedValue.call$1(_s4_), changedValue.call$1(_s5_0), _null); + break $label0$2; + } + if (B.XyzD50ColorSpace_2OB0 === space) { + changedColor = A.SassColor_SassColor$forSpaceInternal0(space, changedValue.call$1("x"), changedValue.call$1("y"), changedValue.call$1("z"), changedValue.call$1(_s5_0)); + break $label0$2; + } + if (B.XyzD65ColorSpace_WiJ0 === space) { + changedColor = A.SassColor_SassColor$forSpaceInternal0(space, changedValue.call$1("x"), changedValue.call$1("y"), changedValue.call$1("z"), changedValue.call$1(_s5_0)); + break $label0$2; + } + throw A.wrapException("No space set"); + } + return changedColor.toSpace$1(t3); + }, + $signature: 407 + }; + A.colorClass___closure.prototype = { + call$1(channel) { + return channel.name === this.key; + }, + $signature: 70 + }; + A.colorClass__closure_changedValue.prototype = { + call$1(channel) { + var t2, + t1 = this.options; + if (channel in t1) { + t2 = t1[channel]; + t2 = !A._asBool($.$get$_isUndefined().call$1(t2)); + } else + t2 = false; + return t2 ? t1[channel] : this.color.channel$1(0, channel); + }, + $signature: 408 + }; + A.colorClass__closure9.prototype = { + call$3($self, color2, options) { + var interpolationMethod, t2, + t1 = options == null, + _1_0 = t1 ? null : J.get$method$x(options); + if (_1_0 != null) + interpolationMethod = A.InterpolationMethod$0($self._color0$_space, A.EnumByName_byName(B.List_nm2, _1_0)); + else { + t2 = $self._color0$_space; + interpolationMethod = !t2.get$isPolarInternal() ? A.InterpolationMethod$0(t2, null) : A.InterpolationMethod$0(t2, B.HueInterpolationMethod_00); + } + return $self.interpolate$3$weight(color2, interpolationMethod, t1 ? null : J.get$weight$x(options)); + }, + call$2($self, color2) { + return this.call$3($self, color2, null); + }, + "call*": "call$3", + $requiredArgCount: 2, + $defaultValues() { + return [null]; + }, + $signature: 409 + }; + A.colorClass__closure10.prototype = { + call$1($self) { + A.warnForDeprecationFromApi("red is deprecated, use `channel` instead.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + return B.JSNumber_methods.round$0($self._color0$_legacyChannel$2(B.RgbColorSpace_i0P0, "red")); + }, + $signature: 39 + }; + A.colorClass__closure11.prototype = { + call$1($self) { + A.warnForDeprecationFromApi("green is deprecated, use `channel` instead.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + return B.JSNumber_methods.round$0($self._color0$_legacyChannel$2(B.RgbColorSpace_i0P0, "green")); + }, + $signature: 39 + }; + A.colorClass__closure12.prototype = { + call$1($self) { + A.warnForDeprecationFromApi("blue is deprecated, use `channel` instead.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + return B.JSNumber_methods.round$0($self._color0$_legacyChannel$2(B.RgbColorSpace_i0P0, "blue")); + }, + $signature: 39 + }; + A.colorClass__closure13.prototype = { + call$1($self) { + A.warnForDeprecationFromApi("hue is deprecated, use `channel` instead.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + return $self._color0$_legacyChannel$2(B.HslColorSpace_JQ20, "hue"); + }, + $signature: 31 + }; + A.colorClass__closure14.prototype = { + call$1($self) { + A.warnForDeprecationFromApi("saturation is deprecated, use `channel` instead.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + return $self._color0$_legacyChannel$2(B.HslColorSpace_JQ20, "saturation"); + }, + $signature: 31 + }; + A.colorClass__closure15.prototype = { + call$1($self) { + A.warnForDeprecationFromApi("lightness is deprecated, use `channel` instead.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + return $self._color0$_legacyChannel$2(B.HslColorSpace_JQ20, "lightness"); + }, + $signature: 31 + }; + A.colorClass__closure16.prototype = { + call$1($self) { + A.warnForDeprecationFromApi("whiteness is deprecated, use `channel` instead.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + return $self._color0$_legacyChannel$2(B.HwbColorSpace_guQ0, "whiteness"); + }, + $signature: 31 + }; + A.colorClass__closure17.prototype = { + call$1($self) { + A.warnForDeprecationFromApi("blackness is deprecated, use `channel` instead.\nMore info: https://sass-lang.com/d/color-4-api", B.Deprecation_FD1); + return $self._color0$_legacyChannel$2(B.HwbColorSpace_guQ0, "blackness"); + }, + $signature: 31 + }; + A.colorClass__closure18.prototype = { + call$1($self) { + var t1 = $self.alphaOrNull; + return t1 == null ? 0 : t1; + }, + $signature: 31 + }; + A.colorClass__closure19.prototype = { + call$1($self) { + return $self._color0$_space.name; + }, + $signature: 410 + }; + A.colorClass__closure20.prototype = { + call$1($self) { + return $self._color0$_space.get$isLegacyInternal(); + }, + $signature: 411 + }; + A.colorClass__closure21.prototype = { + call$1($self) { + return new self.immutable.List($self.get$channelsOrNull()); + }, + $signature: 228 + }; + A.colorClass__closure22.prototype = { + call$1($self) { + return new self.immutable.List($self.get$channels()); + }, + $signature: 228 + }; + A._Channels.prototype = {}; + A._ConstructionOptions.prototype = {}; + A._ChannelOptions.prototype = {}; + A._ToGamutOptions.prototype = {}; + A._InterpolationOptions.prototype = {}; + A._NodeSassColor.prototype = {}; + A.legacyColorClass_closure.prototype = { + call$6(thisArg, redOrArgb, green, blue, alpha, dartValue) { + var red, t1, t2, t3, t4; + if (dartValue != null) { + J.set$dartValue$x(thisArg, dartValue); + return; + } + if (green == null || blue == null) { + A._asInt(redOrArgb); + alpha = B.JSInt_methods._shrOtherPositive$1(redOrArgb, 24) / 255; + red = B.JSInt_methods.$mod(B.JSInt_methods._shrOtherPositive$1(redOrArgb, 16), 256); + green = B.JSInt_methods.$mod(B.JSInt_methods._shrOtherPositive$1(redOrArgb, 8), 256); + blue = B.JSInt_methods.$mod(redOrArgb, 256); + } else { + redOrArgb.toString; + red = redOrArgb; + } + t1 = A.fuzzyRound0(isNaN(red) ? 0 : B.JSNumber_methods.clamp$2(red, 0, 255)); + t2 = A.fuzzyRound0(isNaN(green) ? 0 : B.JSNumber_methods.clamp$2(green, 0, 255)); + t3 = A.fuzzyRound0(isNaN(blue) ? 0 : B.JSNumber_methods.clamp$2(blue, 0, 255)); + t4 = A.NullableExtension_andThen0(alpha, new A.legacyColorClass__closure()); + J.set$dartValue$x(thisArg, A.SassColor_SassColor$rgbInternal0(t1, t2, t3, t4 == null ? 1 : t4, null)); + }, + call$2(thisArg, redOrArgb) { + var _null = null; + return this.call$6(thisArg, redOrArgb, _null, _null, _null, _null); + }, + call$3(thisArg, redOrArgb, green) { + return this.call$6(thisArg, redOrArgb, green, null, null, null); + }, + call$4(thisArg, redOrArgb, green, blue) { + return this.call$6(thisArg, redOrArgb, green, blue, null, null); + }, + call$5(thisArg, redOrArgb, green, blue, alpha) { + return this.call$6(thisArg, redOrArgb, green, blue, alpha, null); + }, + "call*": "call$6", + $requiredArgCount: 2, + $defaultValues() { + return [null, null, null, null]; + }, + $signature: 413 + }; + A.legacyColorClass__closure.prototype = { + call$1(alpha) { + return isNaN(alpha) ? 0 : B.JSNumber_methods.clamp$2(alpha, 0, 1); + }, + $signature: 414 + }; + A.legacyColorClass_closure0.prototype = { + call$1(thisArg) { + return B.JSNumber_methods.round$0(J.get$dartValue$x(thisArg)._color0$_legacyChannel$2(B.RgbColorSpace_i0P0, "red")); + }, + $signature: 124 + }; + A.legacyColorClass_closure1.prototype = { + call$1(thisArg) { + return B.JSNumber_methods.round$0(J.get$dartValue$x(thisArg)._color0$_legacyChannel$2(B.RgbColorSpace_i0P0, "green")); + }, + $signature: 124 + }; + A.legacyColorClass_closure2.prototype = { + call$1(thisArg) { + return B.JSNumber_methods.round$0(J.get$dartValue$x(thisArg)._color0$_legacyChannel$2(B.RgbColorSpace_i0P0, "blue")); + }, + $signature: 124 + }; + A.legacyColorClass_closure3.prototype = { + call$1(thisArg) { + var t1 = J.get$dartValue$x(thisArg).alphaOrNull; + return t1 == null ? 0 : t1; + }, + $signature: 416 + }; + A.legacyColorClass_closure4.prototype = { + call$2(thisArg, value) { + var t1 = J.getInterceptor$x(thisArg), + t2 = t1.get$dartValue(thisArg); + t1.set$dartValue(thisArg, t2.changeRgb$1$red(A.fuzzyRound0(isNaN(value) ? 0 : B.JSNumber_methods.clamp$2(value, 0, 255)))); + }, + $signature: 87 + }; + A.legacyColorClass_closure5.prototype = { + call$2(thisArg, value) { + var t1 = J.getInterceptor$x(thisArg), + t2 = t1.get$dartValue(thisArg); + t1.set$dartValue(thisArg, t2.changeRgb$1$green(A.fuzzyRound0(isNaN(value) ? 0 : B.JSNumber_methods.clamp$2(value, 0, 255)))); + }, + $signature: 87 + }; + A.legacyColorClass_closure6.prototype = { + call$2(thisArg, value) { + var t1 = J.getInterceptor$x(thisArg), + t2 = t1.get$dartValue(thisArg); + t1.set$dartValue(thisArg, t2.changeRgb$1$blue(A.fuzzyRound0(isNaN(value) ? 0 : B.JSNumber_methods.clamp$2(value, 0, 255)))); + }, + $signature: 87 + }; + A.legacyColorClass_closure7.prototype = { + call$2(thisArg, value) { + var t1 = J.getInterceptor$x(thisArg), + t2 = t1.get$dartValue(thisArg); + t1.set$dartValue(thisArg, t2.changeRgb$1$alpha(isNaN(value) ? 0 : B.JSNumber_methods.clamp$2(value, 0, 1))); + }, + $signature: 87 + }; + A.SassColor0.prototype = { + get$channels() { + var t2, t3, + t1 = this.channel0OrNull; + if (t1 == null) + t1 = 0; + t2 = this.channel1OrNull; + if (t2 == null) + t2 = 0; + t3 = this.channel2OrNull; + return A.List_List$unmodifiable([t1, t2, t3 == null ? 0 : t3], type$.double); + }, + get$channelsOrNull() { + return A.List_List$unmodifiable([this.channel0OrNull, this.channel1OrNull, this.channel2OrNull], type$.nullable_double); + }, + get$isChannel0Powerless() { + var t1, t2, _this = this, + _0_0 = _this._color0$_space; + $label0$0: { + if (B.HslColorSpace_JQ20 === _0_0) { + t1 = _this.channel1OrNull; + t1 = A.fuzzyEquals0(t1 == null ? 0 : t1, 0); + break $label0$0; + } + if (B.HwbColorSpace_guQ0 === _0_0) { + t1 = _this.channel1OrNull; + if (t1 == null) + t1 = 0; + t2 = _this.channel2OrNull; + t1 += t2 == null ? 0 : t2; + t1 = t1 > 100 || A.fuzzyEquals0(t1, 100); + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + get$isChannel2Powerless() { + var t1, + _0_0 = this._color0$_space; + $label0$0: { + if (B.LchColorSpace_Bpv0 === _0_0 || B.OklchColorSpace_9Gj0 === _0_0) { + t1 = this.channel1OrNull; + t1 = A.fuzzyEquals0(t1 == null ? 0 : t1, 0); + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + get$isInGamut() { + var t2, t3, _this = this, + t1 = _this._color0$_space; + if (!t1.get$isBoundedInternal()) + return true; + t2 = _this.channel0OrNull; + if (t2 == null) + t2 = 0; + t1 = t1._space$_channels; + t3 = false; + if (_this._color0$_isChannelInGamut$2(t2, t1[0])) { + t2 = _this.channel1OrNull; + if (t2 == null) + t2 = 0; + if (_this._color0$_isChannelInGamut$2(t2, t1[1])) { + t2 = _this.channel2OrNull; + if (t2 == null) + t2 = 0; + t1 = _this._color0$_isChannelInGamut$2(t2, t1[2]); + } else + t1 = t3; + } else + t1 = t3; + return t1; + }, + _color0$_isChannelInGamut$2(value, channel) { + var min, max, t1; + $label0$0: { + if (channel instanceof A.LinearChannel0) { + min = channel.min; + max = channel.max; + if (value < max || A.fuzzyEquals0(value, max)) + t1 = value > min || A.fuzzyEquals0(value, min); + else + t1 = false; + break $label0$0; + } + t1 = true; + break $label0$0; + } + return t1; + }, + accept$1$1(visitor) { + return visitor.visitColor$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + assertColor$1($name) { + return this; + }, + assertLegacy$1($name) { + if (this._color0$_space.get$isLegacyInternal()) + return; + throw A.wrapException(A.SassScriptException$0("Expected " + this.toString$0(0) + string$.x20to_be, $name)); + }, + channel$1(_, channel) { + var t1, _this = this, + channels = _this._color0$_space._space$_channels; + if (channel === channels[0].name) { + t1 = _this.channel0OrNull; + return t1 == null ? 0 : t1; + } + if (channel === channels[1].name) { + t1 = _this.channel1OrNull; + return t1 == null ? 0 : t1; + } + if (channel === channels[2].name) { + t1 = _this.channel2OrNull; + return t1 == null ? 0 : t1; + } + if (channel === "alpha") { + t1 = _this.alphaOrNull; + return t1 == null ? 0 : t1; + } + throw A.wrapException(A.SassScriptException$0("Color " + _this.toString$0(0) + " doesn't have a channel named \"" + channel + '".', null)); + }, + isChannelMissing$3$channelName$colorName(channel, channelName, colorName) { + var _this = this, + channels = _this._color0$_space._space$_channels; + if (channel === channels[0].name) + return _this.channel0OrNull == null; + if (channel === channels[1].name) + return _this.channel1OrNull == null; + if (channel === channels[2].name) + return _this.channel2OrNull == null; + if (channel === "alpha") + return _this.alphaOrNull == null; + throw A.wrapException(A.SassScriptException$0("Color " + _this.toString$0(0) + " doesn't have a channel named \"" + channel + '".', channelName)); + }, + isChannelMissing$1(channel) { + return this.isChannelMissing$3$channelName$colorName(channel, null, null); + }, + isChannelPowerless$3$channelName$colorName(channel, channelName, colorName) { + var _this = this, + channels = _this._color0$_space._space$_channels; + if (channel === channels[0].name) + return _this.get$isChannel0Powerless(); + if (channel === channels[1].name) + return false; + if (channel === channels[2].name) + return _this.get$isChannel2Powerless(); + if (channel === "alpha") + return false; + throw A.wrapException(A.SassScriptException$0("Color " + _this.toString$0(0) + " doesn't have a channel named \"" + channel + '".', channelName)); + }, + isChannelPowerless$1(channel) { + return this.isChannelPowerless$3$channelName$colorName(channel, null, null); + }, + _color0$_legacyChannel$2(space, channel) { + if (!this._color0$_space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0("color." + channel + string$.x28__is_oc, null)); + return this.toSpace$1(space).channel$1(0, channel); + }, + toSpace$2$legacyMissing(space, legacyMissing) { + var t2, converted, t3, t4, _this = this, + t1 = _this._color0$_space; + if (t1 === space) + return _this; + t2 = _this.alphaOrNull; + if (t2 == null) + t2 = 0; + converted = t1.convert$5(space, _this.channel0OrNull, _this.channel1OrNull, _this.channel2OrNull, t2); + t1 = false; + if (!legacyMissing) + if (converted._color0$_space.get$isLegacyInternal()) + t1 = converted.channel0OrNull == null || converted.channel1OrNull == null || converted.channel2OrNull == null || converted.alphaOrNull == null; + if (t1) { + t1 = converted.channel0OrNull; + if (t1 == null) + t1 = 0; + t2 = converted.channel1OrNull; + if (t2 == null) + t2 = 0; + t3 = converted.channel2OrNull; + if (t3 == null) + t3 = 0; + t4 = converted.alphaOrNull; + if (t4 == null) + t4 = 0; + t4 = A.SassColor_SassColor$forSpaceInternal0(converted._color0$_space, t1, t2, t3, t4); + t1 = t4; + } else + t1 = converted; + return t1; + }, + toSpace$1(space) { + return this.toSpace$2$legacyMissing(space, true); + }, + changeRgb$4$alpha$blue$green$red(alpha, blue, green, red) { + var t1, t2, t3, t4, _this = this, _null = null; + if (!_this._color0$_space.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0("color.changeRgb() is only supported for legacy colors. Please use color.changeChannels() instead with an explicit $space argument.", _null)); + t1 = red == null ? _null : red; + if (t1 == null) + t1 = _this.channel$1(0, "red"); + t2 = green == null ? _null : green; + if (t2 == null) + t2 = _this.channel$1(0, "green"); + t3 = blue == null ? _null : blue; + if (t3 == null) + t3 = _this.channel$1(0, "blue"); + t4 = alpha == null ? _null : alpha; + if (t4 == null) { + t4 = _this.alphaOrNull; + if (t4 == null) + t4 = 0; + } + return A.SassColor_SassColor$rgbInternal0(t1, t2, t3, t4, _null); + }, + changeRgb$1$alpha(alpha) { + return this.changeRgb$4$alpha$blue$green$red(alpha, null, null, null); + }, + changeRgb$1$blue(blue) { + return this.changeRgb$4$alpha$blue$green$red(null, blue, null, null); + }, + changeRgb$1$green(green) { + return this.changeRgb$4$alpha$blue$green$red(null, null, green, null); + }, + changeRgb$1$red(red) { + return this.changeRgb$4$alpha$blue$green$red(null, null, null, red); + }, + changeHsl$3$hue$lightness$saturation(hue, lightness, saturation) { + var t2, t3, t4, t5, _this = this, _null = null, + t1 = _this._color0$_space; + if (!t1.get$isLegacyInternal()) + throw A.wrapException(A.SassScriptException$0(string$.color_c, _null)); + t2 = hue == null ? _null : hue; + if (t2 == null) + t2 = _this._color0$_legacyChannel$2(B.HslColorSpace_JQ20, "hue"); + t3 = saturation == null ? _null : saturation; + if (t3 == null) + t3 = _this._color0$_legacyChannel$2(B.HslColorSpace_JQ20, "saturation"); + t4 = lightness == null ? _null : lightness; + if (t4 == null) + t4 = _this._color0$_legacyChannel$2(B.HslColorSpace_JQ20, "lightness"); + t5 = _this.alphaOrNull; + if (t5 == null) + t5 = 0; + return A.SassColor_SassColor$hsl0(t2, t3, t4, t5).toSpace$1(t1); + }, + changeHsl$1$saturation(saturation) { + return this.changeHsl$3$hue$lightness$saturation(null, null, saturation); + }, + changeHsl$1$lightness(lightness) { + return this.changeHsl$3$hue$lightness$saturation(null, lightness, null); + }, + changeHsl$1$hue(hue) { + return this.changeHsl$3$hue$lightness$saturation(hue, null, null); + }, + changeAlpha$1(alpha) { + var t2, t3, _this = this, + t1 = _this.channel0OrNull; + if (t1 == null) + t1 = 0; + t2 = _this.channel1OrNull; + if (t2 == null) + t2 = 0; + t3 = _this.channel2OrNull; + if (t3 == null) + t3 = 0; + return A.SassColor_SassColor$forSpaceInternal0(_this._color0$_space, t1, t2, t3, alpha); + }, + interpolate$4$legacyMissing$weight(other, method, legacyMissing, weight) { + var t1, color1, color2, missing1_0, missing1_1, missing1_2, missing2_0, missing2_1, missing2_2, channel1_0, channel1_1, channel1_2, channel2_0, channel2_1, channel2_2, alpha1, t2, t3, alpha10, alpha2, alpha20, thisMultiplier, t4, t5, otherMultiplier, mixedAlpha, mixed0, mixed1, mixed2, _this = this, _null = null; + if (weight == null) + weight = 0.5; + if (A.fuzzyEquals0(weight, 0)) + return other; + if (A.fuzzyEquals0(weight, 1)) + return _this; + t1 = method.space; + color1 = _this.toSpace$1(t1); + color2 = other.toSpace$1(t1); + if (weight < 0 || weight > 1) + throw A.wrapException(A.RangeError$range(weight, 0, 1, "weight", _null)); + missing1_0 = _this._color0$_isAnalogousChannelMissing$3(_this, color1, 0); + missing1_1 = _this._color0$_isAnalogousChannelMissing$3(_this, color1, 1); + missing1_2 = _this._color0$_isAnalogousChannelMissing$3(_this, color1, 2); + missing2_0 = _this._color0$_isAnalogousChannelMissing$3(other, color2, 0); + missing2_1 = _this._color0$_isAnalogousChannelMissing$3(other, color2, 1); + missing2_2 = _this._color0$_isAnalogousChannelMissing$3(other, color2, 2); + channel1_0 = (missing1_0 ? color2 : color1).channel0OrNull; + if (channel1_0 == null) + channel1_0 = 0; + channel1_1 = (missing1_1 ? color2 : color1).channel1OrNull; + if (channel1_1 == null) + channel1_1 = 0; + channel1_2 = (missing1_2 ? color2 : color1).channel2OrNull; + if (channel1_2 == null) + channel1_2 = 0; + channel2_0 = (missing2_0 ? color1 : color2).channel0OrNull; + if (channel2_0 == null) + channel2_0 = 0; + channel2_1 = (missing2_1 ? color1 : color2).channel1OrNull; + if (channel2_1 == null) + channel2_1 = 0; + channel2_2 = (missing2_2 ? color1 : color2).channel2OrNull; + if (channel2_2 == null) + channel2_2 = 0; + alpha1 = _this.alphaOrNull; + t2 = alpha1 == null; + if (t2) { + t3 = other.alphaOrNull; + alpha10 = t3 == null ? 0 : t3; + } else + alpha10 = alpha1; + alpha2 = other.alphaOrNull; + t3 = alpha2 == null; + if (t3) + alpha20 = t2 ? 0 : alpha1; + else + alpha20 = alpha2; + thisMultiplier = (t2 ? 1 : alpha1) * weight; + t4 = t3 ? 1 : alpha2; + t5 = 1 - weight; + otherMultiplier = t4 * t5; + mixedAlpha = t2 && t3 ? _null : alpha10 * weight + alpha20 * t5; + if (missing1_0 && missing2_0) + mixed0 = _null; + else { + t2 = mixedAlpha == null ? 1 : mixedAlpha; + mixed0 = (channel1_0 * thisMultiplier + channel2_0 * otherMultiplier) / t2; + } + if (missing1_1 && missing2_1) + mixed1 = _null; + else { + t2 = mixedAlpha == null ? 1 : mixedAlpha; + mixed1 = (channel1_1 * thisMultiplier + channel2_1 * otherMultiplier) / t2; + } + if (missing1_2 && missing2_2) + mixed2 = _null; + else { + t2 = mixedAlpha == null ? 1 : mixedAlpha; + mixed2 = (channel1_2 * thisMultiplier + channel2_2 * otherMultiplier) / t2; + } + $label0$0: { + if (B.HslColorSpace_JQ20 === t1 || B.HwbColorSpace_guQ0 === t1) { + if (missing1_0 && missing2_0) + t2 = _null; + else { + t2 = method.hue; + t2.toString; + t2 = _this._color0$_interpolateHues$4(channel1_0, channel2_0, t2, weight); + } + t2 = A.SassColor_SassColor$forSpaceInternal0(t1, t2, mixed1, mixed2, mixedAlpha); + t1 = t2; + break $label0$0; + } + if (B.LchColorSpace_Bpv0 === t1 || B.OklchColorSpace_9Gj0 === t1) { + if (missing1_2 && missing2_2) + t2 = _null; + else { + t2 = method.hue; + t2.toString; + t2 = _this._color0$_interpolateHues$4(channel1_2, channel2_2, t2, weight); + } + t2 = A.SassColor_SassColor$forSpaceInternal0(t1, mixed0, mixed1, t2, mixedAlpha); + t1 = t2; + break $label0$0; + } + t1 = A.SassColor_SassColor$forSpaceInternal0(t1, mixed0, mixed1, mixed2, mixedAlpha); + break $label0$0; + } + return t1.toSpace$2$legacyMissing(_this._color0$_space, legacyMissing); + }, + interpolate$3$weight(other, method, weight) { + return this.interpolate$4$legacyMissing$weight(other, method, true, weight); + }, + _color0$_isAnalogousChannelMissing$3(original, output, outputChannelIndex) { + var originalChannel; + if (output.get$channelsOrNull()[outputChannelIndex] == null) + return true; + if (original === output) + return false; + originalChannel = A.IterableExtension_firstWhereOrNull(original._color0$_space._space$_channels, output._color0$_space._space$_channels[outputChannelIndex].get$isAnalogous()); + if (originalChannel == null) + return false; + return original.isChannelMissing$1(originalChannel.name); + }, + _color0$_interpolateHues$4(hue1, hue2, method, weight) { + var _0_0, _1_0; + $label1$1: { + if (B.HueInterpolationMethod_00 === method) { + $label0$0: { + _0_0 = hue2 - hue1; + if (_0_0 > 180) { + hue1 += 360; + break $label0$0; + } + if (_0_0 < -180) + hue2 += 360; + } + break $label1$1; + } + if (B.HueInterpolationMethod_10 === method) { + $label2$2: { + _1_0 = hue2 - hue1; + if (_1_0 > 0 && _1_0 < 180) { + hue2 += 360; + break $label2$2; + } + if (_1_0 > -180 && _1_0 <= 0) + hue1 += 360; + } + break $label1$1; + } + if (B.HueInterpolationMethod_20 === method && hue2 < hue1) { + hue2 += 360; + break $label1$1; + } + if (B.HueInterpolationMethod_30 === method && hue1 < hue2) { + hue1 += 360; + break $label1$1; + } + } + return hue1 * weight + hue2 * (1 - weight); + }, + plus$1(other) { + if (!(other instanceof A.SassNumber0) && !(other instanceof A.SassColor0)) + return this.super$Value$plus0(other); + throw A.wrapException(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " + " + other.toString$0(0) + '".', null)); + }, + minus$1(other) { + if (!(other instanceof A.SassNumber0) && !(other instanceof A.SassColor0)) + return this.super$Value$minus0(other); + throw A.wrapException(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " - " + other.toString$0(0) + '".', null)); + }, + dividedBy$1(other) { + if (!(other instanceof A.SassNumber0) && !(other instanceof A.SassColor0)) + return this.super$Value$dividedBy0(other); + throw A.wrapException(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " / " + other.toString$0(0) + '".', null)); + }, + $eq(_, other) { + var t1, t2, _this = this; + if (other == null) + return false; + if (!(other instanceof A.SassColor0)) + return false; + t1 = _this._color0$_space; + if (t1.get$isLegacyInternal()) { + t2 = other._color0$_space; + if (!t2.get$isLegacyInternal()) + return false; + if (!A.fuzzyEqualsNullable0(_this.alphaOrNull, other.alphaOrNull)) + return false; + if (t1 === t2) + return A.fuzzyEqualsNullable0(_this.channel0OrNull, other.channel0OrNull) && A.fuzzyEqualsNullable0(_this.channel1OrNull, other.channel1OrNull) && A.fuzzyEqualsNullable0(_this.channel2OrNull, other.channel2OrNull); + else + return _this.toSpace$1(B.RgbColorSpace_i0P0).$eq(0, other.toSpace$1(B.RgbColorSpace_i0P0)); + } + return t1 === other._color0$_space && A.fuzzyEqualsNullable0(_this.channel0OrNull, other.channel0OrNull) && A.fuzzyEqualsNullable0(_this.channel1OrNull, other.channel1OrNull) && A.fuzzyEqualsNullable0(_this.channel2OrNull, other.channel2OrNull) && A.fuzzyEqualsNullable0(_this.alphaOrNull, other.alphaOrNull); + }, + get$hashCode(_) { + var rgb, t2, t3, t4, t5, _this = this, + t1 = _this._color0$_space; + if (t1.get$isLegacyInternal()) { + rgb = _this.toSpace$1(B.RgbColorSpace_i0P0); + t1 = rgb.channel0OrNull; + t1 = A.fuzzyHashCode0(t1 == null ? 0 : t1); + t2 = rgb.channel1OrNull; + t2 = A.fuzzyHashCode0(t2 == null ? 0 : t2); + t3 = rgb.channel2OrNull; + t3 = A.fuzzyHashCode0(t3 == null ? 0 : t3); + t4 = _this.alphaOrNull; + return t1 ^ t2 ^ t3 ^ A.fuzzyHashCode0(t4 == null ? 0 : t4); + } else { + t1 = A.Primitives_objectHashCode(t1); + t2 = _this.channel0OrNull; + t2 = A.fuzzyHashCode0(t2 == null ? 0 : t2); + t3 = _this.channel1OrNull; + t3 = A.fuzzyHashCode0(t3 == null ? 0 : t3); + t4 = _this.channel2OrNull; + t4 = A.fuzzyHashCode0(t4 == null ? 0 : t4); + t5 = _this.alphaOrNull; + return (t1 ^ t2 ^ t3 ^ t4 ^ A.fuzzyHashCode0(t5 == null ? 0 : t5)) >>> 0; + } + } + }; + A.SassColor$_forSpace_closure0.prototype = { + call$1(alpha) { + return A.fuzzyAssertRange0(alpha, 0, 1, "alpha"); + }, + $signature: 16 + }; + A._ColorFormatEnum0.prototype = { + toString$0(_) { + return "rgbFunction"; + } + }; + A.SpanColorFormat0.prototype = {}; + A.Combinator0.prototype = { + _enumToString$0() { + return "Combinator." + this._name; + }, + toString$0(_) { + return this._combinator0$_text; + } + }; + A.ModifiableCssComment0.prototype = { + accept$1$1(visitor) { + return visitor.visitCssComment$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + $isCssComment0: 1, + get$span(receiver) { + return this.span; + } + }; + A.compileAsync_closure.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.NodeCompileResult), + $async$returnValue, $async$self = this, t5, t6, t7, t8, t9, t10, t11, t12, t13, result, t1, t2, t3, t4; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.options; + t2 = t1 == null; + t3 = t2 ? null : J.get$loadPaths$x(t1); + t4 = t2 ? null : J.get$quietDeps$x(t1); + if (t4 == null) + t4 = false; + t5 = A._parseOutputStyle0(t2 ? null : J.get$style$x(t1)); + t6 = t2 ? null : J.get$verbose$x(t1); + if (t6 == null) + t6 = false; + t7 = t2 ? null : J.get$charset$x(t1); + if (t7 == null) + t7 = true; + t8 = t2 ? null : J.get$sourceMap$x(t1); + if (t8 == null) + t8 = false; + t9 = $async$self.logger; + if (t2) + t10 = null; + else { + t10 = J.get$importers$x(t1); + t10 = t10 == null ? null : J.map$1$1$ax(t10, new A.compileAsync__closure(), type$.AsyncImporter); + } + t11 = A._parseFunctions0(t2 ? null : J.get$functions$x(t1), true); + t12 = A.parseDeprecations(t9, t2 ? null : J.get$fatalDeprecations$x(t1), true); + t13 = A.parseDeprecations(t9, t2 ? null : J.get$silenceDeprecations$x(t1), false); + $async$goto = 3; + return A._asyncAwait(A.compileAsync0($async$self.path, t7, t12, t11, A.parseDeprecations(t9, t2 ? null : J.get$futureDeprecations$x(t1), false), A.AsyncImportCache$(t10, t3, null), null, null, t9, null, t4, t13, t8, t5, null, true, t6), $async$call$0); + case 3: + // returning from await. + result = $async$result; + t1 = t2 ? null : J.get$sourceMapIncludeSources$x(t1); + $async$returnValue = A._convertResult(result, t1 == null ? false : t1); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 230 + }; + A.compileAsync__closure.prototype = { + call$1(importer) { + return A._parseAsyncImporter(importer); + }, + $signature: 231 + }; + A.compileStringAsync_closure.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.NodeCompileResult), + $async$returnValue, $async$self = this, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, result, t1, t2, t3, t4, t5, t6; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.options; + t2 = t1 == null; + t3 = A.parseSyntax(t2 ? null : J.get$syntax$x(t1)); + t4 = t2 ? null : A.NullableExtension_andThen0(J.get$url$x(t1), A.utils3__jsToDartUrl$closure()); + t5 = t2 ? null : J.get$loadPaths$x(t1); + t6 = t2 ? null : J.get$quietDeps$x(t1); + if (t6 == null) + t6 = false; + t7 = A._parseOutputStyle0(t2 ? null : J.get$style$x(t1)); + t8 = t2 ? null : J.get$verbose$x(t1); + if (t8 == null) + t8 = false; + t9 = t2 ? null : J.get$charset$x(t1); + if (t9 == null) + t9 = true; + t10 = t2 ? null : J.get$sourceMap$x(t1); + if (t10 == null) + t10 = false; + t11 = $async$self.logger; + if (t2) + t12 = null; + else { + t12 = J.get$importers$x(t1); + t12 = t12 == null ? null : J.map$1$1$ax(t12, new A.compileStringAsync__closure(), type$.AsyncImporter); + } + t13 = t2 ? null : A.NullableExtension_andThen0(J.get$importer$x(t1), new A.compileStringAsync__closure0()); + if (t13 == null) + t13 = (t2 ? null : J.get$url$x(t1)) == null ? new A.NoOpImporter0() : null; + t14 = A._parseFunctions0(t2 ? null : J.get$functions$x(t1), true); + t15 = A.parseDeprecations(t11, t2 ? null : J.get$fatalDeprecations$x(t1), true); + t16 = A.parseDeprecations(t11, t2 ? null : J.get$silenceDeprecations$x(t1), false); + $async$goto = 3; + return A._asyncAwait(A.compileStringAsync0($async$self.text, t9, t15, t14, A.parseDeprecations(t11, t2 ? null : J.get$futureDeprecations$x(t1), false), A.AsyncImportCache$(t12, t5, null), t13, null, null, t11, null, t6, t16, t10, t7, t3, t4, true, t8), $async$call$0); + case 3: + // returning from await. + result = $async$result; + t1 = t2 ? null : J.get$sourceMapIncludeSources$x(t1); + $async$returnValue = A._convertResult(result, t1 == null ? false : t1); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 230 + }; + A.compileStringAsync__closure.prototype = { + call$1(importer) { + return A._parseAsyncImporter(importer); + }, + $signature: 231 + }; + A.compileStringAsync__closure0.prototype = { + call$1(importer) { + return A._parseAsyncImporter(importer); + }, + $signature: 420 + }; + A._wrapAsyncSassExceptions_closure.prototype = { + call$1(error) { + var t1; + if (error instanceof A.SassException0) + t1 = A.throwNodeException(error, this.ascii, this.color, null); + else + t1 = A.jsThrow(error == null ? type$.Object._as(error) : error); + return t1; + }, + $signature: 421 + }; + A._parseFunctions_closure0.prototype = { + call$2(signature, callback) { + var callable, + t1 = this.result; + if (!this.asynch) { + callable = A._Cell$(); + callable.__late_helper$_value = A.Callable_Callable$fromSignature(signature, new A._parseFunctions__closure2(callback, callable), true); + t1.push(callable._readLocal$0()); + } else { + callable = A._Cell$(); + callable.__late_helper$_value = A.AsyncCallable_AsyncCallable$fromSignature(signature, new A._parseFunctions__closure3(callback, callable), true); + t1.push(callable._readLocal$0()); + } + }, + $signature: 126 + }; + A._parseFunctions__closure2.prototype = { + call$1($arguments) { + var t1, t2, + _s42_ = string$.Invali, + result = A.wrapJSExceptions(new A._parseFunctions___closure6(this.callback, $arguments)); + if (result instanceof A.Value0) + return A._simplifyValue(result); + t1 = result != null && result instanceof self.Promise; + t2 = this.callable; + if (t1) { + t1 = t2.readLocal$0(); + throw A.wrapException(_s42_ + t1.get$name(t1) + '":\nPromises may only be returned for sass.compileAsync() and sass.compileStringAsync().'); + } else { + t1 = t2.readLocal$0(); + throw A.wrapException(_s42_ + t1.get$name(t1) + '": ' + A.S(result) + " is not a sass.Value."); + } + }, + $signature: 3 + }; + A._parseFunctions___closure6.prototype = { + call$0() { + return type$.Function._as(this.callback).call$1(A.toJSArray(this.$arguments)); + }, + $signature: 59 + }; + A._parseFunctions__closure3.prototype = { + call$1($arguments) { + return this.$call$body$_parseFunctions__closure0($arguments); + }, + $call$body$_parseFunctions__closure0($arguments) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$self = this, t1, result; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + result = A.wrapJSExceptions(new A._parseFunctions___closure5($async$self.callback, $arguments)); + $async$goto = result != null && result instanceof self.Promise ? 3 : 4; + break; + case 3: + // then + $async$goto = 5; + return A._asyncAwait(A.promiseToFuture0(type$.Promise._as(result), type$.Object), $async$call$1); + case 5: + // returning from await. + result = $async$result; + case 4: + // join + if (result instanceof A.Value0) { + $async$returnValue = A._simplifyValue(result); + // goto return + $async$goto = 1; + break; + } + t1 = $async$self.callable.readLocal$0(); + throw A.wrapException(string$.Invali + t1.get$name(t1) + '": ' + A.S(result) + " is not a sass.Value."); + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 86 + }; + A._parseFunctions___closure5.prototype = { + call$0() { + return type$.Function._as(this.callback).call$1(A.toJSArray(this.$arguments)); + }, + $signature: 59 + }; + A.nodePackageImporterClass_closure.prototype = { + call$0() { + return type$.JSClass._as(A.allowInteropCaptureThisNamed("sass.NodePackageImporter", new A.nodePackageImporterClass__closure())); + }, + $signature: 15 + }; + A.nodePackageImporterClass__closure.prototype = { + call$2($self, entrypointDirectory) { + var directory, t1, filename, t2, _null = null, + _0_3 = A.entrypointFilename(); + $label0$0: { + if (entrypointDirectory != null) { + directory = entrypointDirectory == null ? A._asString(entrypointDirectory) : entrypointDirectory; + t1 = directory; + break $label0$0; + } + if (_0_3 != null) { + filename = _0_3 == null ? A._asString(_0_3) : _0_3; + t1 = $.$get$context().dirname$1(filename); + break $label0$0; + } + t1 = A.throwExpression("The Node package importer cannot determine an entry point because `require.main.filename` is not defined. Please provide an `entryPointDirectory` to the `NodePackageImporter`."); + } + t2 = new A.NodePackageImporter0(); + if (A.isBrowser()) + A.throwExpression(string$.The_No); + t2._node_package$__NodePackageImporter__entryPointDirectory_F = A.absolute(t1, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null); + return t2; + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 423 + }; + A._compileStylesheet_closure1.prototype = { + call$1(url) { + return url === "" ? A.Uri_Uri$dataFromString(A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(this.stylesheet.span.file._decodedChars, 0, null), 0, null), B.C_Utf8Codec, null).get$_text() : this.importCache.sourceMapUrl$1(0, A.Uri_parse(url)).toString$0(0); + }, + $signature: 6 + }; + A.CompileOptions.prototype = {}; + A.CompileStringOptions.prototype = {}; + A.NodeCompileResult.prototype = {}; + A.CompileResult0.prototype = {}; + A.Compiler.prototype = {}; + A.AsyncCompiler.prototype = { + addCompilation$1(compilation) { + this.compilations.add$1(0, A.promiseToFuture(compilation, type$.dynamic).catchError$1(new A.AsyncCompiler_addCompilation_closure())); + } + }; + A.AsyncCompiler_addCompilation_closure.prototype = { + call$1(err) { + }, + $signature: 55 + }; + A.compilerClass_closure.prototype = { + call$0() { + var t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.Compiler", new A.compilerClass__closure())); + A.LinkedHashMap_LinkedHashMap$_literal(["compile", new A.compilerClass__closure0(), "compileString", new A.compilerClass__closure1(), "dispose", new A.compilerClass__closure2()], type$.String, type$.Function).forEach$1(0, A.JSClassExtension_get_defineMethod(jsClass)); + A.JSClassExtension_injectSuperclass(t1._as(new A.Compiler().constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.compilerClass__closure.prototype = { + call$1($self) { + return A.LinkedHashSet_LinkedHashSet$_literal([A.jsThrow(new self.Error("Compiler can not be directly constructed. Please use `sass.initCompiler()` instead."))], type$.Never); + }, + $signature: 232 + }; + A.compilerClass__closure0.prototype = { + call$3($self, path, options) { + if ($self._disposed) + A.jsThrow(new self.Error("Compiler has already been disposed.")); + return A.compile0(path, options); + }, + call$2($self, path) { + return this.call$3($self, path, null); + }, + "call*": "call$3", + $requiredArgCount: 2, + $defaultValues() { + return [null]; + }, + $signature: 425 + }; + A.compilerClass__closure1.prototype = { + call$3($self, source, options) { + if ($self._disposed) + A.jsThrow(new self.Error("Compiler has already been disposed.")); + return A.compileString0(source, options); + }, + call$2($self, source) { + return this.call$3($self, source, null); + }, + "call*": "call$3", + $requiredArgCount: 2, + $defaultValues() { + return [null]; + }, + $signature: 426 + }; + A.compilerClass__closure2.prototype = { + call$1($self) { + $self._disposed = true; + }, + $signature: 427 + }; + A.asyncCompilerClass_closure.prototype = { + call$0() { + var t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.AsyncCompiler", new A.asyncCompilerClass__closure())); + A.LinkedHashMap_LinkedHashMap$_literal(["compileAsync", new A.asyncCompilerClass__closure0(), "compileStringAsync", new A.asyncCompilerClass__closure1(), "dispose", new A.asyncCompilerClass__closure2()], type$.String, type$.Function).forEach$1(0, A.JSClassExtension_get_defineMethod(jsClass)); + A.JSClassExtension_injectSuperclass(t1._as(new A.AsyncCompiler(new A.FutureGroup(new A._AsyncCompleter(new A._Future($.Zone__current, type$._Future_List_void), type$._AsyncCompleter_List_void), [], type$.FutureGroup_void)).constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.asyncCompilerClass__closure.prototype = { + call$1($self) { + return A.LinkedHashSet_LinkedHashSet$_literal([A.jsThrow(new self.Error("AsyncCompiler can not be directly constructed. Please use `sass.initAsyncCompiler()` instead."))], type$.Never); + }, + $signature: 232 + }; + A.asyncCompilerClass__closure0.prototype = { + call$3($self, path, options) { + var compilation; + if ($self._disposed) + A.jsThrow(new self.Error("Compiler has already been disposed.")); + compilation = A.compileAsync1(path, options); + $self.addCompilation$1(compilation); + return compilation; + }, + call$2($self, path) { + return this.call$3($self, path, null); + }, + "call*": "call$3", + $requiredArgCount: 2, + $defaultValues() { + return [null]; + }, + $signature: 428 + }; + A.asyncCompilerClass__closure1.prototype = { + call$3($self, source, options) { + var compilation; + if ($self._disposed) + A.jsThrow(new self.Error("Compiler has already been disposed.")); + compilation = A.compileStringAsync1(source, options); + $self.addCompilation$1(compilation); + return compilation; + }, + call$2($self, source) { + return this.call$3($self, source, null); + }, + "call*": "call$3", + $requiredArgCount: 2, + $defaultValues() { + return [null]; + }, + $signature: 429 + }; + A.asyncCompilerClass__closure2.prototype = { + call$1($self) { + $self._disposed = true; + return A.futureToPromise0(new A.asyncCompilerClass___closure($self).call$0()); + }, + $signature: 430 + }; + A.asyncCompilerClass___closure.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Null), + $async$self = this, t1; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.self.compilations; + t1.close$0(0); + $async$goto = 2; + return A._asyncAwait(t1._future_group$_completer.future, $async$call$0); + case 2: + // returning from await. + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 2 + }; + A.initAsyncCompiler_closure.prototype = { + call$0() { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.AsyncCompiler), + $async$returnValue; + var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$returnValue = new A.AsyncCompiler(new A.FutureGroup(new A._AsyncCompleter(new A._Future($.Zone__current, type$._Future_List_void), type$._AsyncCompleter_List_void), [], type$.FutureGroup_void)); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$0, $async$completer); + }, + $signature: 431 + }; + A.ComplexSassNumber0.prototype = { + get$numeratorUnits(_) { + return this._complex0$_numeratorUnits; + }, + get$denominatorUnits(_) { + return this._complex0$_denominatorUnits; + }, + get$hasUnits() { + return true; + }, + get$hasComplexUnits() { + return true; + }, + hasUnit$1(unit) { + return false; + }, + compatibleWithUnit$1(unit) { + return false; + }, + hasPossiblyCompatibleUnits$1(other) { + throw A.wrapException(A.UnimplementedError$(string$.Comple)); + }, + withValue$1(value) { + return new A.ComplexSassNumber0(this._complex0$_numeratorUnits, this._complex0$_denominatorUnits, value, null); + }, + withSlash$2(numerator, denominator) { + return new A.ComplexSassNumber0(this._complex0$_numeratorUnits, this._complex0$_denominatorUnits, this._number1$_value, new A._Record_2(numerator, denominator)); + } + }; + A.ComplexSelector0.prototype = { + get$specificity() { + var result, _this = this, + value = _this._complex$__ComplexSelector_specificity_FI; + if (value === $) { + result = B.JSArray_methods.fold$2(_this.components, 0, new A.ComplexSelector_specificity_closure0()); + _this._complex$__ComplexSelector_specificity_FI !== $ && A.throwUnnamedLateFieldADI(); + _this._complex$__ComplexSelector_specificity_FI = result; + value = result; + } + return value; + }, + get$singleCompound() { + var _0_0, t1, _0_4, selector; + if (this.leadingCombinators.length !== 0) + return null; + _0_0 = this.components; + $label0$0: { + t1 = false; + if (_0_0.length === 1) { + _0_4 = _0_0[0]; + selector = _0_4.selector; + t1 = _0_4.combinators.length <= 0; + } else + selector = null; + if (t1) { + t1 = selector; + break $label0$0; + } + t1 = null; + break $label0$0; + } + return t1; + }, + accept$1$1(visitor) { + return visitor.visitComplexSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + isSuperselector$1(other) { + return this.leadingCombinators.length === 0 && other.leadingCombinators.length === 0 && A.complexIsSuperselector0(this.components, other.components); + }, + withAdditionalCombinators$1(combinators) { + var _0_0, _0_1, t1, initial, last, _this = this; + if (combinators.length === 0) + return _this; + _0_0 = _this.components; + $label0$0: { + _0_1 = _0_0.length; + if (_0_1 >= 1) { + t1 = _0_1 - 1; + initial = B.JSArray_methods.sublist$2(_0_0, 0, t1); + last = _0_0[t1]; + t1 = A.List_List$of(initial, true, type$.ComplexSelectorComponent_2); + t1.push(last.withAdditionalCombinators$1(combinators)); + t1 = A.ComplexSelector$0(_this.leadingCombinators, t1, _this.span, _this.lineBreak); + break $label0$0; + } + if (_0_1 <= 0) { + t1 = A.List_List$of(_this.leadingCombinators, true, type$.CssValue_Combinator_2); + B.JSArray_methods.addAll$1(t1, combinators); + t1 = A.ComplexSelector$0(t1, B.List_empty16, _this.span, _this.lineBreak); + break $label0$0; + } + t1 = null; + } + return t1; + }, + concatenate$3$forceLineBreak(child, span, forceLineBreak) { + var t2, _0_1, initial, last, _this = this, + t1 = child.leadingCombinators, + _0_0 = _this.components; + if (t1.length === 0) { + t1 = A.List_List$of(_0_0, true, type$.ComplexSelectorComponent_2); + B.JSArray_methods.addAll$1(t1, child.components); + t2 = _this.lineBreak || child.lineBreak || forceLineBreak; + return A.ComplexSelector$0(_this.leadingCombinators, t1, span, t2); + } else { + _0_1 = _0_0.length; + if (_0_1 >= 1) { + t2 = _0_1 - 1; + initial = B.JSArray_methods.sublist$2(_0_0, 0, t2); + last = _0_0[t2]; + t2 = A.List_List$of(initial, true, type$.ComplexSelectorComponent_2); + t2.push(last.withAdditionalCombinators$1(t1)); + B.JSArray_methods.addAll$1(t2, child.components); + t1 = _this.lineBreak || child.lineBreak || forceLineBreak; + return A.ComplexSelector$0(_this.leadingCombinators, t2, span, t1); + } else { + t2 = A.List_List$of(_this.leadingCombinators, true, type$.CssValue_Combinator_2); + B.JSArray_methods.addAll$1(t2, t1); + t1 = _this.lineBreak || child.lineBreak || forceLineBreak; + return A.ComplexSelector$0(t2, child.components, span, t1); + } + } + }, + concatenate$2(child, span) { + return this.concatenate$3$forceLineBreak(child, span, false); + }, + get$hashCode(_) { + return B.C_ListEquality0.hash$1(this.leadingCombinators) ^ B.C_ListEquality0.hash$1(this.components); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.ComplexSelector0 && B.C_ListEquality.equals$2(0, this.leadingCombinators, other.leadingCombinators) && B.C_ListEquality.equals$2(0, this.components, other.components); + } + }; + A.ComplexSelector_specificity_closure0.prototype = { + call$2(sum, component) { + return sum + component.selector.get$specificity(); + }, + $signature: 432 + }; + A.ComplexSelectorComponent0.prototype = { + withAdditionalCombinators$1(combinators) { + var t1, t2, _this = this; + if (combinators.length === 0) + t1 = _this; + else { + t1 = type$.CssValue_Combinator_2; + t2 = A.List_List$of(_this.combinators, true, t1); + B.JSArray_methods.addAll$1(t2, combinators); + t1 = new A.ComplexSelectorComponent0(_this.selector, A.List_List$unmodifiable(t2, t1), _this.span); + } + return t1; + }, + get$hashCode(_) { + return B.C_ListEquality0.hash$1(this.selector.components) ^ B.C_ListEquality0.hash$1(this.combinators); + }, + $eq(_, other) { + var t1; + if (other == null) + return false; + if (other instanceof A.ComplexSelectorComponent0) { + t1 = B.C_ListEquality.equals$2(0, this.selector.components, other.selector.components); + t1 = t1 && B.C_ListEquality.equals$2(0, this.combinators, other.combinators); + } else + t1 = false; + return t1; + }, + toString$0(_) { + var t1 = this.combinators; + return A.serializeSelector0(this.selector, true) + new A.MappedListIterable(t1, new A.ComplexSelectorComponent_toString_closure0(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,String>")).join$1(0, ""); + } + }; + A.ComplexSelectorComponent_toString_closure0.prototype = { + call$1(combinator) { + return " " + combinator.toString$0(0); + }, + $signature: 433 + }; + A.CompoundSelector0.prototype = { + get$specificity() { + var result, _this = this, + value = _this._compound$__CompoundSelector_specificity_FI; + if (value === $) { + result = B.JSArray_methods.fold$2(_this.components, 0, new A.CompoundSelector_specificity_closure0()); + _this._compound$__CompoundSelector_specificity_FI !== $ && A.throwUnnamedLateFieldADI(); + _this._compound$__CompoundSelector_specificity_FI = result; + value = result; + } + return value; + }, + get$hasComplicatedSuperselectorSemantics() { + var result, _this = this, + value = _this._compound$__CompoundSelector_hasComplicatedSuperselectorSemantics_FI; + if (value === $) { + result = B.JSArray_methods.any$1(_this.components, new A.CompoundSelector_hasComplicatedSuperselectorSemantics_closure0()); + _this._compound$__CompoundSelector_hasComplicatedSuperselectorSemantics_FI !== $ && A.throwUnnamedLateFieldADI(); + _this._compound$__CompoundSelector_hasComplicatedSuperselectorSemantics_FI = result; + value = result; + } + return value; + }, + accept$1$1(visitor) { + return visitor.visitCompoundSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + get$hashCode(_) { + return B.C_ListEquality0.hash$1(this.components); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.CompoundSelector0 && B.C_ListEquality.equals$2(0, this.components, other.components); + } + }; + A.CompoundSelector_specificity_closure0.prototype = { + call$2(sum, component) { + return sum + component.get$specificity(); + }, + $signature: 434 + }; + A.CompoundSelector_hasComplicatedSuperselectorSemantics_closure0.prototype = { + call$1(component) { + return component.get$hasComplicatedSuperselectorSemantics(); + }, + $signature: 14 + }; + A.Configuration0.prototype = { + throughForward$1($forward) { + var _0_0, _1_0, _2_0, t1, hiddenVariables, + newValues = this._configuration0$_values; + if (newValues.get$isEmpty(newValues)) + return B.Configuration_Map_empty_null0; + _0_0 = $forward.prefix; + if (_0_0 != null) + newValues = new A.UnprefixedMapView0(newValues, _0_0, type$.UnprefixedMapView_ConfiguredValue_2); + _1_0 = $forward.shownVariables; + if (_1_0 != null) + newValues = new A.LimitedMapView0(newValues, _1_0._base.intersection$1(new A.MapKeySet(newValues, type$.MapKeySet_nullable_Object)), type$.LimitedMapView_String_ConfiguredValue_2); + else { + _2_0 = $forward.hiddenVariables; + if (_2_0 != null) { + t1 = _2_0._base.get$isNotEmpty(0); + hiddenVariables = _2_0; + } else { + hiddenVariables = null; + t1 = false; + } + if (t1) + newValues = A.LimitedMapView$blocklist0(newValues, hiddenVariables, type$.String, type$.ConfiguredValue_2); + } + return this._configuration0$_withValues$1(newValues); + }, + _configuration0$_withValues$1(values) { + var t1 = this._configuration0$__originalConfiguration; + return new A.Configuration0(values, t1 == null ? this : t1); + }, + toString$0(_) { + var t2, t3, + t1 = A._setArrayType([], type$.JSArray_String); + for (t2 = A.MapExtensions_get_pairs0(new A.UnmodifiableMapView(this._configuration0$_values, type$.UnmodifiableMapView_String_ConfiguredValue_2), type$.String, type$.ConfiguredValue_2), t2 = t2.get$iterator(t2); t2.moveNext$0();) { + t3 = t2.get$current(t2); + t1.push("$" + t3._0 + ": " + t3._1.toString$0(0)); + } + return "(" + B.JSArray_methods.join$1(t1, ",") + ")"; + } + }; + A.ExplicitConfiguration0.prototype = { + _configuration0$_withValues$1(values) { + var t1 = this._configuration0$__originalConfiguration; + if (t1 == null) + t1 = this; + return new A.ExplicitConfiguration0(this.nodeWithSpan, values, t1); + } + }; + A.ConfiguredValue0.prototype = { + toString$0(_) { + return this.value.toString$0(0); + } + }; + A.ConfiguredVariable0.prototype = { + toString$0(_) { + var t1 = this.expression.toString$0(0), + t2 = this.isGuarded ? " !default" : ""; + return "$" + this.name + ": " + t1 + t2; + }, + $isAstNode0: 1, + $isSassNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.ContentBlock0.prototype = { + accept$1$1(visitor) { + return visitor.visitContentBlock$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t2, + t1 = this.parameters; + t1 = t1.parameters.length === 0 && t1.restParameter == null ? "" : " using (" + t1.toString$0(0) + ")"; + t2 = this.children; + return t1 + (" {" + (t2 && B.JSArray_methods).join$1(t2, " ") + "}"); + } + }; + A.ContentRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitContentRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.$arguments; + return t1.get$isEmpty(0) ? "@content;" : "@content(" + t1.toString$0(0) + ");"; + }, + get$span(receiver) { + return this.span; + } + }; + A._disallowedFunctionNames_closure0.prototype = { + call$1($function) { + return $function.name; + }, + $signature: 435 + }; + A.CssParser0.prototype = { + get$plainCss() { + return true; + }, + silentComment$0() { + var t1, t2, _this = this; + if (_this._stylesheet0$_inExpression) + return false; + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + _this.super$Parser$silentComment0(); + _this.error$2(0, string$.Silent, t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + atRule$2$root(child, root) { + var $name, _0_0, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expectChar$1(64); + $name = _this.interpolatedIdentifier$0(); + _this.whitespace$1$consumeNewlines(true); + _0_0 = $name.get$asPlain(); + $label0$0: { + if ("at-root" === _0_0 || "content" === _0_0 || "debug" === _0_0 || "each" === _0_0 || "error" === _0_0 || "extend" === _0_0 || "for" === _0_0 || "function" === _0_0 || "if" === _0_0 || "include" === _0_0 || "mixin" === _0_0 || "return" === _0_0 || "warn" === _0_0 || "while" === _0_0) + _this._css$_forbiddenAtRule$1(start); + if ("import" === _0_0) { + t1 = _this._css$_cssImportRule$1(start); + break $label0$0; + } + if ("media" === _0_0) { + t1 = _this.mediaRule$1(start); + break $label0$0; + } + if ("-moz-document" === _0_0) { + t1 = _this.mozDocumentRule$2(start, $name); + break $label0$0; + } + if ("supports" === _0_0) { + t1 = _this.supportsRule$1(start); + break $label0$0; + } + t1 = _this.unknownAtRule$2(start, $name); + break $label0$0; + } + return t1; + }, + _css$_forbiddenAtRule$1(start) { + this.almostAnyValue$0(); + this.error$2(0, "This at-rule isn't allowed in plain CSS.", this.scanner.spanFrom$1(start)); + }, + _css$_cssImportRule$1(start) { + var _0_0, t3, string, $name, _0_3, _0_4, t4, _0_8, t5, modifiers, _this = this, _null = null, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + _1_0 = t1.peekChar$0(); + $label1$1: { + if (117 === _1_0 || 85 === _1_0) { + _0_0 = _this.dynamicUrl$0(); + $label0$0: { + if (_0_0 instanceof A.StringExpression0) { + t3 = _0_0.text; + break $label0$0; + } + string = _null; + t3 = false; + if (_0_0 instanceof A.InterpolatedFunctionExpression0) { + $name = _0_0.name; + _0_3 = _0_0.$arguments; + _0_4 = _0_3.positional; + t4 = _0_4; + if (t4.length === 1) { + _0_8 = _0_4[0]; + t4 = _0_8; + if (t4 instanceof A.StringExpression0) { + type$.StringExpression_2._as(_0_8); + t4 = _0_3.named; + if (t4.get$isEmpty(t4)) + if (_0_3.rest == null) + t3 = _0_3.keywordRest == null; + string = _0_8; + } + } + } else + $name = _null; + if (t3) { + t3 = new A.StringBuffer(""); + t4 = new A.InterpolationBuffer0(t3, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t4.addInterpolation$1($name); + t5 = A.Primitives_stringFromCharCode(40); + t3._contents += t5; + t4.addInterpolation$1(string.asInterpolation$0()); + t5 = A.Primitives_stringFromCharCode(41); + t3._contents += t5; + t4 = t4.interpolation$1(_0_0.span); + t3 = t4; + break $label0$0; + } + t3 = _this.error$2(0, "Unsupported plain CSS import.", _0_0.get$span(_0_0)); + } + break $label1$1; + } + t3 = _this.interpolatedString$0().asInterpolation$1$static(true); + break $label1$1; + } + _this.whitespace$1$consumeNewlines(true); + modifiers = _this.tryImportModifiers$0(); + _this.expectStatementSeparator$1("@import rule"); + t2 = A._setArrayType([new A.StaticImport0(t3, modifiers, t1.spanFrom$1(new A._SpanScannerState(t1, t2)))], type$.JSArray_Import_2); + t1 = t1.spanFrom$1(start); + return new A.ImportRule0(A.List_List$unmodifiable(t2, type$.Import_2), t1); + }, + parentheses$0() { + var expression, + t1 = this.scanner, + t2 = t1._string_scanner$_position; + t1.expectChar$1(40); + this.whitespace$1$consumeNewlines(true); + expression = this.expressionUntilComma$0(); + t1.expectChar$1(41); + return new A.ParenthesizedExpression0(expression, t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + identifierLike$0() { + var t2, allowEmptySecondArg, $arguments, t3, t4, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + identifier = _this.interpolatedIdentifier$0(), + plain = identifier.get$asPlain(), + lower = plain.toLowerCase(), + _0_0 = _this.trySpecialFunction$2(lower, start); + if (_0_0 != null) + return _0_0; + t2 = t1._string_scanner$_position; + if (t1.scanChar$1(46)) + return _this.namespacedExpression$2(plain, start); + if (!t1.scanChar$1(40)) + return new A.StringExpression0(identifier, false); + allowEmptySecondArg = lower === "var"; + $arguments = A._setArrayType([], type$.JSArray_Expression_2); + if (!t1.scanChar$1(41)) { + do { + _this.whitespace$1$consumeNewlines(true); + if (allowEmptySecondArg && $arguments.length === 1 && t1.peekChar$0() === 41) { + t3 = A.FileLocation$_(t1._sourceFile, t1._string_scanner$_position); + t4 = t3.offset; + t4 = A._FileSpan$(t3.file, t4, t4); + $arguments.push(new A.StringExpression0(new A.Interpolation0(A.List_List$unmodifiable([""], type$.Object), B.List_null, t4), false)); + break; + } + $arguments.push(_this.expressionUntilComma$1$singleEquals(true)); + _this.whitespace$1$consumeNewlines(true); + } while (t1.scanChar$1(44)); + t1.expectChar$1(41); + } + if ($.$get$_disallowedFunctionNames0().contains$1(0, plain)) + _this.error$2(0, string$.This_f, t1.spanFrom$1(start)); + t2 = t1.spanFrom$1(new A._SpanScannerState(t1, t2)); + t3 = type$.Expression_2; + t4 = A.List_List$unmodifiable($arguments, t3); + t3 = A.ConstantMap_ConstantMap$from(B.Map_empty14, type$.String, t3); + t1 = t1.spanFrom$1(start); + return new A.FunctionExpression0(null, A.stringReplaceAllUnchecked(plain, "_", "-"), plain, new A.ArgumentList0(t4, t3, null, null, t2), t1); + }, + namespacedExpression$2(namespace, start) { + var expression = this.super$StylesheetParser$namespacedExpression0(namespace, start); + this.error$2(0, string$.Modulen, expression.get$span(expression)); + } + }; + A.DebugRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitDebugRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "@debug " + this.expression.toString$0(0) + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A.ModifiableCssDeclaration0.prototype = { + accept$1$1(visitor) { + return visitor.visitCssDeclaration$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return this.name.toString$0(0) + ": " + this.value.toString$0(0) + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A.Declaration0.prototype = { + accept$1$1(visitor) { + return visitor.visitDeclaration$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t3, _0_0, + buffer = new A.StringBuffer(""), + t1 = this.name, + t2 = "" + t1.toString$0(0); + buffer._contents = t2; + t2 = buffer._contents = t2 + A.Primitives_stringFromCharCode(58); + t3 = this.value; + if (t3 != null) { + t1 = !B.JSString_methods.startsWith$1(t1.get$initialPlain(), "--") ? buffer._contents = t2 + A.Primitives_stringFromCharCode(32) : t2; + buffer._contents = t1 + t3.toString$0(0); + } + _0_0 = this.children; + if (_0_0 != null) + return buffer.toString$0(0) + " {" + B.JSArray_methods.join$1(_0_0, " ") + "}"; + else + return buffer.toString$0(0) + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A.SupportsDeclaration0.prototype = { + get$isCustomProperty() { + var t1, + _0_0 = this.name; + $label0$0: { + if (_0_0 instanceof A.StringExpression0 && !_0_0.hasQuotes) { + t1 = B.JSString_methods.startsWith$1(_0_0.text.get$initialPlain(), "--"); + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + toInterpolation$0() { + var visitor, _1_0, _null = null, + t1 = new A.StringBuffer(""), + t2 = type$.JSArray_Object, + t3 = type$.JSArray_nullable_FileSpan, + buffer = new A.InterpolationBuffer0(t1, A._setArrayType([], t2), A._setArrayType([], t3)), + t4 = this.span, + t5 = this.name, + t6 = A.SpanExtensions_before(t4, t5.get$span(t5)); + t6 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t6.file._decodedChars, t6._file$_start, t6._end), 0, _null); + t1._contents += t6; + if (t5 instanceof A.StringExpression0 && !t5.hasQuotes) + buffer.addInterpolation$1(t5.text); + else + buffer.add$2(0, t5, t5.get$span(t5)); + t6 = this.value; + t5 = A.SpanExtensions_between(t5.get$span(t5), t6.get$span(t6)); + t5 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t5.file._decodedChars, t5._file$_start, t5._end), 0, _null); + t1._contents += t5; + visitor = new A.SourceInterpolationVisitor(new A.InterpolationBuffer0(new A.StringBuffer(""), A._setArrayType([], t2), A._setArrayType([], t3))); + t6.accept$1(visitor); + t3 = visitor.buffer; + _1_0 = t3 == null ? _null : t3.interpolation$1(t6.get$span(t6)); + if (_1_0 != null) + buffer.addInterpolation$1(_1_0); + else + buffer.add$2(0, t6, t6.get$span(t6)); + t2 = A.SpanExtensions_after(t4, t6.get$span(t6)); + t2 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t2.file._decodedChars, t2._file$_start, t2._end), 0, _null); + t1._contents += t2; + return buffer.interpolation$1(t4); + }, + withSpan$1(span) { + return new A.SupportsDeclaration0(this.name, this.value, span); + }, + toString$0(_) { + return "(" + this.name.toString$0(0) + ": " + this.value.toString$0(0) + ")"; + }, + $isAstNode0: 1, + $isSassNode: 1, + $isSupportsCondition: 1, + get$span(receiver) { + return this.span; + } + }; + A.Deprecation0.prototype = { + _enumToString$0() { + return "Deprecation." + this._name; + }, + get$deprecatedIn(_) { + return A.NullableExtension_andThen0(this._deprecation$_deprecatedIn, A.version_Version___parse_tearOff$closure()); + }, + get$obsoleteIn(_) { + return null; + }, + toString$0(_) { + return this.id; + } + }; + A.Deprecation_fromId_closure0.prototype = { + call$1(deprecation) { + return deprecation.id === this.id; + }, + $signature: 436 + }; + A.DeprecationProcessingLogger0.prototype = { + validate$0() { + var t1, t2, t3, t4, t5, _this = this, _null = null; + for (t1 = _this.fatalDeprecations, t1 = A._LinkedHashSetIterator$(t1, t1._modifications, A._instanceType(t1)._precomputed1), t2 = _this.silenceDeprecations, t3 = t1.$ti._precomputed1; t1.moveNext$0();) { + t4 = t1._collection$_current; + if (t4 == null) + t4 = t3._as(t4); + t5 = t2.contains$1(0, t4); + if (t5) { + t4 = t4.toString$0(0); + _this.internalWarn$4$deprecation$span$trace("Ignoring setting to silence " + t4 + string$.x20deprex2c, _null, _null, _null); + continue; + } + } + for (t1 = A._LinkedHashSetIterator$(t2, t2._modifications, A._instanceType(t2)._precomputed1), t2 = t1.$ti._precomputed1, t3 = _this.futureDeprecations; t1.moveNext$0();) { + t4 = t1._collection$_current; + if (B.Deprecation_ZVM === (t4 == null ? t2._as(t4) : t4)) { + _this.internalWarn$4$deprecation$span$trace(string$.User_a, _null, _null, _null); + continue; + } + } + for (t1 = A._LinkedHashSetIterator$(t3, t3._modifications, A._instanceType(t3)._precomputed1), t2 = t1.$ti._precomputed1; t1.moveNext$0();) { + t3 = t1._collection$_current; + t3 = (t3 == null ? t2._as(t3) : t3).toString$0(0); + _this.internalWarn$4$deprecation$span$trace(t3 + string$.x20is_noaf, _null, _null, _null); + } + }, + internalWarn$4$deprecation$span$trace(message, deprecation, span, trace) { + if (deprecation != null) + this._deprecation_processing$_handleDeprecation$4$span$trace(deprecation, message, span, trace); + else + this._deprecation_processing$_inner.internalWarn$4$deprecation$span$trace(message, null, span, trace); + }, + _deprecation_processing$_handleDeprecation$4$span$trace(deprecation, message, span, trace) { + var _0_3_isSet, _0_3, t1, span0, t2, count, _this = this, _null = null; + if (_this.fatalDeprecations.contains$1(0, deprecation)) { + message += string$.x0a_This + deprecation.toString$0(0) + string$.x20deprex20; + $label0$0: { + _0_3_isSet = span != null; + _0_3 = _null; + t1 = false; + if (_0_3_isSet) { + span0 = span == null ? type$.FileSpan._as(span) : span; + t1 = trace != null; + _0_3 = trace; + } else + span0 = _null; + if (t1) { + if (_0_3_isSet) + trace = _0_3; + t1 = A.SassRuntimeException$0(message, span0, trace == null ? type$.Trace._as(trace) : trace, _null); + break $label0$0; + } + t1 = false; + if (span != null) + t1 = (_0_3_isSet ? _0_3 : trace) == null; + else + span = _null; + if (t1) { + t1 = A.SassException$0(message, span, _null); + break $label0$0; + } + t1 = A.SassScriptException$0(message, _null); + break $label0$0; + } + throw A.wrapException(t1); + } + if (_this.silenceDeprecations.contains$1(0, deprecation)) + return; + if (_this.limitRepetition) { + t1 = _this._deprecation_processing$_warningCounts; + t2 = t1.$index(0, deprecation); + count = (t2 == null ? 0 : t2) + 1; + t1.$indexSet(0, deprecation, count); + if (count > 5) + return; + } + _this._deprecation_processing$_inner.internalWarn$4$deprecation$span$trace(message, deprecation, span, trace); + }, + debug$2(_, message, span) { + return this._deprecation_processing$_inner.debug$2(0, message, span); + }, + summarize$1$js(js) { + var t1 = this._deprecation_processing$_warningCounts, + t2 = A._instanceType(t1)._eval$1("LinkedHashMapValuesIterable<2>"), + total = A.IterableIntegerExtension_get_sum(new A.MappedIterable(new A.WhereIterable(new A.LinkedHashMapValuesIterable(t1, t2), new A.DeprecationProcessingLogger_summarize_closure1(), t2._eval$1("WhereIterable")), new A.DeprecationProcessingLogger_summarize_closure2(), t2._eval$1("MappedIterable"))); + if (total > 0) { + t1 = js ? "" : string$.x0aRun_i; + this._deprecation_processing$_inner.internalWarn$4$deprecation$span$trace("" + total + string$.x20repet + t1, null, null, null); + } + } + }; + A.DeprecationProcessingLogger_summarize_closure1.prototype = { + call$1(count) { + return count > 5; + }, + $signature: 48 + }; + A.DeprecationProcessingLogger_summarize_closure2.prototype = { + call$1(count) { + return count - 5; + }, + $signature: 157 + }; + A.Deprecation1.prototype = {}; + A.deprecations_closure.prototype = { + call$0() { + var _0_8_isSet, _0_8, t1, + _0_0 = this.deprecation; + $label0$0: { + _0_8_isSet = A.NullableExtension_andThen0(_0_0._deprecation$_deprecatedIn, A.version_Version___parse_tearOff$closure()) == null; + if (_0_8_isSet) { + _0_8 = _0_0.get$obsoleteIn(0) == null; + t1 = _0_8; + } else { + _0_8 = null; + t1 = false; + } + if (t1) { + t1 = "user"; + break $label0$0; + } + if (_0_8_isSet ? _0_8 : _0_0.get$obsoleteIn(0) == null) { + t1 = "active"; + break $label0$0; + } + t1 = "obsolete"; + break $label0$0; + } + return t1; + }, + $signature: 26 + }; + A.parseDeprecations_closure.prototype = { + call$0() { + return new A._SyncStarIterable(this.$call$body$parseDeprecations_closure(), type$._SyncStarIterable_Deprecation); + }, + $call$body$parseDeprecations_closure() { + var $async$self = this; + return function() { + var $async$goto = 0, $async$handler = 1, $async$errorStack = [], t1, t2, t3, t4, item, t5, id, deprecation, version; + return function $async$call$0($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = J.get$iterator$ax($async$self.deprecations), t2 = type$.Deprecation_2, t3 = $async$self.supportVersions, t4 = $async$self.logger; + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + item = t1.get$current(t1); + t5 = typeof item == "string"; + id = t5 ? item : null; + $async$goto = t5 ? 4 : 5; + break; + case 4: + // then + deprecation = A.Deprecation_fromId0(id); + $async$goto = deprecation == null ? 6 : 8; + break; + case 6: + // then + t4.internalWarn$4$deprecation$span$trace('Invalid deprecation "' + A.S(id) + '".', null, null, null); + // goto join + $async$goto = 7; + break; + case 8: + // else + $async$goto = 9; + return $async$iterator._async$_current = deprecation, 1; + case 9: + // after yield + case 7: + // join + // goto for condition + $async$goto = 2; + break; + case 5: + // join + t5 = t2._is(item); + id = t5 ? J.get$id$x(item) : null; + $async$goto = t5 ? 10 : 11; + break; + case 10: + // then + deprecation = A.Deprecation_fromId0(id); + $async$goto = deprecation == null ? 12 : 14; + break; + case 12: + // then + t4.internalWarn$4$deprecation$span$trace('Invalid deprecation "' + A.S(id) + '".', null, null, null); + // goto join + $async$goto = 13; + break; + case 14: + // else + $async$goto = 15; + return $async$iterator._async$_current = deprecation, 1; + case 15: + // after yield + case 13: + // join + // goto for condition + $async$goto = 2; + break; + case 11: + // join + if (item instanceof A.Version) { + t5 = t3; + version = item; + } else { + version = null; + t5 = false; + } + $async$goto = t5 ? 16 : 17; + break; + case 16: + // then + $async$goto = 18; + return $async$iterator._yieldStar$1(A.Deprecation_forVersion0(version)); + case 18: + // after yield + case 17: + // join + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return 0; + case 1: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + }, + $signature: 437 + }; + A.versionClass_closure.prototype = { + call$0() { + var t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.Version", new A.versionClass__closure())); + jsClass.parse = A.allowInteropNamed("parse", new A.versionClass__closure0()); + A.JSClassExtension_injectSuperclass(t1._as(A.Version_Version(0, 0, 0, null).constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.versionClass__closure.prototype = { + call$4($self, major, minor, patch) { + return A.Version_Version(major, minor, patch, null); + }, + "call*": "call$4", + $requiredArgCount: 4, + $signature: 438 + }; + A.versionClass__closure0.prototype = { + call$1(version) { + var v = A.Version_Version$parse(version); + if (v.preRelease.length !== 0 || v.build.length !== 0) + throw A.wrapException(A.FormatException$("Build identifiers and prerelease versions not supported.", null, null)); + return v; + }, + $signature: 233 + }; + A.DisplayP3ColorSpace0.prototype = { + get$isBoundedInternal() { + return true; + }, + toLinear$1(channel) { + return A.srgbAndDisplayP3ToLinear0(channel); + }, + fromLinear$1(channel) { + return A.srgbAndDisplayP3FromLinear0(channel); + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.SrgbLinearColorSpace_kUj0 === dest || B.SrgbColorSpace_thf0 === dest || B.RgbColorSpace_i0P0 === dest) { + t1 = $.$get$linearDisplayP3ToLinearSrgb0(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf20 === dest) { + t1 = $.$get$linearDisplayP3ToLinearA98Rgb0(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz0 === dest) { + t1 = $.$get$linearDisplayP3ToLinearProphotoRgb0(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo0 === dest) { + t1 = $.$get$linearDisplayP3ToLinearRec20200(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ0 === dest) { + t1 = $.$get$linearDisplayP3ToXyzD650(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB0 === dest) { + t1 = $.$get$linearDisplayP3ToXyzD500(); + break $label0$0; + } + if (B.LmsColorSpace_Os30 === dest) { + t1 = $.$get$linearDisplayP3ToLms0(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix0(dest); + break $label0$0; + } + return t1; + } + }; + A.DynamicImport0.prototype = { + toString$0(_) { + return A.StringExpression_quoteText0(this.urlString); + }, + $isImport0: 1, + $isAstNode0: 1, + $isSassNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.EachRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitEachRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.variables, + t2 = this.children; + return "@each " + new A.MappedListIterable(t1, new A.EachRule_toString_closure0(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,String>")).join$1(0, ", ") + " in " + this.list.toString$0(0) + " {" + (t2 && B.JSArray_methods).join$1(t2, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.EachRule_toString_closure0.prototype = { + call$1(variable) { + return "$" + variable; + }, + $signature: 6 + }; + A.EmptyExtensionStore0.prototype = { + get$_extension_store$_extensions() { + return A.throwExpression(A.NoSuchMethodError_NoSuchMethodError$withInvocation(this, A.JSInvocationMirror$(B.Symbol__extensions, "get$_empty_extension_store0$_extensions", 1, [], [], 0))); + }, + get$_extension_store$_sourceSpecificity() { + return A.throwExpression(A.NoSuchMethodError_NoSuchMethodError$withInvocation(this, A.JSInvocationMirror$(B.Symbol__sourceSpecificity, "get$_empty_extension_store0$_sourceSpecificity", 1, [], [], 0))); + }, + get$isEmpty(_) { + return true; + }, + get$simpleSelectors() { + return B.C_EmptyUnmodifiableSet0; + }, + extensionsWhereTarget$1(callback) { + return B.List_empty18; + }, + addSelector$2(selector, mediaContext) { + throw A.wrapException(A.UnsupportedError$("addSelector() can't be called for a const ExtensionStore.")); + }, + addExtension$4(extender, target, extend, mediaContext) { + throw A.wrapException(A.UnsupportedError$("addExtension() can't be called for a const ExtensionStore.")); + }, + addExtensions$1(extenders) { + throw A.wrapException(A.UnsupportedError$(string$.addExt)); + }, + clone$0() { + return B.Record2_EmptyExtensionStore_Map_empty0; + }, + $isExtensionStore0: 1 + }; + A.Environment0.prototype = { + closure$0() { + var t4, t5, t6, _this = this, + t1 = _this._environment0$_forwardedModules, + t2 = _this._environment0$_nestedForwardedModules, + t3 = _this._environment0$_variables; + t3 = A._setArrayType(t3.slice(0), A._arrayInstanceType(t3)); + t4 = _this._environment0$_variableNodes; + t4 = A._setArrayType(t4.slice(0), A._arrayInstanceType(t4)); + t5 = _this._environment0$_functions; + t5 = A._setArrayType(t5.slice(0), A._arrayInstanceType(t5)); + t6 = _this._environment0$_mixins; + t6 = A._setArrayType(t6.slice(0), A._arrayInstanceType(t6)); + return A.Environment$_0(_this._environment0$_modules, _this._environment0$_namespaceNodes, _this._environment0$_globalModules, _this._environment0$_importedModules, t1, t2, _this._environment0$_allModules, t3, t4, t5, t6, _this._environment0$_content); + }, + forwardModule$2(module, rule) { + var view, t1, t2, _this = this, + forwardedModules = _this._environment0$_forwardedModules; + if (forwardedModules == null) + forwardedModules = _this._environment0$_forwardedModules = A.LinkedHashMap_LinkedHashMap$_empty(type$.Module_Callable_2, type$.AstNode_2); + view = A.ForwardedModuleView_ifNecessary0(module, rule, type$.Callable_2); + for (t1 = new A.LinkedHashMapKeyIterator(forwardedModules, forwardedModules.__js_helper$_modifications, forwardedModules.__js_helper$_first); t1.moveNext$0();) { + t2 = t1.__js_helper$_current; + _this._environment0$_assertNoConflicts$5(view.get$variables(), t2.get$variables(), view, t2, "variable"); + _this._environment0$_assertNoConflicts$5(view.get$functions(view), t2.get$functions(t2), view, t2, "function"); + _this._environment0$_assertNoConflicts$5(view.get$mixins(), t2.get$mixins(), view, t2, "mixin"); + } + _this._environment0$_allModules.push(module); + forwardedModules.$indexSet(0, view, rule); + }, + _environment0$_assertNoConflicts$5(newMembers, oldMembers, newModule, oldModule, type) { + var larger, smaller, t1, t2, t3, t4, $name, small, large, span; + if (newMembers.get$length(newMembers) < oldMembers.get$length(oldMembers)) { + larger = oldMembers; + smaller = newMembers; + } else { + larger = newMembers; + smaller = oldMembers; + } + for (t1 = type$.String, t2 = A.MapExtensions_get_pairs0(smaller, t1, type$.Object), t2 = t2.get$iterator(t2), t3 = type === "variable"; t2.moveNext$0();) { + t4 = t2.get$current(t2); + $name = t4._0; + small = t4._1; + large = larger.$index(0, $name); + if (large == null) + continue; + if (t3 ? newModule.variableIdentity$1($name) === oldModule.variableIdentity$1($name) : J.$eq$(large, small)) + continue; + if (t3) + $name = "$" + $name; + t2 = this._environment0$_forwardedModules; + if (t2 == null) + span = null; + else { + t2 = t2.$index(0, oldModule); + span = t2 == null ? null : t2.get$span(t2); + } + t2 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, t1); + if (span != null) + t2.$indexSet(0, span, "original @forward"); + throw A.wrapException(A.MultiSpanSassScriptException$0("Two forwarded modules both define a " + type + " named " + $name + ".", "new @forward", t2)); + } + }, + importForwards$1(module) { + var forwardedModules, t1, t2, t3, t4, node, t5, t6, t7, t8, t9, t10, _i, t11, shadowed, t12, t13, _length, _list, _this = this, + forwarded = module._environment0$_environment._environment0$_forwardedModules; + if (forwarded == null) + return; + forwardedModules = _this._environment0$_forwardedModules; + if (forwardedModules != null) { + t1 = type$.Module_Callable_2; + t2 = type$.AstNode_2; + t3 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t1 = A.MapExtensions_get_pairs0(forwarded, t1, t2), t1 = t1.get$iterator(t1), t2 = _this._environment0$_globalModules; t1.moveNext$0();) { + t4 = t1.get$current(t1); + module = t4._0; + node = t4._1; + if (!forwardedModules.containsKey$1(module) || !t2.containsKey$1(module)) + t3.$indexSet(0, module, node); + } + forwarded = t3; + } else + forwardedModules = _this._environment0$_forwardedModules = A.LinkedHashMap_LinkedHashMap$_empty(type$.Module_Callable_2, type$.AstNode_2); + t1 = type$.String; + t2 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + for (t3 = new A.LinkedHashMapKeyIterator(forwarded, forwarded.__js_helper$_modifications, forwarded.__js_helper$_first); t3.moveNext$0();) + for (t4 = t3.__js_helper$_current.get$variables(), t4 = J.get$iterator$ax(t4.get$keys(t4)); t4.moveNext$0();) + t2.add$1(0, t4.get$current(t4)); + t3 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + for (t4 = new A.LinkedHashMapKeyIterator(forwarded, forwarded.__js_helper$_modifications, forwarded.__js_helper$_first); t4.moveNext$0();) { + t5 = t4.__js_helper$_current; + for (t5 = t5.get$functions(t5), t5 = J.get$iterator$ax(t5.get$keys(t5)); t5.moveNext$0();) + t3.add$1(0, t5.get$current(t5)); + } + t1 = A.LinkedHashSet_LinkedHashSet$_empty(t1); + for (t4 = new A.LinkedHashMapKeyIterator(forwarded, forwarded.__js_helper$_modifications, forwarded.__js_helper$_first); t4.moveNext$0();) + for (t5 = t4.__js_helper$_current.get$mixins(), t5 = J.get$iterator$ax(t5.get$keys(t5)); t5.moveNext$0();) + t1.add$1(0, t5.get$current(t5)); + t4 = _this._environment0$_variables; + t5 = t4.length; + if (t5 === 1) { + for (t5 = _this._environment0$_importedModules, t6 = type$.Module_Callable_2, t7 = type$.AstNode_2, t8 = A.MapExtensions_get_pairs0(t5, t6, t7).toList$0(0), t9 = t8.length, t10 = type$.Callable_2, _i = 0; _i < t8.length; t8.length === t9 || (0, A.throwConcurrentModificationError)(t8), ++_i) { + t11 = t8[_i]; + module = t11._0; + shadowed = A.ShadowedModuleView_ifNecessary0(module, t3, t1, t2, t10); + if (shadowed != null) { + t5.remove$1(0, module); + t12 = shadowed.variables; + t13 = false; + if (t12.get$isEmpty(t12)) { + t12 = shadowed.functions; + if (t12.get$isEmpty(t12)) { + t12 = shadowed.mixins; + if (t12.get$isEmpty(t12)) { + t12 = shadowed._shadowed_view0$_inner; + t12 = t12.get$css(t12); + t12 = J.get$isEmpty$asx(t12.get$children(t12)); + } else + t12 = t13; + } else + t12 = t13; + } else + t12 = t13; + if (!t12) + t5.$indexSet(0, shadowed, t11._1); + } + } + for (t6 = A.MapExtensions_get_pairs0(forwardedModules, t6, t7).toList$0(0), t7 = t6.length, _i = 0; _i < t6.length; t6.length === t7 || (0, A.throwConcurrentModificationError)(t6), ++_i) { + t8 = t6[_i]; + module = t8._0; + shadowed = A.ShadowedModuleView_ifNecessary0(module, t3, t1, t2, t10); + if (shadowed != null) { + forwardedModules.remove$1(0, module); + t9 = shadowed.variables; + t11 = false; + if (t9.get$isEmpty(t9)) { + t9 = shadowed.functions; + if (t9.get$isEmpty(t9)) { + t9 = shadowed.mixins; + if (t9.get$isEmpty(t9)) { + t9 = shadowed._shadowed_view0$_inner; + t9 = t9.get$css(t9); + t9 = J.get$isEmpty$asx(t9.get$children(t9)); + } else + t9 = t11; + } else + t9 = t11; + } else + t9 = t11; + if (!t9) + forwardedModules.$indexSet(0, shadowed, t8._1); + } + } + t5.addAll$1(0, forwarded); + forwardedModules.addAll$1(0, forwarded); + } else { + t6 = _this._environment0$_nestedForwardedModules; + if (t6 == null) { + _length = t5 - 1; + _list = J.JSArray_JSArray$allocateGrowable(_length, type$.List_Module_Callable_2); + for (t5 = type$.JSArray_Module_Callable_2, _i = 0; _i < _length; ++_i) + _list[_i] = A._setArrayType([], t5); + _this._environment0$_nestedForwardedModules = _list; + t5 = _list; + } else + t5 = t6; + B.JSArray_methods.addAll$1(B.JSArray_methods.get$last(t5), new A.LinkedHashMapKeysIterable(forwarded, A._instanceType(forwarded)._eval$1("LinkedHashMapKeysIterable<1>"))); + } + for (t2 = A._LinkedHashSetIterator$(t2, t2._modifications, t2.$ti._precomputed1), t5 = _this._environment0$_variableIndices, t6 = _this._environment0$_variableNodes, t7 = t2.$ti._precomputed1; t2.moveNext$0();) { + t8 = t2._collection$_current; + if (t8 == null) + t8 = t7._as(t8); + t5.remove$1(0, t8); + J.remove$1$z(B.JSArray_methods.get$last(t4), t8); + J.remove$1$z(B.JSArray_methods.get$last(t6), t8); + } + for (t2 = A._LinkedHashSetIterator$(t3, t3._modifications, t3.$ti._precomputed1), t3 = _this._environment0$_functionIndices, t4 = _this._environment0$_functions, t5 = t2.$ti._precomputed1; t2.moveNext$0();) { + t6 = t2._collection$_current; + if (t6 == null) + t6 = t5._as(t6); + t3.remove$1(0, t6); + J.remove$1$z(B.JSArray_methods.get$last(t4), t6); + } + for (t1 = A._LinkedHashSetIterator$(t1, t1._modifications, t1.$ti._precomputed1), t2 = _this._environment0$_mixinIndices, t3 = _this._environment0$_mixins, t4 = t1.$ti._precomputed1; t1.moveNext$0();) { + t5 = t1._collection$_current; + if (t5 == null) + t5 = t4._as(t5); + t2.remove$1(0, t5); + J.remove$1$z(B.JSArray_methods.get$last(t3), t5); + } + }, + getVariable$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) + return _this._environment0$_getModule$1(namespace).get$variables().$index(0, $name); + if (_this._environment0$_lastVariableName === $name) { + t1 = _this._environment0$_lastVariableIndex; + t1.toString; + t1 = _this._environment0$_variables[t1].$index(0, $name); + return t1 == null ? _this._environment0$_getVariableFromGlobalModule$1($name) : t1; + } + t1 = _this._environment0$_variableIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + _this._environment0$_lastVariableName = $name; + _this._environment0$_lastVariableIndex = _0_0; + t1 = _this._environment0$_variables[_0_0].$index(0, $name); + return t1 == null ? _this._environment0$_getVariableFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._environment0$_variableIndex$1($name); + if (_1_0 != null) { + _this._environment0$_lastVariableName = $name; + _this._environment0$_lastVariableIndex = _1_0; + t1.$indexSet(0, $name, _1_0); + t1 = _this._environment0$_variables[_1_0].$index(0, $name); + return t1 == null ? _this._environment0$_getVariableFromGlobalModule$1($name) : t1; + } else + return _this._environment0$_getVariableFromGlobalModule$1($name); + } + }, + getVariable$1($name) { + return this.getVariable$2$namespace($name, null); + }, + _environment0$_getVariableFromGlobalModule$1($name) { + return this._environment0$_fromOneModule$3($name, "variable", new A.Environment__getVariableFromGlobalModule_closure0($name)); + }, + getVariableNode$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) + return _this._environment0$_getModule$1(namespace).get$variableNodes().$index(0, $name); + if (_this._environment0$_lastVariableName === $name) { + t1 = _this._environment0$_lastVariableIndex; + t1.toString; + t1 = _this._environment0$_variableNodes[t1].$index(0, $name); + return t1 == null ? _this._environment0$_getVariableNodeFromGlobalModule$1($name) : t1; + } + t1 = _this._environment0$_variableIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + _this._environment0$_lastVariableName = $name; + _this._environment0$_lastVariableIndex = _0_0; + t1 = _this._environment0$_variableNodes[_0_0].$index(0, $name); + return t1 == null ? _this._environment0$_getVariableNodeFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._environment0$_variableIndex$1($name); + if (_1_0 != null) { + _this._environment0$_lastVariableName = $name; + _this._environment0$_lastVariableIndex = _1_0; + t1.$indexSet(0, $name, _1_0); + t1 = _this._environment0$_variableNodes[_1_0].$index(0, $name); + return t1 == null ? _this._environment0$_getVariableNodeFromGlobalModule$1($name) : t1; + } else + return _this._environment0$_getVariableNodeFromGlobalModule$1($name); + } + }, + _environment0$_getVariableNodeFromGlobalModule$1($name) { + var t1, t2, _0_0; + for (t1 = this._environment0$_importedModules, t2 = this._environment0$_globalModules, t2 = new A.LinkedHashMapKeysIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapKeysIterable<1>")).followedBy$1(0, new A.LinkedHashMapKeysIterable(t2, A._instanceType(t2)._eval$1("LinkedHashMapKeysIterable<1>"))), t2 = new A.FollowedByIterator(J.get$iterator$ax(t2.__internal$_first), t2._second); t2.moveNext$0();) { + t1 = t2._currentIterator; + _0_0 = t1.get$current(t1).get$variableNodes().$index(0, $name); + if (_0_0 != null) + return _0_0; + } + return null; + }, + globalVariableExists$2$namespace($name, namespace) { + if (namespace != null) + return this._environment0$_getModule$1(namespace).get$variables().containsKey$1($name); + if (B.JSArray_methods.get$first(this._environment0$_variables).containsKey$1($name)) + return true; + return this._environment0$_getVariableFromGlobalModule$1($name) != null; + }, + globalVariableExists$1($name) { + return this.globalVariableExists$2$namespace($name, null); + }, + _environment0$_variableIndex$1($name) { + var t1, i; + for (t1 = this._environment0$_variables, i = t1.length - 1; i >= 0; --i) + if (t1[i].containsKey$1($name)) + return i; + return null; + }, + setVariable$5$global$namespace($name, value, nodeWithSpan, global, namespace) { + var t1, moduleWithName, nestedForwardedModules, t2, t3, t4, t5, index, _this = this; + if (namespace != null) { + _this._environment0$_getModule$1(namespace).setVariable$3($name, value, nodeWithSpan); + return; + } + if (global || _this._environment0$_variables.length === 1) { + _this._environment0$_variableIndices.putIfAbsent$2($name, new A.Environment_setVariable_closure2(_this, $name)); + t1 = _this._environment0$_variables; + if (!B.JSArray_methods.get$first(t1).containsKey$1($name)) { + moduleWithName = _this._environment0$_fromOneModule$3($name, "variable", new A.Environment_setVariable_closure3($name)); + if (moduleWithName != null) { + moduleWithName.setVariable$3($name, value, nodeWithSpan); + return; + } + } + J.$indexSet$ax(B.JSArray_methods.get$first(t1), $name, value); + J.$indexSet$ax(B.JSArray_methods.get$first(_this._environment0$_variableNodes), $name, nodeWithSpan); + return; + } + nestedForwardedModules = _this._environment0$_nestedForwardedModules; + if (nestedForwardedModules != null && !_this._environment0$_variableIndices.containsKey$1($name) && _this._environment0$_variableIndex$1($name) == null) + for (t1 = A._arrayInstanceType(nestedForwardedModules)._eval$1("ReversedListIterable<1>"), t2 = new A.ReversedListIterable(nestedForwardedModules, t1), t2 = new A.ListIterator(t2, t2.get$length(0), t1._eval$1("ListIterator")), t1 = t1._eval$1("ListIterable.E"); t2.moveNext$0();) { + t3 = t2.__internal$_current; + for (t3 = J.get$reversed$ax(t3 == null ? t1._as(t3) : t3), t4 = t3.$ti, t3 = new A.ListIterator(t3, t3.get$length(0), t4._eval$1("ListIterator")), t4 = t4._eval$1("ListIterable.E"); t3.moveNext$0();) { + t5 = t3.__internal$_current; + if (t5 == null) + t5 = t4._as(t5); + if (t5.get$variables().containsKey$1($name)) { + t5.setVariable$3($name, value, nodeWithSpan); + return; + } + } + } + if (_this._environment0$_lastVariableName === $name) { + t1 = _this._environment0$_lastVariableIndex; + t1.toString; + index = t1; + } else + index = _this._environment0$_variableIndices.putIfAbsent$2($name, new A.Environment_setVariable_closure4(_this, $name)); + if (!_this._environment0$_inSemiGlobalScope && index === 0) { + index = _this._environment0$_variables.length - 1; + _this._environment0$_variableIndices.$indexSet(0, $name, index); + } + _this._environment0$_lastVariableName = $name; + _this._environment0$_lastVariableIndex = index; + _this._environment0$_variables[index].$indexSet(0, $name, value); + _this._environment0$_variableNodes[index].$indexSet(0, $name, nodeWithSpan); + }, + setVariable$4$global($name, value, nodeWithSpan, global) { + return this.setVariable$5$global$namespace($name, value, nodeWithSpan, global, null); + }, + setLocalVariable$3($name, value, nodeWithSpan) { + var index, _this = this, + t1 = _this._environment0$_variables, + t2 = t1.length; + _this._environment0$_lastVariableName = $name; + index = _this._environment0$_lastVariableIndex = t2 - 1; + _this._environment0$_variableIndices.$indexSet(0, $name, index); + t1[index].$indexSet(0, $name, value); + _this._environment0$_variableNodes[index].$indexSet(0, $name, nodeWithSpan); + }, + getFunction$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) { + t1 = _this._environment0$_getModule$1(namespace); + return t1.get$functions(t1).$index(0, $name); + } + t1 = _this._environment0$_functionIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + t1 = _this._environment0$_functions[_0_0].$index(0, $name); + return t1 == null ? _this._environment0$_getFunctionFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._environment0$_functionIndex$1($name); + if (_1_0 != null) { + t1.$indexSet(0, $name, _1_0); + t1 = _this._environment0$_functions[_1_0].$index(0, $name); + return t1 == null ? _this._environment0$_getFunctionFromGlobalModule$1($name) : t1; + } else + return _this._environment0$_getFunctionFromGlobalModule$1($name); + } + }, + getFunction$1($name) { + return this.getFunction$2$namespace($name, null); + }, + _environment0$_getFunctionFromGlobalModule$1($name) { + return this._environment0$_fromOneModule$3($name, "function", new A.Environment__getFunctionFromGlobalModule_closure0($name)); + }, + _environment0$_functionIndex$1($name) { + var t1, i; + for (t1 = this._environment0$_functions, i = t1.length - 1; i >= 0; --i) + if (t1[i].containsKey$1($name)) + return i; + return null; + }, + getMixin$2$namespace($name, namespace) { + var t1, _0_0, _1_0, _this = this; + if (namespace != null) + return _this._environment0$_getModule$1(namespace).get$mixins().$index(0, $name); + t1 = _this._environment0$_mixinIndices; + _0_0 = t1.$index(0, $name); + if (_0_0 != null) { + t1 = _this._environment0$_mixins[_0_0].$index(0, $name); + return t1 == null ? _this._environment0$_getMixinFromGlobalModule$1($name) : t1; + } else { + _1_0 = _this._environment0$_mixinIndex$1($name); + if (_1_0 != null) { + t1.$indexSet(0, $name, _1_0); + t1 = _this._environment0$_mixins[_1_0].$index(0, $name); + return t1 == null ? _this._environment0$_getMixinFromGlobalModule$1($name) : t1; + } else + return _this._environment0$_getMixinFromGlobalModule$1($name); + } + }, + _environment0$_getMixinFromGlobalModule$1($name) { + return this._environment0$_fromOneModule$3($name, "mixin", new A.Environment__getMixinFromGlobalModule_closure0($name)); + }, + _environment0$_mixinIndex$1($name) { + var t1, i; + for (t1 = this._environment0$_mixins, i = t1.length - 1; i >= 0; --i) + if (t1[i].containsKey$1($name)) + return i; + return null; + }, + withContent$2($content, callback) { + var oldContent = this._environment0$_content; + this._environment0$_content = $content; + callback.call$0(); + this._environment0$_content = oldContent; + }, + asMixin$1(callback) { + var oldInMixin = this._environment0$_inMixin; + this._environment0$_inMixin = true; + callback.call$0(); + this._environment0$_inMixin = oldInMixin; + }, + scope$1$3$semiGlobal$when(callback, semiGlobal, when) { + var wasInSemiGlobalScope, $name, name0, name1, t1, t2, t3, t4, t5, t6, _this = this; + semiGlobal = semiGlobal && _this._environment0$_inSemiGlobalScope; + wasInSemiGlobalScope = _this._environment0$_inSemiGlobalScope; + _this._environment0$_inSemiGlobalScope = semiGlobal; + if (!when) + try { + t1 = callback.call$0(); + return t1; + } finally { + _this._environment0$_inSemiGlobalScope = wasInSemiGlobalScope; + } + t1 = _this._environment0$_variables; + t2 = type$.String; + B.JSArray_methods.add$1(t1, A.LinkedHashMap_LinkedHashMap$_empty(t2, type$.Value_2)); + t3 = _this._environment0$_variableNodes; + B.JSArray_methods.add$1(t3, A.LinkedHashMap_LinkedHashMap$_empty(t2, type$.AstNode_2)); + t4 = _this._environment0$_functions; + t5 = type$.Callable_2; + B.JSArray_methods.add$1(t4, A.LinkedHashMap_LinkedHashMap$_empty(t2, t5)); + t6 = _this._environment0$_mixins; + B.JSArray_methods.add$1(t6, A.LinkedHashMap_LinkedHashMap$_empty(t2, t5)); + t5 = _this._environment0$_nestedForwardedModules; + if (t5 != null) + t5.push(A._setArrayType([], type$.JSArray_Module_Callable_2)); + try { + t2 = callback.call$0(); + return t2; + } finally { + _this._environment0$_inSemiGlobalScope = wasInSemiGlobalScope; + _this._environment0$_lastVariableIndex = _this._environment0$_lastVariableName = null; + for (t1 = J.get$iterator$ax(J.get$keys$z(B.JSArray_methods.removeLast$0(t1))), t2 = _this._environment0$_variableIndices; t1.moveNext$0();) { + $name = t1.get$current(t1); + t2.remove$1(0, $name); + } + B.JSArray_methods.removeLast$0(t3); + for (t1 = J.get$iterator$ax(J.get$keys$z(B.JSArray_methods.removeLast$0(t4))), t2 = _this._environment0$_functionIndices; t1.moveNext$0();) { + name0 = t1.get$current(t1); + t2.remove$1(0, name0); + } + for (t1 = J.get$iterator$ax(J.get$keys$z(B.JSArray_methods.removeLast$0(t6))), t2 = _this._environment0$_mixinIndices; t1.moveNext$0();) { + name1 = t1.get$current(t1); + t2.remove$1(0, name1); + } + t1 = _this._environment0$_nestedForwardedModules; + if (t1 != null) + t1.pop(); + } + }, + scope$1$1(callback) { + return this.scope$1$3$semiGlobal$when(callback, false, true); + }, + scope$1$2$when(callback, when) { + return this.scope$1$3$semiGlobal$when(callback, false, when); + }, + scope$1$2$semiGlobal(callback, semiGlobal) { + return this.scope$1$3$semiGlobal$when(callback, semiGlobal, true); + }, + toImplicitConfiguration$0() { + var t2, t3, t4, i, values, nodes, t5, t6, $name, value, + t1 = type$.String, + configuration = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.ConfiguredValue_2); + for (t2 = this._environment0$_variables, t3 = type$.Value_2, t4 = this._environment0$_variableNodes, i = 0; i < t2.length; ++i) { + values = t2[i]; + nodes = t4[i]; + for (t5 = A.MapExtensions_get_pairs0(values, t1, t3), t5 = t5.get$iterator(t5); t5.moveNext$0();) { + t6 = t5.get$current(t5); + $name = t6._0; + value = t6._1; + t6 = nodes.$index(0, $name); + t6.toString; + configuration.$indexSet(0, $name, new A.ConfiguredValue0(value, null, t6)); + } + } + return new A.Configuration0(configuration, null); + }, + toModule$3(css, preModuleComments, extensionStore) { + return A._EnvironmentModule__EnvironmentModule1(this, css, preModuleComments, extensionStore, A.NullableExtension_andThen0(this._environment0$_forwardedModules, new A.Environment_toModule_closure0())); + }, + toDummyModule$0() { + return A._EnvironmentModule__EnvironmentModule1(this, new A.CssStylesheet0(new A.UnmodifiableListView(B.List_empty17, type$.UnmodifiableListView_CssNode_2), A.SourceFile$decoded(B.List_empty4, "").span$1(0, 0)), B.Map_empty10, B.C_EmptyExtensionStore0, A.NullableExtension_andThen0(this._environment0$_forwardedModules, new A.Environment_toDummyModule_closure0())); + }, + _environment0$_getModule$1(namespace) { + var _0_0 = this._environment0$_modules.$index(0, namespace); + if (_0_0 != null) + return _0_0; + throw A.wrapException(A.SassScriptException$0('There is no module with the namespace "' + namespace + '".', null)); + }, + _environment0$_fromOneModule$1$3($name, type, callback) { + var t1, t2, t3, t4, t5, _1_0, _2_0, value, identity, valueInModule, identityFromModule, module, node, + _0_0 = this._environment0$_nestedForwardedModules; + if (_0_0 != null) + for (t1 = A._arrayInstanceType(_0_0)._eval$1("ReversedListIterable<1>"), t2 = new A.ReversedListIterable(_0_0, t1), t2 = new A.ListIterator(t2, t2.get$length(0), t1._eval$1("ListIterator")), t1 = t1._eval$1("ListIterable.E"); t2.moveNext$0();) { + t3 = t2.__internal$_current; + for (t3 = J.get$reversed$ax(t3 == null ? t1._as(t3) : t3), t4 = t3.$ti, t3 = new A.ListIterator(t3, t3.get$length(0), t4._eval$1("ListIterator")), t4 = t4._eval$1("ListIterable.E"); t3.moveNext$0();) { + t5 = t3.__internal$_current; + _1_0 = callback.call$1(t5 == null ? t4._as(t5) : t5); + if (_1_0 != null) + return _1_0; + } + } + for (t1 = this._environment0$_importedModules, t1 = new A.LinkedHashMapKeyIterator(t1, t1.__js_helper$_modifications, t1.__js_helper$_first); t1.moveNext$0();) { + _2_0 = callback.call$1(t1.__js_helper$_current); + if (_2_0 != null) + return _2_0; + } + for (t1 = this._environment0$_globalModules, t2 = new A.LinkedHashMapKeyIterator(t1, t1.__js_helper$_modifications, t1.__js_helper$_first), t3 = type$.Callable_2, value = null, identity = null; t2.moveNext$0();) { + t4 = t2.__js_helper$_current; + valueInModule = callback.call$1(t4); + if (valueInModule == null) + continue; + identityFromModule = t3._is(valueInModule) ? valueInModule : t4.variableIdentity$1($name); + if (identityFromModule.$eq(0, identity)) + continue; + if (value != null) { + t2 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + for (t3 = A.MapExtensions_get_pairs0(t1, type$.Module_Callable_2, type$.AstNode_2), t3 = t3.get$iterator(t3), t4 = "includes " + type; t3.moveNext$0();) { + t1 = t3.get$current(t3); + module = t1._0; + node = t1._1; + if (callback.call$1(module) != null) + t2.$indexSet(0, node.get$span(node), t4); + } + throw A.wrapException(A.MultiSpanSassScriptException$0("This " + type + string$.x20is_av, type + " use", t2)); + } + identity = identityFromModule; + value = valueInModule; + } + return value; + }, + _environment0$_fromOneModule$3($name, type, callback) { + return this._environment0$_fromOneModule$1$3($name, type, callback, type$.dynamic); + } + }; + A.Environment__getVariableFromGlobalModule_closure0.prototype = { + call$1(module) { + return module.get$variables().$index(0, this.name); + }, + $signature: 441 + }; + A.Environment_setVariable_closure2.prototype = { + call$0() { + var t1 = this.$this; + t1._environment0$_lastVariableName = this.name; + return t1._environment0$_lastVariableIndex = 0; + }, + $signature: 10 + }; + A.Environment_setVariable_closure3.prototype = { + call$1(module) { + return module.get$variables().containsKey$1(this.name) ? module : null; + }, + $signature: 442 + }; + A.Environment_setVariable_closure4.prototype = { + call$0() { + var t1 = this.$this, + t2 = t1._environment0$_variableIndex$1(this.name); + return t2 == null ? t1._environment0$_variables.length - 1 : t2; + }, + $signature: 10 + }; + A.Environment__getFunctionFromGlobalModule_closure0.prototype = { + call$1(module) { + return module.get$functions(module).$index(0, this.name); + }, + $signature: 235 + }; + A.Environment__getMixinFromGlobalModule_closure0.prototype = { + call$1(module) { + return module.get$mixins().$index(0, this.name); + }, + $signature: 235 + }; + A.Environment_toModule_closure0.prototype = { + call$1(modules) { + return new A.MapKeySet(modules, type$.MapKeySet_Module_Callable_2); + }, + $signature: 236 + }; + A.Environment_toDummyModule_closure0.prototype = { + call$1(modules) { + return new A.MapKeySet(modules, type$.MapKeySet_Module_Callable_2); + }, + $signature: 236 + }; + A._EnvironmentModule1.prototype = { + get$url(_) { + var t1 = this.css; + return t1.get$span(t1).file.url; + }, + setVariable$3($name, value, nodeWithSpan) { + var t1, t2, + _0_0 = this._environment0$_modulesByVariable.$index(0, $name); + if (_0_0 != null) { + _0_0.setVariable$3($name, value, nodeWithSpan); + return; + } + t1 = this._environment0$_environment; + t2 = t1._environment0$_variables; + if (!B.JSArray_methods.get$first(t2).containsKey$1($name)) + throw A.wrapException(A.SassScriptException$0("Undefined variable.", null)); + J.$indexSet$ax(B.JSArray_methods.get$first(t2), $name, value); + J.$indexSet$ax(B.JSArray_methods.get$first(t1._environment0$_variableNodes), $name, nodeWithSpan); + return; + }, + variableIdentity$1($name) { + var module = this._environment0$_modulesByVariable.$index(0, $name); + return module == null ? this : module.variableIdentity$1($name); + }, + cloneCss$0() { + var _0_0, _this = this; + if (!_this.transitivelyContainsCss) + return _this; + _0_0 = A.cloneCssStylesheet0(_this.css, _this.extensionStore); + return A._EnvironmentModule$_1(_this._environment0$_environment, _0_0._0, _this.preModuleComments, _0_0._1, _this._environment0$_modulesByVariable, _this.variables, _this.variableNodes, _this.functions, _this.mixins, true, _this.transitivelyContainsExtensions); + }, + toString$0(_) { + var t2, + t1 = this.css; + if (t1.get$span(t1).file.url == null) + t1 = ""; + else { + t1 = t1.get$span(t1).file.url; + t2 = $.$get$context(); + t1.toString; + t1 = t2.prettyUri$1(t1); + } + return t1; + }, + $isModule1: 1, + get$upstream() { + return this.upstream; + }, + get$variables() { + return this.variables; + }, + get$variableNodes() { + return this.variableNodes; + }, + get$functions(receiver) { + return this.functions; + }, + get$mixins() { + return this.mixins; + }, + get$extensionStore() { + return this.extensionStore; + }, + get$css(receiver) { + return this.css; + }, + get$preModuleComments() { + return this.preModuleComments; + }, + get$transitivelyContainsCss() { + return this.transitivelyContainsCss; + }, + get$transitivelyContainsExtensions() { + return this.transitivelyContainsExtensions; + } + }; + A._EnvironmentModule__EnvironmentModule_closure11.prototype = { + call$1(module) { + return module.get$variables(); + }, + $signature: 445 + }; + A._EnvironmentModule__EnvironmentModule_closure12.prototype = { + call$1(module) { + return module.get$variableNodes(); + }, + $signature: 446 + }; + A._EnvironmentModule__EnvironmentModule_closure13.prototype = { + call$1(module) { + return module.get$functions(module); + }, + $signature: 237 + }; + A._EnvironmentModule__EnvironmentModule_closure14.prototype = { + call$1(module) { + return module.get$mixins(); + }, + $signature: 237 + }; + A._EnvironmentModule__EnvironmentModule_closure15.prototype = { + call$1(module) { + return module.get$transitivelyContainsCss(); + }, + $signature: 127 + }; + A._EnvironmentModule__EnvironmentModule_closure16.prototype = { + call$1(module) { + return module.get$transitivelyContainsExtensions(); + }, + $signature: 127 + }; + A.ErrorRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitErrorRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "@error " + this.expression.toString$0(0) + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A._EvaluateVisitor1.prototype = { + _EvaluateVisitor$6$functions$importCache$logger$nodeImporter$quietDeps$sourceMap1(functions, importCache, logger, nodeImporter, quietDeps, sourceMap) { + var t2, metaModule, t3, _i, module, $function, t4, _this = this, + _s20_ = "$name, $module: null", + _s9_ = "sass:meta", + _s7_ = "$module", + t1 = type$.JSArray_BuiltInCallable_2, + metaFunctions = A._setArrayType([A.BuiltInCallable$function0("global-variable-exists", _s20_, new A._EvaluateVisitor_closure25(_this), _s9_), A.BuiltInCallable$function0("variable-exists", "$name", new A._EvaluateVisitor_closure26(_this), _s9_), A.BuiltInCallable$function0("function-exists", _s20_, new A._EvaluateVisitor_closure27(_this), _s9_), A.BuiltInCallable$function0("mixin-exists", _s20_, new A._EvaluateVisitor_closure28(_this), _s9_), A.BuiltInCallable$function0("content-exists", "", new A._EvaluateVisitor_closure29(_this), _s9_), A.BuiltInCallable$function0("module-variables", _s7_, new A._EvaluateVisitor_closure30(_this), _s9_), A.BuiltInCallable$function0("module-functions", _s7_, new A._EvaluateVisitor_closure31(_this), _s9_), A.BuiltInCallable$function0("module-mixins", _s7_, new A._EvaluateVisitor_closure32(_this), _s9_), A.BuiltInCallable$function0("get-function", "$name, $css: false, $module: null", new A._EvaluateVisitor_closure33(_this), _s9_), A.BuiltInCallable$function0("get-mixin", _s20_, new A._EvaluateVisitor_closure34(_this), _s9_), A.BuiltInCallable$function0("call", "$function, $args...", new A._EvaluateVisitor_closure35(_this), _s9_)], t1), + metaMixins = A._setArrayType([A.BuiltInCallable$mixin0("load-css", "$url, $with: null", new A._EvaluateVisitor_closure36(_this), false, _s9_), A.BuiltInCallable$mixin0("apply", "$mixin, $args...", new A._EvaluateVisitor_closure37(_this), true, _s9_)], t1); + t1 = type$.BuiltInCallable_2; + t2 = A.List_List$of($.$get$moduleFunctions0(), true, t1); + B.JSArray_methods.addAll$1(t2, metaFunctions); + metaModule = A.BuiltInModule$0("meta", t2, metaMixins, null, t1); + for (t1 = A.List_List$of($.$get$coreModules0(), true, type$.BuiltInModule_Callable_2), t1.push(metaModule), t2 = t1.length, t3 = _this._evaluate0$_builtInModules, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + module = t1[_i]; + t3.$indexSet(0, module.url, module); + } + t1 = type$.JSArray_Callable_2; + t2 = A._setArrayType([], t1); + B.JSArray_methods.addAll$1(t2, functions); + B.JSArray_methods.addAll$1(t2, $.$get$globalFunctions0()); + t1 = A._setArrayType([], t1); + for (_i = 0; _i < 11; ++_i) + t1.push(metaFunctions[_i].withDeprecationWarning$1("meta")); + B.JSArray_methods.addAll$1(t2, t1); + for (t1 = t2.length, t3 = _this._evaluate0$_builtInFunctions, _i = 0; _i < t2.length; t2.length === t1 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + $function = t2[_i]; + t4 = $function.get$name($function); + t3.$indexSet(0, A.stringReplaceAllUnchecked(t4, "_", "-"), $function); + } + }, + run$2(_, importer, node) { + var error, stackTrace, t1, exception; + try { + t1 = type$.nullable_Object; + t1 = A.runZoned(new A._EvaluateVisitor_run_closure1(this, node, importer), A.LinkedHashMap_LinkedHashMap$_literal([B.Symbol__evaluationContext, new A._EvaluationContext1(this, node)], t1, t1), type$.Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet_2); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException0) { + error = t1; + stackTrace = A.getTraceFromException(exception); + A.throwWithTrace0(error.withLoadedUrls$1(this._evaluate0$_loadedUrls), error, stackTrace); + } else + throw exception; + } + }, + _evaluate0$_assertInModule$1$2(value, $name) { + if (value != null) + return value; + throw A.wrapException(A.StateError$("Can't access " + $name + " outside of a module.")); + }, + _evaluate0$_assertInModule$2(value, $name) { + return this._evaluate0$_assertInModule$1$2(value, $name, type$.dynamic); + }, + _evaluate0$_loadModule$7$baseUrl$configuration$namesInErrors(url, stackFrame, nodeWithSpan, callback, baseUrl, configuration, namesInErrors) { + var t2, _this = this, + _0_0 = _this._evaluate0$_builtInModules.$index(0, url), + t1 = {}; + t1.builtInModule = null; + if (_0_0 != null) { + t1.builtInModule = _0_0; + if (configuration instanceof A.ExplicitConfiguration0) { + t1 = namesInErrors ? "Built-in module " + url.toString$0(0) + " can't be configured." : "Built-in modules can't be configured."; + t2 = configuration.nodeWithSpan; + throw A.wrapException(_this._evaluate0$_exception$2(t1, t2.get$span(t2))); + } + _this._evaluate0$_addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__loadModule_closure3(t1, callback)); + return; + } + _this._evaluate0$_withStackFrame$3(stackFrame, nodeWithSpan, new A._EvaluateVisitor__loadModule_closure4(_this, url, nodeWithSpan, baseUrl, namesInErrors, configuration, callback)); + }, + _evaluate0$_loadModule$5$configuration(url, stackFrame, nodeWithSpan, callback, configuration) { + return this._evaluate0$_loadModule$7$baseUrl$configuration$namesInErrors(url, stackFrame, nodeWithSpan, callback, null, configuration, false); + }, + _evaluate0$_loadModule$4(url, stackFrame, nodeWithSpan, callback) { + return this._evaluate0$_loadModule$7$baseUrl$configuration$namesInErrors(url, stackFrame, nodeWithSpan, callback, null, null, false); + }, + _evaluate0$_execute$5$configuration$namesInErrors$nodeWithSpan(importer, stylesheet, configuration, namesInErrors, nodeWithSpan) { + var currentConfiguration, t2, t3, message, existingSpan, configurationSpan, environment, css, preModuleComments, extensionStore, module, _this = this, + url = stylesheet.span.file.url, + t1 = _this._evaluate0$_modules, + _0_0 = t1.$index(0, url); + if (_0_0 != null) { + t1 = configuration == null; + currentConfiguration = t1 ? _this._evaluate0$_configuration : configuration; + t2 = _this._evaluate0$_moduleConfigurations.$index(0, url); + t3 = t2._configuration0$__originalConfiguration; + t2 = t3 == null ? t2 : t3; + t3 = currentConfiguration._configuration0$__originalConfiguration; + if (t2 !== (t3 == null ? currentConfiguration : t3) && currentConfiguration instanceof A.ExplicitConfiguration0) { + if (namesInErrors) { + t2 = $.$get$context(); + url.toString; + message = t2.prettyUri$1(url) + string$.x20was_a; + } else + message = string$.This_mw; + t2 = _this._evaluate0$_moduleNodes.$index(0, url); + existingSpan = t2 == null ? null : t2.get$span(t2); + if (t1) { + t1 = currentConfiguration.nodeWithSpan; + configurationSpan = t1.get$span(t1); + } else + configurationSpan = null; + t1 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + if (existingSpan != null) + t1.$indexSet(0, existingSpan, "original load"); + if (configurationSpan != null) + t1.$indexSet(0, configurationSpan, "configuration"); + throw A.wrapException(t1.get$isEmpty(0) ? _this._evaluate0$_exception$1(message) : _this._evaluate0$_multiSpanException$3(message, "new load", t1)); + } + return _0_0; + } + environment = A.Environment$0(); + css = A._Cell$(); + preModuleComments = A._Cell$(); + extensionStore = A.ExtensionStore$0(); + _this._evaluate0$_withEnvironment$2(environment, new A._EvaluateVisitor__execute_closure1(_this, importer, stylesheet, extensionStore, configuration, css, preModuleComments)); + t2 = css._readLocal$0(); + t3 = preModuleComments._readLocal$0(); + module = environment.toModule$3(t2, t3 == null ? B.Map_empty10 : t3, extensionStore); + if (url != null) { + t1.$indexSet(0, url, module); + _this._evaluate0$_moduleConfigurations.$indexSet(0, url, _this._evaluate0$_configuration); + if (nodeWithSpan != null) + _this._evaluate0$_moduleNodes.$indexSet(0, url, nodeWithSpan); + } + return module; + }, + _evaluate0$_execute$2(importer, stylesheet) { + return this._evaluate0$_execute$5$configuration$namesInErrors$nodeWithSpan(importer, stylesheet, null, false, null); + }, + _evaluate0$_addOutOfOrderImports$0() { + var t1, t2, _this = this, _s5_ = "_root", + _s13_ = "_endOfImports", + _0_0 = _this._evaluate0$_outOfOrderImports; + $label0$0: { + if (_0_0 == null) { + t1 = _this._evaluate0$_assertInModule$2(_this._evaluate0$__root, _s5_).children; + break $label0$0; + } + t1 = _this._evaluate0$_assertInModule$2(_this._evaluate0$__root, _s5_).children; + t1 = A.List_List$of(A.SubListIterable$(t1, 0, A.checkNotNullable(_this._evaluate0$_assertInModule$2(_this._evaluate0$__endOfImports, _s13_), "count", type$.int), t1.$ti._eval$1("ListBase.E")), true, type$.ModifiableCssNode_2); + B.JSArray_methods.addAll$1(t1, _0_0); + t2 = _this._evaluate0$_assertInModule$2(_this._evaluate0$__root, _s5_).children; + B.JSArray_methods.addAll$1(t1, A.SubListIterable$(t2, _this._evaluate0$_assertInModule$2(_this._evaluate0$__endOfImports, _s13_), null, t2.$ti._eval$1("ListBase.E"))); + break $label0$0; + } + return t1; + }, + _evaluate0$_combineCss$2$clone(root, clone) { + var selectors, _0_0, t1, imports, css, sorted, t2; + if (!B.JSArray_methods.any$1(root.get$upstream(), new A._EvaluateVisitor__combineCss_closure3())) { + selectors = root.get$extensionStore().get$simpleSelectors(); + _0_0 = A.IterableExtension_get_firstOrNull(root.get$extensionStore().extensionsWhereTarget$1(new A._EvaluateVisitor__combineCss_closure4(selectors))); + if (_0_0 != null) + this._evaluate0$_throwForUnsatisfiedExtension$1(_0_0); + return root.get$css(root); + } + t1 = type$.JSArray_CssNode_2; + imports = A._setArrayType([], t1); + css = A._setArrayType([], t1); + t1 = type$.Module_Callable_2; + sorted = A.ListQueue$(t1); + new A._EvaluateVisitor__combineCss_visitModule1(this, A.LinkedHashSet_LinkedHashSet$_empty(t1), clone, css, imports, sorted).call$1(root); + if (root.get$transitivelyContainsExtensions()) + this._evaluate0$_extendModules$1(sorted); + t1 = B.JSArray_methods.$add(imports, css); + t2 = root.get$css(root); + return new A.CssStylesheet0(new A.UnmodifiableListView(t1, type$.UnmodifiableListView_CssNode_2), t2.get$span(t2)); + }, + _evaluate0$_combineCss$1(root) { + return this._evaluate0$_combineCss$2$clone(root, false); + }, + _evaluate0$_extendModules$1(sortedModules) { + var t1, t2, t3, originalSelectors, $self, t4, t5, _i, upstream, _0_0, + downstreamExtensionStores = A.LinkedHashMap_LinkedHashMap$_empty(type$.Uri, type$.List_ExtensionStore_2), + unsatisfiedExtensions = new A._LinkedIdentityHashSet(type$._LinkedIdentityHashSet_Extension_2); + for (t1 = A._ListQueueIterator$(sortedModules, sortedModules.$ti._precomputed1), t2 = t1.$ti._precomputed1; t1.moveNext$0();) { + t3 = t1._collection$_current; + if (t3 == null) + t3 = t2._as(t3); + originalSelectors = t3.get$extensionStore().get$simpleSelectors().toSet$0(0); + unsatisfiedExtensions.addAll$1(0, t3.get$extensionStore().extensionsWhereTarget$1(new A._EvaluateVisitor__extendModules_closure3(originalSelectors))); + $self = downstreamExtensionStores.$index(0, t3.get$url(t3)); + t4 = t3.get$extensionStore().get$addExtensions(); + if ($self != null) + t4.call$1($self); + t4 = t3.get$extensionStore(); + if (t4.get$isEmpty(t4)) + continue; + for (t4 = t3.get$upstream(), t5 = t4.length, _i = 0; _i < t4.length; t4.length === t5 || (0, A.throwConcurrentModificationError)(t4), ++_i) { + upstream = t4[_i]; + _0_0 = upstream.get$url(upstream); + if (_0_0 != null) + J.add$1$ax(downstreamExtensionStores.putIfAbsent$2(_0_0, new A._EvaluateVisitor__extendModules_closure4()), t3.get$extensionStore()); + } + unsatisfiedExtensions.removeAll$1(t3.get$extensionStore().extensionsWhereTarget$1(originalSelectors.get$contains(originalSelectors))); + } + if (unsatisfiedExtensions._collection$_length !== 0) + this._evaluate0$_throwForUnsatisfiedExtension$1(unsatisfiedExtensions.get$first(0)); + }, + _evaluate0$_throwForUnsatisfiedExtension$1(extension) { + throw A.wrapException(A.SassException$0(string$.The_ta + extension.target.toString$0(0) + ' !optional" to avoid this error.', extension.span, null)); + }, + _evaluate0$_indexAfterImports$1(statements) { + var t1, lastImport, i, _0_0; + for (t1 = J.getInterceptor$asx(statements), lastImport = -1, i = 0; i < t1.get$length(statements); ++i) { + $label0$0: { + _0_0 = t1.$index(statements, i); + if (_0_0 instanceof A.ModifiableCssImport0) + break $label0$0; + if (_0_0 instanceof A.ModifiableCssComment0) + continue; + break; + } + lastImport = i; + } + return lastImport + 1; + }, + visitStylesheet$1(_, node) { + var t1, t2, warning, _i, $name, span; + for (t1 = node.parseTimeWarnings, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + warning = t1.__internal$_current; + if (warning == null) + warning = t2._as(warning); + this._evaluate0$_warn$3(warning._1, warning._2, warning._0); + } + for (t1 = node.children, t2 = t1.length, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(this); + for (t1 = A.MapExtensions_get_pairs0(node.globalVariables, type$.String, type$.FileSpan), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t2 = t1.get$current(t1); + $name = t2._0; + span = t2._1; + this.visitVariableDeclaration$1(0, new A.VariableDeclaration0(null, $name, new A.NullExpression0(span), true, false, span)); + } + return null; + }, + visitAtRootRule$1(_, node) { + var t1, _2_0, root, first, rest, innerCopy, outerCopy, _i, copy, _this = this, _null = null, + _s8_ = "__parent", + _0_0 = node.query, + query = _0_0 != null ? new A.AtRootQueryParser0(A.SpanScanner$(_this._evaluate0$_performInterpolationWithMap$2$warnForColor(_0_0, true)._0, _null), _null).parse$0(0) : B.AtRootQuery_bfj0, + $parent = _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_), + included = A._setArrayType([], type$.JSArray_ModifiableCssParentNode_2); + for (t1 = type$.CssStylesheet_2; !t1._is($parent); $parent = _2_0) { + if (!query.excludes$1($parent)) + included.push($parent); + _2_0 = $parent._node$_parent; + if (_2_0 == null) + throw A.wrapException(A.StateError$(string$.CssNod)); + } + root = _this._evaluate0$_trimIncluded$1(included); + if (root === _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_)) { + _this._evaluate0$_environment.scope$1$2$when(new A._EvaluateVisitor_visitAtRootRule_closure3(_this, node), node.hasDeclarations, type$.Null); + return _null; + } + if (included.length >= 1) { + first = included[0]; + rest = B.JSArray_methods.sublist$1(included, 1); + innerCopy = first.copyWithoutChildren$0(); + for (t1 = rest.length, outerCopy = innerCopy, _i = 0; _i < rest.length; rest.length === t1 || (0, A.throwConcurrentModificationError)(rest), ++_i, outerCopy = copy) { + copy = rest[_i].copyWithoutChildren$0(); + copy.addChild$1(outerCopy); + } + root.addChild$1(outerCopy); + } else + innerCopy = root; + _this._evaluate0$_scopeForAtRoot$4(node, innerCopy, query, included).call$1(new A._EvaluateVisitor_visitAtRootRule_closure4(_this, node)); + return _null; + }, + _evaluate0$_trimIncluded$1(nodes) { + var $parent, t1, innermostContiguous, i, t2, _0_0, _1_0, root, _this = this, _null = null, _s5_ = "_root", + _s22_ = " to be an ancestor of "; + if (nodes.length === 0) + return _this._evaluate0$_assertInModule$2(_this._evaluate0$__root, _s5_); + $parent = _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, "__parent"); + for (t1 = nodes.length, innermostContiguous = _null, i = 0; i < t1; ++i, $parent = _1_0) { + for (; t2 = nodes[i], $parent !== t2; innermostContiguous = _null, $parent = _0_0) { + _0_0 = $parent._node$_parent; + if (_0_0 == null) + throw A.wrapException(A.ArgumentError$("Expected " + t2.toString$0(0) + _s22_ + _this.toString$0(0) + ".", _null)); + } + if (innermostContiguous == null) + innermostContiguous = i; + _1_0 = $parent._node$_parent; + if (_1_0 == null) + throw A.wrapException(A.ArgumentError$("Expected " + t2.toString$0(0) + _s22_ + _this.toString$0(0) + ".", _null)); + } + if ($parent !== _this._evaluate0$_assertInModule$2(_this._evaluate0$__root, _s5_)) + return _this._evaluate0$_assertInModule$2(_this._evaluate0$__root, _s5_); + innermostContiguous.toString; + root = nodes[innermostContiguous]; + B.JSArray_methods.removeRange$2(nodes, innermostContiguous, nodes.length); + return root; + }, + _evaluate0$_scopeForAtRoot$4(node, newParent, query, included) { + var _this = this, + scope = new A._EvaluateVisitor__scopeForAtRoot_closure11(_this, newParent, node), + t1 = query._at_root_query0$_all || query._at_root_query0$_rule; + if (t1 !== query.include) + scope = new A._EvaluateVisitor__scopeForAtRoot_closure12(_this, scope); + if (_this._evaluate0$_mediaQueries != null && query.excludesName$1("media")) + scope = new A._EvaluateVisitor__scopeForAtRoot_closure13(_this, scope); + if (_this._evaluate0$_inKeyframes && query.excludesName$1("keyframes")) + scope = new A._EvaluateVisitor__scopeForAtRoot_closure14(_this, scope); + return _this._evaluate0$_inUnknownAtRule && !B.JSArray_methods.any$1(included, new A._EvaluateVisitor__scopeForAtRoot_closure15()) ? new A._EvaluateVisitor__scopeForAtRoot_closure16(_this, scope) : scope; + }, + visitContentBlock$1(_, node) { + return A.throwExpression(A.UnsupportedError$(string$.Evalua)); + }, + visitContentRule$1(_, node) { + var $content = this._evaluate0$_environment._environment0$_content; + if ($content == null) + return null; + this._evaluate0$_runUserDefinedCallable$1$4(node.$arguments, $content, node, new A._EvaluateVisitor_visitContentRule_closure1(this, $content), type$.Null); + return null; + }, + visitDebugRule$1(_, node) { + var value = node.expression.accept$1(this), + t1 = value instanceof A.SassString0 ? value._string0$_text : A.serializeValue0(value, true, true); + this._evaluate0$_logger.debug$2(0, t1, node.span); + return null; + }, + visitDeclaration$1(_, node) { + var siblings, interleavedRules, t1, t2, t3, t4, t5, t6, rule, rule0, $name, _1_0, _2_0, value, _3_0, oldDeclarationName, _this = this, _null = null, + _s8_ = "__parent"; + if ((_this._evaluate0$_atRootExcludingStyleRule ? _null : _this._evaluate0$_styleRuleIgnoringAtRoot) == null && !_this._evaluate0$_inUnknownAtRule && !_this._evaluate0$_inKeyframes) + throw A.wrapException(_this._evaluate0$_exception$2(string$.Declarm, node.span)); + if (_this._evaluate0$_declarationName != null && B.JSString_methods.startsWith$1(node.name.get$initialPlain(), "--")) + throw A.wrapException(_this._evaluate0$_exception$2(string$.Declarw, node.span)); + siblings = _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_)._node$_parent.children; + interleavedRules = A._setArrayType([], type$.JSArray_CssStyleRule_2); + if (siblings.get$last(siblings) !== _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_)) + t1 = !(_this._evaluate0$_quietDeps && _this._evaluate0$_inDependency); + else + t1 = false; + if (t1) + for (t1 = A.SubListIterable$(siblings, siblings.indexOf$1(siblings, _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_)) + 1, _null, siblings.$ti._eval$1("ListBase.E")), t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = node.span, t4 = type$.SourceSpan, t5 = type$.String, t2 = t2._eval$1("ListIterable.E"); t1.moveNext$0();) { + t6 = t1.__internal$_current; + rule = t6 == null ? t2._as(t6) : t6; + $label0$1: { + if (rule instanceof A.ModifiableCssComment0) + continue; + t6 = rule instanceof A.ModifiableCssStyleRule0; + rule0 = t6 ? rule : _null; + if (t6) { + interleavedRules.push(rule0); + break $label0$1; + } + _this._evaluate0$_warn$3(string$.Sassx27s, new A.MultiSpan0(t3, "declaration", A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_literal([rule.get$span(rule), "nested rule"], t4, t5), t4, t5)), B.Deprecation_MSr); + B.JSArray_methods.clear$0(interleavedRules); + break $label0$1; + } + } + t1 = node.name; + $name = _this._evaluate0$_interpolationToValue$2$warnForColor(t1, true); + _1_0 = _this._evaluate0$_declarationName; + if (_1_0 != null) + $name = new A.CssValue0(_1_0 + "-" + A.S($name.value), $name.span, type$.CssValue_String_2); + _2_0 = node.value; + if (_2_0 != null) { + value = _2_0.accept$1(_this); + if (!value.get$isBlank() || value.get$asList().length === 0) { + t2 = _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_); + t3 = _2_0.get$span(_2_0); + t4 = node.span; + t1 = B.JSString_methods.startsWith$1(t1.get$initialPlain(), "--"); + t5 = interleavedRules.length === 0 ? _null : _this._evaluate0$_stackTrace$1(t4); + if (_this._evaluate0$_sourceMap) { + t6 = A.NullableExtension_andThen0(_2_0, _this.get$_evaluate0$_expressionNode()); + t6 = t6 == null ? _null : J.get$span$z(t6); + } else + t6 = _null; + t2.addChild$1(A.ModifiableCssDeclaration$0($name, new A.CssValue0(value, t3, type$.CssValue_Value_2), t4, interleavedRules, t1, t5, t6)); + } else if (J.startsWith$1$s($name.value, "--")) + throw A.wrapException(_this._evaluate0$_exception$2("Custom property values may not be empty.", _2_0.get$span(_2_0))); + } + _3_0 = node.children; + t1 = {}; + t1.children = null; + if (_3_0 != null) { + t1.children = _3_0; + oldDeclarationName = _this._evaluate0$_declarationName; + _this._evaluate0$_declarationName = $name.value; + _this._evaluate0$_environment.scope$1$2$when(new A._EvaluateVisitor_visitDeclaration_closure1(t1, _this), node.hasDeclarations, type$.Null); + _this._evaluate0$_declarationName = oldDeclarationName; + } + return _null; + }, + visitEachRule$1(_, node) { + var _this = this, + t1 = node.list, + list = t1.accept$1(_this), + nodeWithSpan = _this._evaluate0$_expressionNode$1(t1), + _0_0 = node.variables; + $label0$0: { + t1 = {}; + t1.variable = null; + if (_0_0.length === 1) { + t1.variable = _0_0[0]; + t1 = new A._EvaluateVisitor_visitEachRule_closure5(t1, _this, nodeWithSpan); + break $label0$0; + } + t1 = {}; + t1.variables = null; + t1.variables = _0_0; + t1 = new A._EvaluateVisitor_visitEachRule_closure6(t1, _this, nodeWithSpan); + break $label0$0; + } + return _this._evaluate0$_environment.scope$1$2$semiGlobal(new A._EvaluateVisitor_visitEachRule_closure7(_this, list, t1, node), true, type$.nullable_Value_2); + }, + _evaluate0$_setMultipleVariables$3(variables, value, nodeWithSpan) { + var i, + list = value.get$asList(), + t1 = variables.length, + minLength = Math.min(t1, list.length); + for (i = 0; i < minLength; ++i) + this._evaluate0$_environment.setLocalVariable$3(variables[i], this._evaluate0$_withoutSlash$2(list[i], nodeWithSpan), nodeWithSpan); + for (i = minLength; i < t1; ++i) + this._evaluate0$_environment.setLocalVariable$3(variables[i], B.C__SassNull0, nodeWithSpan); + }, + visitErrorRule$1(_, node) { + throw A.wrapException(this._evaluate0$_exception$2(node.expression.accept$1(this).toString$0(0), node.span)); + }, + visitExtendRule$1(_, node) { + var t1, t2, t3, t4, t5, _i, complex, visitor, t6, t7, _0_0, compound, _this = this, _null = null, + styleRule = _this._evaluate0$_atRootExcludingStyleRule ? _null : _this._evaluate0$_styleRuleIgnoringAtRoot; + if (styleRule == null || _this._evaluate0$_declarationName != null) + throw A.wrapException(_this._evaluate0$_exception$2(string$.x40exten, node.span)); + for (t1 = styleRule.originalSelector.components, t2 = t1.length, t3 = node.span, t4 = type$.SourceSpan, t5 = type$.String, _i = 0; _i < t2; ++_i) { + complex = t1[_i]; + if (!complex.accept$1(B._IsBogusVisitor_true0)) + continue; + visitor = A._SerializeVisitor$0(_null, true, _null, _null, true, false, _null, true); + complex.accept$1(visitor); + t6 = B.JSString_methods.trim$0(visitor._serialize0$_buffer.toString$0(0)); + t7 = complex.accept$1(B.C__IsUselessVisitor0) ? "can't" : "shouldn't"; + _this._evaluate0$_warn$3('The selector "' + t6 + '" is invalid CSS and ' + t7 + string$.x20be_an, new A.MultiSpan0(A.SpanExtensions_trimRight0(complex.span), "invalid selector", A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_literal([t3, "@extend rule"], t4, t5), t4, t5)), B.Deprecation_SHb); + } + _0_0 = _this._evaluate0$_performInterpolationWithMap$2$warnForColor(node.selector, true); + for (t1 = A.SelectorList_SelectorList$parse0(A.trimAscii0(_0_0._0, true), false, _0_0._1, false).components, t2 = t1.length, t3 = styleRule._style_rule0$_selector._box0$_inner, _i = 0; _i < t2; ++_i) { + complex = t1[_i]; + compound = complex.get$singleCompound(); + if (compound == null) + throw A.wrapException(A.SassFormatException$0("complex selectors may not be extended.", complex.span, _null)); + t4 = compound.components; + t5 = t4.length === 1 ? B.JSArray_methods.get$first(t4) : _null; + if (t5 == null) + throw A.wrapException(A.SassFormatException$0(string$.compou + B.JSArray_methods.join$1(t4, ", ") + string$.x60_inst, compound.span, _null)); + _this._evaluate0$_assertInModule$2(_this._evaluate0$__extensionStore, "_extensionStore").addExtension$4(t3.value, t5, node, _this._evaluate0$_mediaQueries); + } + return _null; + }, + visitAtRule$1(_, node) { + var $name, value, children, wasInKeyframes, wasInUnknownAtRule, _this = this; + if (_this._evaluate0$_declarationName != null) + throw A.wrapException(_this._evaluate0$_exception$2(string$.At_rul, node.span)); + $name = _this._evaluate0$_interpolationToValue$1(node.name); + value = A.NullableExtension_andThen0(node.value, new A._EvaluateVisitor_visitAtRule_closure5(_this)); + children = node.children; + if (children == null) { + _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, "__parent").addChild$1(A.ModifiableCssAtRule$0($name, node.span, true, value)); + return null; + } + wasInKeyframes = _this._evaluate0$_inKeyframes; + wasInUnknownAtRule = _this._evaluate0$_inUnknownAtRule; + if (A.unvendor0($name.value) === "keyframes") + _this._evaluate0$_inKeyframes = true; + else + _this._evaluate0$_inUnknownAtRule = true; + _this._evaluate0$_withParent$2$4$scopeWhen$through(A.ModifiableCssAtRule$0($name, node.span, false, value), new A._EvaluateVisitor_visitAtRule_closure6(_this, $name, children), node.hasDeclarations, new A._EvaluateVisitor_visitAtRule_closure7(), type$.ModifiableCssAtRule_2, type$.Null); + _this._evaluate0$_inUnknownAtRule = wasInUnknownAtRule; + _this._evaluate0$_inKeyframes = wasInKeyframes; + return null; + }, + visitForRule$1(_, node) { + var _this = this, t1 = {}, + t2 = node.from, + fromNumber = _this._evaluate0$_addExceptionSpan$2(t2, new A._EvaluateVisitor_visitForRule_closure9(_this, node)), + t3 = node.to, + toNumber = _this._evaluate0$_addExceptionSpan$2(t3, new A._EvaluateVisitor_visitForRule_closure10(_this, node)), + from = _this._evaluate0$_addExceptionSpan$2(t2, new A._EvaluateVisitor_visitForRule_closure11(fromNumber)), + to = t1.to = _this._evaluate0$_addExceptionSpan$2(t3, new A._EvaluateVisitor_visitForRule_closure12(toNumber, fromNumber)), + direction = from > to ? -1 : 1; + if (from === (!node.isExclusive ? t1.to = to + direction : to)) + return null; + return _this._evaluate0$_environment.scope$1$2$semiGlobal(new A._EvaluateVisitor_visitForRule_closure13(t1, _this, node, from, direction, fromNumber), true, type$.nullable_Value_2); + }, + visitForwardRule$1(_, node) { + var newConfiguration, t4, _i, variable, $name, _this = this, + _s8_ = "@forward", + oldConfiguration = _this._evaluate0$_configuration, + adjustedConfiguration = oldConfiguration.throughForward$1(node), + t1 = node.configuration, + t2 = t1.length, + t3 = node.url; + if (t2 !== 0) { + newConfiguration = _this._evaluate0$_addForwardConfiguration$2(adjustedConfiguration, node); + _this._evaluate0$_loadModule$5$configuration(t3, _s8_, node, new A._EvaluateVisitor_visitForwardRule_closure3(_this, node), newConfiguration); + t3 = type$.String; + t4 = A.LinkedHashSet_LinkedHashSet$_empty(t3); + for (_i = 0; _i < t2; ++_i) { + variable = t1[_i]; + if (!variable.isGuarded) + t4.add$1(0, variable.name); + } + _this._evaluate0$_removeUsedConfiguration$3$except(adjustedConfiguration, newConfiguration, t4); + t3 = A.LinkedHashSet_LinkedHashSet$_empty(t3); + for (_i = 0; _i < t2; ++_i) + t3.add$1(0, t1[_i].name); + for (t1 = newConfiguration._configuration0$_values, t2 = J.toList$0$ax(t1.get$keys(t1)), t4 = t2.length, _i = 0; _i < t2.length; t2.length === t4 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + $name = t2[_i]; + if (!t3.contains$1(0, $name)) + if (!t1.get$isEmpty(t1)) + t1.remove$1(0, $name); + } + _this._evaluate0$_assertConfigurationIsEmpty$1(newConfiguration); + } else { + _this._evaluate0$_configuration = adjustedConfiguration; + _this._evaluate0$_loadModule$4(t3, _s8_, node, new A._EvaluateVisitor_visitForwardRule_closure4(_this, node)); + _this._evaluate0$_configuration = oldConfiguration; + } + return null; + }, + _evaluate0$_addForwardConfiguration$2(configuration, node) { + var t2, t3, _i, variable, t4, _0_0, t5, oldValue, variableNodeWithSpan, _null = null, + t1 = configuration._configuration0$_values, + newValues = A.LinkedHashMap_LinkedHashMap$of(new A.UnmodifiableMapView(t1, type$.UnmodifiableMapView_String_ConfiguredValue_2), type$.String, type$.ConfiguredValue_2); + for (t2 = node.configuration, t3 = t2.length, _i = 0; _i < t3; ++_i) { + variable = t2[_i]; + if (variable.isGuarded) { + t4 = variable.name; + _0_0 = t1.get$isEmpty(t1) ? _null : t1.remove$1(0, t4); + if (_0_0 != null) { + t5 = !_0_0.value.$eq(0, B.C__SassNull0); + oldValue = _0_0; + } else { + oldValue = _null; + t5 = false; + } + if (t5) { + newValues.$indexSet(0, t4, oldValue); + continue; + } + } + t4 = variable.expression; + variableNodeWithSpan = this._evaluate0$_expressionNode$1(t4); + newValues.$indexSet(0, variable.name, new A.ConfiguredValue0(this._evaluate0$_withoutSlash$2(t4.accept$1(this), variableNodeWithSpan), variable.span, variableNodeWithSpan)); + } + if (configuration instanceof A.ExplicitConfiguration0 || t1.get$isEmpty(t1)) + return new A.ExplicitConfiguration0(node, newValues, _null); + else + return new A.Configuration0(newValues, _null); + }, + _evaluate0$_registerCommentsForModule$1(module) { + var _this = this, _s5_ = "_root", + t1 = _this._evaluate0$__root; + if (t1 == null) + return; + if (_this._evaluate0$_assertInModule$2(t1, _s5_).children.get$length(0) === 0 || !module.get$transitivelyContainsCss()) + return; + t1 = _this._evaluate0$_preModuleComments; + if (t1 == null) + t1 = _this._evaluate0$_preModuleComments = A.LinkedHashMap_LinkedHashMap$_empty(type$.Module_Callable_2, type$.List_CssComment_2); + J.addAll$1$ax(t1.putIfAbsent$2(module, new A._EvaluateVisitor__registerCommentsForModule_closure1()), new A.UnmodifiableListView(J.cast$1$0$ax(_this._evaluate0$_assertInModule$2(_this._evaluate0$__root, _s5_).children._collection$_source, type$.CssComment_2), type$.UnmodifiableListView_CssComment_2)); + _this._evaluate0$_assertInModule$2(_this._evaluate0$__root, _s5_).clearChildren$0(); + _this._evaluate0$__endOfImports = 0; + }, + _evaluate0$_removeUsedConfiguration$3$except(upstream, downstream, except) { + var t1, t2, t3, t4, _i, $name; + for (t1 = upstream._configuration0$_values, t2 = J.toList$0$ax(t1.get$keys(t1)), t3 = t2.length, t4 = downstream._configuration0$_values, _i = 0; _i < t2.length; t2.length === t3 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + $name = t2[_i]; + if (except.contains$1(0, $name)) + continue; + if (!t4.containsKey$1($name)) + if (!t1.get$isEmpty(t1)) + t1.remove$1(0, $name); + } + }, + _evaluate0$_assertConfigurationIsEmpty$2$nameInError(configuration, nameInError) { + var t1, _0_0, $name, value; + if (!(configuration instanceof A.ExplicitConfiguration0)) + return; + t1 = configuration._configuration0$_values; + if (t1.get$isEmpty(t1)) + return; + t1 = A.MapExtensions_get_pairs0(new A.UnmodifiableMapView(t1, type$.UnmodifiableMapView_String_ConfiguredValue_2), type$.String, type$.ConfiguredValue_2); + _0_0 = t1.get$first(t1); + $name = _0_0._0; + value = _0_0._1; + t1 = nameInError ? "$" + $name + string$.x20was_n : string$.This_v; + throw A.wrapException(this._evaluate0$_exception$2(t1, value.configurationSpan)); + }, + _evaluate0$_assertConfigurationIsEmpty$1(configuration) { + return this._evaluate0$_assertConfigurationIsEmpty$2$nameInError(configuration, false); + }, + visitFunctionRule$1(_, node) { + var t1 = this._evaluate0$_environment, + t2 = t1.closure$0(), + t3 = this._evaluate0$_inDependency, + t4 = t1._environment0$_functions, + index = t4.length - 1, + t5 = node.name; + t1._environment0$_functionIndices.$indexSet(0, t5, index); + t4[index].$indexSet(0, t5, new A.UserDefinedCallable0(node, t2, t3, type$.UserDefinedCallable_Environment_2)); + return null; + }, + visitIfRule$1(_, node) { + var t1, t2, _i, clauseToCheck, + clause = node.lastClause; + for (t1 = node.clauses, t2 = t1.length, _i = 0; _i < t2; ++_i) { + clauseToCheck = t1[_i]; + if (clauseToCheck.expression.accept$1(this).get$isTruthy()) { + clause = clauseToCheck; + break; + } + } + return A.NullableExtension_andThen0(clause, new A._EvaluateVisitor_visitIfRule_closure1(this)); + }, + visitImportRule$1(_, node) { + var t1, t2, t3, t4, t5, t6, _i, $import, t7, _0_0, $self, t8, _this = this, + _s8_ = "__parent", + _s5_ = "_root", + _s13_ = "_endOfImports"; + for (t1 = node.imports, t2 = t1.length, t3 = type$.CssValue_String_2, t4 = _this.get$_evaluate0$_interpolationToValue(), t5 = type$.StaticImport_2, t6 = type$.JSArray_ModifiableCssImport_2, _i = 0; _i < t2; ++_i) { + $import = t1[_i]; + if ($import instanceof A.DynamicImport0) + _this._evaluate0$_visitDynamicImport$1($import); + else { + t5._as($import); + t7 = $import.url; + _0_0 = _this._evaluate0$_performInterpolationHelper$3$sourceMap$warnForColor(t7, false, false); + $self = $import.modifiers; + t8 = $self == null ? null : t4.call$1($self); + node = new A.ModifiableCssImport0(new A.CssValue0(_0_0._0, t7.span, t3), t8, $import.span); + if (_this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_) !== _this._evaluate0$_assertInModule$2(_this._evaluate0$__root, _s5_)) + _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_).addChild$1(node); + else if (_this._evaluate0$_assertInModule$2(_this._evaluate0$__endOfImports, _s13_) === J.get$length$asx(_this._evaluate0$_assertInModule$2(_this._evaluate0$__root, _s5_).children._collection$_source)) { + t7 = _this._evaluate0$_assertInModule$2(_this._evaluate0$__root, _s5_); + node._node$_parent = t7; + t7 = t7._node$_children; + node._node$_indexInParent = t7.length; + t7.push(node); + _this._evaluate0$__endOfImports = _this._evaluate0$_assertInModule$2(_this._evaluate0$__endOfImports, _s13_) + 1; + } else { + t7 = _this._evaluate0$_outOfOrderImports; + (t7 == null ? _this._evaluate0$_outOfOrderImports = A._setArrayType([], t6) : t7).push(node); + } + } + } + return null; + }, + _evaluate0$_visitDynamicImport$1($import) { + return this._evaluate0$_withStackFrame$3("@import", $import, new A._EvaluateVisitor__visitDynamicImport_closure1(this, $import)); + }, + _evaluate0$_loadStylesheet$4$baseUrl$forImport(url, span, baseUrl, forImport) { + var _0_0, importCache, _1_0, importer, canonicalUrl, originalUrl, isDependency, _2_0, stylesheet, _3_0, result, error, stackTrace, error0, stackTrace0, t1, t2, exception, _this = this, + _s11_ = "_stylesheet"; + baseUrl = baseUrl; + try { + _this._evaluate0$_importSpan = span; + _0_0 = _this._evaluate0$_importCache; + importCache = null; + if (_0_0 != null) { + importCache = _0_0; + if (baseUrl == null) + baseUrl = _this._evaluate0$_assertInModule$2(_this._evaluate0$__stylesheet, _s11_).span.file.url; + _1_0 = J.canonicalize$4$baseImporter$baseUrl$forImport$x(importCache, A.Uri_parse(url), _this._evaluate0$_importer, baseUrl, forImport); + importer = null; + canonicalUrl = null; + originalUrl = null; + if (type$.Record_3_nullable_Object_and_nullable_Object_and_nullable_Object_originalUrl._is(_1_0)) { + importer = _1_0._0; + canonicalUrl = _1_0._1; + originalUrl = _1_0._2; + if (canonicalUrl.get$scheme() === "") + A.WarnForDeprecation_warnForDeprecation0(_this._evaluate0$_logger, B.Deprecation_Ord, "Importer " + A.S(importer) + " canonicalized " + url + " to " + A.S(canonicalUrl) + string$.x2e_Rela, null, null); + _this._evaluate0$_loadedUrls.add$1(0, canonicalUrl); + isDependency = _this._evaluate0$_inDependency || !J.$eq$(importer, _this._evaluate0$_importer); + _2_0 = importCache.importCanonical$3$originalUrl(importer, canonicalUrl, originalUrl); + stylesheet = null; + if (_2_0 != null) { + stylesheet = _2_0; + t1 = stylesheet; + t2 = importer; + return new A._Record_3_importer_isDependency(t1, t2, isDependency); + } + } + } + if (_this._nodeImporter != null) { + t1 = baseUrl; + _3_0 = _this._importLikeNode$3(url, t1 == null ? _this._evaluate0$_assertInModule$2(_this._evaluate0$__stylesheet, _s11_).span.file.url : t1, forImport); + result = null; + if (_3_0 != null) { + result = _3_0; + t1 = _this._evaluate0$_loadedUrls; + A.NullableExtension_andThen0(result._0.span.file.url, t1.get$add(t1)); + t1 = result; + return t1; + } + } + t1 = B.JSString_methods.startsWith$1(url, "package:"); + if (t1) + throw A.wrapException(string$.x22packa); + else + throw A.wrapException("Can't find stylesheet to import."); + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException0) + throw exception; + else if (t1 instanceof A.ArgumentError) { + error = t1; + stackTrace = A.getTraceFromException(exception); + A.throwWithTrace0(_this._evaluate0$_exception$1(J.toString$0$(error)), error, stackTrace); + } else { + error0 = t1; + stackTrace0 = A.getTraceFromException(exception); + A.throwWithTrace0(_this._evaluate0$_exception$1(_this._evaluate0$_getErrorMessage$1(error0)), error0, stackTrace0); + } + } finally { + _this._evaluate0$_importSpan = null; + } + }, + _evaluate0$_loadStylesheet$3$baseUrl(url, span, baseUrl) { + return this._evaluate0$_loadStylesheet$4$baseUrl$forImport(url, span, baseUrl, false); + }, + _evaluate0$_loadStylesheet$3$forImport(url, span, forImport) { + return this._evaluate0$_loadStylesheet$4$baseUrl$forImport(url, span, null, forImport); + }, + _importLikeNode$3(originalUrl, previous, forImport) { + var isDependency, url, + t1 = this._nodeImporter, + result = t1.loadRelative$3(originalUrl, previous, forImport); + if (result != null) + isDependency = this._evaluate0$_inDependency; + else { + result = t1.load$3(0, originalUrl, previous, forImport); + if (result == null) + return null; + isDependency = true; + } + url = result._1; + t1 = B.JSString_methods.startsWith$1(url, "file") ? A.Syntax_forPath0(url) : B.Syntax_SCSS_scss0; + return new A._Record_3_importer_isDependency(A.Stylesheet_Stylesheet$parse0(result._0, t1, url), null, isDependency); + }, + _evaluate0$_applyMixin$5(mixin, contentCallable, $arguments, nodeWithSpan, nodeWithSpanWithoutContent) { + var t1, _0_0, t2, _1_8, _this = this, + _s37_ = "Mixin doesn't accept a content block.", + _s10_ = "invocation"; + $label0$0: { + if (mixin == null) + throw A.wrapException(_this._evaluate0$_exception$2("Undefined mixin.", nodeWithSpan.get$span(nodeWithSpan))); + t1 = mixin instanceof A.BuiltInCallable0; + if (t1 && !mixin.acceptsContent && contentCallable != null) { + t1 = _this._evaluate0$_evaluateArguments$1($arguments)._values; + _0_0 = mixin.callbackFor$2(t1[2].length, new A.MapKeySet(t1[0], type$.MapKeySet_String)); + throw A.wrapException(A.MultiSpanSassRuntimeException$0(_s37_, nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent), _s10_, A.LinkedHashMap_LinkedHashMap$_literal([_0_0._0.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), _this._evaluate0$_stackTrace$1(nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent)), null)); + } + if (t1) { + _this._evaluate0$_environment.withContent$2(contentCallable, new A._EvaluateVisitor__applyMixin_closure3(_this, $arguments, mixin, nodeWithSpanWithoutContent)); + break $label0$0; + } + t1 = type$.UserDefinedCallable_Environment_2._is(mixin); + t2 = false; + if (t1) { + _1_8 = mixin.declaration; + if (_1_8 instanceof A.MixinRule0) + t2 = !type$.MixinRule_2._as(_1_8).get$hasContent() && contentCallable != null; + } + if (t2) + throw A.wrapException(A.MultiSpanSassRuntimeException$0(_s37_, nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent), _s10_, A.LinkedHashMap_LinkedHashMap$_literal([mixin.declaration.parameters.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), _this._evaluate0$_stackTrace$1(nodeWithSpanWithoutContent.get$span(nodeWithSpanWithoutContent)), null)); + if (t1) { + _this._evaluate0$_runUserDefinedCallable$1$4($arguments, mixin, nodeWithSpanWithoutContent, new A._EvaluateVisitor__applyMixin_closure4(_this, contentCallable, mixin, nodeWithSpanWithoutContent), type$.Null); + break $label0$0; + } + throw A.wrapException(A.UnsupportedError$("Unknown callable type " + mixin.toString$0(0) + ".")); + } + }, + visitIncludeRule$1(_, node) { + var _this = this, + mixin = _this._evaluate0$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitIncludeRule_closure5(_this, node)); + if (B.JSString_methods.startsWith$1(node.originalName, "--") && mixin instanceof A.UserDefinedCallable0 && !B.JSString_methods.startsWith$1(mixin.declaration.originalName, "--")) + _this._evaluate0$_warn$3(string$.Sassx20_m, node.get$nameSpan(), B.Deprecation_d4j); + _this._evaluate0$_applyMixin$5(mixin, A.NullableExtension_andThen0(node.content, new A._EvaluateVisitor_visitIncludeRule_closure6(_this)), node.$arguments, node, new A._FakeAstNode0(new A._EvaluateVisitor_visitIncludeRule_closure7(node))); + return null; + }, + visitMixinRule$1(_, node) { + var t1 = this._evaluate0$_environment, + t2 = t1.closure$0(), + t3 = this._evaluate0$_inDependency, + t4 = t1._environment0$_mixins, + index = t4.length - 1, + t5 = node.name; + t1._environment0$_mixinIndices.$indexSet(0, t5, index); + t4[index].$indexSet(0, t5, new A.UserDefinedCallable0(node, t2, t3, type$.UserDefinedCallable_Environment_2)); + return null; + }, + visitLoudComment$1(_, node) { + var t1, text, _this = this, + _s8_ = "__parent", + _s13_ = "_endOfImports"; + if (_this._evaluate0$_inFunction) + return null; + if (_this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_) === _this._evaluate0$_assertInModule$2(_this._evaluate0$__root, "_root") && _this._evaluate0$_assertInModule$2(_this._evaluate0$__endOfImports, _s13_) === J.get$length$asx(_this._evaluate0$_assertInModule$2(_this._evaluate0$__root, "_root").children._collection$_source)) + _this._evaluate0$__endOfImports = _this._evaluate0$_assertInModule$2(_this._evaluate0$__endOfImports, _s13_) + 1; + t1 = node.text; + text = _this._evaluate0$_performInterpolation$1(t1); + if (!B.JSString_methods.endsWith$1(text, "*/")) + text += " */"; + _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_).addChild$1(new A.ModifiableCssComment0(text, t1.span)); + return null; + }, + visitMediaRule$1(_, node) { + var _0_0, queries, mergedQueries, t1, mergedSources, t2, t3, _this = this; + if (_this._evaluate0$_declarationName != null) + throw A.wrapException(_this._evaluate0$_exception$2(string$.Media_, node.span)); + _0_0 = _this._evaluate0$_performInterpolationWithMap$2$warnForColor(node.query, true); + queries = new A.MediaQueryParser0(A.SpanScanner$(_0_0._0, null), _0_0._1).parse$0(0); + mergedQueries = A.NullableExtension_andThen0(_this._evaluate0$_mediaQueries, new A._EvaluateVisitor_visitMediaRule_closure5(_this, queries)); + t1 = mergedQueries == null; + if (!t1 && J.get$isEmpty$asx(mergedQueries)) + return null; + if (t1) + mergedSources = B.Set_empty5; + else { + t2 = _this._evaluate0$_mediaQuerySources; + t2.toString; + t2 = A.LinkedHashSet_LinkedHashSet$of(t2, type$.CssMediaQuery_2); + t3 = _this._evaluate0$_mediaQueries; + t3.toString; + t2.addAll$1(0, t3); + t2.addAll$1(0, queries); + mergedSources = t2; + } + t1 = t1 ? queries : mergedQueries; + _this._evaluate0$_withParent$2$4$scopeWhen$through(A.ModifiableCssMediaRule$0(t1, node.span), new A._EvaluateVisitor_visitMediaRule_closure6(_this, mergedQueries, queries, mergedSources, node), node.hasDeclarations, new A._EvaluateVisitor_visitMediaRule_closure7(mergedSources), type$.ModifiableCssMediaRule_2, type$.Null); + return null; + }, + _evaluate0$_mergeMediaQueries$2(queries1, queries2) { + var t1, t2, t3, t4, _0_0, t5, result, + queries = A._setArrayType([], type$.JSArray_CssMediaQuery_2); + for (t1 = J.get$iterator$ax(queries1), t2 = J.getInterceptor$ax(queries2); t1.moveNext$0();) { + t3 = t1.get$current(t1); + for (t4 = t2.get$iterator(queries2); t4.moveNext$0();) { + _0_0 = t3.merge$1(t4.get$current(t4)); + if (B._SingletonCssMediaQueryMergeResult_00 === _0_0) + continue; + if (B._SingletonCssMediaQueryMergeResult_10 === _0_0) + return null; + t5 = _0_0 instanceof A.MediaQuerySuccessfulMergeResult0; + result = t5 ? _0_0 : null; + if (t5) + queries.push(result.query); + } + } + return queries; + }, + visitReturnRule$1(_, node) { + var t1 = node.expression; + return this._evaluate0$_withoutSlash$2(t1.accept$1(this), t1); + }, + visitSilentComment$1(_, node) { + return null; + }, + visitStyleRule$1(_, node) { + var t1, _0_0, selectorText, selectorMap, parsedSelector, nest, t2, _i, _1_0, first, t3, rule, oldAtRootExcludingStyleRule, _this = this, _null = null, + _s8_ = "__parent", + _s11_ = "_stylesheet"; + if (_this._evaluate0$_declarationName != null) + throw A.wrapException(_this._evaluate0$_exception$2(string$.Style_n, node.span)); + else if (_this._evaluate0$_inKeyframes && _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_) instanceof A.ModifiableCssKeyframeBlock0) + throw A.wrapException(_this._evaluate0$_exception$2(string$.Style_k, node.span)); + t1 = node.selector; + _0_0 = _this._evaluate0$_performInterpolationWithMap$2$warnForColor(t1, true); + selectorText = _0_0._0; + selectorMap = _0_0._1; + if (_this._evaluate0$_inKeyframes) { + _this._evaluate0$_withParent$2$4$scopeWhen$through(A.ModifiableCssKeyframeBlock$0(new A.CssValue0(A.List_List$unmodifiable(new A.KeyframeSelectorParser0(A.SpanScanner$(selectorText, _null), selectorMap).parse$0(0), type$.String), t1.span, type$.CssValue_List_String_2), node.span), new A._EvaluateVisitor_visitStyleRule_closure7(_this, node), node.hasDeclarations, new A._EvaluateVisitor_visitStyleRule_closure8(), type$.ModifiableCssKeyframeBlock_2, type$.Null); + return _null; + } + parsedSelector = A.SelectorList_SelectorList$parse0(selectorText, true, selectorMap, _this._evaluate0$_assertInModule$2(_this._evaluate0$__stylesheet, _s11_).plainCss); + t1 = _this._evaluate0$_atRootExcludingStyleRule ? _null : _this._evaluate0$_styleRuleIgnoringAtRoot; + t1 = t1 == null ? _null : t1.fromPlainCss; + nest = t1 !== true; + if (nest) { + if (_this._evaluate0$_assertInModule$2(_this._evaluate0$__stylesheet, _s11_).plainCss) + for (t1 = parsedSelector.components, t2 = t1.length, _i = 0; _i < t2; ++_i) { + _1_0 = t1[_i].leadingCombinators; + if (_1_0.length >= 1) { + first = _1_0[0]; + t3 = _this._evaluate0$_assertInModule$2(_this._evaluate0$__stylesheet, _s11_).plainCss; + } else { + first = _null; + t3 = false; + } + if (t3) + throw A.wrapException(_this._evaluate0$_exception$2(string$.Top_lel, first.span)); + } + t1 = _this._evaluate0$_styleRuleIgnoringAtRoot; + t1 = t1 == null ? _null : t1.originalSelector; + parsedSelector = parsedSelector.nestWithin$3$implicitParent$preserveParentSelectors(t1, !_this._evaluate0$_atRootExcludingStyleRule, _this._evaluate0$_assertInModule$2(_this._evaluate0$__stylesheet, _s11_).plainCss); + } + rule = A.ModifiableCssStyleRule$0(_this._evaluate0$_assertInModule$2(_this._evaluate0$__extensionStore, "_extensionStore").addSelector$2(parsedSelector, _this._evaluate0$_mediaQueries), node.span, _this._evaluate0$_assertInModule$2(_this._evaluate0$__stylesheet, _s11_).plainCss, parsedSelector); + oldAtRootExcludingStyleRule = _this._evaluate0$_atRootExcludingStyleRule; + t1 = _this._evaluate0$_atRootExcludingStyleRule = false; + t2 = nest ? new A._EvaluateVisitor_visitStyleRule_closure9() : _null; + _this._evaluate0$_withParent$2$4$scopeWhen$through(rule, new A._EvaluateVisitor_visitStyleRule_closure10(_this, rule, node), node.hasDeclarations, t2, type$.ModifiableCssStyleRule_2, type$.Null); + _this._evaluate0$_atRootExcludingStyleRule = oldAtRootExcludingStyleRule; + _this._evaluate0$_warnForBogusCombinators$1(rule); + if ((_this._evaluate0$_atRootExcludingStyleRule ? _null : _this._evaluate0$_styleRuleIgnoringAtRoot) == null) { + t1 = _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_).children; + t1 = !t1.get$isEmpty(t1); + } + if (t1) { + t1 = _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_).children; + t1.get$last(t1).isGroupEnd = true; + } + return _null; + }, + _evaluate0$_warnForBogusCombinators$1(rule) { + var t1, t2, t3, t4, t5, _i, complex, visitor, t6, t7, t8, t9, _this = this, _null = null; + if (!rule.accept$1(B._IsInvisibleVisitor_false_false0)) + for (t1 = rule._style_rule0$_selector._box0$_inner.value.components, t2 = t1.length, t3 = type$.SourceSpan, t4 = type$.String, t5 = rule.children, _i = 0; _i < t2; ++_i) { + complex = t1[_i]; + if (!complex.accept$1(B._IsBogusVisitor_true0)) + continue; + if (complex.accept$1(B.C__IsUselessVisitor0)) { + visitor = A._SerializeVisitor$0(_null, true, _null, _null, true, false, _null, true); + complex.accept$1(visitor); + _this._evaluate0$_warn$3('The selector "' + B.JSString_methods.trim$0(visitor._serialize0$_buffer.toString$0(0)) + string$.x22x20is_ix20, A.SpanExtensions_trimRight0(complex.span), B.Deprecation_SHb); + } else if (complex.leadingCombinators.length !== 0) { + if (!_this._evaluate0$_assertInModule$2(_this._evaluate0$__stylesheet, "_stylesheet").plainCss) { + visitor = A._SerializeVisitor$0(_null, true, _null, _null, true, false, _null, true); + complex.accept$1(visitor); + _this._evaluate0$_warn$3('The selector "' + B.JSString_methods.trim$0(visitor._serialize0$_buffer.toString$0(0)) + string$.x22x20is_ix0a, A.SpanExtensions_trimRight0(complex.span), B.Deprecation_SHb); + } + } else { + visitor = A._SerializeVisitor$0(_null, true, _null, _null, true, false, _null, true); + complex.accept$1(visitor); + t6 = B.JSString_methods.trim$0(visitor._serialize0$_buffer.toString$0(0)); + t7 = complex.accept$1(B._IsBogusVisitor_false0) ? string$.x20It_wi : ""; + t8 = A.SpanExtensions_trimRight0(complex.span); + if (t5.get$length(0) === 0) + A.throwExpression(A.IterableElementError_noElement()); + t9 = J.get$span$z(t5.$index(0, 0)); + _this._evaluate0$_warn$3('The selector "' + t6 + string$.x22x20is_o + t7 + string$.x0aThis_, new A.MultiSpan0(t8, "invalid selector", A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_literal([t9, "this is not a style rule" + (t5.every$1(t5, new A._EvaluateVisitor__warnForBogusCombinators_closure1()) ? "\n(try converting to a //-style comment)" : "")], t3, t4), t3, t4)), B.Deprecation_SHb); + } + } + }, + visitSupportsRule$1(_, node) { + var t1, _this = this; + if (_this._evaluate0$_declarationName != null) + throw A.wrapException(_this._evaluate0$_exception$2(string$.Suppor, node.span)); + t1 = node.condition; + _this._evaluate0$_withParent$2$4$scopeWhen$through(A.ModifiableCssSupportsRule$0(new A.CssValue0(_this._evaluate0$_visitSupportsCondition$1(t1), t1.get$span(t1), type$.CssValue_String_2), node.span), new A._EvaluateVisitor_visitSupportsRule_closure3(_this, node), node.hasDeclarations, new A._EvaluateVisitor_visitSupportsRule_closure4(), type$.ModifiableCssSupportsRule_2, type$.Null); + return null; + }, + _evaluate0$_visitSupportsCondition$1(condition) { + var t1, _this = this; + $label0$0: { + if (condition instanceof A.SupportsOperation0) { + t1 = condition.operator; + t1 = _this._evaluate0$_parenthesize$2(condition.left, t1) + " " + t1 + " " + _this._evaluate0$_parenthesize$2(condition.right, t1); + break $label0$0; + } + if (condition instanceof A.SupportsNegation0) { + t1 = "not " + _this._evaluate0$_parenthesize$1(condition.condition); + break $label0$0; + } + if (condition instanceof A.SupportsInterpolation0) { + t1 = condition.expression; + t1 = _this._evaluate0$_serialize$3$quote(t1.accept$1(_this), t1, false); + break $label0$0; + } + t1 = {}; + t1.declaration = null; + if (condition instanceof A.SupportsDeclaration0) { + t1.declaration = condition; + t1 = _this._evaluate0$_withSupportsDeclaration$1(new A._EvaluateVisitor__visitSupportsCondition_closure1(t1, _this)); + break $label0$0; + } + if (condition instanceof A.SupportsFunction0) { + t1 = _this._evaluate0$_performInterpolation$1(condition.name) + "(" + _this._evaluate0$_performInterpolation$1(condition.$arguments) + ")"; + break $label0$0; + } + if (condition instanceof A.SupportsAnything0) { + t1 = "(" + _this._evaluate0$_performInterpolation$1(condition.contents) + ")"; + break $label0$0; + } + t1 = A.throwExpression(A.ArgumentError$("Unknown supports condition type " + A.getRuntimeTypeOfDartObject(condition).toString$0(0) + ".", null)); + } + return t1; + }, + _evaluate0$_withSupportsDeclaration$1$1(callback) { + var t1, + oldInSupportsDeclaration = this._evaluate0$_inSupportsDeclaration; + this._evaluate0$_inSupportsDeclaration = true; + try { + t1 = callback.call$0(); + return t1; + } finally { + this._evaluate0$_inSupportsDeclaration = oldInSupportsDeclaration; + } + }, + _evaluate0$_withSupportsDeclaration$1(callback) { + return this._evaluate0$_withSupportsDeclaration$1$1(callback, type$.dynamic); + }, + _evaluate0$_parenthesize$2(condition, operator) { + var t1; + if (!(condition instanceof A.SupportsNegation0)) + if (condition instanceof A.SupportsOperation0) + t1 = operator == null || operator !== condition.operator; + else + t1 = false; + else + t1 = true; + if (t1) + return "(" + this._evaluate0$_visitSupportsCondition$1(condition) + ")"; + return this._evaluate0$_visitSupportsCondition$1(condition); + }, + _evaluate0$_parenthesize$1(condition) { + return this._evaluate0$_parenthesize$2(condition, null); + }, + visitVariableDeclaration$1(_, node) { + var t1, _0_0, t2, value, _this = this, _null = null; + if (node.isGuarded) { + if (node.namespace == null && _this._evaluate0$_environment._environment0$_variables.length === 1) { + t1 = _this._evaluate0$_configuration._configuration0$_values; + _0_0 = t1.get$isEmpty(t1) ? _null : t1.remove$1(0, node.name); + t1 = {}; + t1.override = null; + if (_0_0 != null) { + t1.override = _0_0; + t2 = !_0_0.value.$eq(0, B.C__SassNull0); + } else + t2 = false; + if (t2) { + _this._evaluate0$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitVariableDeclaration_closure5(t1, _this, node)); + return _null; + } + } + value = _this._evaluate0$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitVariableDeclaration_closure6(_this, node)); + if (value != null && !value.$eq(0, B.C__SassNull0)) + return _null; + } + if (node.isGlobal && !_this._evaluate0$_environment.globalVariableExists$1(node.name)) { + t1 = _this._evaluate0$_environment._environment0$_variables.length === 1 ? string$.As_of_S : string$.As_of_R + A.declarationName0(node.span) + ": null` at the stylesheet root."; + _this._evaluate0$_warn$3(t1, node.span, B.Deprecation_mSy); + } + t1 = node.expression; + _this._evaluate0$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitVariableDeclaration_closure7(_this, node, _this._evaluate0$_withoutSlash$2(t1.accept$1(_this), t1))); + return _null; + }, + visitUseRule$1(_, node) { + var values, _i, variable, t3, variableNodeWithSpan, configuration, _this = this, + t1 = node.configuration, + t2 = t1.length; + if (t2 !== 0) { + values = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.ConfiguredValue_2); + for (_i = 0; _i < t2; ++_i) { + variable = t1[_i]; + t3 = variable.expression; + variableNodeWithSpan = _this._evaluate0$_expressionNode$1(t3); + values.$indexSet(0, variable.name, new A.ConfiguredValue0(_this._evaluate0$_withoutSlash$2(t3.accept$1(_this), variableNodeWithSpan), variable.span, variableNodeWithSpan)); + } + configuration = new A.ExplicitConfiguration0(node, values, null); + } else + configuration = B.Configuration_Map_empty_null0; + _this._evaluate0$_loadModule$5$configuration(node.url, "@use", node, new A._EvaluateVisitor_visitUseRule_closure1(_this, node), configuration); + _this._evaluate0$_assertConfigurationIsEmpty$1(configuration); + return null; + }, + visitWarnRule$1(_, node) { + var _this = this, + value = _this._evaluate0$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitWarnRule_closure1(_this, node)), + t1 = value instanceof A.SassString0 ? value._string0$_text : _this._evaluate0$_serialize$2(value, node.expression), + t2 = _this._evaluate0$_stackTrace$1(node.span); + _this._evaluate0$_logger.internalWarn$4$deprecation$span$trace(t1, null, null, t2); + return null; + }, + visitWhileRule$1(_, node) { + return this._evaluate0$_environment.scope$1$3$semiGlobal$when(new A._EvaluateVisitor_visitWhileRule_closure1(this, node), true, node.hasDeclarations, type$.nullable_Value_2); + }, + visitBinaryOperationExpression$1(_, node) { + var t1, _this = this; + if (_this._evaluate0$_assertInModule$2(_this._evaluate0$__stylesheet, "_stylesheet").plainCss) { + t1 = node.operator; + t1 = t1 !== B.BinaryOperator_Kyq0 && t1 !== B.BinaryOperator_Mh50; + } else + t1 = false; + if (t1) + throw A.wrapException(_this._evaluate0$_exception$2("Operators aren't allowed in plain CSS.", node.get$operatorSpan())); + return _this._evaluate0$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitBinaryOperationExpression_closure1(_this, node)); + }, + _evaluate0$_slash$3(left, right, node) { + var t2, _1_1, + result = left.dividedBy$1(right), + _1_2_isSet = left instanceof A.SassNumber0, + _1_2 = null, right0 = null, + t1 = false; + if (_1_2_isSet) { + t2 = type$.SassNumber_2; + t2._as(left); + if (right instanceof A.SassNumber0) { + t2._as(right); + t1 = node.allowsSlash && this._evaluate0$_operandAllowsSlash$1(node.left) && this._evaluate0$_operandAllowsSlash$1(node.right); + right0 = right; + _1_2 = right0; + } else + _1_2 = right; + _1_1 = left; + } else { + _1_1 = left; + left = null; + } + if (t1) + return type$.SassNumber_2._as(result).withSlash$2(left, right0); + if (_1_1 instanceof A.SassNumber0) + t1 = (_1_2_isSet ? _1_2 : right) instanceof A.SassNumber0; + else + t1 = false; + if (t1) { + this._evaluate0$_warn$3(string$.Using__o + A.S(new A._EvaluateVisitor__slash_recommendation1().call$1(node)) + " or " + A.expressionToCalc0(node).toString$0(0) + string$.x0a_Morex20, node.get$span(0), B.Deprecation_FyB); + return result; + } + return result; + }, + _evaluate0$_operandAllowsSlash$1(node) { + var t1; + if (node instanceof A.FunctionExpression0) + if (node.namespace == null) { + t1 = node.name; + t1 = B.Set_Pr3yj.contains$1(0, t1.toLowerCase()) && this._evaluate0$_environment.getFunction$1(t1) == null; + } else + t1 = false; + else + t1 = true; + return t1; + }, + visitValueExpression$1(_, node) { + return node.value; + }, + visitVariableExpression$1(_, node) { + var result = this._evaluate0$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitVariableExpression_closure1(this, node)); + if (result != null) + return result; + throw A.wrapException(this._evaluate0$_exception$2("Undefined variable.", node.span)); + }, + visitUnaryOperationExpression$1(_, node) { + return this._evaluate0$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitUnaryOperationExpression_closure1(node, node.operand.accept$1(this))); + }, + visitBooleanExpression$1(_, node) { + return node.value ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + visitIfExpression$1(_, node) { + var condition, t1, ifTrue, ifFalse, result, _this = this, + _0_0 = _this._evaluate0$_evaluateMacroArguments$1(node), + positional = _0_0._0, + named = _0_0._1; + _this._evaluate0$_verifyArguments$4(positional.length, named, $.$get$IfExpression_declaration0(), node); + condition = A.ListExtensions_elementAtOrNull(positional, 0); + if (condition == null) { + t1 = named.$index(0, "condition"); + t1.toString; + condition = t1; + } + ifTrue = A.ListExtensions_elementAtOrNull(positional, 1); + if (ifTrue == null) { + t1 = named.$index(0, "if-true"); + t1.toString; + ifTrue = t1; + } + ifFalse = A.ListExtensions_elementAtOrNull(positional, 2); + if (ifFalse == null) { + t1 = named.$index(0, "if-false"); + t1.toString; + ifFalse = t1; + } + result = condition.accept$1(_this).get$isTruthy() ? ifTrue : ifFalse; + return _this._evaluate0$_withoutSlash$2(result.accept$1(_this), _this._evaluate0$_expressionNode$1(result)); + }, + visitNullExpression$1(_, node) { + return B.C__SassNull0; + }, + visitNumberExpression$1(_, node) { + return A.SassNumber_SassNumber0(node.value, node.unit); + }, + visitParenthesizedExpression$1(_, node) { + var _this = this; + return _this._evaluate0$_assertInModule$2(_this._evaluate0$__stylesheet, "_stylesheet").plainCss ? A.throwExpression(_this._evaluate0$_exception$2("Parentheses aren't allowed in plain CSS.", node.span)) : node.expression.accept$1(_this); + }, + visitColorExpression$1(_, node) { + return node.value; + }, + visitListExpression$1(_, node) { + var t1 = node.contents; + return A.SassList$0(new A.MappedListIterable(t1, new A._EvaluateVisitor_visitListExpression_closure1(this), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Value0>")), node.separator, node.hasBrackets); + }, + visitMapExpression$1(_, node) { + var t2, t3, _i, t4, key, keyValue, valueValue, oldValueSpan, + t1 = type$.Value_2, + map = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1), + keyNodes = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.AstNode_2); + for (t2 = node.pairs, t3 = t2.length, _i = 0; _i < t3; ++_i) { + t4 = t2[_i]; + key = t4._0; + keyValue = key.accept$1(this); + valueValue = t4._1.accept$1(this); + if (map.containsKey$1(keyValue)) { + t1 = keyNodes.$index(0, keyValue); + oldValueSpan = t1 == null ? null : t1.get$span(t1); + t1 = key.get$span(key); + t2 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + if (oldValueSpan != null) + t2.$indexSet(0, oldValueSpan, "first key"); + throw A.wrapException(A.MultiSpanSassRuntimeException$0("Duplicate key.", t1, "second key", t2, this._evaluate0$_stackTrace$1(key.get$span(key)), null)); + } + map.$indexSet(0, keyValue, valueValue); + keyNodes.$indexSet(0, keyValue, key); + } + return new A.SassMap0(A.ConstantMap_ConstantMap$from(map, t1, t1)); + }, + visitFunctionExpression$1(_, node) { + var t2, _0_0, t3, t4, $name, oldInFunction, result, _this = this, + _s11_ = "_stylesheet", + t1 = {}, + $function = _this._evaluate0$_assertInModule$2(_this._evaluate0$__stylesheet, _s11_).plainCss ? null : _this._evaluate0$_addExceptionSpan$2(node, new A._EvaluateVisitor_visitFunctionExpression_closure5(_this, node)); + t1.$function = $function; + if ($function == null) { + if (node.namespace != null) + throw A.wrapException(_this._evaluate0$_exception$2("Undefined function.", node.span)); + t2 = node.name; + _0_0 = t2.toLowerCase(); + t3 = false; + if ("min" === _0_0 || "max" === _0_0 || "round" === _0_0 || "abs" === _0_0) { + t3 = node.$arguments; + t4 = t3.named; + t3 = t4.get$isEmpty(t4) && t3.rest == null && B.JSArray_methods.every$1(t3.positional, new A._EvaluateVisitor_visitFunctionExpression_closure6()); + $name = _0_0; + } else + $name = null; + if (t3) + return _this._evaluate0$_visitCalculation$2$inLegacySassFunction(node, $name); + if ("calc" === _0_0 || "clamp" === _0_0 || "hypot" === _0_0 || "sin" === _0_0 || "cos" === _0_0 || "tan" === _0_0 || "asin" === _0_0 || "acos" === _0_0 || "atan" === _0_0 || "sqrt" === _0_0 || "exp" === _0_0 || "sign" === _0_0 || "mod" === _0_0 || "rem" === _0_0 || "atan2" === _0_0 || "pow" === _0_0 || "log" === _0_0 || "calc-size" === _0_0) + return _this._evaluate0$_visitCalculation$1(node); + $function = _this._evaluate0$_assertInModule$2(_this._evaluate0$__stylesheet, _s11_).plainCss ? null : _this._evaluate0$_builtInFunctions.$index(0, t2); + t2 = t1.$function = $function == null ? new A.PlainCssCallable0(node.originalName) : $function; + } else + t2 = $function; + if (B.JSString_methods.startsWith$1(node.originalName, "--") && t2 instanceof A.UserDefinedCallable0 && !B.JSString_methods.startsWith$1(t2.declaration.originalName, "--")) + _this._evaluate0$_warn$3(string$.Sassx20_f_, node.get$nameSpan(), B.Deprecation_d4j); + oldInFunction = _this._evaluate0$_inFunction; + _this._evaluate0$_inFunction = true; + result = _this._evaluate0$_addErrorSpan$2(node, new A._EvaluateVisitor_visitFunctionExpression_closure7(t1, _this, node)); + _this._evaluate0$_inFunction = oldInFunction; + return result; + }, + _evaluate0$_visitCalculation$2$inLegacySassFunction(node, inLegacySassFunction) { + var $arguments, oldCallableNode, t1, _0_0, error, stackTrace, t4, _i, exception, _this = this, + t2 = node.$arguments, + t3 = t2.named; + if (t3.get$isNotEmpty(t3)) + throw A.wrapException(_this._evaluate0$_exception$2(string$.Keywor, node.span)); + else if (t2.rest != null) + throw A.wrapException(_this._evaluate0$_exception$2(string$.Rest_a, node.span)); + _this._evaluate0$_checkCalculationArguments$1(node); + t3 = A._setArrayType([], type$.JSArray_Object); + for (t2 = t2.positional, t4 = t2.length, _i = 0; _i < t4; ++_i) + t3.push(_this._evaluate0$_visitCalculationExpression$2$inLegacySassFunction(t2[_i], inLegacySassFunction)); + $arguments = t3; + if (_this._evaluate0$_inSupportsDeclaration) + return new A.SassCalculation0(node.name, A.List_List$unmodifiable($arguments, type$.Object)); + oldCallableNode = _this._evaluate0$_callableNode; + _this._evaluate0$_callableNode = node; + try { + t1 = null; + t3 = node.name; + _0_0 = t3.toLowerCase(); + $label0$0: { + if ("calc" === _0_0) { + t1 = A.SassCalculation_calc0(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("sqrt" === _0_0) { + t1 = A.SassCalculation__singleArgument0("sqrt", J.$index$asx($arguments, 0), A.number2__sqrt$closure(), true); + break $label0$0; + } + if ("sin" === _0_0) { + t1 = A.SassCalculation__singleArgument0("sin", J.$index$asx($arguments, 0), A.number2__sin$closure(), false); + break $label0$0; + } + if ("cos" === _0_0) { + t1 = A.SassCalculation__singleArgument0("cos", J.$index$asx($arguments, 0), A.number2__cos$closure(), false); + break $label0$0; + } + if ("tan" === _0_0) { + t1 = A.SassCalculation__singleArgument0("tan", J.$index$asx($arguments, 0), A.number2__tan$closure(), false); + break $label0$0; + } + if ("asin" === _0_0) { + t1 = A.SassCalculation__singleArgument0("asin", J.$index$asx($arguments, 0), A.number2__asin$closure(), true); + break $label0$0; + } + if ("acos" === _0_0) { + t1 = A.SassCalculation__singleArgument0("acos", J.$index$asx($arguments, 0), A.number2__acos$closure(), true); + break $label0$0; + } + if ("atan" === _0_0) { + t1 = A.SassCalculation__singleArgument0("atan", J.$index$asx($arguments, 0), A.number2__atan$closure(), true); + break $label0$0; + } + if ("abs" === _0_0) { + t1 = A.SassCalculation_abs0(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("exp" === _0_0) { + t1 = A.SassCalculation_exp0(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("sign" === _0_0) { + t1 = A.SassCalculation_sign0(J.$index$asx($arguments, 0)); + break $label0$0; + } + if ("min" === _0_0) { + t1 = A.SassCalculation_min0($arguments); + break $label0$0; + } + if ("max" === _0_0) { + t1 = A.SassCalculation_max0($arguments); + break $label0$0; + } + if ("hypot" === _0_0) { + t1 = A.SassCalculation_hypot0($arguments); + break $label0$0; + } + if ("pow" === _0_0) { + t1 = A.SassCalculation_pow0(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("atan2" === _0_0) { + t1 = A.SassCalculation_atan20(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("log" === _0_0) { + t1 = A.SassCalculation_log0(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("mod" === _0_0) { + t1 = A.SassCalculation_mod0(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("rem" === _0_0) { + t1 = A.SassCalculation_rem0(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + if ("round" === _0_0) { + t1 = A.SassCalculation_roundInternal0(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1), A.ListExtensions_elementAtOrNull($arguments, 2), inLegacySassFunction, node.span, new A._EvaluateVisitor__visitCalculation_closure1(_this, node)); + break $label0$0; + } + if ("clamp" === _0_0) { + t1 = A.SassCalculation_clamp0(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1), A.ListExtensions_elementAtOrNull($arguments, 2)); + break $label0$0; + } + if ("calc-size" === _0_0) { + t1 = A.SassCalculation_calcSize0(J.$index$asx($arguments, 0), A.ListExtensions_elementAtOrNull($arguments, 1)); + break $label0$0; + } + t3 = A.UnsupportedError$('Unknown calculation name "' + t3 + '".'); + t1 = A.throwExpression(t3); + } + t1 = t1; + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassScriptException0) { + error = t1; + stackTrace = A.getTraceFromException(exception); + if (B.JSString_methods.contains$1(error.message, "compatible")) + _this._evaluate0$_verifyCompatibleNumbers$2($arguments, t2); + A.throwWithTrace0(_this._evaluate0$_exception$2(error.message, node.span), error, stackTrace); + } else + throw exception; + } finally { + _this._evaluate0$_callableNode = oldCallableNode; + } + }, + _evaluate0$_visitCalculation$1(node) { + return this._evaluate0$_visitCalculation$2$inLegacySassFunction(node, null); + }, + _evaluate0$_checkCalculationArguments$1(node) { + var t1, _0_0, + check = new A._EvaluateVisitor__checkCalculationArguments_check1(this, node); + $label0$0: { + t1 = node.name; + _0_0 = t1.toLowerCase(); + if ("calc" === _0_0 || "sqrt" === _0_0 || "sin" === _0_0 || "cos" === _0_0 || "tan" === _0_0 || "asin" === _0_0 || "acos" === _0_0 || "atan" === _0_0 || "abs" === _0_0 || "exp" === _0_0 || "sign" === _0_0) { + check.call$1(1); + break $label0$0; + } + if ("min" === _0_0 || "max" === _0_0 || "hypot" === _0_0) { + check.call$0(); + break $label0$0; + } + if ("pow" === _0_0 || "atan2" === _0_0 || "log" === _0_0 || "mod" === _0_0 || "rem" === _0_0 || "calc-size" === _0_0) { + check.call$1(2); + break $label0$0; + } + if ("round" === _0_0 || "clamp" === _0_0) { + check.call$1(3); + break $label0$0; + } + throw A.wrapException(A.UnsupportedError$('Unknown calculation name "' + t1 + '".')); + } + }, + _evaluate0$_verifyCompatibleNumbers$2(args, nodesWithSpans) { + var i, t1, _0_0, arg, t2, number1, j, number2, t3, t4, t5, t6; + for (i = 0; t1 = args.length, i < t1; ++i) { + _0_0 = args[i]; + if (_0_0 instanceof A.SassNumber0) { + t1 = _0_0.get$hasComplexUnits(); + arg = _0_0; + } else { + arg = null; + t1 = false; + } + if (t1) { + t1 = A.S(arg); + t2 = nodesWithSpans[i]; + throw A.wrapException(this._evaluate0$_exception$2("Number " + t1 + " isn't compatible with CSS calculations.", t2.get$span(t2))); + } + } + for (i = 0; i < t1 - 1; ++i) { + number1 = args[i]; + if (!(number1 instanceof A.SassNumber0)) + continue; + for (j = i + 1; t1 = args.length, j < t1; ++j) { + number2 = args[j]; + if (!(number2 instanceof A.SassNumber0)) + continue; + if (number1.hasPossiblyCompatibleUnits$1(number2)) + continue; + t1 = number1.toString$0(0); + t2 = number2.toString$0(0); + t3 = nodesWithSpans[i]; + t3 = t3.get$span(t3); + t4 = number1.toString$0(0); + t5 = nodesWithSpans[j]; + t5 = A.LinkedHashMap_LinkedHashMap$_literal([t5.get$span(t5), number2.toString$0(0)], type$.FileSpan, type$.String); + t6 = nodesWithSpans[i]; + throw A.wrapException(A.MultiSpanSassRuntimeException$0(t1 + " and " + t2 + " are incompatible.", t3, t4, t5, this._evaluate0$_stackTrace$1(t6.get$span(t6)), null)); + } + } + }, + _evaluate0$_visitCalculationExpression$2$inLegacySassFunction(node, inLegacySassFunction) { + var result, t2, _0_0, _box_0, _1_0, t3, _i, i, _this = this, _null = null, + t1 = node instanceof A.ParenthesizedExpression0, + inner = t1 ? node.expression : _null; + if (t1) { + result = _this._evaluate0$_visitCalculationExpression$2$inLegacySassFunction(inner, inLegacySassFunction); + return result instanceof A.SassString0 ? new A.SassString0("(" + result._string0$_text + ")", false) : result; + } + if (node instanceof A.StringExpression0 && node.accept$1(B.C_IsCalculationSafeVisitor0)) { + t1 = node.text; + t2 = t1.get$asPlain(); + _0_0 = t2 == null ? _null : t2.toLowerCase(); + $label0$0: { + if ("pi" === _0_0) { + t1 = A.SassNumber_SassNumber0(3.141592653589793, _null); + break $label0$0; + } + if ("e" === _0_0) { + t1 = A.SassNumber_SassNumber0(2.718281828459045, _null); + break $label0$0; + } + if ("infinity" === _0_0) { + t1 = A.SassNumber_SassNumber0(1 / 0, _null); + break $label0$0; + } + if ("-infinity" === _0_0) { + t1 = A.SassNumber_SassNumber0(-1 / 0, _null); + break $label0$0; + } + if ("nan" === _0_0) { + t1 = A.SassNumber_SassNumber0(0 / 0, _null); + break $label0$0; + } + t1 = new A.SassString0(_this._evaluate0$_performInterpolation$1(t1), false); + break $label0$0; + } + return t1; + } + _box_0 = {}; + _box_0.right = _box_0.left = _box_0.operator = null; + t1 = node instanceof A.BinaryOperationExpression0; + if (t1) { + _box_0.operator = node.operator; + _box_0.left = node.left; + _box_0.right = node.right; + } + if (t1) { + _this._evaluate0$_checkWhitespaceAroundCalculationOperator$1(node); + return _this._evaluate0$_addExceptionSpan$2(node, new A._EvaluateVisitor__visitCalculationExpression_closure1(_box_0, _this, node, inLegacySassFunction)); + } + if (node instanceof A.NumberExpression0 || node instanceof A.VariableExpression0 || node instanceof A.FunctionExpression0 || node instanceof A.IfExpression0) { + _1_0 = node.accept$1(_this); + $label1$1: { + if (_1_0 instanceof A.SassNumber0) { + t1 = _1_0; + break $label1$1; + } + if (_1_0 instanceof A.SassCalculation0) { + t1 = _1_0; + break $label1$1; + } + if (_1_0 instanceof A.SassString0) { + t1 = !_1_0._string0$_hasQuotes; + result = _1_0; + } else { + result = _null; + t1 = false; + } + if (t1) { + t1 = result; + break $label1$1; + } + t1 = A.throwExpression(_this._evaluate0$_exception$2("Value " + _1_0.toString$0(0) + " can't be used in a calculation.", node.get$span(node))); + } + return t1; + } + if (node instanceof A.ListExpression0 && !node.hasBrackets && B.ListSeparator_qSL0 === node.separator && node.contents.length >= 2) { + t1 = A._setArrayType([], type$.JSArray_Object); + for (t2 = node.contents, t3 = t2.length, _i = 0; _i < t3; ++_i) + t1.push(_this._evaluate0$_visitCalculationExpression$2$inLegacySassFunction(t2[_i], inLegacySassFunction)); + _this._evaluate0$_checkAdjacentCalculationValues$2(t1, node); + for (i = 0; i < t1.length; ++i) { + t3 = t1[i]; + if (t3 instanceof A.CalculationOperation0 && t2[i] instanceof A.ParenthesizedExpression0) + t1[i] = new A.SassString0("(" + A.S(t3) + ")", false); + } + return new A.SassString0(B.JSArray_methods.join$1(t1, " "), false); + } + throw A.wrapException(_this._evaluate0$_exception$2(string$.This_e, node.get$span(node))); + }, + _evaluate0$_checkWhitespaceAroundCalculationOperator$1(node) { + var t2, t3, t4, textBetweenOperands, first, last, + t1 = node.operator; + if (t1 !== B.BinaryOperator_Swh0 && t1 !== B.BinaryOperator_QG10) + return; + t1 = node.left; + t2 = t1.get$span(t1); + t2 = t2.get$file(t2); + t3 = node.right; + t4 = t3.get$span(t3); + if (t2 !== t4.get$file(t4)) + return; + t2 = t1.get$span(t1); + t2 = t2.get$end(t2); + t4 = t3.get$span(t3); + if (t2.offset >= t4.get$start(t4).offset) + return; + t2 = t1.get$span(t1); + t2 = t2.get$file(t2); + t1 = t1.get$span(t1); + t1 = t1.get$end(t1); + t3 = t3.get$span(t3); + textBetweenOperands = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t2._decodedChars, t1.offset, t3.get$start(t3).offset), 0, null); + first = textBetweenOperands.charCodeAt(0); + last = textBetweenOperands.charCodeAt(textBetweenOperands.length - 1); + if (first === 32 || first === 9 || first === 10 || first === 13 || first === 12 || first === 47) + t1 = !(last === 32 || last === 9 || last === 10 || last === 13 || last === 12 || last === 47); + else + t1 = true; + if (t1) + throw A.wrapException(this._evaluate0$_exception$2(string$.x22x2b__an, node.get$operatorSpan())); + }, + _evaluate0$_binaryOperatorToCalculationOperator$2(operator, node) { + var t1; + $label0$0: { + if (B.BinaryOperator_Swh0 === operator) { + t1 = B.CalculationOperator_F7i0; + break $label0$0; + } + if (B.BinaryOperator_QG10 === operator) { + t1 = B.CalculationOperator_oum0; + break $label0$0; + } + if (B.BinaryOperator_tht0 === operator) { + t1 = B.CalculationOperator_kkN0; + break $label0$0; + } + if (B.BinaryOperator_Mh50 === operator) { + t1 = B.CalculationOperator_bo50; + break $label0$0; + } + t1 = A.throwExpression(this._evaluate0$_exception$2(string$.This_o, node.get$operatorSpan())); + } + return t1; + }, + _evaluate0$_checkAdjacentCalculationValues$2(elements, node) { + var t1, i, t2, previous, current, previousNode, currentNode, _0_2; + for (t1 = elements.length, i = 1; i < t1; ++i) { + t2 = i - 1; + previous = elements[t2]; + current = elements[i]; + if (previous instanceof A.SassString0 || current instanceof A.SassString0) + continue; + t1 = node.contents; + previousNode = t1[t2]; + currentNode = t1[i]; + if (currentNode instanceof A.UnaryOperationExpression0) { + _0_2 = currentNode.operator; + if (B.UnaryOperator_UCP0 !== _0_2) + t1 = B.UnaryOperator_Rbl0 === _0_2; + else + t1 = true; + } else + t1 = false; + if (!t1) + t1 = currentNode instanceof A.NumberExpression0 && currentNode.value < 0; + else + t1 = true; + if (t1) + throw A.wrapException(this._evaluate0$_exception$2(string$.x22x2b__an, A.FileSpanExtension_subspan(currentNode.get$span(currentNode), 0, 1))); + else + throw A.wrapException(this._evaluate0$_exception$2("Missing math operator.", previousNode.get$span(previousNode).expand$1(0, currentNode.get$span(currentNode)))); + } + }, + visitInterpolatedFunctionExpression$1(_, node) { + var result, _this = this, + t1 = _this._evaluate0$_performInterpolation$1(node.name), + oldInFunction = _this._evaluate0$_inFunction; + _this._evaluate0$_inFunction = true; + result = _this._evaluate0$_addErrorSpan$2(node, new A._EvaluateVisitor_visitInterpolatedFunctionExpression_closure1(_this, node, new A.PlainCssCallable0(t1))); + _this._evaluate0$_inFunction = oldInFunction; + return result; + }, + _evaluate0$_runUserDefinedCallable$1$4($arguments, callable, nodeWithSpan, run, $V) { + var oldCallable, oldInDependency, result, _this = this, + evaluated = _this._evaluate0$_evaluateArguments$1($arguments), + $name = callable.declaration.name; + if ($name !== "@content") + $name += "()"; + oldCallable = _this._evaluate0$_currentCallable; + oldInDependency = _this._evaluate0$_inDependency; + _this._evaluate0$_currentCallable = callable; + _this._evaluate0$_inDependency = callable.inDependency; + result = _this._evaluate0$_withStackFrame$3($name, nodeWithSpan, new A._EvaluateVisitor__runUserDefinedCallable_closure1(_this, callable, evaluated, nodeWithSpan, run, $V)); + _this._evaluate0$_currentCallable = oldCallable; + _this._evaluate0$_inDependency = oldInDependency; + return result; + }, + _evaluate0$_runFunctionCallable$3($arguments, callable, nodeWithSpan) { + var buffer, first, argument, restArg, rest, error, t1, t2, _i, t3, t4, exception, _this = this; + if (callable instanceof A.BuiltInCallable0) + return _this._evaluate0$_withoutSlash$2(_this._evaluate0$_runBuiltInCallable$3($arguments, callable, nodeWithSpan), nodeWithSpan); + else if (type$.UserDefinedCallable_Environment_2._is(callable)) + return _this._evaluate0$_runUserDefinedCallable$1$4($arguments, callable, nodeWithSpan, new A._EvaluateVisitor__runFunctionCallable_closure1(_this, callable), type$.Value_2); + else if (callable instanceof A.PlainCssCallable0) { + t1 = $arguments.named; + if (t1.get$isNotEmpty(t1) || $arguments.keywordRest != null) + throw A.wrapException(_this._evaluate0$_exception$2(string$.Plain_, nodeWithSpan.get$span(nodeWithSpan))); + buffer = new A.StringBuffer(callable.name + "("); + try { + first = true; + for (t1 = $arguments.positional, t2 = t1.length, _i = 0; _i < t2; ++_i) { + argument = t1[_i]; + if (first) + first = false; + else + buffer._contents += ", "; + t3 = buffer; + t4 = argument; + t4 = _this._evaluate0$_serialize$3$quote(t4.accept$1(_this), t4, true); + t3._contents += t4; + } + restArg = $arguments.rest; + if (restArg != null) { + rest = restArg.accept$1(_this); + if (!first) + buffer._contents += ", "; + t1 = buffer; + t2 = _this._evaluate0$_serialize$2(rest, restArg); + t1._contents += t2; + } + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.SassRuntimeException_2._is(t1)) { + error = t1; + if (!B.JSString_methods.endsWith$1(error._span_exception$_message, "isn't a valid CSS value.")) + throw exception; + throw A.wrapException(A.MultiSpanSassRuntimeException$0(error._span_exception$_message, J.get$span$z(error), "value", A.LinkedHashMap_LinkedHashMap$_literal([nodeWithSpan.get$span(nodeWithSpan), "unknown function treated as plain CSS"], type$.FileSpan, type$.String), J.get$trace$z(error), null)); + } else + throw exception; + } + t1 = buffer; + t2 = A.Primitives_stringFromCharCode(41); + t1._contents += t2; + t2 = buffer._contents; + return new A.SassString0(t2.charCodeAt(0) == 0 ? t2 : t2, false); + } else + throw A.wrapException(A.ArgumentError$("Unknown callable type " + J.get$runtimeType$(callable).toString$0(0) + ".", null)); + }, + _evaluate0$_runBuiltInCallable$3($arguments, callable, nodeWithSpan) { + var result, error, stackTrace, namedSet, _0_0, parameters, i, t1, parameter, t2, t3, rest, argumentList, exception, _this = this, _box_0 = {}, + evaluated = _this._evaluate0$_evaluateArguments$1($arguments), + oldCallableNode = _this._evaluate0$_callableNode; + _this._evaluate0$_callableNode = nodeWithSpan; + namedSet = new A.MapKeySet(evaluated._values[0], type$.MapKeySet_String); + _box_0.callback = _box_0.overload = null; + _0_0 = callable.callbackFor$2(evaluated._values[2].length, namedSet); + _box_0.overload = _0_0._0; + _box_0.callback = _0_0._1; + _this._evaluate0$_addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__runBuiltInCallable_closure5(_box_0, evaluated, namedSet)); + parameters = _box_0.overload.parameters; + for (i = evaluated._values[2].length, t1 = parameters.length; i < t1; ++i) { + parameter = parameters[i]; + t2 = evaluated._values[2]; + t3 = evaluated._values[0].remove$1(0, parameter.name); + if (t3 == null) { + t3 = parameter.defaultValue; + t3 = _this._evaluate0$_withoutSlash$2(t3.accept$1(_this), t3); + } + t2.push(t3); + } + if (_box_0.overload.restParameter != null) { + if (evaluated._values[2].length > t1) { + rest = B.JSArray_methods.sublist$1(evaluated._values[2], t1); + B.JSArray_methods.removeRange$2(evaluated._values[2], t1, evaluated._values[2].length); + } else + rest = B.List_empty20; + t1 = evaluated._values[0]; + argumentList = A.SassArgumentList$0(rest, t1, evaluated._values[4] === B.ListSeparator_undecided_null_undecided0 ? B.ListSeparator_qVN0 : evaluated._values[4]); + evaluated._values[2].push(argumentList); + } else + argumentList = null; + result = null; + try { + result = _this._evaluate0$_addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__runBuiltInCallable_closure6(_box_0, evaluated)); + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException0) + throw exception; + else { + error = t1; + stackTrace = A.getTraceFromException(exception); + A.throwWithTrace0(_this._evaluate0$_exception$2(_this._evaluate0$_getErrorMessage$1(error), nodeWithSpan.get$span(nodeWithSpan)), error, stackTrace); + } + } + _this._evaluate0$_callableNode = oldCallableNode; + if (argumentList == null) + return result; + if (evaluated._values[0].__js_helper$_length === 0) + return result; + if (argumentList._argument_list$_wereKeywordsAccessed) + return result; + throw A.wrapException(A.MultiSpanSassRuntimeException$0("No " + A.pluralize0("parameter", evaluated._values[0].get$keys(0).get$length(0), null) + " named " + A.toSentence0(evaluated._values[0].get$keys(0).map$1$1(0, new A._EvaluateVisitor__runBuiltInCallable_closure7(), type$.Object), "or") + ".", nodeWithSpan.get$span(nodeWithSpan), "invocation", A.LinkedHashMap_LinkedHashMap$_literal([_box_0.overload.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), _this._evaluate0$_stackTrace$1(nodeWithSpan.get$span(nodeWithSpan)), null)); + }, + _evaluate0$_evaluateArguments$1($arguments) { + var t1, t2, _i, expression, nodeForSpan, named, namedNodes, t3, t4, $name, value, restArgs, rest, restNodeForSpan, t5, separator, keywordRestArgs, keywordRest, keywordRestNodeForSpan, _this = this, + positional = A._setArrayType([], type$.JSArray_Value_2), + positionalNodes = A._setArrayType([], type$.JSArray_AstNode_2); + for (t1 = $arguments.positional, t2 = t1.length, _i = 0; _i < t2; ++_i) { + expression = t1[_i]; + nodeForSpan = _this._evaluate0$_expressionNode$1(expression); + positional.push(_this._evaluate0$_withoutSlash$2(expression.accept$1(_this), nodeForSpan)); + positionalNodes.push(nodeForSpan); + } + t1 = type$.String; + named = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Value_2); + t2 = type$.AstNode_2; + namedNodes = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t3 = A.MapExtensions_get_pairs0($arguments.named, t1, type$.Expression_2), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + $name = t4._0; + value = t4._1; + nodeForSpan = _this._evaluate0$_expressionNode$1(value); + named.$indexSet(0, $name, _this._evaluate0$_withoutSlash$2(value.accept$1(_this), nodeForSpan)); + namedNodes.$indexSet(0, $name, nodeForSpan); + } + restArgs = $arguments.rest; + if (restArgs == null) + return new A._Record_5_named_namedNodes_positional_positionalNodes_separator([named, namedNodes, positional, positionalNodes, B.ListSeparator_undecided_null_undecided0]); + rest = restArgs.accept$1(_this); + restNodeForSpan = _this._evaluate0$_expressionNode$1(restArgs); + if (rest instanceof A.SassMap0) { + _this._evaluate0$_addRestMap$4(named, rest, restArgs, new A._EvaluateVisitor__evaluateArguments_closure7()); + t3 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t4 = rest._map0$_contents, t4 = J.get$iterator$ax(t4.get$keys(t4)), t5 = type$.SassString_2; t4.moveNext$0();) + t3.$indexSet(0, t5._as(t4.get$current(t4))._string0$_text, restNodeForSpan); + namedNodes.addAll$1(0, t3); + separator = B.ListSeparator_undecided_null_undecided0; + } else if (rest instanceof A.SassList0) { + t3 = rest._list1$_contents; + B.JSArray_methods.addAll$1(positional, new A.MappedListIterable(t3, new A._EvaluateVisitor__evaluateArguments_closure8(_this, restNodeForSpan), A._arrayInstanceType(t3)._eval$1("MappedListIterable<1,Value0>"))); + B.JSArray_methods.addAll$1(positionalNodes, A.List_List$filled(t3.length, restNodeForSpan, false, t2)); + separator = rest._list1$_separator; + if (rest instanceof A.SassArgumentList0) { + rest._argument_list$_wereKeywordsAccessed = true; + rest._argument_list$_keywords.forEach$1(0, new A._EvaluateVisitor__evaluateArguments_closure9(_this, named, restNodeForSpan, namedNodes)); + } + } else { + positional.push(_this._evaluate0$_withoutSlash$2(rest, restNodeForSpan)); + positionalNodes.push(restNodeForSpan); + separator = B.ListSeparator_undecided_null_undecided0; + } + keywordRestArgs = $arguments.keywordRest; + if (keywordRestArgs == null) + return new A._Record_5_named_namedNodes_positional_positionalNodes_separator([named, namedNodes, positional, positionalNodes, separator]); + keywordRest = keywordRestArgs.accept$1(_this); + keywordRestNodeForSpan = _this._evaluate0$_expressionNode$1(keywordRestArgs); + if (keywordRest instanceof A.SassMap0) { + _this._evaluate0$_addRestMap$4(named, keywordRest, keywordRestArgs, new A._EvaluateVisitor__evaluateArguments_closure10()); + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t2 = keywordRest._map0$_contents, t2 = J.get$iterator$ax(t2.get$keys(t2)), t3 = type$.SassString_2; t2.moveNext$0();) + t1.$indexSet(0, t3._as(t2.get$current(t2))._string0$_text, keywordRestNodeForSpan); + namedNodes.addAll$1(0, t1); + return new A._Record_5_named_namedNodes_positional_positionalNodes_separator([named, namedNodes, positional, positionalNodes, separator]); + } else + throw A.wrapException(_this._evaluate0$_exception$2(string$.Variabs + keywordRest.toString$0(0) + ").", keywordRestArgs.get$span(keywordRestArgs))); + }, + _evaluate0$_evaluateMacroArguments$1(invocation) { + var t2, positional, named, rest, restNodeForSpan, keywordRestArgs_, keywordRest, keywordRestNodeForSpan, _this = this, + t1 = invocation.$arguments, + restArgs_ = t1.rest; + if (restArgs_ == null) + return new A._Record_2(t1.positional, t1.named); + t2 = t1.positional; + positional = A._setArrayType(t2.slice(0), A._arrayInstanceType(t2)); + named = A.LinkedHashMap_LinkedHashMap$of(t1.named, type$.String, type$.Expression_2); + rest = restArgs_.accept$1(_this); + restNodeForSpan = _this._evaluate0$_expressionNode$1(restArgs_); + if (rest instanceof A.SassMap0) + _this._evaluate0$_addRestMap$4(named, rest, invocation, new A._EvaluateVisitor__evaluateMacroArguments_closure7(restArgs_)); + else if (rest instanceof A.SassList0) { + t2 = rest._list1$_contents; + B.JSArray_methods.addAll$1(positional, new A.MappedListIterable(t2, new A._EvaluateVisitor__evaluateMacroArguments_closure8(_this, restNodeForSpan, restArgs_), A._arrayInstanceType(t2)._eval$1("MappedListIterable<1,Expression0>"))); + if (rest instanceof A.SassArgumentList0) { + rest._argument_list$_wereKeywordsAccessed = true; + rest._argument_list$_keywords.forEach$1(0, new A._EvaluateVisitor__evaluateMacroArguments_closure9(_this, named, restNodeForSpan, restArgs_)); + } + } else + positional.push(new A.ValueExpression0(_this._evaluate0$_withoutSlash$2(rest, restNodeForSpan), restArgs_.get$span(restArgs_))); + keywordRestArgs_ = t1.keywordRest; + if (keywordRestArgs_ == null) + return new A._Record_2(positional, named); + keywordRest = keywordRestArgs_.accept$1(_this); + keywordRestNodeForSpan = _this._evaluate0$_expressionNode$1(keywordRestArgs_); + if (keywordRest instanceof A.SassMap0) { + _this._evaluate0$_addRestMap$4(named, keywordRest, invocation, new A._EvaluateVisitor__evaluateMacroArguments_closure10(_this, keywordRestNodeForSpan, keywordRestArgs_)); + return new A._Record_2(positional, named); + } else + throw A.wrapException(_this._evaluate0$_exception$2(string$.Variabs + keywordRest.toString$0(0) + ").", keywordRestArgs_.get$span(keywordRestArgs_))); + }, + _evaluate0$_addRestMap$1$4(values, map, nodeWithSpan, convert) { + map._map0$_contents.forEach$1(0, new A._EvaluateVisitor__addRestMap_closure1(this, values, convert, this._evaluate0$_expressionNode$1(nodeWithSpan), map, nodeWithSpan)); + }, + _evaluate0$_addRestMap$4(values, map, nodeWithSpan, convert) { + return this._evaluate0$_addRestMap$1$4(values, map, nodeWithSpan, convert, type$.dynamic); + }, + _evaluate0$_verifyArguments$4(positional, named, parameters, nodeWithSpan) { + return this._evaluate0$_addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__verifyArguments_closure1(parameters, positional, named)); + }, + visitSelectorExpression$1(_, node) { + var t1 = this._evaluate0$_styleRuleIgnoringAtRoot; + t1 = t1 == null ? null : t1.originalSelector.get$asSassList(); + return t1 == null ? B.C__SassNull0 : t1; + }, + visitStringExpression$1(_, node) { + var t1, t2, t3, _i, value, t4, _0_0, text, _this = this, + oldInSupportsDeclaration = _this._evaluate0$_inSupportsDeclaration; + _this._evaluate0$_inSupportsDeclaration = false; + t1 = A._setArrayType([], type$.JSArray_String); + for (t2 = node.text.contents, t3 = t2.length, _i = 0; _i < t3; ++_i) { + value = t2[_i]; + $label0$0: { + if (typeof value == "string") { + t4 = value; + break $label0$0; + } + if (value instanceof A.Expression0) { + _0_0 = value.accept$1(_this); + $label1$1: { + if (_0_0 instanceof A.SassString0) { + text = _0_0._string0$_text; + t4 = text; + break $label1$1; + } + t4 = _this._evaluate0$_serialize$3$quote(_0_0, value, false); + break $label1$1; + } + break $label0$0; + } + t4 = A.throwExpression(A.UnsupportedError$("Unknown interpolation value " + A.S(value))); + } + t1.push(t4); + } + t1 = B.JSArray_methods.join$0(t1); + _this._evaluate0$_inSupportsDeclaration = oldInSupportsDeclaration; + return new A.SassString0(t1, node.hasQuotes); + }, + visitSupportsExpression$1(_, expression) { + return new A.SassString0(this._evaluate0$_visitSupportsCondition$1(expression.condition), false); + }, + visitCssAtRule$1(node) { + var wasInKeyframes, wasInUnknownAtRule, t1, _this = this; + if (_this._evaluate0$_declarationName != null) + throw A.wrapException(_this._evaluate0$_exception$2(string$.At_rul, node.span)); + if (node.isChildless) { + _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, "__parent").addChild$1(A.ModifiableCssAtRule$0(node.name, node.span, true, node.value)); + return; + } + wasInKeyframes = _this._evaluate0$_inKeyframes; + wasInUnknownAtRule = _this._evaluate0$_inUnknownAtRule; + t1 = node.name; + if (A.unvendor0(t1.value) === "keyframes") + _this._evaluate0$_inKeyframes = true; + else + _this._evaluate0$_inUnknownAtRule = true; + _this._evaluate0$_withParent$2$4$scopeWhen$through(A.ModifiableCssAtRule$0(t1, node.span, false, node.value), new A._EvaluateVisitor_visitCssAtRule_closure3(_this, node), false, new A._EvaluateVisitor_visitCssAtRule_closure4(), type$.ModifiableCssAtRule_2, type$.Null); + _this._evaluate0$_inUnknownAtRule = wasInUnknownAtRule; + _this._evaluate0$_inKeyframes = wasInKeyframes; + }, + visitCssComment$1(node) { + var _this = this, + _s8_ = "__parent", + _s13_ = "_endOfImports"; + if (_this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_) === _this._evaluate0$_assertInModule$2(_this._evaluate0$__root, "_root") && _this._evaluate0$_assertInModule$2(_this._evaluate0$__endOfImports, _s13_) === J.get$length$asx(_this._evaluate0$_assertInModule$2(_this._evaluate0$__root, "_root").children._collection$_source)) + _this._evaluate0$__endOfImports = _this._evaluate0$_assertInModule$2(_this._evaluate0$__endOfImports, _s13_) + 1; + _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_).addChild$1(new A.ModifiableCssComment0(node.text, node.span)); + }, + visitCssDeclaration$1(node) { + this._evaluate0$_assertInModule$2(this._evaluate0$__parent, "__parent").addChild$1(A.ModifiableCssDeclaration$0(node.name, node.value, node.span, null, node.parsedAsCustomProperty, null, node.valueSpanForMap)); + }, + visitCssImport$1(node) { + var t1, _this = this, + _s8_ = "__parent", + _s5_ = "_root", + _s13_ = "_endOfImports", + modifiableNode = new A.ModifiableCssImport0(node.url, node.modifiers, node.span); + if (_this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_) !== _this._evaluate0$_assertInModule$2(_this._evaluate0$__root, _s5_)) + _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_).addChild$1(modifiableNode); + else if (_this._evaluate0$_assertInModule$2(_this._evaluate0$__endOfImports, _s13_) === J.get$length$asx(_this._evaluate0$_assertInModule$2(_this._evaluate0$__root, _s5_).children._collection$_source)) { + _this._evaluate0$_assertInModule$2(_this._evaluate0$__root, _s5_).addChild$1(modifiableNode); + _this._evaluate0$__endOfImports = _this._evaluate0$_assertInModule$2(_this._evaluate0$__endOfImports, _s13_) + 1; + } else { + t1 = _this._evaluate0$_outOfOrderImports; + (t1 == null ? _this._evaluate0$_outOfOrderImports = A._setArrayType([], type$.JSArray_ModifiableCssImport_2) : t1).push(modifiableNode); + } + }, + visitCssKeyframeBlock$1(node) { + this._evaluate0$_withParent$2$4$scopeWhen$through(A.ModifiableCssKeyframeBlock$0(node.selector, node.span), new A._EvaluateVisitor_visitCssKeyframeBlock_closure3(this, node), false, new A._EvaluateVisitor_visitCssKeyframeBlock_closure4(), type$.ModifiableCssKeyframeBlock_2, type$.Null); + }, + visitCssMediaRule$1(node) { + var mergedQueries, t1, mergedSources, t2, t3, _this = this; + if (_this._evaluate0$_declarationName != null) + throw A.wrapException(_this._evaluate0$_exception$2(string$.Media_, node.span)); + mergedQueries = A.NullableExtension_andThen0(_this._evaluate0$_mediaQueries, new A._EvaluateVisitor_visitCssMediaRule_closure5(_this, node)); + t1 = mergedQueries == null; + if (!t1 && J.get$isEmpty$asx(mergedQueries)) + return; + if (t1) + mergedSources = B.Set_empty5; + else { + t2 = _this._evaluate0$_mediaQuerySources; + t2.toString; + t2 = A.LinkedHashSet_LinkedHashSet$of(t2, type$.CssMediaQuery_2); + t3 = _this._evaluate0$_mediaQueries; + t3.toString; + t2.addAll$1(0, t3); + t2.addAll$1(0, node.queries); + mergedSources = t2; + } + t1 = t1 ? node.queries : mergedQueries; + _this._evaluate0$_withParent$2$4$scopeWhen$through(A.ModifiableCssMediaRule$0(t1, node.span), new A._EvaluateVisitor_visitCssMediaRule_closure6(_this, mergedQueries, node, mergedSources), false, new A._EvaluateVisitor_visitCssMediaRule_closure7(mergedSources), type$.ModifiableCssMediaRule_2, type$.Null); + }, + visitCssStyleRule$1(node) { + var t1, styleRule, t2, nest, t3, originalSelector, rule, oldAtRootExcludingStyleRule, _0_1, lastChild, _this = this, _null = null, + _s8_ = "__parent"; + if (_this._evaluate0$_declarationName != null) + throw A.wrapException(_this._evaluate0$_exception$2(string$.Style_n, node.span)); + else if (_this._evaluate0$_inKeyframes && _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_) instanceof A.ModifiableCssKeyframeBlock0) + throw A.wrapException(_this._evaluate0$_exception$2(string$.Style_k, node.span)); + t1 = _this._evaluate0$_atRootExcludingStyleRule; + styleRule = t1 ? _null : _this._evaluate0$_styleRuleIgnoringAtRoot; + t2 = t1 ? _null : _this._evaluate0$_styleRuleIgnoringAtRoot; + t2 = t2 == null ? _null : t2.fromPlainCss; + nest = t2 !== true; + t2 = node._style_rule0$_selector._box0$_inner; + if (nest) { + t2 = t2.value; + t3 = styleRule == null ? _null : styleRule.originalSelector; + originalSelector = t2.nestWithin$3$implicitParent$preserveParentSelectors(t3, !t1, node.fromPlainCss); + } else + originalSelector = t2.value; + rule = A.ModifiableCssStyleRule$0(_this._evaluate0$_assertInModule$2(_this._evaluate0$__extensionStore, "_extensionStore").addSelector$2(originalSelector, _this._evaluate0$_mediaQueries), node.span, node.fromPlainCss, originalSelector); + oldAtRootExcludingStyleRule = _this._evaluate0$_atRootExcludingStyleRule; + _this._evaluate0$_atRootExcludingStyleRule = false; + t1 = nest ? new A._EvaluateVisitor_visitCssStyleRule_closure3() : _null; + _this._evaluate0$_withParent$2$4$scopeWhen$through(rule, new A._EvaluateVisitor_visitCssStyleRule_closure4(_this, rule, node), false, t1, type$.ModifiableCssStyleRule_2, type$.Null); + _this._evaluate0$_atRootExcludingStyleRule = oldAtRootExcludingStyleRule; + t1 = _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, _s8_).children._collection$_source; + t2 = J.getInterceptor$asx(t1); + _0_1 = t2.get$length(t1); + if (_0_1 >= 1) { + lastChild = t2.elementAt$1(t1, _0_1 - 1); + t1 = styleRule == null; + } else { + lastChild = _null; + t1 = false; + } + if (t1) + lastChild.isGroupEnd = true; + }, + visitCssStylesheet$1(node) { + var t1; + for (t1 = J.get$iterator$ax(node.get$children(node)); t1.moveNext$0();) + t1.get$current(t1).accept$1(this); + }, + visitCssSupportsRule$1(node) { + var _this = this; + if (_this._evaluate0$_declarationName != null) + throw A.wrapException(_this._evaluate0$_exception$2(string$.Suppor, node.span)); + _this._evaluate0$_withParent$2$4$scopeWhen$through(A.ModifiableCssSupportsRule$0(node.condition, node.span), new A._EvaluateVisitor_visitCssSupportsRule_closure3(_this, node), false, new A._EvaluateVisitor_visitCssSupportsRule_closure4(), type$.ModifiableCssSupportsRule_2, type$.Null); + }, + _evaluate0$_handleReturn$1$2(list, callback) { + var t1, _i, _0_0; + for (t1 = list.length, _i = 0; _i < list.length; list.length === t1 || (0, A.throwConcurrentModificationError)(list), ++_i) { + _0_0 = callback.call$1(list[_i]); + if (_0_0 != null) + return _0_0; + } + return null; + }, + _evaluate0$_handleReturn$2(list, callback) { + return this._evaluate0$_handleReturn$1$2(list, callback, type$.dynamic); + }, + _evaluate0$_withEnvironment$1$2(environment, callback) { + var result, + oldEnvironment = this._evaluate0$_environment; + this._evaluate0$_environment = environment; + result = callback.call$0(); + this._evaluate0$_environment = oldEnvironment; + return result; + }, + _evaluate0$_withEnvironment$2(environment, callback) { + return this._evaluate0$_withEnvironment$1$2(environment, callback, type$.dynamic); + }, + _evaluate0$_interpolationToValue$3$trim$warnForColor(interpolation, trim, warnForColor) { + var result = this._evaluate0$_performInterpolation$2$warnForColor(interpolation, warnForColor), + t1 = trim ? A.trimAscii0(result, true) : result; + return new A.CssValue0(t1, interpolation.span, type$.CssValue_String_2); + }, + _evaluate0$_interpolationToValue$1(interpolation) { + return this._evaluate0$_interpolationToValue$3$trim$warnForColor(interpolation, false, false); + }, + _evaluate0$_interpolationToValue$2$warnForColor(interpolation, warnForColor) { + return this._evaluate0$_interpolationToValue$3$trim$warnForColor(interpolation, false, warnForColor); + }, + _evaluate0$_performInterpolation$2$warnForColor(interpolation, warnForColor) { + return this._evaluate0$_performInterpolationHelper$3$sourceMap$warnForColor(interpolation, false, warnForColor)._0; + }, + _evaluate0$_performInterpolation$1(interpolation) { + return this._evaluate0$_performInterpolation$2$warnForColor(interpolation, false); + }, + _evaluate0$_performInterpolationWithMap$2$warnForColor(interpolation, warnForColor) { + var _0_0 = this._evaluate0$_performInterpolationHelper$3$sourceMap$warnForColor(interpolation, true, true), + map = _0_0._1; + map.toString; + return new A._Record_2(_0_0._0, map); + }, + _evaluate0$_performInterpolationHelper$3$sourceMap$warnForColor(interpolation, sourceMap, warnForColor) { + var t1, t2, t3, t4, t5, t6, first, _i, t7, value, result, result0, t8, _this = this, _null = null, + targetLocations = sourceMap ? A._setArrayType([], type$.JSArray_SourceLocation) : _null, + oldInSupportsDeclaration = _this._evaluate0$_inSupportsDeclaration; + _this._evaluate0$_inSupportsDeclaration = false; + for (t1 = interpolation.contents, t2 = t1.length, t3 = type$.Expression_2, t4 = targetLocations == null, t5 = interpolation.span, t6 = type$.Object, first = true, _i = 0, t7 = ""; _i < t2; ++_i, first = false) { + value = t1[_i]; + if (!first) + if (!t4) + targetLocations.push(A.SourceLocation$(t7.length, _null, _null, _null)); + if (typeof value == "string") { + t7 += value; + continue; + } + t3._as(value); + result = value.accept$1(_this); + if (warnForColor && $.$get$namesByColor0().containsKey$1(result)) { + result0 = A.List_List$from([""], false, t6); + result0.$flags = 3; + t8 = $.$get$namesByColor0(); + _this._evaluate0$_warn$2(string$.You_pr + A.S(t8.$index(0, result)) + string$.x20in_in + result.toString$0(0) + string$.x2c_whicw + A.S(t8.$index(0, result)) + string$.x22x29__If + new A.BinaryOperationExpression0(B.BinaryOperator_Swh0, new A.StringExpression0(new A.Interpolation0(result0, B.List_null, t5), true), value, false).toString$0(0) + "'.", value.get$span(value)); + } + t7 += _this._evaluate0$_serialize$3$quote(result, value, false); + } + _this._evaluate0$_inSupportsDeclaration = oldInSupportsDeclaration; + return new A._Record_2(t7.charCodeAt(0) == 0 ? t7 : t7, A.NullableExtension_andThen0(targetLocations, new A._EvaluateVisitor__performInterpolationHelper_closure1(interpolation))); + }, + _evaluate0$_serialize$3$quote(value, nodeWithSpan, quote) { + return this._evaluate0$_addExceptionSpan$2(nodeWithSpan, new A._EvaluateVisitor__serialize_closure1(value, quote)); + }, + _evaluate0$_serialize$2(value, nodeWithSpan) { + return this._evaluate0$_serialize$3$quote(value, nodeWithSpan, true); + }, + _evaluate0$_expressionNode$1(expression) { + var t1; + if (expression instanceof A.VariableExpression0) { + t1 = this._evaluate0$_addExceptionSpan$2(expression, new A._EvaluateVisitor__expressionNode_closure1(this, expression)); + return t1 == null ? expression : t1; + } else + return expression; + }, + _evaluate0$_withParent$2$4$scopeWhen$through(node, callback, scopeWhen, through, $S, $T) { + var oldParent, result, _this = this; + _this._evaluate0$_addChild$2$through(node, through); + oldParent = _this._evaluate0$_assertInModule$2(_this._evaluate0$__parent, "__parent"); + _this._evaluate0$__parent = node; + result = _this._evaluate0$_environment.scope$1$2$when(callback, scopeWhen, $T); + _this._evaluate0$__parent = oldParent; + return result; + }, + _evaluate0$_withParent$2$3$scopeWhen(node, callback, scopeWhen, $S, $T) { + return this._evaluate0$_withParent$2$4$scopeWhen$through(node, callback, scopeWhen, null, $S, $T); + }, + _evaluate0$_withParent$2$2(node, callback, $S, $T) { + return this._evaluate0$_withParent$2$4$scopeWhen$through(node, callback, true, null, $S, $T); + }, + _evaluate0$_addChild$2$through(node, through) { + var _0_0, grandparent, t1, + $parent = this._evaluate0$_assertInModule$2(this._evaluate0$__parent, "__parent"); + if (through != null) { + for (; through.call$1($parent); $parent = _0_0) { + _0_0 = $parent._node$_parent; + if (_0_0 == null) + throw A.wrapException(A.ArgumentError$(string$.throug + node.toString$0(0) + ".", null)); + } + if ($parent.get$hasFollowingSibling()) { + grandparent = $parent._node$_parent; + t1 = grandparent.children; + if ($parent.equalsIgnoringChildren$1(t1.get$last(t1))) + $parent = type$.ModifiableCssParentNode_2._as(t1.get$last(t1)); + else { + $parent = $parent.copyWithoutChildren$0(); + grandparent.addChild$1($parent); + } + } + } + $parent.addChild$1(node); + }, + _evaluate0$_addChild$1(node) { + return this._evaluate0$_addChild$2$through(node, null); + }, + _evaluate0$_withStyleRule$1$2(rule, callback) { + var result, + oldRule = this._evaluate0$_styleRuleIgnoringAtRoot; + this._evaluate0$_styleRuleIgnoringAtRoot = rule; + result = callback.call$0(); + this._evaluate0$_styleRuleIgnoringAtRoot = oldRule; + return result; + }, + _evaluate0$_withStyleRule$2(rule, callback) { + return this._evaluate0$_withStyleRule$1$2(rule, callback, type$.dynamic); + }, + _evaluate0$_withMediaQueries$1$3(queries, sources, callback) { + var result, _this = this, + oldMediaQueries = _this._evaluate0$_mediaQueries, + oldSources = _this._evaluate0$_mediaQuerySources; + _this._evaluate0$_mediaQueries = queries; + _this._evaluate0$_mediaQuerySources = sources; + result = callback.call$0(); + _this._evaluate0$_mediaQueries = oldMediaQueries; + _this._evaluate0$_mediaQuerySources = oldSources; + return result; + }, + _evaluate0$_withMediaQueries$3(queries, sources, callback) { + return this._evaluate0$_withMediaQueries$1$3(queries, sources, callback, type$.dynamic); + }, + _evaluate0$_withStackFrame$1$3(member, nodeWithSpan, callback) { + var oldMember, result, _this = this, + t1 = _this._evaluate0$_stack; + t1.push(new A._Record_2(_this._evaluate0$_member, nodeWithSpan)); + oldMember = _this._evaluate0$_member; + _this._evaluate0$_member = member; + result = callback.call$0(); + _this._evaluate0$_member = oldMember; + t1.pop(); + return result; + }, + _evaluate0$_withStackFrame$3(member, nodeWithSpan, callback) { + return this._evaluate0$_withStackFrame$1$3(member, nodeWithSpan, callback, type$.dynamic); + }, + _evaluate0$_withoutSlash$2(value, nodeForSpan) { + var t1; + if (value instanceof A.SassNumber0) + t1 = value.asSlash != null; + else + t1 = false; + if (t1) + this._evaluate0$_warn$3(string$.Using__i + A.S(new A._EvaluateVisitor__withoutSlash_recommendation1().call$1(value)) + string$.x0a_Morex20, nodeForSpan.get$span(nodeForSpan), B.Deprecation_FyB); + return value.withoutSlash$0(); + }, + _evaluate0$_stackFrame$2(member, span) { + return A.frameForSpan0(span, member, A.NullableExtension_andThen0(span.get$sourceUrl(span), new A._EvaluateVisitor__stackFrame_closure1(this))); + }, + _evaluate0$_stackTrace$1(span) { + var t2, t3, _i, t4, nodeWithSpan, _this = this, + t1 = A._setArrayType([], type$.JSArray_Frame); + for (t2 = _this._evaluate0$_stack, t3 = t2.length, _i = 0; _i < t2.length; t2.length === t3 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + t4 = t2[_i]; + nodeWithSpan = t4._1; + t1.push(_this._evaluate0$_stackFrame$2(t4._0, nodeWithSpan.get$span(nodeWithSpan))); + } + if (span != null) + t1.push(_this._evaluate0$_stackFrame$2(_this._evaluate0$_member, span)); + return A.Trace$(new A.ReversedListIterable(t1, type$.ReversedListIterable_Frame), null); + }, + _evaluate0$_stackTrace$0() { + return this._evaluate0$_stackTrace$1(null); + }, + _evaluate0$_warn$3(message, span, deprecation) { + var trace, t1, _this = this; + if (_this._evaluate0$_quietDeps && _this._evaluate0$_inDependency) + return; + if (!_this._evaluate0$_warningsEmitted.add$1(0, new A._Record_2(message, span))) + return; + trace = _this._evaluate0$_stackTrace$1(span); + t1 = _this._evaluate0$_logger; + if (deprecation == null) + t1.internalWarn$4$deprecation$span$trace(message, null, span, trace); + else + A.WarnForDeprecation_warnForDeprecation0(t1, deprecation, message, span, trace); + }, + _evaluate0$_warn$2(message, span) { + return this._evaluate0$_warn$3(message, span, null); + }, + _evaluate0$_exception$2(message, span) { + var t1, t2; + if (span == null) { + t1 = B.JSArray_methods.get$last(this._evaluate0$_stack)._1; + t1 = t1.get$span(t1); + } else + t1 = span; + t2 = this._evaluate0$_stackTrace$1(span); + return new A.SassRuntimeException0(t2, B.Set_empty, message, t1); + }, + _evaluate0$_exception$1(message) { + return this._evaluate0$_exception$2(message, null); + }, + _evaluate0$_multiSpanException$3(message, primaryLabel, secondaryLabels) { + var t1 = B.JSArray_methods.get$last(this._evaluate0$_stack)._1; + return A.MultiSpanSassRuntimeException$0(message, t1.get$span(t1), primaryLabel, secondaryLabels, this._evaluate0$_stackTrace$0(), null); + }, + _evaluate0$_addExceptionSpan$1$3$addStackFrame(nodeWithSpan, callback, addStackFrame) { + var error, stackTrace, t1, exception; + try { + t1 = callback.call$0(); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassScriptException0) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = error.withSpan$1(nodeWithSpan.get$span(nodeWithSpan)); + A.throwWithTrace0(t1.withTrace$1(this._evaluate0$_stackTrace$1(addStackFrame ? nodeWithSpan.get$span(nodeWithSpan) : null)), error, stackTrace); + } else + throw exception; + } + }, + _evaluate0$_addExceptionSpan$2(nodeWithSpan, callback) { + return this._evaluate0$_addExceptionSpan$1$3$addStackFrame(nodeWithSpan, callback, true, type$.dynamic); + }, + _evaluate0$_addExceptionSpan$3$addStackFrame(nodeWithSpan, callback, addStackFrame) { + return this._evaluate0$_addExceptionSpan$1$3$addStackFrame(nodeWithSpan, callback, addStackFrame, type$.dynamic); + }, + _evaluate0$_addExceptionTrace$1$1(callback) { + var error, stackTrace, t1, exception, t2; + try { + t1 = callback.call$0(); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.SassRuntimeException_2._is(t1)) + throw exception; + else if (t1 instanceof A.SassException0) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = error; + t2 = J.getInterceptor$z(t1); + A.throwWithTrace0(error.withTrace$1(this._evaluate0$_stackTrace$1(A.SourceSpanException.prototype.get$span.call(t2, t1))), error, stackTrace); + } else + throw exception; + } + }, + _evaluate0$_addExceptionTrace$1(callback) { + return this._evaluate0$_addExceptionTrace$1$1(callback, type$.dynamic); + }, + _evaluate0$_addErrorSpan$1$2(nodeWithSpan, callback) { + var error, stackTrace, t1, exception, t2, t3; + try { + t1 = callback.call$0(); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.SassRuntimeException_2._is(t1)) { + error = t1; + stackTrace = A.getTraceFromException(exception); + if (!B.JSString_methods.startsWith$1(J.get$span$z(error).get$text(), "@error")) + throw exception; + t1 = error._span_exception$_message; + t2 = nodeWithSpan.get$span(nodeWithSpan); + t3 = this._evaluate0$_stackTrace$0(); + A.throwWithTrace0(new A.SassRuntimeException0(t3, B.Set_empty, t1, t2), error, stackTrace); + } else + throw exception; + } + }, + _evaluate0$_addErrorSpan$2(nodeWithSpan, callback) { + return this._evaluate0$_addErrorSpan$1$2(nodeWithSpan, callback, type$.dynamic); + }, + _evaluate0$_getErrorMessage$1(error) { + var t1, exception; + if (type$.Error._is(error)) + return error.toString$0(0); + try { + t1 = A._asString(J.get$message$x(error)); + return t1; + } catch (exception) { + t1 = J.toString$0$(error); + return t1; + } + }, + $isExpressionVisitor: 1, + $isStatementVisitor: 1 + }; + A._EvaluateVisitor_closure25.prototype = { + call$1($arguments) { + var module, t2, + t1 = J.getInterceptor$asx($arguments), + variable = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this._evaluate0$_environment; + t2 = A.stringReplaceAllUnchecked(variable._string0$_text, "_", "-"); + return t1.globalVariableExists$2$namespace(t2, module == null ? null : module._string0$_text) ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._EvaluateVisitor_closure26.prototype = { + call$1($arguments) { + var variable = J.$index$asx($arguments, 0).assertString$1("name"), + t1 = this.$this._evaluate0$_environment; + return t1.getVariable$1(A.stringReplaceAllUnchecked(variable._string0$_text, "_", "-")) != null ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._EvaluateVisitor_closure27.prototype = { + call$1($arguments) { + var module, t2, t3, t4, + t1 = J.getInterceptor$asx($arguments), + variable = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this; + t2 = t1._evaluate0$_environment; + t3 = variable._string0$_text; + t4 = A.stringReplaceAllUnchecked(t3, "_", "-"); + return t2.getFunction$2$namespace(t4, module == null ? null : module._string0$_text) != null || t1._evaluate0$_builtInFunctions.containsKey$1(t3) ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._EvaluateVisitor_closure28.prototype = { + call$1($arguments) { + var module, t2, + t1 = J.getInterceptor$asx($arguments), + variable = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this._evaluate0$_environment; + t2 = A.stringReplaceAllUnchecked(variable._string0$_text, "_", "-"); + return t1.getMixin$2$namespace(t2, module == null ? null : module._string0$_text) != null ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._EvaluateVisitor_closure29.prototype = { + call$1($arguments) { + var t1 = this.$this._evaluate0$_environment; + if (!t1._environment0$_inMixin) + throw A.wrapException(A.SassScriptException$0(string$.conten, null)); + return t1._environment0$_content != null ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._EvaluateVisitor_closure30.prototype = { + call$1($arguments) { + var t2, t3, t4, + t1 = J.$index$asx($arguments, 0).assertString$1("module")._string0$_text, + module = this.$this._evaluate0$_environment._environment0$_modules.$index(0, t1); + if (module == null) + throw A.wrapException('There is no module with namespace "' + t1 + '".'); + t1 = type$.Value_2; + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t3 = A.MapExtensions_get_pairs0(module.get$variables(), type$.String, t1), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t2.$indexSet(0, new A.SassString0(t4._0, true), t4._1); + } + return new A.SassMap0(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 37 + }; + A._EvaluateVisitor_closure31.prototype = { + call$1($arguments) { + var t2, t3, t4, + t1 = J.$index$asx($arguments, 0).assertString$1("module")._string0$_text, + module = this.$this._evaluate0$_environment._environment0$_modules.$index(0, t1); + if (module == null) + throw A.wrapException('There is no module with namespace "' + t1 + '".'); + t1 = type$.Value_2; + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t3 = A.MapExtensions_get_pairs0(module.get$functions(module), type$.String, type$.Callable_2), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t2.$indexSet(0, new A.SassString0(t4._0, true), new A.SassFunction0(t4._1)); + } + return new A.SassMap0(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 37 + }; + A._EvaluateVisitor_closure32.prototype = { + call$1($arguments) { + var t2, t3, t4, + t1 = J.$index$asx($arguments, 0).assertString$1("module")._string0$_text, + module = this.$this._evaluate0$_environment._environment0$_modules.$index(0, t1); + if (module == null) + throw A.wrapException('There is no module with namespace "' + t1 + '".'); + t1 = type$.Value_2; + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t3 = A.MapExtensions_get_pairs0(module.get$mixins(), type$.String, type$.Callable_2), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t2.$indexSet(0, new A.SassString0(t4._0, true), new A.SassMixin0(t4._1)); + } + return new A.SassMap0(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 37 + }; + A._EvaluateVisitor_closure33.prototype = { + call$1($arguments) { + var module, t2, callable, + t1 = J.getInterceptor$asx($arguments), + $name = t1.$index($arguments, 0).assertString$1("name"), + css = t1.$index($arguments, 1).get$isTruthy(); + t1 = t1.$index($arguments, 2).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + if (css) { + if (module != null) + throw A.wrapException(string$.x24css_a); + return new A.SassFunction0(new A.PlainCssCallable0($name._string0$_text)); + } + t1 = this.$this; + t2 = t1._evaluate0$_callableNode; + t2.toString; + callable = t1._evaluate0$_addExceptionSpan$2(t2, new A._EvaluateVisitor__closure10(t1, $name, module)); + if (callable == null) + throw A.wrapException("Function not found: " + $name.toString$0(0)); + return new A.SassFunction0(callable); + }, + $signature: 205 + }; + A._EvaluateVisitor__closure10.prototype = { + call$0() { + var local, + normalizedName = A.stringReplaceAllUnchecked(this.name._string0$_text, "_", "-"), + t1 = this.module, + namespace = t1 == null ? null : t1._string0$_text; + t1 = this.$this; + local = t1._evaluate0$_environment.getFunction$2$namespace(normalizedName, namespace); + if (local != null || namespace != null) + return local; + return t1._evaluate0$_builtInFunctions.$index(0, normalizedName); + }, + $signature: 103 + }; + A._EvaluateVisitor_closure34.prototype = { + call$1($arguments) { + var module, t2, callable, + t1 = J.getInterceptor$asx($arguments), + $name = t1.$index($arguments, 0).assertString$1("name"); + t1 = t1.$index($arguments, 1).get$realNull(); + module = t1 == null ? null : t1.assertString$1("module"); + t1 = this.$this; + t2 = t1._evaluate0$_callableNode; + t2.toString; + callable = t1._evaluate0$_addExceptionSpan$2(t2, new A._EvaluateVisitor__closure9(t1, $name, module)); + if (callable == null) + throw A.wrapException("Mixin not found: " + $name.toString$0(0)); + return new A.SassMixin0(callable); + }, + $signature: 206 + }; + A._EvaluateVisitor__closure9.prototype = { + call$0() { + var t1 = this.$this._evaluate0$_environment, + t2 = A.stringReplaceAllUnchecked(this.name._string0$_text, "_", "-"), + t3 = this.module; + return t1.getMixin$2$namespace(t2, t3 == null ? null : t3._string0$_text); + }, + $signature: 103 + }; + A._EvaluateVisitor_closure35.prototype = { + call$1($arguments) { + var t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, invocation, callableNode, callable, + t1 = J.getInterceptor$asx($arguments), + $function = t1.$index($arguments, 0), + args = type$.SassArgumentList_2._as(t1.$index($arguments, 1)); + t1 = this.$this; + t2 = t1._evaluate0$_callableNode; + t2.toString; + t3 = A._setArrayType([], type$.JSArray_Expression_2); + t4 = type$.String; + t5 = type$.Expression_2; + t6 = t2.get$span(t2); + t7 = t2.get$span(t2); + args._argument_list$_wereKeywordsAccessed = true; + t8 = args._argument_list$_keywords; + if (t8.get$isEmpty(t8)) + t2 = null; + else { + t9 = type$.Value_2; + t10 = A.LinkedHashMap_LinkedHashMap$_empty(t9, t9); + args._argument_list$_wereKeywordsAccessed = true; + t8 = A.MapExtensions_get_pairs0(t8, t4, t9); + t8 = t8.get$iterator(t8); + for (; t8.moveNext$0();) { + t11 = t8.get$current(t8); + t10.$indexSet(0, new A.SassString0(t11._0, false), t11._1); + } + t2 = new A.ValueExpression0(new A.SassMap0(A.ConstantMap_ConstantMap$from(t10, t9, t9)), t2.get$span(t2)); + } + invocation = new A.ArgumentList0(A.List_List$unmodifiable(t3, t5), A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_empty(t4, t5), t4, t5), new A.ValueExpression0(args, t7), t2, t6); + if ($function instanceof A.SassString0) { + A.warnForDeprecation0(string$.Passina + $function.toString$0(0) + "))", B.Deprecation_aM0); + callableNode = t1._evaluate0$_callableNode; + t2 = $function._string0$_text; + t3 = callableNode.get$span(callableNode); + return t1.visitFunctionExpression$1(0, new A.FunctionExpression0(null, A.stringReplaceAllUnchecked(t2, "_", "-"), t2, invocation, t3)); + } + callable = $function.assertFunction$1("function").callable; + if (type$.Callable_2._is(callable)) { + t2 = t1._evaluate0$_callableNode; + t2.toString; + return t1._evaluate0$_runFunctionCallable$3(invocation, callable, t2); + } else + throw A.wrapException(A.SassScriptException$0("The function " + callable.get$name(callable) + string$.x20is_as, null)); + }, + $signature: 3 + }; + A._EvaluateVisitor_closure36.prototype = { + call$1($arguments) { + var withMap, t2, values, configuration, t3, + t1 = J.getInterceptor$asx($arguments), + url = A.Uri_parse(t1.$index($arguments, 0).assertString$1("url")._string0$_text); + t1 = t1.$index($arguments, 1).get$realNull(); + withMap = t1 == null ? null : t1.assertMap$1("with")._map0$_contents; + t1 = this.$this; + t2 = t1._evaluate0$_callableNode; + t2.toString; + if (withMap != null) { + values = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.ConfiguredValue_2); + withMap.forEach$1(0, new A._EvaluateVisitor__closure7(values, t2.get$span(t2), t2)); + configuration = new A.ExplicitConfiguration0(t2, values, null); + } else + configuration = B.Configuration_Map_empty_null0; + t3 = t2.get$span(t2); + t1._evaluate0$_loadModule$7$baseUrl$configuration$namesInErrors(url, "load-css()", t2, new A._EvaluateVisitor__closure8(t1), t3.get$sourceUrl(t3), configuration, true); + t1._evaluate0$_assertConfigurationIsEmpty$2$nameInError(configuration, true); + }, + $signature: 239 + }; + A._EvaluateVisitor__closure7.prototype = { + call$2(variable, value) { + var t1 = variable.assertString$1("with key"), + $name = A.stringReplaceAllUnchecked(t1._string0$_text, "_", "-"); + t1 = this.values; + if (t1.containsKey$1($name)) + throw A.wrapException("The variable $" + $name + " was configured twice."); + t1.$indexSet(0, $name, new A.ConfiguredValue0(value, this.span, this.callableNode)); + }, + $signature: 98 + }; + A._EvaluateVisitor__closure8.prototype = { + call$2(module, _) { + var t1 = this.$this; + return t1._evaluate0$_combineCss$2$clone(module, true).accept$1(t1); + }, + $signature: 102 + }; + A._EvaluateVisitor_closure37.prototype = { + call$1($arguments) { + var callableNode, t2, t3, t4, t5, callable, $content, + t1 = J.getInterceptor$asx($arguments), + mixin = t1.$index($arguments, 0), + args = type$.SassArgumentList_2._as(t1.$index($arguments, 1)); + t1 = this.$this; + callableNode = t1._evaluate0$_callableNode; + t2 = callableNode.get$span(callableNode); + t3 = callableNode.get$span(callableNode); + t4 = type$.Expression_2; + t5 = A.List_List$unmodifiable(B.List_empty21, t4); + t4 = A.ConstantMap_ConstantMap$from(B.Map_empty14, type$.String, t4); + callable = mixin.assertMixin$1("mixin").callable; + $content = t1._evaluate0$_environment._environment0$_content; + if (type$.Callable_2._is(callable)) + t1._evaluate0$_applyMixin$5(callable, $content, new A.ArgumentList0(t5, t4, new A.ValueExpression0(args, t3), null, t2), callableNode, callableNode); + else + throw A.wrapException(A.SassScriptException$0("The mixin " + callable.get$name(callable) + string$.x20is_as, null)); + }, + $signature: 239 + }; + A._EvaluateVisitor_run_closure1.prototype = { + call$0() { + var module, t2, _this = this, + t1 = _this.node, + _0_0 = t1.span.file.url, + url = null; + if (_0_0 != null) { + url = _0_0; + t2 = _this.$this; + t2._evaluate0$_activeModules.$indexSet(0, url, null); + if (!(t2._nodeImporter != null && J.toString$0$(url) === "stdin")) + t2._evaluate0$_loadedUrls.add$1(0, url); + } + t2 = _this.$this; + module = t2._evaluate0$_addExceptionTrace$1(new A._EvaluateVisitor_run__closure1(t2, _this.importer, t1)); + return new A._Record_2_loadedUrls_stylesheet(t2._evaluate0$_loadedUrls, t2._evaluate0$_combineCss$1(module)); + }, + $signature: 453 + }; + A._EvaluateVisitor_run__closure1.prototype = { + call$0() { + return this.$this._evaluate0$_execute$2(this.importer, this.node); + }, + $signature: 454 + }; + A._EvaluateVisitor__loadModule_closure3.prototype = { + call$0() { + return this.callback.call$2(this._box_0.builtInModule, false); + }, + $signature: 0 + }; + A._EvaluateVisitor__loadModule_closure4.prototype = { + call$0() { + var canonicalUrl, oldInDependency, t4, message, _this = this, t1 = {}, stylesheet = null, importer = null, + t2 = _this.$this, + t3 = _this.nodeWithSpan, + _1_0 = t2._evaluate0$_loadStylesheet$3$baseUrl(_this.url.toString$0(0), t3.get$span(t3), _this.baseUrl); + stylesheet = _1_0._0; + importer = _1_0._1; + canonicalUrl = stylesheet.span.file.url; + if (canonicalUrl != null) { + t4 = t2._evaluate0$_activeModules; + if (t4.containsKey$1(canonicalUrl)) { + if (_this.namesInErrors) { + t1 = canonicalUrl; + t3 = $.$get$context(); + t1.toString; + message = "Module loop: " + t3.prettyUri$1(t1) + " is already being loaded."; + } else + message = string$.Modulel; + t1 = A.NullableExtension_andThen0(t4.$index(0, canonicalUrl), new A._EvaluateVisitor__loadModule__closure3(t2, message)); + throw A.wrapException(t1 == null ? t2._evaluate0$_exception$1(message) : t1); + } else + t4.$indexSet(0, canonicalUrl, t3); + } + t4 = t2._evaluate0$_modules.containsKey$1(canonicalUrl); + oldInDependency = t2._evaluate0$_inDependency; + t2._evaluate0$_inDependency = _1_0._2; + t1.module = null; + try { + t1.module = t2._evaluate0$_execute$5$configuration$namesInErrors$nodeWithSpan(importer, stylesheet, _this.configuration, _this.namesInErrors, t3); + } finally { + t2._evaluate0$_activeModules.remove$1(0, canonicalUrl); + t2._evaluate0$_inDependency = oldInDependency; + } + t2._evaluate0$_addExceptionSpan$3$addStackFrame(t3, new A._EvaluateVisitor__loadModule__closure4(t1, _this.callback, !t4), false); + }, + $signature: 1 + }; + A._EvaluateVisitor__loadModule__closure3.prototype = { + call$1(previousLoad) { + return this.$this._evaluate0$_multiSpanException$3(this.message, "new load", A.LinkedHashMap_LinkedHashMap$_literal([previousLoad.get$span(previousLoad), "original load"], type$.FileSpan, type$.String)); + }, + $signature: 99 + }; + A._EvaluateVisitor__loadModule__closure4.prototype = { + call$0() { + return this.callback.call$2(this._box_1.module, this.firstLoad); + }, + $signature: 0 + }; + A._EvaluateVisitor__execute_closure1.prototype = { + call$0() { + var t3, t4, t5, t6, _this = this, + t1 = _this.$this, + oldImporter = t1._evaluate0$_importer, + oldStylesheet = t1._evaluate0$__stylesheet, + oldRoot = t1._evaluate0$__root, + oldPreModuleComments = t1._evaluate0$_preModuleComments, + oldParent = t1._evaluate0$__parent, + oldEndOfImports = t1._evaluate0$__endOfImports, + oldOutOfOrderImports = t1._evaluate0$_outOfOrderImports, + oldExtensionStore = t1._evaluate0$__extensionStore, + t2 = t1._evaluate0$_atRootExcludingStyleRule, + oldStyleRule = t2 ? null : t1._evaluate0$_styleRuleIgnoringAtRoot, + oldMediaQueries = t1._evaluate0$_mediaQueries, + oldDeclarationName = t1._evaluate0$_declarationName, + oldInUnknownAtRule = t1._evaluate0$_inUnknownAtRule, + oldInKeyframes = t1._evaluate0$_inKeyframes, + oldConfiguration = t1._evaluate0$_configuration; + t1._evaluate0$_importer = _this.importer; + t3 = t1._evaluate0$__stylesheet = _this.stylesheet; + t4 = t3.span; + t5 = t1._evaluate0$__parent = t1._evaluate0$__root = A.ModifiableCssStylesheet$0(t4); + t1._evaluate0$__endOfImports = 0; + t1._evaluate0$_outOfOrderImports = null; + t1._evaluate0$__extensionStore = _this.extensionStore; + t1._evaluate0$_declarationName = t1._evaluate0$_mediaQueries = t1._evaluate0$_styleRuleIgnoringAtRoot = null; + t1._evaluate0$_inKeyframes = t1._evaluate0$_atRootExcludingStyleRule = t1._evaluate0$_inUnknownAtRule = false; + t6 = _this.configuration; + if (t6 != null) + t1._evaluate0$_configuration = t6; + t1.visitStylesheet$1(0, t3); + t3 = t1._evaluate0$_outOfOrderImports == null ? t5 : new A.CssStylesheet0(new A.UnmodifiableListView(t1._evaluate0$_addOutOfOrderImports$0(), type$.UnmodifiableListView_CssNode_2), t4); + _this.css.__late_helper$_value = t3; + _this.preModuleComments.__late_helper$_value = t1._evaluate0$_preModuleComments; + t1._evaluate0$_importer = oldImporter; + t1._evaluate0$__stylesheet = oldStylesheet; + t1._evaluate0$__root = oldRoot; + t1._evaluate0$_preModuleComments = oldPreModuleComments; + t1._evaluate0$__parent = oldParent; + t1._evaluate0$__endOfImports = oldEndOfImports; + t1._evaluate0$_outOfOrderImports = oldOutOfOrderImports; + t1._evaluate0$__extensionStore = oldExtensionStore; + t1._evaluate0$_styleRuleIgnoringAtRoot = oldStyleRule; + t1._evaluate0$_mediaQueries = oldMediaQueries; + t1._evaluate0$_declarationName = oldDeclarationName; + t1._evaluate0$_inUnknownAtRule = oldInUnknownAtRule; + t1._evaluate0$_atRootExcludingStyleRule = t2; + t1._evaluate0$_inKeyframes = oldInKeyframes; + t1._evaluate0$_configuration = oldConfiguration; + }, + $signature: 1 + }; + A._EvaluateVisitor__combineCss_closure3.prototype = { + call$1(module) { + return module.get$transitivelyContainsCss(); + }, + $signature: 127 + }; + A._EvaluateVisitor__combineCss_closure4.prototype = { + call$1(target) { + return !this.selectors.contains$1(0, target); + }, + $signature: 14 + }; + A._EvaluateVisitor__combineCss_visitModule1.prototype = { + call$1(module) { + var t1, t2, t3, t4, _i, upstream, _1_0, statements, index, _this = this; + if (!_this.seen.add$1(0, module)) + return; + if (_this.clone) + module = module.cloneCss$0(); + for (t1 = module.get$upstream(), t2 = t1.length, t3 = _this.css, t4 = _this.imports, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + upstream = t1[_i]; + if (upstream.get$transitivelyContainsCss()) { + _1_0 = module.get$preModuleComments().$index(0, upstream); + if (_1_0 != null) + B.JSArray_methods.addAll$1(t3.length === 0 ? t4 : t3, _1_0); + _this.call$1(upstream); + } + } + _this.sorted.addFirst$1(module); + t1 = module.get$css(module); + statements = t1.get$children(t1); + index = _this.$this._evaluate0$_indexAfterImports$1(statements); + t1 = J.getInterceptor$ax(statements); + B.JSArray_methods.addAll$1(t4, t1.getRange$2(statements, 0, index)); + B.JSArray_methods.addAll$1(t3, t1.getRange$2(statements, index, t1.get$length(statements))); + }, + $signature: 455 + }; + A._EvaluateVisitor__extendModules_closure3.prototype = { + call$1(target) { + return !this.originalSelectors.contains$1(0, target); + }, + $signature: 14 + }; + A._EvaluateVisitor__extendModules_closure4.prototype = { + call$0() { + return A._setArrayType([], type$.JSArray_ExtensionStore_2); + }, + $signature: 209 + }; + A._EvaluateVisitor_visitAtRootRule_closure3.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.node.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitAtRootRule_closure4.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.node.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 0 + }; + A._EvaluateVisitor__scopeForAtRoot_closure11.prototype = { + call$1(callback) { + var t1 = this.$this, + oldParent = t1._evaluate0$_assertInModule$2(t1._evaluate0$__parent, "__parent"); + t1._evaluate0$__parent = this.newParent; + t1._evaluate0$_environment.scope$1$2$when(callback, this.node.hasDeclarations, type$.void); + t1._evaluate0$__parent = oldParent; + }, + $signature: 35 + }; + A._EvaluateVisitor__scopeForAtRoot_closure12.prototype = { + call$1(callback) { + var t1 = this.$this, + oldAtRootExcludingStyleRule = t1._evaluate0$_atRootExcludingStyleRule; + t1._evaluate0$_atRootExcludingStyleRule = true; + this.innerScope.call$1(callback); + t1._evaluate0$_atRootExcludingStyleRule = oldAtRootExcludingStyleRule; + }, + $signature: 35 + }; + A._EvaluateVisitor__scopeForAtRoot_closure13.prototype = { + call$1(callback) { + return this.$this._evaluate0$_withMediaQueries$3(null, null, new A._EvaluateVisitor__scopeForAtRoot__closure1(this.innerScope, callback)); + }, + $signature: 35 + }; + A._EvaluateVisitor__scopeForAtRoot__closure1.prototype = { + call$0() { + return this.innerScope.call$1(this.callback); + }, + $signature: 1 + }; + A._EvaluateVisitor__scopeForAtRoot_closure14.prototype = { + call$1(callback) { + var t1 = this.$this, + wasInKeyframes = t1._evaluate0$_inKeyframes; + t1._evaluate0$_inKeyframes = false; + this.innerScope.call$1(callback); + t1._evaluate0$_inKeyframes = wasInKeyframes; + }, + $signature: 35 + }; + A._EvaluateVisitor__scopeForAtRoot_closure15.prototype = { + call$1($parent) { + return $parent instanceof A.ModifiableCssAtRule0; + }, + $signature: 210 + }; + A._EvaluateVisitor__scopeForAtRoot_closure16.prototype = { + call$1(callback) { + var t1 = this.$this, + wasInUnknownAtRule = t1._evaluate0$_inUnknownAtRule; + t1._evaluate0$_inUnknownAtRule = false; + this.innerScope.call$1(callback); + t1._evaluate0$_inUnknownAtRule = wasInUnknownAtRule; + }, + $signature: 35 + }; + A._EvaluateVisitor_visitContentRule_closure1.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.content.declaration.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + return null; + }, + $signature: 1 + }; + A._EvaluateVisitor_visitDeclaration_closure1.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this._box_0.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitEachRule_closure5.prototype = { + call$1(value) { + var t1 = this.$this, + t2 = this.nodeWithSpan; + return t1._evaluate0$_environment.setLocalVariable$3(this._box_0.variable, t1._evaluate0$_withoutSlash$2(value, t2), t2); + }, + $signature: 66 + }; + A._EvaluateVisitor_visitEachRule_closure6.prototype = { + call$1(value) { + return this.$this._evaluate0$_setMultipleVariables$3(this._box_1.variables, value, this.nodeWithSpan); + }, + $signature: 66 + }; + A._EvaluateVisitor_visitEachRule_closure7.prototype = { + call$0() { + var _this = this, + t1 = _this.$this; + return t1._evaluate0$_handleReturn$2(_this.list.get$asList(), new A._EvaluateVisitor_visitEachRule__closure1(t1, _this.setVariables, _this.node)); + }, + $signature: 44 + }; + A._EvaluateVisitor_visitEachRule__closure1.prototype = { + call$1(element) { + var t1; + this.setVariables.call$1(element); + t1 = this.$this; + return t1._evaluate0$_handleReturn$2(this.node.children, new A._EvaluateVisitor_visitEachRule___closure1(t1)); + }, + $signature: 240 + }; + A._EvaluateVisitor_visitEachRule___closure1.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 94 + }; + A._EvaluateVisitor_visitAtRule_closure5.prototype = { + call$1(value) { + return this.$this._evaluate0$_interpolationToValue$3$trim$warnForColor(value, true, true); + }, + $signature: 458 + }; + A._EvaluateVisitor_visitAtRule_closure6.prototype = { + call$0() { + var t2, t3, _i, _this = this, + t1 = _this.$this, + styleRule = t1._evaluate0$_atRootExcludingStyleRule ? null : t1._evaluate0$_styleRuleIgnoringAtRoot; + if (styleRule == null || t1._evaluate0$_inKeyframes || J.$eq$(_this.name.value, "font-face")) + for (t2 = _this.children, t3 = t2.length, _i = 0; _i < t3; ++_i) + t2[_i].accept$1(t1); + else + t1._evaluate0$_withParent$2$3$scopeWhen(A.ModifiableCssStyleRule$0(styleRule._style_rule0$_selector, styleRule.span, false, styleRule.originalSelector), new A._EvaluateVisitor_visitAtRule__closure1(t1, _this.children), false, type$.ModifiableCssStyleRule_2, type$.Null); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitAtRule__closure1.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitAtRule_closure7.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitForRule_closure9.prototype = { + call$0() { + return this.node.from.accept$1(this.$this).assertNumber$0(); + }, + $signature: 241 + }; + A._EvaluateVisitor_visitForRule_closure10.prototype = { + call$0() { + return this.node.to.accept$1(this.$this).assertNumber$0(); + }, + $signature: 241 + }; + A._EvaluateVisitor_visitForRule_closure11.prototype = { + call$0() { + return this.fromNumber.assertInt$0(); + }, + $signature: 10 + }; + A._EvaluateVisitor_visitForRule_closure12.prototype = { + call$0() { + var t1 = this.fromNumber; + return this.toNumber.coerce$2(t1.get$numeratorUnits(t1), t1.get$denominatorUnits(t1)).assertInt$0(); + }, + $signature: 10 + }; + A._EvaluateVisitor_visitForRule_closure13.prototype = { + call$0() { + var i, t3, t4, t5, t6, t7, t8, _0_0, _this = this, + t1 = _this.$this, + t2 = _this.node, + nodeWithSpan = t1._evaluate0$_expressionNode$1(t2.from); + for (i = _this.from, t3 = _this._box_0, t4 = _this.direction, t5 = t2.variable, t6 = _this.fromNumber, t2 = t2.children; i !== t3.to; i += t4) { + t7 = t1._evaluate0$_environment; + t8 = t6.get$numeratorUnits(t6); + t7.setLocalVariable$3(t5, A.SassNumber_SassNumber$withUnits0(i, t6.get$denominatorUnits(t6), t8), nodeWithSpan); + _0_0 = t1._evaluate0$_handleReturn$2(t2, new A._EvaluateVisitor_visitForRule__closure1(t1)); + if (_0_0 != null) + return _0_0; + } + return null; + }, + $signature: 44 + }; + A._EvaluateVisitor_visitForRule__closure1.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 94 + }; + A._EvaluateVisitor_visitForwardRule_closure3.prototype = { + call$2(module, firstLoad) { + if (firstLoad) + this.$this._evaluate0$_registerCommentsForModule$1(module); + this.$this._evaluate0$_environment.forwardModule$2(module, this.node); + }, + $signature: 102 + }; + A._EvaluateVisitor_visitForwardRule_closure4.prototype = { + call$2(module, firstLoad) { + if (firstLoad) + this.$this._evaluate0$_registerCommentsForModule$1(module); + this.$this._evaluate0$_environment.forwardModule$2(module, this.node); + }, + $signature: 102 + }; + A._EvaluateVisitor__registerCommentsForModule_closure1.prototype = { + call$0() { + return A._setArrayType([], type$.JSArray_CssComment_2); + }, + $signature: 214 + }; + A._EvaluateVisitor_visitIfRule_closure1.prototype = { + call$1(clause) { + var t1 = this.$this; + return t1._evaluate0$_environment.scope$1$3$semiGlobal$when(new A._EvaluateVisitor_visitIfRule__closure1(t1, clause), true, clause.hasDeclarations, type$.nullable_Value_2); + }, + $signature: 460 + }; + A._EvaluateVisitor_visitIfRule__closure1.prototype = { + call$0() { + var t1 = this.$this; + return t1._evaluate0$_handleReturn$2(this.clause.children, new A._EvaluateVisitor_visitIfRule___closure1(t1)); + }, + $signature: 44 + }; + A._EvaluateVisitor_visitIfRule___closure1.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 94 + }; + A._EvaluateVisitor__visitDynamicImport_closure1.prototype = { + call$0() { + var t1, t2, _0_0, stylesheet, importer, isDependency, url, t3, oldImporter, oldStylesheet, oldInDependency, loadsUserDefinedModules, children, t4, t5, t6, t7, t8, t9, t10, environment, module, visitor, _box_0 = {}; + _box_0.isDependency = _box_0.importer = _box_0.stylesheet = null; + t1 = this.$this; + t2 = this.$import; + _0_0 = t1._evaluate0$_loadStylesheet$3$forImport(t2.urlString, t2.span, true); + stylesheet = _box_0.stylesheet = _0_0._0; + importer = _0_0._1; + _box_0.importer = importer; + isDependency = _0_0._2; + _box_0.isDependency = isDependency; + url = stylesheet.span.file.url; + if (url != null) { + t3 = t1._evaluate0$_activeModules; + if (t3.containsKey$1(url)) { + t2 = A.NullableExtension_andThen0(t3.$index(0, url), new A._EvaluateVisitor__visitDynamicImport__closure7(t1)); + throw A.wrapException(t2 == null ? t1._evaluate0$_exception$1("This file is already being loaded.") : t2); + } + t3.$indexSet(0, url, t2); + } + t2 = stylesheet._stylesheet1$_uses; + t3 = type$.UnmodifiableListView_UseRule_2; + if (new A.UnmodifiableListView(t2, t3).get$length(0) === 0 && new A.UnmodifiableListView(stylesheet._stylesheet1$_forwards, type$.UnmodifiableListView_ForwardRule_2).get$length(0) === 0) { + oldImporter = t1._evaluate0$_importer; + oldStylesheet = t1._evaluate0$_assertInModule$2(t1._evaluate0$__stylesheet, "_stylesheet"); + oldInDependency = t1._evaluate0$_inDependency; + t1._evaluate0$_importer = importer; + t1._evaluate0$__stylesheet = stylesheet; + t1._evaluate0$_inDependency = isDependency; + t1.visitStylesheet$1(0, stylesheet); + t1._evaluate0$_importer = oldImporter; + t1._evaluate0$__stylesheet = oldStylesheet; + t1._evaluate0$_inDependency = oldInDependency; + t1._evaluate0$_activeModules.remove$1(0, url); + return; + } + t2 = new A.UnmodifiableListView(t2, t3); + if (!t2.any$1(t2, new A._EvaluateVisitor__visitDynamicImport__closure8())) { + t2 = new A.UnmodifiableListView(stylesheet._stylesheet1$_forwards, type$.UnmodifiableListView_ForwardRule_2); + loadsUserDefinedModules = t2.any$1(t2, new A._EvaluateVisitor__visitDynamicImport__closure9()); + } else + loadsUserDefinedModules = true; + children = A._Cell$(); + t2 = t1._evaluate0$_environment; + t3 = type$.String; + t4 = type$.Module_Callable_2; + t5 = type$.AstNode_2; + t6 = A._setArrayType([], type$.JSArray_Module_Callable_2); + t7 = t2._environment0$_variables; + t7 = A._setArrayType(t7.slice(0), A._arrayInstanceType(t7)); + t8 = t2._environment0$_variableNodes; + t8 = A._setArrayType(t8.slice(0), A._arrayInstanceType(t8)); + t9 = t2._environment0$_functions; + t9 = A._setArrayType(t9.slice(0), A._arrayInstanceType(t9)); + t10 = t2._environment0$_mixins; + t10 = A._setArrayType(t10.slice(0), A._arrayInstanceType(t10)); + environment = A.Environment$_0(A.LinkedHashMap_LinkedHashMap$_empty(t3, t4), A.LinkedHashMap_LinkedHashMap$_empty(t3, t5), A.LinkedHashMap_LinkedHashMap$_empty(t4, t5), t2._environment0$_importedModules, null, null, t6, t7, t8, t9, t10, t2._environment0$_content); + t1._evaluate0$_withEnvironment$2(environment, new A._EvaluateVisitor__visitDynamicImport__closure10(_box_0, t1, loadsUserDefinedModules, environment, children)); + module = environment.toDummyModule$0(); + t1._evaluate0$_environment.importForwards$1(module); + if (loadsUserDefinedModules) { + if (module.transitivelyContainsCss) + t1._evaluate0$_combineCss$2$clone(module, module.transitivelyContainsExtensions).accept$1(t1); + visitor = new A._ImportedCssVisitor1(t1); + for (t2 = J.get$iterator$ax(children._readLocal$0()); t2.moveNext$0();) + t2.get$current(t2).accept$1(visitor); + } + t1._evaluate0$_activeModules.remove$1(0, url); + }, + $signature: 0 + }; + A._EvaluateVisitor__visitDynamicImport__closure7.prototype = { + call$1(previousLoad) { + return this.$this._evaluate0$_multiSpanException$3("This file is already being loaded.", "new load", A.LinkedHashMap_LinkedHashMap$_literal([previousLoad.get$span(previousLoad), "original load"], type$.FileSpan, type$.String)); + }, + $signature: 99 + }; + A._EvaluateVisitor__visitDynamicImport__closure8.prototype = { + call$1(rule) { + return rule.url.get$scheme() !== "sass"; + }, + $signature: 215 + }; + A._EvaluateVisitor__visitDynamicImport__closure9.prototype = { + call$1(rule) { + return rule.url.get$scheme() !== "sass"; + }, + $signature: 216 + }; + A._EvaluateVisitor__visitDynamicImport__closure10.prototype = { + call$0() { + var t3, t4, _this = this, + t1 = _this.$this, + oldImporter = t1._evaluate0$_importer, + oldStylesheet = t1._evaluate0$_assertInModule$2(t1._evaluate0$__stylesheet, "_stylesheet"), + oldRoot = t1._evaluate0$_assertInModule$2(t1._evaluate0$__root, "_root"), + oldParent = t1._evaluate0$_assertInModule$2(t1._evaluate0$__parent, "__parent"), + oldEndOfImports = t1._evaluate0$_assertInModule$2(t1._evaluate0$__endOfImports, "_endOfImports"), + oldOutOfOrderImports = t1._evaluate0$_outOfOrderImports, + oldConfiguration = t1._evaluate0$_configuration, + oldInDependency = t1._evaluate0$_inDependency, + t2 = _this._box_0; + t1._evaluate0$_importer = t2.importer; + t3 = t2.stylesheet; + t1._evaluate0$__stylesheet = t3; + t4 = _this.loadsUserDefinedModules; + if (t4) { + t3 = A.ModifiableCssStylesheet$0(t3.span); + t1._evaluate0$__root = t3; + t1._evaluate0$__parent = t1._evaluate0$_assertInModule$2(t3, "_root"); + t1._evaluate0$__endOfImports = 0; + t1._evaluate0$_outOfOrderImports = null; + } + t1._evaluate0$_inDependency = t2.isDependency; + t3 = new A.UnmodifiableListView(t2.stylesheet._stylesheet1$_forwards, type$.UnmodifiableListView_ForwardRule_2); + if (!t3.get$isEmpty(t3)) + t1._evaluate0$_configuration = _this.environment.toImplicitConfiguration$0(); + t1.visitStylesheet$1(0, t2.stylesheet); + t2 = t4 ? t1._evaluate0$_addOutOfOrderImports$0() : A._setArrayType([], type$.JSArray_ModifiableCssNode_2); + _this.children.__late_helper$_value = t2; + t1._evaluate0$_importer = oldImporter; + t1._evaluate0$__stylesheet = oldStylesheet; + if (t4) { + t1._evaluate0$__root = oldRoot; + t1._evaluate0$__parent = oldParent; + t1._evaluate0$__endOfImports = oldEndOfImports; + t1._evaluate0$_outOfOrderImports = oldOutOfOrderImports; + } + t1._evaluate0$_configuration = oldConfiguration; + t1._evaluate0$_inDependency = oldInDependency; + }, + $signature: 1 + }; + A._EvaluateVisitor__applyMixin_closure3.prototype = { + call$0() { + var _this = this, + t1 = _this.$this; + t1._evaluate0$_environment.asMixin$1(new A._EvaluateVisitor__applyMixin__closure4(t1, _this.$arguments, _this.mixin, _this.nodeWithSpanWithoutContent)); + }, + $signature: 0 + }; + A._EvaluateVisitor__applyMixin__closure4.prototype = { + call$0() { + var _this = this; + _this.$this._evaluate0$_runBuiltInCallable$3(_this.$arguments, _this.mixin, _this.nodeWithSpanWithoutContent); + }, + $signature: 0 + }; + A._EvaluateVisitor__applyMixin_closure4.prototype = { + call$0() { + var _this = this, + t1 = _this.$this; + t1._evaluate0$_environment.withContent$2(_this.contentCallable, new A._EvaluateVisitor__applyMixin__closure3(t1, _this.mixin, _this.nodeWithSpanWithoutContent)); + }, + $signature: 1 + }; + A._EvaluateVisitor__applyMixin__closure3.prototype = { + call$0() { + var t1 = this.$this; + t1._evaluate0$_environment.asMixin$1(new A._EvaluateVisitor__applyMixin___closure1(t1, this.mixin, this.nodeWithSpanWithoutContent)); + }, + $signature: 0 + }; + A._EvaluateVisitor__applyMixin___closure1.prototype = { + call$0() { + var t1, t2, t3, t4, _i; + for (t1 = this.mixin.declaration.children, t2 = t1.length, t3 = this.$this, t4 = this.nodeWithSpanWithoutContent, _i = 0; _i < t2; ++_i) + t3._evaluate0$_addErrorSpan$2(t4, new A._EvaluateVisitor__applyMixin____closure1(t3, t1[_i])); + }, + $signature: 0 + }; + A._EvaluateVisitor__applyMixin____closure1.prototype = { + call$0() { + return this.statement.accept$1(this.$this); + }, + $signature: 44 + }; + A._EvaluateVisitor_visitIncludeRule_closure5.prototype = { + call$0() { + var t1 = this.node; + return this.$this._evaluate0$_environment.getMixin$2$namespace(t1.name, t1.namespace); + }, + $signature: 103 + }; + A._EvaluateVisitor_visitIncludeRule_closure6.prototype = { + call$1($content) { + var t1 = this.$this; + return new A.UserDefinedCallable0($content, t1._evaluate0$_environment.closure$0(), t1._evaluate0$_inDependency, type$.UserDefinedCallable_Environment_2); + }, + $signature: 461 + }; + A._EvaluateVisitor_visitIncludeRule_closure7.prototype = { + call$0() { + return this.node.get$spanWithoutContent(); + }, + $signature: 29 + }; + A._EvaluateVisitor_visitMediaRule_closure5.prototype = { + call$1(mediaQueries) { + return this.$this._evaluate0$_mergeMediaQueries$2(mediaQueries, this.queries); + }, + $signature: 104 + }; + A._EvaluateVisitor_visitMediaRule_closure6.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this.mergedQueries; + if (t2 == null) + t2 = _this.queries; + t1._evaluate0$_withMediaQueries$3(t2, _this.mergedSources, new A._EvaluateVisitor_visitMediaRule__closure1(t1, _this.node)); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitMediaRule__closure1.prototype = { + call$0() { + var t2, t3, _i, + t1 = this.$this, + _0_0 = t1._evaluate0$_atRootExcludingStyleRule ? null : t1._evaluate0$_styleRuleIgnoringAtRoot; + if (_0_0 != null) + t1._evaluate0$_withParent$2$3$scopeWhen(A.ModifiableCssStyleRule$0(_0_0._style_rule0$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitMediaRule___closure1(t1, this.node), false, type$.ModifiableCssStyleRule_2, type$.Null); + else + for (t2 = this.node.children, t3 = t2.length, _i = 0; _i < t3; ++_i) + t2[_i].accept$1(t1); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitMediaRule___closure1.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.node.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitMediaRule_closure7.prototype = { + call$1(node) { + var t1; + if (!(node instanceof A.ModifiableCssStyleRule0)) { + t1 = this.mergedSources; + t1 = t1.get$isNotEmpty(t1) && node instanceof A.ModifiableCssMediaRule0 && B.JSArray_methods.every$1(node.queries, t1.get$contains(t1)); + } else + t1 = true; + return t1; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitStyleRule_closure7.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.node.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitStyleRule_closure8.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitStyleRule_closure10.prototype = { + call$0() { + var t1 = this.$this; + t1._evaluate0$_withStyleRule$2(this.rule, new A._EvaluateVisitor_visitStyleRule__closure1(t1, this.node)); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitStyleRule__closure1.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.node.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitStyleRule_closure9.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor__warnForBogusCombinators_closure1.prototype = { + call$1(child) { + return child instanceof A.ModifiableCssComment0; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitSupportsRule_closure3.prototype = { + call$0() { + var t2, t3, _i, + t1 = this.$this, + _0_0 = t1._evaluate0$_atRootExcludingStyleRule ? null : t1._evaluate0$_styleRuleIgnoringAtRoot; + if (_0_0 != null) + t1._evaluate0$_withParent$2$2(A.ModifiableCssStyleRule$0(_0_0._style_rule0$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitSupportsRule__closure1(t1, this.node), type$.ModifiableCssStyleRule_2, type$.Null); + else + for (t2 = this.node.children, t3 = t2.length, _i = 0; _i < t3; ++_i) + t2[_i].accept$1(t1); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitSupportsRule__closure1.prototype = { + call$0() { + var t1, t2, t3, _i; + for (t1 = this.node.children, t2 = t1.length, t3 = this.$this, _i = 0; _i < t2; ++_i) + t1[_i].accept$1(t3); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitSupportsRule_closure4.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor__visitSupportsCondition_closure1.prototype = { + call$0() { + var t4, + t1 = this.$this, + t2 = this._box_0, + t3 = t2.declaration.name; + t3 = t1._evaluate0$_serialize$3$quote(t3.accept$1(t1), t3, true); + t4 = t2.declaration.get$isCustomProperty() ? "" : " "; + t2 = t2.declaration.value; + return "(" + t3 + ":" + t4 + t1._evaluate0$_serialize$3$quote(t2.accept$1(t1), t2, true) + ")"; + }, + $signature: 26 + }; + A._EvaluateVisitor_visitVariableDeclaration_closure5.prototype = { + call$0() { + var t1 = this.$this._evaluate0$_environment, + t2 = this._box_0.override; + t1.setVariable$4$global(this.node.name, t2.value, t2.assignmentNode, true); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitVariableDeclaration_closure6.prototype = { + call$0() { + var t1 = this.node; + return this.$this._evaluate0$_environment.getVariable$2$namespace(t1.name, t1.namespace); + }, + $signature: 44 + }; + A._EvaluateVisitor_visitVariableDeclaration_closure7.prototype = { + call$0() { + var t1 = this.$this, + t2 = this.node; + t1._evaluate0$_environment.setVariable$5$global$namespace(t2.name, this.value, t1._evaluate0$_expressionNode$1(t2.expression), t2.isGlobal, t2.namespace); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitUseRule_closure1.prototype = { + call$2(module, firstLoad) { + var t1, t2, t3, _0_0, t4, t5, span; + if (firstLoad) + this.$this._evaluate0$_registerCommentsForModule$1(module); + t1 = this.$this._evaluate0$_environment; + t2 = this.node; + t3 = t2.namespace; + if (t3 == null) { + t1._environment0$_globalModules.$indexSet(0, module, t2); + t1._environment0$_allModules.push(module); + _0_0 = A.IterableExtension_firstWhereOrNull(J.get$keys$z(B.JSArray_methods.get$first(t1._environment0$_variables)), module.get$variables().get$containsKey()); + if (_0_0 != null) + A.throwExpression(A.SassScriptException$0(string$.This_ma + _0_0 + '".', null)); + } else { + t4 = t1._environment0$_modules; + if (t4.containsKey$1(t3)) { + t5 = t1._environment0$_namespaceNodes.$index(0, t3); + span = t5 == null ? null : t5.span; + t5 = A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String); + if (span != null) + t5.$indexSet(0, span, "original @use"); + A.throwExpression(A.MultiSpanSassScriptException$0(string$.There_ + t3 + '".', "new @use", t5)); + } + t4.$indexSet(0, t3, module); + t1._environment0$_namespaceNodes.$indexSet(0, t3, t2); + t1._environment0$_allModules.push(module); + } + }, + $signature: 102 + }; + A._EvaluateVisitor_visitWarnRule_closure1.prototype = { + call$0() { + return this.node.expression.accept$1(this.$this); + }, + $signature: 49 + }; + A._EvaluateVisitor_visitWhileRule_closure1.prototype = { + call$0() { + var t1, t2, t3, _0_0; + for (t1 = this.node, t2 = t1.condition, t3 = this.$this, t1 = t1.children; t2.accept$1(t3).get$isTruthy();) { + _0_0 = t3._evaluate0$_handleReturn$2(t1, new A._EvaluateVisitor_visitWhileRule__closure1(t3)); + if (_0_0 != null) + return _0_0; + } + return null; + }, + $signature: 44 + }; + A._EvaluateVisitor_visitWhileRule__closure1.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 94 + }; + A._EvaluateVisitor_visitBinaryOperationExpression_closure1.prototype = { + call$0() { + var t1 = this.node, + t2 = this.$this, + left = t1.left.accept$1(t2); + switch (t1.operator) { + case B.BinaryOperator_Kyq0: + t1 = t1.right.accept$1(t2); + t1 = new A.SassString0(A.serializeValue0(left, false, true) + "=" + A.serializeValue0(t1, false, true), false); + break; + case B.BinaryOperator_tKu0: + t1 = left.get$isTruthy() ? left : t1.right.accept$1(t2); + break; + case B.BinaryOperator_uke0: + t1 = left.get$isTruthy() ? t1.right.accept$1(t2) : left; + break; + case B.BinaryOperator_r840: + t1 = left.$eq(0, t1.right.accept$1(t2)) ? B.SassBoolean_true0 : B.SassBoolean_false0; + break; + case B.BinaryOperator_qGq0: + t1 = !left.$eq(0, t1.right.accept$1(t2)) ? B.SassBoolean_true0 : B.SassBoolean_false0; + break; + case B.BinaryOperator_o8O0: + t1 = left.greaterThan$1(t1.right.accept$1(t2)); + break; + case B.BinaryOperator_JiR0: + t1 = left.greaterThanOrEquals$1(t1.right.accept$1(t2)); + break; + case B.BinaryOperator_qHy0: + t1 = left.lessThan$1(t1.right.accept$1(t2)); + break; + case B.BinaryOperator_FPG0: + t1 = left.lessThanOrEquals$1(t1.right.accept$1(t2)); + break; + case B.BinaryOperator_Swh0: + t1 = left.plus$1(t1.right.accept$1(t2)); + break; + case B.BinaryOperator_QG10: + t1 = left.minus$1(t1.right.accept$1(t2)); + break; + case B.BinaryOperator_tht0: + t1 = left.times$1(t1.right.accept$1(t2)); + break; + case B.BinaryOperator_Mh50: + t1 = t2._evaluate0$_slash$3(left, t1.right.accept$1(t2), t1); + break; + case B.BinaryOperator_s7T0: + t1 = left.modulo$1(t1.right.accept$1(t2)); + break; + default: + t1 = null; + } + return t1; + }, + $signature: 49 + }; + A._EvaluateVisitor__slash_recommendation1.prototype = { + call$1(expression) { + var t1; + $label0$0: { + if (expression instanceof A.BinaryOperationExpression0 && B.BinaryOperator_Mh50 === expression.operator) { + t1 = "math.div(" + A.S(this.call$1(expression.left)) + ", " + A.S(this.call$1(expression.right)) + ")"; + break $label0$0; + } + if (expression instanceof A.ParenthesizedExpression0) { + t1 = expression.expression.toString$0(0); + break $label0$0; + } + t1 = expression.toString$0(0); + break $label0$0; + } + return t1; + }, + $signature: 113 + }; + A._EvaluateVisitor_visitVariableExpression_closure1.prototype = { + call$0() { + var t1 = this.node; + return this.$this._evaluate0$_environment.getVariable$2$namespace(t1.name, t1.namespace); + }, + $signature: 44 + }; + A._EvaluateVisitor_visitUnaryOperationExpression_closure1.prototype = { + call$0() { + var t1, _this = this; + switch (_this.node.operator) { + case B.UnaryOperator_Rbl0: + t1 = _this.operand.unaryPlus$0(); + break; + case B.UnaryOperator_UCP0: + t1 = _this.operand.unaryMinus$0(); + break; + case B.UnaryOperator_lZV0: + t1 = new A.SassString0("/" + A.serializeValue0(_this.operand, false, true), false); + break; + case B.UnaryOperator_not_not_not0: + t1 = _this.operand.unaryNot$0(); + break; + default: + t1 = null; + } + return t1; + }, + $signature: 49 + }; + A._EvaluateVisitor_visitListExpression_closure1.prototype = { + call$1(expression) { + return expression.accept$1(this.$this); + }, + $signature: 462 + }; + A._EvaluateVisitor_visitFunctionExpression_closure5.prototype = { + call$0() { + var t1 = this.node; + return this.$this._evaluate0$_environment.getFunction$2$namespace(t1.name, t1.namespace); + }, + $signature: 103 + }; + A._EvaluateVisitor_visitFunctionExpression_closure6.prototype = { + call$1(argument) { + return argument.accept$1(B.C_IsCalculationSafeVisitor0); + }, + $signature: 140 + }; + A._EvaluateVisitor_visitFunctionExpression_closure7.prototype = { + call$0() { + var t1 = this.node; + return this.$this._evaluate0$_runFunctionCallable$3(t1.$arguments, this._box_0.$function, t1); + }, + $signature: 49 + }; + A._EvaluateVisitor__visitCalculation_closure1.prototype = { + call$2(message, deprecation) { + return this.$this._evaluate0$_warn$3(message, this.node.span, deprecation); + }, + call$1(message) { + return this.call$2(message, null); + }, + $signature: 110 + }; + A._EvaluateVisitor__checkCalculationArguments_check1.prototype = { + call$1(maxArgs) { + var t1 = this.node, + t2 = t1.$arguments.positional.length; + if (t2 === 0) + throw A.wrapException(this.$this._evaluate0$_exception$2("Missing argument.", t1.span)); + else if (maxArgs != null && t2 > maxArgs) + throw A.wrapException(this.$this._evaluate0$_exception$2("Only " + A.S(maxArgs) + " " + A.pluralize0("argument", maxArgs, null) + " allowed, but " + t2 + " " + A.pluralize0("was", t2, "were") + " passed.", t1.span)); + }, + call$0() { + return this.call$1(null); + }, + $signature: 106 + }; + A._EvaluateVisitor__visitCalculationExpression_closure1.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this._box_0, + t3 = _this.node, + t4 = _this.inLegacySassFunction; + return A.SassCalculation_operateInternal0(t1._evaluate0$_binaryOperatorToCalculationOperator$2(t2.operator, t3), t1._evaluate0$_visitCalculationExpression$2$inLegacySassFunction(t2.left, t4), t1._evaluate0$_visitCalculationExpression$2$inLegacySassFunction(t2.right, t4), t4, !t1._evaluate0$_inSupportsDeclaration, new A._EvaluateVisitor__visitCalculationExpression__closure1(t1, t3)); + }, + $signature: 84 + }; + A._EvaluateVisitor__visitCalculationExpression__closure1.prototype = { + call$2(message, deprecation) { + return this.$this._evaluate0$_warn$3(message, this.node.get$span(0), deprecation); + }, + call$1(message) { + return this.call$2(message, null); + }, + $signature: 110 + }; + A._EvaluateVisitor_visitInterpolatedFunctionExpression_closure1.prototype = { + call$0() { + var t1 = this.node; + return this.$this._evaluate0$_runFunctionCallable$3(t1.$arguments, this.$function, t1); + }, + $signature: 49 + }; + A._EvaluateVisitor__runUserDefinedCallable_closure1.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this.callable; + return t1._evaluate0$_withEnvironment$2(t2.environment.closure$0(), new A._EvaluateVisitor__runUserDefinedCallable__closure1(t1, _this.evaluated, t2, _this.nodeWithSpan, _this.run, _this.V)); + }, + $signature() { + return this.V._eval$1("0()"); + } + }; + A._EvaluateVisitor__runUserDefinedCallable__closure1.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this.V; + return t1._evaluate0$_environment.scope$1$1(new A._EvaluateVisitor__runUserDefinedCallable___closure1(t1, _this.evaluated, _this.callable, _this.nodeWithSpan, _this.run, t2), t2); + }, + $signature() { + return this.V._eval$1("0()"); + } + }; + A._EvaluateVisitor__runUserDefinedCallable___closure1.prototype = { + call$0() { + var parameters, t5, minLength, i, parameter, t6, value, t7, t8, restParameter, rest, argumentList, result, parameterWord, _this = this, + t1 = _this.$this, + t2 = _this.evaluated._values, + t3 = _this.callable.declaration.parameters, + t4 = _this.nodeWithSpan; + t1._evaluate0$_verifyArguments$4(t2[2].length, t2[0], t3, t4); + parameters = t3.parameters; + t5 = parameters.length; + minLength = Math.min(t2[2].length, t5); + for (i = 0; i < minLength; ++i) + t1._evaluate0$_environment.setLocalVariable$3(parameters[i].name, t2[2][i], t2[3][i]); + for (i = t2[2].length; i < t5; ++i) { + parameter = parameters[i]; + t6 = parameter.name; + value = t2[0].remove$1(0, t6); + if (value == null) { + t7 = parameter.defaultValue; + value = t1._evaluate0$_withoutSlash$2(t7.accept$1(t1), t1._evaluate0$_expressionNode$1(t7)); + } + t7 = t1._evaluate0$_environment; + t8 = t2[1].$index(0, t6); + if (t8 == null) { + t8 = parameter.defaultValue; + t8.toString; + t8 = t1._evaluate0$_expressionNode$1(t8); + } + t7.setLocalVariable$3(t6, value, t8); + } + restParameter = t3.restParameter; + if (restParameter != null) { + t6 = t2[2]; + rest = t6.length > t5 ? B.JSArray_methods.sublist$1(t6, t5) : B.List_empty20; + t5 = t2[0]; + t6 = t2[4]; + argumentList = A.SassArgumentList$0(rest, t5, t6 === B.ListSeparator_undecided_null_undecided0 ? B.ListSeparator_qVN0 : t6); + t1._evaluate0$_environment.setLocalVariable$3(restParameter, argumentList, t4); + } else + argumentList = null; + result = _this.run.call$0(); + if (argumentList == null) + return result; + t5 = t2[0].__js_helper$_length; + if (t5 === 0) + return result; + if (argumentList._argument_list$_wereKeywordsAccessed) + return result; + parameterWord = A.pluralize0("parameter", t5, null); + t2 = t2[0]; + t5 = A._instanceType(t2)._eval$1("LinkedHashMapKeysIterable<1>"); + throw A.wrapException(A.MultiSpanSassRuntimeException$0("No " + parameterWord + " named " + A.toSentence0(A.MappedIterable_MappedIterable(new A.LinkedHashMapKeysIterable(t2, t5), new A._EvaluateVisitor__runUserDefinedCallable____closure1(), t5._eval$1("Iterable.E"), type$.Object), "or") + ".", t4.get$span(t4), "invocation", A.LinkedHashMap_LinkedHashMap$_literal([t3.get$spanWithName(), "declaration"], type$.FileSpan, type$.String), t1._evaluate0$_stackTrace$1(t4.get$span(t4)), null)); + }, + $signature() { + return this.V._eval$1("0()"); + } + }; + A._EvaluateVisitor__runUserDefinedCallable____closure1.prototype = { + call$1($name) { + return "$" + $name; + }, + $signature: 6 + }; + A._EvaluateVisitor__runFunctionCallable_closure1.prototype = { + call$0() { + var t1, t2, t3, t4, _i, $returnValue; + for (t1 = this.callable.declaration, t2 = t1.children, t3 = t2.length, t4 = this.$this, _i = 0; _i < t3; ++_i) { + $returnValue = t2[_i].accept$1(t4); + if ($returnValue instanceof A.Value0) + return $returnValue; + } + throw A.wrapException(t4._evaluate0$_exception$2("Function finished without @return.", t1.span)); + }, + $signature: 49 + }; + A._EvaluateVisitor__runBuiltInCallable_closure5.prototype = { + call$0() { + return this._box_0.overload.verify$2(this.evaluated._values[2].length, this.namedSet); + }, + $signature: 0 + }; + A._EvaluateVisitor__runBuiltInCallable_closure6.prototype = { + call$0() { + return this._box_0.callback.call$1(this.evaluated._values[2]); + }, + $signature: 49 + }; + A._EvaluateVisitor__runBuiltInCallable_closure7.prototype = { + call$1($name) { + return "$" + $name; + }, + $signature: 6 + }; + A._EvaluateVisitor__evaluateArguments_closure7.prototype = { + call$1(value) { + return value; + }, + $signature: 43 + }; + A._EvaluateVisitor__evaluateArguments_closure8.prototype = { + call$1(value) { + return this.$this._evaluate0$_withoutSlash$2(value, this.restNodeForSpan); + }, + $signature: 43 + }; + A._EvaluateVisitor__evaluateArguments_closure9.prototype = { + call$2(key, value) { + var _this = this, + t1 = _this.restNodeForSpan; + _this.named.$indexSet(0, key, _this.$this._evaluate0$_withoutSlash$2(value, t1)); + _this.namedNodes.$indexSet(0, key, t1); + }, + $signature: 109 + }; + A._EvaluateVisitor__evaluateArguments_closure10.prototype = { + call$1(value) { + return value; + }, + $signature: 43 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure7.prototype = { + call$1(value) { + var t1 = this.restArgs; + return new A.ValueExpression0(value, t1.get$span(t1)); + }, + $signature: 65 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure8.prototype = { + call$1(value) { + var t1 = this.restArgs; + return new A.ValueExpression0(this.$this._evaluate0$_withoutSlash$2(value, this.restNodeForSpan), t1.get$span(t1)); + }, + $signature: 65 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure9.prototype = { + call$2(key, value) { + var _this = this, + t1 = _this.restArgs; + _this.named.$indexSet(0, key, new A.ValueExpression0(_this.$this._evaluate0$_withoutSlash$2(value, _this.restNodeForSpan), t1.get$span(t1))); + }, + $signature: 109 + }; + A._EvaluateVisitor__evaluateMacroArguments_closure10.prototype = { + call$1(value) { + var t1 = this.keywordRestArgs; + return new A.ValueExpression0(this.$this._evaluate0$_withoutSlash$2(value, this.keywordRestNodeForSpan), t1.get$span(t1)); + }, + $signature: 65 + }; + A._EvaluateVisitor__addRestMap_closure1.prototype = { + call$2(key, value) { + var t2, _this = this, + t1 = _this.$this; + if (key instanceof A.SassString0) + _this.values.$indexSet(0, key._string0$_text, _this.convert.call$1(t1._evaluate0$_withoutSlash$2(value, _this.expressionNode))); + else { + t2 = _this.nodeWithSpan; + throw A.wrapException(t1._evaluate0$_exception$2(string$.Variab_ + key.toString$0(0) + " is not a string in " + _this.map.toString$0(0) + ".", t2.get$span(t2))); + } + }, + $signature: 98 + }; + A._EvaluateVisitor__verifyArguments_closure1.prototype = { + call$0() { + return this.parameters.verify$2(this.positional, new A.MapKeySet(this.named, type$.MapKeySet_String)); + }, + $signature: 0 + }; + A._EvaluateVisitor_visitCssAtRule_closure3.prototype = { + call$0() { + var t1, t2, t3, t4; + for (t1 = this.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = this.$this, t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t4 = t1.__internal$_current; + (t4 == null ? t2._as(t4) : t4).accept$1(t3); + } + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssAtRule_closure4.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitCssKeyframeBlock_closure3.prototype = { + call$0() { + var t1, t2, t3, t4; + for (t1 = this.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = this.$this, t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t4 = t1.__internal$_current; + (t4 == null ? t2._as(t4) : t4).accept$1(t3); + } + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssKeyframeBlock_closure4.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitCssMediaRule_closure5.prototype = { + call$1(mediaQueries) { + return this.$this._evaluate0$_mergeMediaQueries$2(mediaQueries, this.node.queries); + }, + $signature: 104 + }; + A._EvaluateVisitor_visitCssMediaRule_closure6.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this.mergedQueries; + if (t2 == null) + t2 = _this.node.queries; + t1._evaluate0$_withMediaQueries$3(t2, _this.mergedSources, new A._EvaluateVisitor_visitCssMediaRule__closure1(t1, _this.node)); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssMediaRule__closure1.prototype = { + call$0() { + var t2, t3, t4, + t1 = this.$this, + _0_0 = t1._evaluate0$_atRootExcludingStyleRule ? null : t1._evaluate0$_styleRuleIgnoringAtRoot; + if (_0_0 != null) + t1._evaluate0$_withParent$2$3$scopeWhen(A.ModifiableCssStyleRule$0(_0_0._style_rule0$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitCssMediaRule___closure1(t1, this.node), false, type$.ModifiableCssStyleRule_2, type$.Null); + else + for (t2 = this.node.children, t3 = t2.$ti, t2 = new A.ListIterator(t2, t2.get$length(0), t3._eval$1("ListIterator")), t3 = t3._eval$1("ListBase.E"); t2.moveNext$0();) { + t4 = t2.__internal$_current; + (t4 == null ? t3._as(t4) : t4).accept$1(t1); + } + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssMediaRule___closure1.prototype = { + call$0() { + var t1, t2, t3, t4; + for (t1 = this.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = this.$this, t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t4 = t1.__internal$_current; + (t4 == null ? t2._as(t4) : t4).accept$1(t3); + } + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssMediaRule_closure7.prototype = { + call$1(node) { + var t1; + if (!(node instanceof A.ModifiableCssStyleRule0)) { + t1 = this.mergedSources; + t1 = t1.get$isNotEmpty(t1) && node instanceof A.ModifiableCssMediaRule0 && B.JSArray_methods.every$1(node.queries, t1.get$contains(t1)); + } else + t1 = true; + return t1; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitCssStyleRule_closure4.prototype = { + call$0() { + var t1 = this.$this; + t1._evaluate0$_withStyleRule$2(this.rule, new A._EvaluateVisitor_visitCssStyleRule__closure1(t1, this.node)); + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssStyleRule__closure1.prototype = { + call$0() { + var t1, t2, t3, t4; + for (t1 = this.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = this.$this, t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t4 = t1.__internal$_current; + (t4 == null ? t2._as(t4) : t4).accept$1(t3); + } + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssStyleRule_closure3.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor_visitCssSupportsRule_closure3.prototype = { + call$0() { + var t2, t3, t4, + t1 = this.$this, + _0_0 = t1._evaluate0$_atRootExcludingStyleRule ? null : t1._evaluate0$_styleRuleIgnoringAtRoot; + if (_0_0 != null) + t1._evaluate0$_withParent$2$2(A.ModifiableCssStyleRule$0(_0_0._style_rule0$_selector, _0_0.span, false, _0_0.originalSelector), new A._EvaluateVisitor_visitCssSupportsRule__closure1(t1, this.node), type$.ModifiableCssStyleRule_2, type$.Null); + else + for (t2 = this.node.children, t3 = t2.$ti, t2 = new A.ListIterator(t2, t2.get$length(0), t3._eval$1("ListIterator")), t3 = t3._eval$1("ListBase.E"); t2.moveNext$0();) { + t4 = t2.__internal$_current; + (t4 == null ? t3._as(t4) : t4).accept$1(t1); + } + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssSupportsRule__closure1.prototype = { + call$0() { + var t1, t2, t3, t4; + for (t1 = this.node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t3 = this.$this, t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t4 = t1.__internal$_current; + (t4 == null ? t2._as(t4) : t4).accept$1(t3); + } + }, + $signature: 1 + }; + A._EvaluateVisitor_visitCssSupportsRule_closure4.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluateVisitor__performInterpolationHelper_closure1.prototype = { + call$1(targetLocations) { + return A.InterpolationMap$0(this.interpolation, targetLocations); + }, + $signature: 218 + }; + A._EvaluateVisitor__serialize_closure1.prototype = { + call$0() { + return A.serializeValue0(this.value, false, this.quote); + }, + $signature: 26 + }; + A._EvaluateVisitor__expressionNode_closure1.prototype = { + call$0() { + var t1 = this.expression; + return this.$this._evaluate0$_environment.getVariableNode$2$namespace(t1.name, t1.namespace); + }, + $signature: 219 + }; + A._EvaluateVisitor__withoutSlash_recommendation1.prototype = { + call$1(number) { + var before, after, t1, + _1_0 = number.asSlash; + $label0$0: { + if (type$.Record_2_nullable_Object_and_nullable_Object._is(_1_0)) { + before = _1_0._0; + after = _1_0._1; + t1 = "math.div(" + A.S(this.call$1(before)) + ", " + A.S(this.call$1(after)) + ")"; + break $label0$0; + } + t1 = A.serializeValue0(number, true, true); + break $label0$0; + } + return t1; + }, + $signature: 220 + }; + A._EvaluateVisitor__stackFrame_closure1.prototype = { + call$1(url) { + var t1 = this.$this._evaluate0$_importCache; + t1 = t1 == null ? null : t1.humanize$1(url); + return t1 == null ? url : t1; + }, + $signature: 50 + }; + A._ImportedCssVisitor1.prototype = { + visitCssAtRule$1(node) { + var t1 = node.isChildless ? null : new A._ImportedCssVisitor_visitCssAtRule_closure1(); + this._evaluate0$_visitor._evaluate0$_addChild$2$through(node, t1); + }, + visitCssComment$1(node) { + return this._evaluate0$_visitor._evaluate0$_addChild$1(node); + }, + visitCssDeclaration$1(node) { + }, + visitCssImport$1(node) { + var t2, + _s13_ = "_endOfImports", + t1 = this._evaluate0$_visitor; + if (t1._evaluate0$_assertInModule$2(t1._evaluate0$__parent, "__parent") !== t1._evaluate0$_assertInModule$2(t1._evaluate0$__root, "_root")) + t1._evaluate0$_addChild$1(node); + else if (t1._evaluate0$_assertInModule$2(t1._evaluate0$__endOfImports, _s13_) === J.get$length$asx(t1._evaluate0$_assertInModule$2(t1._evaluate0$__root, "_root").children._collection$_source)) { + t1._evaluate0$_addChild$1(node); + t1._evaluate0$__endOfImports = t1._evaluate0$_assertInModule$2(t1._evaluate0$__endOfImports, _s13_) + 1; + } else { + t2 = t1._evaluate0$_outOfOrderImports; + (t2 == null ? t1._evaluate0$_outOfOrderImports = A._setArrayType([], type$.JSArray_ModifiableCssImport_2) : t2).push(node); + } + }, + visitCssKeyframeBlock$1(node) { + }, + visitCssMediaRule$1(node) { + var t1 = this._evaluate0$_visitor, + mediaQueries = t1._evaluate0$_mediaQueries; + t1._evaluate0$_addChild$2$through(node, new A._ImportedCssVisitor_visitCssMediaRule_closure1(mediaQueries == null || t1._evaluate0$_mergeMediaQueries$2(mediaQueries, node.queries) != null)); + }, + visitCssStyleRule$1(node) { + return this._evaluate0$_visitor._evaluate0$_addChild$2$through(node, new A._ImportedCssVisitor_visitCssStyleRule_closure1()); + }, + visitCssStylesheet$1(node) { + var t1, t2, t3; + for (t1 = node.children, t2 = t1.$ti, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t3 = t1.__internal$_current; + (t3 == null ? t2._as(t3) : t3).accept$1(this); + } + }, + visitCssSupportsRule$1(node) { + return this._evaluate0$_visitor._evaluate0$_addChild$2$through(node, new A._ImportedCssVisitor_visitCssSupportsRule_closure1()); + } + }; + A._ImportedCssVisitor_visitCssAtRule_closure1.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._ImportedCssVisitor_visitCssMediaRule_closure1.prototype = { + call$1(node) { + var t1; + if (!(node instanceof A.ModifiableCssStyleRule0)) + t1 = this.hasBeenMerged && node instanceof A.ModifiableCssMediaRule0; + else + t1 = true; + return t1; + }, + $signature: 7 + }; + A._ImportedCssVisitor_visitCssStyleRule_closure1.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._ImportedCssVisitor_visitCssSupportsRule_closure1.prototype = { + call$1(node) { + return node instanceof A.ModifiableCssStyleRule0; + }, + $signature: 7 + }; + A._EvaluationContext1.prototype = { + get$currentCallableSpan() { + var _0_0 = this._evaluate0$_visitor._evaluate0$_callableNode; + if (_0_0 != null) + return _0_0.get$span(_0_0); + throw A.wrapException(A.StateError$(string$.No_Sasc)); + }, + warn$2(_, message, deprecation) { + var t1 = this._evaluate0$_visitor, + t2 = t1._evaluate0$_importSpan; + if (t2 == null) { + t2 = t1._evaluate0$_callableNode; + t2 = t2 == null ? null : t2.get$span(t2); + } + t1._evaluate0$_warn$3(message, t2 == null ? this._evaluate0$_defaultWarnNodeWithSpan.span : t2, deprecation); + }, + $isEvaluationContext0: 1 + }; + A.EveryCssVisitor0.prototype = { + visitCssAtRule$1(node) { + var t1 = node.children; + return t1.every$1(t1, new A.EveryCssVisitor_visitCssAtRule_closure0(this)); + }, + visitCssComment$1(node) { + return false; + }, + visitCssDeclaration$1(node) { + return false; + }, + visitCssImport$1(node) { + return false; + }, + visitCssKeyframeBlock$1(node) { + var t1 = node.children; + return t1.every$1(t1, new A.EveryCssVisitor_visitCssKeyframeBlock_closure0(this)); + }, + visitCssMediaRule$1(node) { + var t1 = node.children; + return t1.every$1(t1, new A.EveryCssVisitor_visitCssMediaRule_closure0(this)); + }, + visitCssStyleRule$1(node) { + var t1 = node.children; + return t1.every$1(t1, new A.EveryCssVisitor_visitCssStyleRule_closure0(this)); + }, + visitCssStylesheet$1(node) { + return J.every$1$ax(node.get$children(node), new A.EveryCssVisitor_visitCssStylesheet_closure0(this)); + }, + visitCssSupportsRule$1(node) { + var t1 = node.children; + return t1.every$1(t1, new A.EveryCssVisitor_visitCssSupportsRule_closure0(this)); + } + }; + A.EveryCssVisitor_visitCssAtRule_closure0.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 7 + }; + A.EveryCssVisitor_visitCssKeyframeBlock_closure0.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 7 + }; + A.EveryCssVisitor_visitCssMediaRule_closure0.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 7 + }; + A.EveryCssVisitor_visitCssStyleRule_closure0.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 7 + }; + A.EveryCssVisitor_visitCssStylesheet_closure0.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 7 + }; + A.EveryCssVisitor_visitCssSupportsRule_closure0.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature: 7 + }; + A._NodeException.prototype = {}; + A.exceptionClass_closure.prototype = { + call$0() { + var jsClass = type$.JSClass._as(new self.Function("", " return class Exception extends Error {\n constructor(dartException, message) {\n super(message);\n\n // Define this as non-enumerable so that it doesn't show up when the\n // exception hits the top level.\n Object.defineProperty(this, '_dartException', {\n value: dartException,\n enumerable: false\n });\n }\n\n toString() {\n return this.message;\n }\n }\n ").call$0()); + A.defineGetter(jsClass, "name", null, "sass.Exception"); + A.LinkedHashMap_LinkedHashMap$_literal(["sassMessage", new A.exceptionClass__closure(), "sassStack", new A.exceptionClass__closure0(), "span", new A.exceptionClass__closure1()], type$.String, type$.Function).forEach$1(0, A.JSClassExtension_get_defineGetter(jsClass)); + return jsClass; + }, + $signature: 15 + }; + A.exceptionClass__closure.prototype = { + call$1(exception) { + return J.get$_dartException$x(exception)._span_exception$_message; + }, + $signature: 242 + }; + A.exceptionClass__closure0.prototype = { + call$1(exception) { + return J.get$trace$z(J.get$_dartException$x(exception)).toString$0(0); + }, + $signature: 242 + }; + A.exceptionClass__closure1.prototype = { + call$1(exception) { + var t1 = J.get$_dartException$x(exception), + t2 = J.getInterceptor$z(t1); + return A.SourceSpanException.prototype.get$span.call(t2, t1); + }, + $signature: 464 + }; + A.SassException0.prototype = { + get$trace(_) { + return A.Trace$(A._setArrayType([A.frameForSpan0(A.SourceSpanException.prototype.get$span.call(this, 0), "root stylesheet", null)], type$.JSArray_Frame), null); + }, + get$span(_) { + return A.SourceSpanException.prototype.get$span.call(this, 0); + }, + withAdditionalSpan$2(span, label) { + return A.MultiSpanSassException$0(this._span_exception$_message, A.SourceSpanException.prototype.get$span.call(this, 0), "", A.LinkedHashMap_LinkedHashMap$_literal([span, label], type$.FileSpan, type$.String), this.loadedUrls); + }, + withTrace$1(trace) { + var t1 = A.SourceSpanException.prototype.get$span.call(this, 0), + t2 = A.Set_Set$unmodifiable(this.loadedUrls, type$.Uri); + return new A.SassRuntimeException0(trace, t2, this._span_exception$_message, t1); + }, + withLoadedUrls$1(loadedUrls) { + var t1 = A.SourceSpanException.prototype.get$span.call(this, 0), + t2 = A.Set_Set$unmodifiable(loadedUrls, type$.Uri); + return new A.SassException0(t2, this._span_exception$_message, t1); + }, + toString$1$color(_, color) { + var t2, _i, frame, t3, _this = this, + buffer = new A.StringBuffer(""), + t1 = "" + ("Error: " + _this._span_exception$_message + "\n"); + buffer._contents = t1; + buffer._contents = t1 + A.SourceSpanException.prototype.get$span.call(_this, 0).highlight$1$color(color); + for (t1 = _this.get$trace(_this).toString$0(0).split("\n"), t2 = t1.length, _i = 0; _i < t2; ++_i) { + frame = t1[_i]; + if (frame.length === 0) + continue; + t3 = buffer._contents += "\n"; + buffer._contents = t3 + (" " + frame); + } + t1 = buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + toString$0(_) { + return this.toString$1$color(0, null); + } + }; + A.MultiSpanSassException0.prototype = { + withAdditionalSpan$2(span, label) { + var _this = this, + t1 = A.SourceSpanException.prototype.get$span.call(_this, 0), + t2 = A.LinkedHashMap_LinkedHashMap$of(_this.secondarySpans, type$.FileSpan, type$.String); + t2.$indexSet(0, span, label); + return A.MultiSpanSassException$0(_this._span_exception$_message, t1, _this.primaryLabel, t2, _this.loadedUrls); + }, + withTrace$1(trace) { + var _this = this; + return A.MultiSpanSassRuntimeException$0(_this._span_exception$_message, A.SourceSpanException.prototype.get$span.call(_this, 0), _this.primaryLabel, _this.secondarySpans, trace, _this.loadedUrls); + }, + withLoadedUrls$1(loadedUrls) { + var _this = this; + return A.MultiSpanSassException$0(_this._span_exception$_message, A.SourceSpanException.prototype.get$span.call(_this, 0), _this.primaryLabel, _this.secondarySpans, loadedUrls); + }, + toString$1$color(_, color) { + var t1, t2, _i, frame, t3, _this = this, + useColor = color === true, + buffer = new A.StringBuffer("Error: " + _this._span_exception$_message + "\n"); + A.NullableExtension_andThen0(A.Highlighter$multiple(A.SourceSpanException.prototype.get$span.call(_this, 0), _this.primaryLabel, _this.secondarySpans, useColor, null, null).highlight$0(), buffer.get$write(buffer)); + for (t1 = _this.get$trace(_this).toString$0(0).split("\n"), t2 = t1.length, _i = 0; _i < t2; ++_i) { + frame = t1[_i]; + if (frame.length === 0) + continue; + t3 = buffer._contents += "\n"; + buffer._contents = t3 + (" " + frame); + } + t1 = buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + toString$0(_) { + return this.toString$1$color(0, null); + }, + get$primaryLabel() { + return this.primaryLabel; + }, + get$secondarySpans() { + return this.secondarySpans; + } + }; + A.SassRuntimeException0.prototype = { + withAdditionalSpan$2(span, label) { + var _this = this; + return A.MultiSpanSassRuntimeException$0(_this._span_exception$_message, A.SourceSpanException.prototype.get$span.call(_this, 0), "", A.LinkedHashMap_LinkedHashMap$_literal([span, label], type$.FileSpan, type$.String), _this.trace, _this.loadedUrls); + }, + withLoadedUrls$1(loadedUrls) { + var t1 = A.SourceSpanException.prototype.get$span.call(this, 0), + t2 = A.Set_Set$unmodifiable(loadedUrls, type$.Uri); + return new A.SassRuntimeException0(this.trace, t2, this._span_exception$_message, t1); + }, + get$trace(receiver) { + return this.trace; + } + }; + A.MultiSpanSassRuntimeException0.prototype = { + withAdditionalSpan$2(span, label) { + var _this = this, + t1 = A.SourceSpanException.prototype.get$span.call(_this, 0), + t2 = A.LinkedHashMap_LinkedHashMap$of(_this.secondarySpans, type$.FileSpan, type$.String); + t2.$indexSet(0, span, label); + return A.MultiSpanSassRuntimeException$0(_this._span_exception$_message, t1, _this.primaryLabel, t2, _this.trace, _this.loadedUrls); + }, + withLoadedUrls$1(loadedUrls) { + var _this = this; + return A.MultiSpanSassRuntimeException$0(_this._span_exception$_message, A.SourceSpanException.prototype.get$span.call(_this, 0), _this.primaryLabel, _this.secondarySpans, _this.trace, loadedUrls); + }, + $isSassRuntimeException0: 1, + get$trace(receiver) { + return this.trace; + } + }; + A.SassFormatException0.prototype = { + get$source() { + var t1 = A.SourceSpanException.prototype.get$span.call(this, 0); + return A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1.get$file(t1)._decodedChars, 0, null), 0, null); + }, + withAdditionalSpan$2(span, label) { + return A.MultiSpanSassFormatException$0(this._span_exception$_message, A.SourceSpanException.prototype.get$span.call(this, 0), "", A.LinkedHashMap_LinkedHashMap$_literal([span, label], type$.FileSpan, type$.String), this.loadedUrls); + }, + withLoadedUrls$1(loadedUrls) { + var t1 = A.SourceSpanException.prototype.get$span.call(this, 0), + t2 = A.Set_Set$unmodifiable(loadedUrls, type$.Uri); + return new A.SassFormatException0(t2, this._span_exception$_message, t1); + }, + $isFormatException: 1, + $isSourceSpanFormatException: 1 + }; + A.MultiSpanSassFormatException0.prototype = { + get$source() { + var t1 = A.SourceSpanException.prototype.get$span.call(this, 0); + return A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1.get$file(t1)._decodedChars, 0, null), 0, null); + }, + withAdditionalSpan$2(span, label) { + var _this = this, + t1 = A.SourceSpanException.prototype.get$span.call(_this, 0), + t2 = A.LinkedHashMap_LinkedHashMap$of(_this.secondarySpans, type$.FileSpan, type$.String); + t2.$indexSet(0, span, label); + return A.MultiSpanSassFormatException$0(_this._span_exception$_message, t1, _this.primaryLabel, t2, _this.loadedUrls); + }, + withLoadedUrls$1(loadedUrls) { + var _this = this; + return A.MultiSpanSassFormatException$0(_this._span_exception$_message, A.SourceSpanException.prototype.get$span.call(_this, 0), _this.primaryLabel, _this.secondarySpans, loadedUrls); + }, + $isFormatException: 1, + $isSourceSpanFormatException: 1, + $isMultiSourceSpanFormatException: 1, + $isSassFormatException0: 1 + }; + A.SassScriptException0.prototype = { + withSpan$1(span) { + return new A.SassException0(B.Set_empty, this.message, span); + }, + toString$0(_) { + return this.message + string$.x0a_BUG_; + }, + get$message(receiver) { + return this.message; + } + }; + A.MultiSpanSassScriptException0.prototype = { + withSpan$1(span) { + return A.MultiSpanSassException$0(this.message, span, this.primaryLabel, this.secondarySpans, null); + } + }; + A.Exports.prototype = {}; + A.LoggerNamespace.prototype = {}; + A.Expression0.prototype = {$isAstNode0: 1, $isSassNode: 1}; + A.JSExpressionVisitor.prototype = { + visitBinaryOperationExpression$1(_, node) { + return J.visitBinaryOperationExpression$1$x(this._expression$_inner, node); + }, + visitBooleanExpression$1(_, node) { + return J.visitBooleanExpression$1$x(this._expression$_inner, node); + }, + visitColorExpression$1(_, node) { + return J.visitColorExpression$1$x(this._expression$_inner, node); + }, + visitInterpolatedFunctionExpression$1(_, node) { + return J.visitInterpolatedFunctionExpression$1$x(this._expression$_inner, node); + }, + visitFunctionExpression$1(_, node) { + return J.visitFunctionExpression$1$x(this._expression$_inner, node); + }, + visitIfExpression$1(_, node) { + return J.visitIfExpression$1$x(this._expression$_inner, node); + }, + visitListExpression$1(_, node) { + return J.visitListExpression$1$x(this._expression$_inner, node); + }, + visitMapExpression$1(_, node) { + return J.visitMapExpression$1$x(this._expression$_inner, node); + }, + visitNullExpression$1(_, node) { + return J.visitNullExpression$1$x(this._expression$_inner, node); + }, + visitNumberExpression$1(_, node) { + return J.visitNumberExpression$1$x(this._expression$_inner, node); + }, + visitParenthesizedExpression$1(_, node) { + return J.visitParenthesizedExpression$1$x(this._expression$_inner, node); + }, + visitSelectorExpression$1(_, node) { + return J.visitSelectorExpression$1$x(this._expression$_inner, node); + }, + visitStringExpression$1(_, node) { + return J.visitStringExpression$1$x(this._expression$_inner, node); + }, + visitSupportsExpression$1(_, node) { + return J.visitSupportsExpression$1$x(this._expression$_inner, node); + }, + visitUnaryOperationExpression$1(_, node) { + return J.visitUnaryOperationExpression$1$x(this._expression$_inner, node); + }, + visitValueExpression$1(_, node) { + return J.visitValueExpression$1$x(this._expression$_inner, node); + }, + visitVariableExpression$1(_, node) { + return J.visitVariableExpression$1$x(this._expression$_inner, node); + }, + $isExpressionVisitor: 1 + }; + A.JSExpressionVisitorObject.prototype = {}; + A._MakeExpressionCalculationSafe0.prototype = { + visitBinaryOperationExpression$1(_, node) { + var t1, t2, t3, t4; + if (node.operator === B.BinaryOperator_s7T0) { + t1 = A._setArrayType([node], type$.JSArray_Expression_2); + t2 = node.get$span(0); + t3 = type$.Expression_2; + t1 = A.List_List$unmodifiable(t1, t3); + t3 = A.ConstantMap_ConstantMap$from(B.Map_empty14, type$.String, t3); + t4 = node.get$span(0); + t1 = new A.FunctionExpression0("math", A.stringReplaceAllUnchecked("max", "_", "-"), "max", new A.ArgumentList0(t1, t3, null, null, t2), t4); + } else + t1 = this.super$ReplaceExpressionVisitor$visitBinaryOperationExpression0(0, node); + return t1; + }, + visitInterpolatedFunctionExpression$1(_, node) { + return node; + }, + visitUnaryOperationExpression$1(_, node) { + var t1, + _0_0 = node.operator; + $label0$0: { + if (B.UnaryOperator_Rbl0 === _0_0) { + t1 = node.operand; + break $label0$0; + } + if (B.UnaryOperator_UCP0 === _0_0) { + t1 = new A.BinaryOperationExpression0(B.BinaryOperator_tht0, new A.NumberExpression0(-1, null, node.span), node.operand, false); + break $label0$0; + } + t1 = this.super$ReplaceExpressionVisitor$visitUnaryOperationExpression0(0, node); + break $label0$0; + } + return t1; + }, + $isExpressionVisitor: 1 + }; + A.__MakeExpressionCalculationSafe_Object_ReplaceExpressionVisitor0.prototype = {}; + A.ExtendRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitExtendRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.selector.toString$0(0), + t2 = this.isOptional ? " !optional" : ""; + return "@extend " + t1 + t2 + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A.Extension0.prototype = { + toString$0(_) { + var t1 = this.extender.toString$0(0), + t2 = this.target.toString$0(0), + t3 = this.isOptional ? " !optional" : ""; + return t1 + " {@extend " + t2 + t3 + "}"; + } + }; + A.Extender0.prototype = { + assertCompatibleMediaContext$1(mediaContext) { + var expectedMediaContext, + extension = this._extension$_extension; + if (extension == null) + return; + expectedMediaContext = extension.mediaContext; + if (expectedMediaContext == null) + return; + if (mediaContext != null && B.C_ListEquality.equals$2(0, expectedMediaContext, mediaContext)) + return; + throw A.wrapException(A.SassException$0(string$.You_ma, extension.span, null)); + }, + toString$0(_) { + return A.serializeSelector0(this.selector, true); + } + }; + A.ExtensionStore0.prototype = { + get$isEmpty(_) { + return this._extension_store$_extensions.__js_helper$_length === 0; + }, + get$simpleSelectors() { + return new A.MapKeySet(this._extension_store$_selectors, type$.MapKeySet_SimpleSelector_2); + }, + extensionsWhereTarget$1(callback) { + return new A._SyncStarIterable(this.extensionsWhereTarget$body$ExtensionStore0(callback), type$._SyncStarIterable_Extension_2); + }, + extensionsWhereTarget$body$ExtensionStore0($async$callback) { + var $async$self = this; + return function() { + var callback = $async$callback; + var $async$goto = 0, $async$handler = 1, $async$errorStack = [], t1, t2, simple, sources, t3; + return function $async$extensionsWhereTarget$1($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = A.MapExtensions_get_pairs0($async$self._extension_store$_extensions, type$.SimpleSelector_2, type$.Map_ComplexSelector_Extension_2), t1 = t1.get$iterator(t1); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + t2 = t1.get$current(t1); + simple = t2._0; + sources = t2._1; + if (!callback.call$1(simple)) { + // goto for condition + $async$goto = 2; + break; + } + t2 = sources.get$values(sources), t2 = t2.get$iterator(t2); + case 4: + // for condition + if (!t2.moveNext$0()) { + // goto after for + $async$goto = 5; + break; + } + t3 = t2.get$current(t2); + $async$goto = t3 instanceof A.MergedExtension0 ? 6 : 8; + break; + case 6: + // then + t3 = t3.unmerge$0(); + $async$goto = 9; + return $async$iterator._yieldStar$1(new A.WhereIterable(t3, new A.ExtensionStore_extensionsWhereTarget_closure0(), t3.$ti._eval$1("WhereIterable"))); + case 9: + // after yield + // goto join + $async$goto = 7; + break; + case 8: + // else + $async$goto = !t3.isOptional ? 10 : 11; + break; + case 10: + // then + $async$goto = 12; + return $async$iterator._async$_current = t3, 1; + case 12: + // after yield + case 11: + // join + case 7: + // join + // goto for condition + $async$goto = 4; + break; + case 5: + // after for + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return 0; + case 1: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + }, + addSelector$2(selector, mediaContext) { + var originalSelector, error, stackTrace, t1, exception, t2, t3, t4, modifiableSelector, _this = this; + selector = selector; + originalSelector = selector; + if (!originalSelector.accept$1(B._IsInvisibleVisitor_true0)) + _this._extension_store$_originals.addAll$1(0, originalSelector.components); + t1 = _this._extension_store$_extensions; + if (t1.__js_helper$_length !== 0) + try { + selector = _this._extension_store$_extendList$3(originalSelector, t1, mediaContext); + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException0) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = error; + t2 = J.getInterceptor$z(t1); + t1 = A.SourceSpanException.prototype.get$span.call(t2, t1).message$1(0, ""); + t2 = error._span_exception$_message; + t3 = error; + t4 = J.getInterceptor$z(t3); + t3 = A.SourceSpanException.prototype.get$span.call(t4, t3); + A.throwWithTrace0(new A.SassException0(B.Set_empty, "From " + t1 + "\n" + t2, t3), error, stackTrace); + } else + throw exception; + } + modifiableSelector = new A.ModifiableBox0(selector, type$.ModifiableBox_SelectorList_2); + if (mediaContext != null) + _this._extension_store$_mediaContexts.$indexSet(0, modifiableSelector, mediaContext); + _this._extension_store$_registerSelector$2(selector, modifiableSelector); + return new A.Box0(modifiableSelector, type$.Box_SelectorList_2); + }, + _extension_store$_registerSelector$2(list, selector) { + var t1, t2, t3, t4, _i, t5, t6, _i0, t7, t8, _i1, simple, _0_2_isSet, _0_2, t9, selectorInPseudo; + for (t1 = list.components, t2 = t1.length, t3 = this._extension_store$_selectors, t4 = type$.SelectorList_2, _i = 0; _i < t2; ++_i) + for (t5 = t1[_i].components, t6 = t5.length, _i0 = 0; _i0 < t6; ++_i0) + for (t7 = t5[_i0].selector.components, t8 = t7.length, _i1 = 0; _i1 < t8; ++_i1) { + simple = t7[_i1]; + t3.putIfAbsent$2(simple, new A.ExtensionStore__registerSelector_closure0()).add$1(0, selector); + _0_2_isSet = simple instanceof A.PseudoSelector0; + if (_0_2_isSet) { + _0_2 = simple.selector; + t9 = _0_2 != null; + } else { + _0_2 = null; + t9 = false; + } + if (t9) { + selectorInPseudo = _0_2_isSet ? _0_2 : simple.selector; + this._extension_store$_registerSelector$2(selectorInPseudo == null ? t4._as(selectorInPseudo) : selectorInPseudo, selector); + } + } + }, + addExtension$4(extender, target, extend, mediaContext) { + var t2, t3, t4, t5, t6, t7, t8, t9, t10, newExtensions, _i, complex, t11, extension, _0_0, t12, newExtensionsByTarget, additionalExtensions, _this = this, + selectors = _this._extension_store$_selectors.$index(0, target), + t1 = _this._extension_store$_extensionsByExtender, + existingExtensions = t1.$index(0, target), + sources = _this._extension_store$_extensions.putIfAbsent$2(target, new A.ExtensionStore_addExtension_closure2()); + for (t2 = extender.components, t3 = t2.length, t4 = selectors == null, t5 = _this._extension_store$_sourceSpecificity, t6 = extend.span, t7 = extend.isOptional, t8 = existingExtensions != null, t9 = type$.ComplexSelector_2, t10 = type$.Extension_2, newExtensions = null, _i = 0; _i < t3; ++_i) { + complex = t2[_i]; + if (complex.accept$1(B.C__IsUselessVisitor0)) + continue; + complex.get$specificity(); + t11 = new A.Extender0(complex, false); + extension = t11._extension$_extension = new A.Extension0(t11, target, mediaContext, t7, t6); + _0_0 = sources.$index(0, complex); + if (_0_0 != null) { + sources.$indexSet(0, complex, A.MergedExtension_merge0(_0_0, extension)); + continue; + } + sources.$indexSet(0, complex, extension); + for (t11 = new A._SyncStarIterator(_this._extension_store$_simpleSelectors$1(complex)._outerHelper()); t11.moveNext$0();) { + t12 = t11._async$_current; + J.add$1$ax(t1.putIfAbsent$2(t12, new A.ExtensionStore_addExtension_closure3()), extension); + t5.putIfAbsent$2(t12, new A.ExtensionStore_addExtension_closure4(complex)); + } + if (!t4 || t8) { + if (newExtensions == null) + newExtensions = A.LinkedHashMap_LinkedHashMap$_empty(t9, t10); + newExtensions.$indexSet(0, complex, extension); + } + } + if (newExtensions == null) + return; + t1 = type$.SimpleSelector_2; + newExtensionsByTarget = A.LinkedHashMap_LinkedHashMap$_literal([target, newExtensions], t1, type$.Map_ComplexSelector_Extension_2); + if (t8) { + additionalExtensions = _this._extension_store$_extendExistingExtensions$2(existingExtensions, newExtensionsByTarget); + if (additionalExtensions != null) + A.mapAddAll20(newExtensionsByTarget, additionalExtensions, t1, t9, t10); + } + if (!t4) + _this._extension_store$_extendExistingSelectors$2(selectors, newExtensionsByTarget); + }, + _extension_store$_simpleSelectors$1(complex) { + return new A._SyncStarIterable(this._simpleSelectors$body$ExtensionStore0(complex), type$._SyncStarIterable_SimpleSelector_2); + }, + _simpleSelectors$body$ExtensionStore0($async$complex) { + var $async$self = this; + return function() { + var complex = $async$complex; + var $async$goto = 0, $async$handler = 1, $async$errorStack = [], t1, t2, t3, _i, t4, t5, _i0, simple, _0_2_isSet, _0_2, t6, selector, t7, _i1; + return function $async$_extension_store$_simpleSelectors$1($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = complex.components, t2 = t1.length, t3 = type$.SelectorList_2, _i = 0; + case 2: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 4; + break; + } + t4 = t1[_i].selector.components, t5 = t4.length, _i0 = 0; + case 5: + // for condition + if (!(_i0 < t5)) { + // goto after for + $async$goto = 7; + break; + } + simple = t4[_i0]; + $async$goto = 8; + return $async$iterator._async$_current = simple, 1; + case 8: + // after yield + _0_2_isSet = simple instanceof A.PseudoSelector0; + if (_0_2_isSet) { + _0_2 = simple.selector; + t6 = _0_2 != null; + } else { + _0_2 = null; + t6 = false; + } + $async$goto = t6 ? 9 : 10; + break; + case 9: + // then + selector = _0_2_isSet ? _0_2 : simple.selector; + t6 = (selector == null ? t3._as(selector) : selector).components, t7 = t6.length, _i1 = 0; + case 11: + // for condition + if (!(_i1 < t7)) { + // goto after for + $async$goto = 13; + break; + } + $async$goto = 14; + return $async$iterator._yieldStar$1($async$self._extension_store$_simpleSelectors$1(t6[_i1])); + case 14: + // after yield + case 12: + // for update + ++_i1; + // goto for condition + $async$goto = 11; + break; + case 13: + // after for + case 10: + // join + case 6: + // for update + ++_i0; + // goto for condition + $async$goto = 5; + break; + case 7: + // after for + case 3: + // for update + ++_i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return 0; + case 1: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + }, + _extension_store$_extendExistingExtensions$2(extensions, newExtensions) { + var extension, selectors, error, stackTrace, t1, t2, t3, t4, t5, t6, additionalExtensions, _i, t7, exception, t8, t9, selectors0, t10, t11, t12, t13, t14, withExtender, _0_0, _i0, _i1; + for (t1 = J.toList$0$ax(extensions), t2 = t1.length, t3 = this._extension_store$_extensionsByExtender, t4 = type$.SimpleSelector_2, t5 = type$.Map_ComplexSelector_Extension_2, t6 = this._extension_store$_extensions, additionalExtensions = null, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + extension = t1[_i]; + t7 = t6.$index(0, extension.target); + t7.toString; + selectors = null; + try { + selectors = this._extension_store$_extendComplex$3(extension.extender.selector, newExtensions, extension.mediaContext); + if (selectors == null) + continue; + } catch (exception) { + t8 = A.unwrapException(exception); + if (t8 instanceof A.SassException0) { + error = t8; + stackTrace = A.getTraceFromException(exception); + A.throwWithTrace0(error.withAdditionalSpan$2(extension.extender.selector.span, "target selector"), error, stackTrace); + } else + throw exception; + } + t8 = J.get$first$ax(selectors); + t9 = extension.extender.selector; + if (B.C_ListEquality.equals$2(0, t8.leadingCombinators, t9.leadingCombinators) && B.C_ListEquality.equals$2(0, t8.components, t9.components)) { + t8 = selectors; + t9 = A._arrayInstanceType(t8); + selectors0 = new A.SubListIterable(t8, 1, null, t9._eval$1("SubListIterable<1>")); + selectors0.SubListIterable$3(t8, 1, null, t9._precomputed1); + selectors = selectors0; + } + for (t8 = J.get$iterator$ax(selectors); t8.moveNext$0();) { + t9 = t8.get$current(t8); + t10 = extension; + t11 = t10.target; + t12 = t10.span; + t13 = t10.mediaContext; + t10 = t10.isOptional; + t9.get$specificity(); + t14 = new A.Extender0(t9, false); + withExtender = t14._extension$_extension = new A.Extension0(t14, t11, t13, t10, t12); + _0_0 = t7.$index(0, t9); + if (_0_0 != null) + t7.$indexSet(0, t9, A.MergedExtension_merge0(_0_0, withExtender)); + else { + t7.$indexSet(0, t9, withExtender); + for (t10 = t9.components, t11 = t10.length, _i0 = 0; _i0 < t11; ++_i0) + for (t12 = t10[_i0].selector.components, t13 = t12.length, _i1 = 0; _i1 < t13; ++_i1) + J.add$1$ax(t3.putIfAbsent$2(t12[_i1], new A.ExtensionStore__extendExistingExtensions_closure1()), withExtender); + if (newExtensions.containsKey$1(extension.target)) { + if (additionalExtensions == null) + additionalExtensions = A.LinkedHashMap_LinkedHashMap$_empty(t4, t5); + additionalExtensions.putIfAbsent$2(extension.target, new A.ExtensionStore__extendExistingExtensions_closure2()).$indexSet(0, t9, withExtender); + } + } + } + } + return additionalExtensions; + }, + _extension_store$_extendExistingSelectors$2(selectors, newExtensions) { + var selector, error, stackTrace, t1, t2, oldValue, exception, t3, t4, t5, t6; + for (t1 = selectors.get$iterator(selectors), t2 = this._extension_store$_mediaContexts; t1.moveNext$0();) { + selector = t1.get$current(t1); + oldValue = selector.value; + try { + selector.value = this._extension_store$_extendList$3(selector.value, newExtensions, t2.$index(0, selector)); + } catch (exception) { + t3 = A.unwrapException(exception); + if (t3 instanceof A.SassException0) { + error = t3; + stackTrace = A.getTraceFromException(exception); + t3 = selector.value.span.message$1(0, ""); + t4 = error._span_exception$_message; + t5 = error; + t6 = J.getInterceptor$z(t5); + t5 = A.SourceSpanException.prototype.get$span.call(t6, t5); + A.throwWithTrace0(new A.SassException0(B.Set_empty, "From " + t3 + "\n" + t4, t5), error, stackTrace); + } else + throw exception; + } + if (oldValue === selector.value) + continue; + this._extension_store$_registerSelector$2(selector.value, selector); + } + }, + addExtensions$1(extensionStores) { + var t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, newExtensions, selectorsToExtend, extensionsToExtend, t12, t13, target, newSources, first, extensionsForTarget, t14, selectorsForTarget, t15, _2_0, t16, extender, extension, _this = this, _null = null; + for (t1 = J.get$iterator$ax(extensionStores), t2 = type$.SimpleSelector_2, t3 = type$.Map_ComplexSelector_Extension_2, t4 = _this._extension_store$_extensions, t5 = type$.ComplexSelector_2, t6 = type$.Extension_2, t7 = _this._extension_store$_selectors, t8 = _this._extension_store$_extensionsByExtender, t9 = type$.JSArray_Extension_2, t10 = type$.ModifiableBox_SelectorList_2, t11 = _this._extension_store$_sourceSpecificity, newExtensions = _null, selectorsToExtend = newExtensions, extensionsToExtend = selectorsToExtend; t1.moveNext$0();) { + t12 = t1.get$current(t1); + if (t12.get$isEmpty(t12)) + continue; + t11.addAll$1(0, t12.get$_extension_store$_sourceSpecificity()); + for (t12 = A.MapExtensions_get_pairs0(t12.get$_extension_store$_extensions(), t2, t3), t12 = t12.get$iterator(t12); t12.moveNext$0();) { + t13 = t12.get$current(t12); + target = t13._0; + newSources = t13._1; + if (target instanceof A.PlaceholderSelector0) { + first = target.name.charCodeAt(0); + t13 = first === 45 || first === 95; + } else + t13 = false; + if (t13) + continue; + extensionsForTarget = t8.$index(0, target); + t13 = extensionsForTarget == null; + if (!t13) { + if (extensionsToExtend == null) { + extensionsToExtend = A._setArrayType([], t9); + t14 = extensionsToExtend; + } else + t14 = extensionsToExtend; + B.JSArray_methods.addAll$1(t14, extensionsForTarget); + } + selectorsForTarget = t7.$index(0, target); + t14 = selectorsForTarget != null; + if (t14) { + if (selectorsToExtend == null) { + selectorsToExtend = A.LinkedHashSet_LinkedHashSet$_empty(t10); + t15 = selectorsToExtend; + } else + t15 = selectorsToExtend; + t15.addAll$1(0, selectorsForTarget); + } + _2_0 = t4.$index(0, target); + if (_2_0 != null) + for (t15 = A.MapExtensions_get_pairs0(newSources, t5, t6), t15 = t15.get$iterator(t15); t15.moveNext$0();) { + t16 = t15.get$current(t15); + extender = t16._0; + extension = t16._1; + if (_2_0.containsKey$1(extender)) { + t16 = _2_0.$index(0, extender); + extension = A.MergedExtension_merge0(t16 == null ? t6._as(t16) : t16, extension); + _2_0.$indexSet(0, extender, extension); + } else + _2_0.$indexSet(0, extender, extension); + if (!t13 || t14) { + if (newExtensions == null) { + newExtensions = A.LinkedHashMap_LinkedHashMap$_empty(t2, t3); + t16 = newExtensions; + } else + t16 = newExtensions; + t16.putIfAbsent$2(target, new A.ExtensionStore_addExtensions_closure0()).$indexSet(0, extender, extension); + } + } + else { + t15 = A.LinkedHashMap_LinkedHashMap(_null, _null, _null, t5, t6); + t15.addAll$1(0, newSources); + t4.$indexSet(0, target, t15); + if (!t13 || t14) { + if (newExtensions == null) { + newExtensions = A.LinkedHashMap_LinkedHashMap$_empty(t2, t3); + t13 = newExtensions; + } else + t13 = newExtensions; + t14 = A.LinkedHashMap_LinkedHashMap(_null, _null, _null, t5, t6); + t14.addAll$1(0, newSources); + t13.$indexSet(0, target, t14); + } + } + } + } + if (newExtensions != null) { + if (extensionsToExtend != null) + _this._extension_store$_extendExistingExtensions$2(extensionsToExtend, newExtensions); + if (selectorsToExtend != null) + _this._extension_store$_extendExistingSelectors$2(selectorsToExtend, newExtensions); + } + }, + _extension_store$_extendList$3(list, extensions, mediaQueryContext) { + var t1, t2, t3, extended, i, complex, result, t4; + for (t1 = list.components, t2 = t1.length, t3 = type$.JSArray_ComplexSelector_2, extended = null, i = 0; i < t2; ++i) { + complex = t1[i]; + result = this._extension_store$_extendComplex$3(complex, extensions, mediaQueryContext); + if (result == null) { + if (extended != null) + extended.push(complex); + } else { + if (extended == null) + if (i === 0) + extended = A._setArrayType([], t3); + else { + t4 = B.JSArray_methods.sublist$2(t1, 0, i); + extended = A._setArrayType(t4.slice(0), A._arrayInstanceType(t4)); + } + B.JSArray_methods.addAll$1(extended, result); + } + } + if (extended == null) + return list; + t1 = this._extension_store$_originals; + return A.SelectorList$0(this._extension_store$_trim$2(extended, t1.get$contains(t1)), list.span); + }, + _extension_store$_extendList$2(list, extensions) { + return this._extension_store$_extendList$3(list, extensions, null); + }, + _extension_store$_extendComplex$3(complex, extensions, mediaQueryContext) { + var isOriginal, t3, t4, t5, t6, t7, t8, t9, t10, extendedNotExpanded, i, component, extended, t11, t12, t13, t14, _box_0 = {}, + t1 = complex.leadingCombinators, + t2 = t1.length; + if (t2 > 1) + return null; + isOriginal = this._extension_store$_originals.contains$1(0, complex); + for (t3 = complex.components, t4 = t3.length, t5 = type$.JSArray_List_ComplexSelector_2, t6 = complex.lineBreak, t7 = !t6, t8 = complex.span, t9 = type$.JSArray_ComplexSelector_2, t2 = t2 === 0, t10 = type$.JSArray_ComplexSelectorComponent_2, extendedNotExpanded = null, i = 0; i < t4; ++i) { + component = t3[i]; + extended = this._extension_store$_extendCompound$4$inOriginal(component, extensions, mediaQueryContext, isOriginal); + if (extended == null) { + if (extendedNotExpanded != null) + extendedNotExpanded.push(A._setArrayType([A.ComplexSelector$0(B.List_empty14, A._setArrayType([component], t10), t8, t6)], t9)); + } else if (extendedNotExpanded != null) + extendedNotExpanded.push(extended); + else if (i !== 0) { + t11 = A._arrayInstanceType(t3); + t12 = new A.SubListIterable(t3, 0, i, t11._eval$1("SubListIterable<1>")); + t12.SubListIterable$3(t3, 0, i, t11._precomputed1); + extendedNotExpanded = A._setArrayType([A._setArrayType([A.ComplexSelector$0(t1, t12, t8, t6)], t9), extended], t5); + } else if (t2) + extendedNotExpanded = A._setArrayType([extended], t5); + else { + t11 = A._setArrayType([], t9); + for (t12 = J.get$iterator$ax(extended); t12.moveNext$0();) { + t13 = t12.get$current(t12); + t14 = t13.leadingCombinators; + if (t14.length === 0 || B.C_ListEquality.equals$2(0, t1, t14)) { + t14 = t13.components; + t11.push(A.ComplexSelector$0(t1, t14, t8, !t7 || t13.lineBreak)); + } + } + extendedNotExpanded = A._setArrayType([t11], t5); + } + } + if (extendedNotExpanded == null) + return null; + _box_0.first = true; + t1 = type$.ComplexSelector_2; + t1 = J.expand$1$1$ax(A.paths0(extendedNotExpanded, t1), new A.ExtensionStore__extendComplex_closure0(_box_0, this, complex), t1); + return A.List_List$of(t1, true, t1.$ti._eval$1("Iterable.E")); + }, + _extension_store$_extendCompound$4$inOriginal(component, extensions, mediaQueryContext, inOriginal) { + var t3, t4, t5, t6, t7, t8, t9, t10, t11, options, i, simple, extended, t12, result, compound, complex, extenderPaths, withCombinators, isOriginal, _this = this, _null = null, + t1 = _this._extension_store$_mode, + targetsUsed = t1 === B.ExtendMode_normal_normal0 || extensions.__js_helper$_length < 2 ? _null : A.LinkedHashSet_LinkedHashSet$_empty(type$.SimpleSelector_2), + t2 = component.selector, + simples = t2.components; + for (t3 = simples.length, t4 = type$.JSArray_List_Extender_2, t5 = type$.JSArray_Extender_2, t6 = type$.CssValue_Combinator_2, t7 = type$.JSArray_ComplexSelectorComponent_2, t8 = A._arrayInstanceType(simples), t9 = t8._precomputed1, t8 = t8._eval$1("SubListIterable<1>"), t10 = component.span, t11 = type$.SimpleSelector_2, options = _null, i = 0; i < t3; ++i) { + simple = simples[i]; + extended = _this._extension_store$_extendSimple$4(simple, extensions, mediaQueryContext, targetsUsed); + if (extended == null) { + if (options != null) + options.push(A._setArrayType([_this._extension_store$_extenderForSimple$1(simple)], t5)); + } else { + if (options == null) { + options = A._setArrayType([], t4); + if (i !== 0) { + t12 = new A.SubListIterable(simples, 0, i, t8); + t12.SubListIterable$3(simples, 0, i, t9); + result = A.List_List$from(t12, false, t11); + result.$flags = 3; + t12 = result; + compound = new A.CompoundSelector0(t12, t10); + if (t12.length === 0) + A.throwExpression(A.ArgumentError$("components may not be empty.", _null)); + result = A.List_List$from(B.List_empty14, false, t6); + result.$flags = 3; + t12 = A.ComplexSelector$0(B.List_empty14, A._setArrayType([new A.ComplexSelectorComponent0(compound, result, t10)], t7), t10, false); + _this._extension_store$_sourceSpecificityFor$1(compound); + options.push(A._setArrayType([new A.Extender0(t12, true)], t5)); + } + } + B.JSArray_methods.addAll$1(options, extended); + } + } + if (options == null) + return _null; + if (targetsUsed != null && targetsUsed._collection$_length !== extensions.__js_helper$_length) + return _null; + if (options.length === 1) { + for (t1 = J.get$iterator$ax(options[0]), t2 = component.combinators, t3 = type$.JSArray_ComplexSelector_2, result = _null; t1.moveNext$0();) { + t4 = t1.get$current(t1); + t4.assertCompatibleMediaContext$1(mediaQueryContext); + complex = t4.selector.withAdditionalCombinators$1(t2); + if (complex.accept$1(B.C__IsUselessVisitor0)) + continue; + if (result == null) + result = A._setArrayType([], t3); + result.push(complex); + } + return result; + } + extenderPaths = A.paths0(options, type$.Extender_2); + t3 = A._setArrayType([], type$.JSArray_ComplexSelector_2); + t1 = t1 === B.ExtendMode_replace_replace0; + t4 = !t1; + if (t4) + t3.push(A.ComplexSelector$0(B.List_empty14, A._setArrayType([new A.ComplexSelectorComponent0(A.CompoundSelector$0(J.expand$1$1$ax(J.get$first$ax(extenderPaths), new A.ExtensionStore__extendCompound_closure2(), t11), t2.span), A.List_List$unmodifiable(component.combinators, t6), t10)], t7), t10, false)); + t2 = J.skip$1$ax(extenderPaths, t1 ? 0 : 1); + t5 = t2.$ti; + t2 = new A.ListIterator(t2, t2.get$length(0), t5._eval$1("ListIterator")); + t6 = component.combinators; + t5 = t5._eval$1("ListIterable.E"); + for (; t2.moveNext$0();) { + t1 = t2.__internal$_current; + extended = _this._extension_store$_unifyExtenders$3(t1 == null ? t5._as(t1) : t1, mediaQueryContext, t10); + if (extended == null) + continue; + for (t1 = J.get$iterator$ax(extended); t1.moveNext$0();) { + withCombinators = t1.get$current(t1).withAdditionalCombinators$1(t6); + if (!withCombinators.accept$1(B.C__IsUselessVisitor0)) + t3.push(withCombinators); + } + } + isOriginal = new A.ExtensionStore__extendCompound_closure3(); + return _this._extension_store$_trim$2(t3, inOriginal && t4 ? new A.ExtensionStore__extendCompound_closure4(B.JSArray_methods.get$first(t3)) : isOriginal); + }, + _extension_store$_unifyExtenders$3(extenders, mediaQueryContext, span) { + var t1, t2, t3, originals, originalsLineBreak, t4, complexes, _null = null, + toUnify = A.QueueList$(_null, type$.ComplexSelector_2); + for (t1 = J.getInterceptor$ax(extenders), t2 = t1.get$iterator(extenders), t3 = type$.JSArray_SimpleSelector_2, originals = _null, originalsLineBreak = false; t2.moveNext$0();) { + t4 = t2.get$current(t2); + if (t4.isOriginal) { + if (originals == null) + originals = A._setArrayType([], t3); + t4 = t4.selector; + B.JSArray_methods.addAll$1(originals, B.JSArray_methods.get$last(t4.components).selector.components); + originalsLineBreak = originalsLineBreak || t4.lineBreak; + } else { + t4 = t4.selector; + if (t4.accept$1(B.C__IsUselessVisitor0)) + return _null; + else + toUnify._queue_list$_add$1(t4); + } + } + if (originals != null) + toUnify.addFirst$1(A.ComplexSelector$0(B.List_empty14, A._setArrayType([new A.ComplexSelectorComponent0(A.CompoundSelector$0(originals, span), A.List_List$unmodifiable(B.List_empty14, type$.CssValue_Combinator_2), span)], type$.JSArray_ComplexSelectorComponent_2), span, originalsLineBreak)); + complexes = A.unifyComplex0(toUnify, span); + if (complexes == null) + return _null; + for (t1 = t1.get$iterator(extenders); t1.moveNext$0();) + t1.get$current(t1).assertCompatibleMediaContext$1(mediaQueryContext); + return complexes; + }, + _extension_store$_extendSimple$4(simple, extensions, mediaQueryContext, targetsUsed) { + var t2, _1_0, + t1 = new A.ExtensionStore__extendSimple_withoutPseudo0(this, extensions, targetsUsed); + if (simple instanceof A.PseudoSelector0) + t2 = simple.selector != null; + else + t2 = false; + if (t2) { + _1_0 = this._extension_store$_extendPseudo$3(simple, extensions, mediaQueryContext); + if (_1_0 != null) + return new A.MappedListIterable(_1_0, new A.ExtensionStore__extendSimple_closure1(this, t1), A._arrayInstanceType(_1_0)._eval$1("MappedListIterable<1,List>")); + } + return A.NullableExtension_andThen0(t1.call$1(simple), new A.ExtensionStore__extendSimple_closure2()); + }, + _extension_store$_extenderForSimple$1(simple) { + var t1 = simple.span; + t1 = A.ComplexSelector$0(B.List_empty14, A._setArrayType([new A.ComplexSelectorComponent0(A.CompoundSelector$0(A._setArrayType([simple], type$.JSArray_SimpleSelector_2), t1), A.List_List$unmodifiable(B.List_empty14, type$.CssValue_Combinator_2), t1)], type$.JSArray_ComplexSelectorComponent_2), t1, false); + this._extension_store$_sourceSpecificity.$index(0, simple); + return new A.Extender0(t1, true); + }, + _extension_store$_extendPseudo$3(pseudo, extensions, mediaQueryContext) { + var extended, complexes, t1, result, + selector = pseudo.selector; + if (selector == null) + throw A.wrapException(A.ArgumentError$("Selector " + pseudo.toString$0(0) + " must have a selector argument.", null)); + extended = this._extension_store$_extendList$3(selector, extensions, mediaQueryContext); + if (extended === selector) + return null; + complexes = extended.components; + t1 = pseudo.normalizedName === "not"; + if (t1 && !B.JSArray_methods.any$1(selector.components, new A.ExtensionStore__extendPseudo_closure4()) && B.JSArray_methods.any$1(complexes, new A.ExtensionStore__extendPseudo_closure5())) + complexes = new A.WhereIterable(complexes, new A.ExtensionStore__extendPseudo_closure6(), A._arrayInstanceType(complexes)._eval$1("WhereIterable<1>")); + complexes = J.expand$1$1$ax(complexes, new A.ExtensionStore__extendPseudo_closure7(pseudo), type$.ComplexSelector_2); + if (t1 && selector.components.length === 1) { + t1 = A.MappedIterable_MappedIterable(complexes, new A.ExtensionStore__extendPseudo_closure8(pseudo, selector), complexes.$ti._eval$1("Iterable.E"), type$.PseudoSelector_2); + result = A.List_List$of(t1, true, A._instanceType(t1)._eval$1("Iterable.E")); + return result.length === 0 ? null : result; + } else + return A._setArrayType([pseudo.withSelector$1(A.SelectorList$0(complexes, selector.span))], type$.JSArray_PseudoSelector_2); + }, + _extension_store$_trim$2(selectors, isOriginal) { + var result, i, t1, t2, numOriginals, _box_0, complex1, j, t3, t4, _i, t5, maxSpecificity; + if (selectors.length > 100) + return selectors; + result = A.QueueList$(null, type$.ComplexSelector_2); + $label0$0: + for (i = selectors.length - 1, t1 = A._arrayInstanceType(selectors), t2 = t1._precomputed1, t1 = t1._eval$1("SubListIterable<1>"), numOriginals = 0; i >= 0; --i) { + _box_0 = {}; + complex1 = selectors[i]; + if (isOriginal.call$1(complex1)) { + for (j = 0; j < numOriginals; ++j) + if (result.$index(0, j).$eq(0, complex1)) { + A.rotateSlice0(result, 0, j + 1); + continue $label0$0; + } + ++numOriginals; + result.addFirst$1(complex1); + continue $label0$0; + } + _box_0.maxSpecificity = 0; + for (t3 = complex1.components, t4 = t3.length, _i = 0, t5 = 0; _i < t4; ++_i, t5 = maxSpecificity) { + maxSpecificity = Math.max(t5, this._extension_store$_sourceSpecificityFor$1(t3[_i].selector)); + _box_0.maxSpecificity = maxSpecificity; + } + if (result.any$1(result, new A.ExtensionStore__trim_closure1(_box_0, complex1))) + continue $label0$0; + t3 = new A.SubListIterable(selectors, 0, i, t1); + t3.SubListIterable$3(selectors, 0, i, t2); + if (t3.any$1(0, new A.ExtensionStore__trim_closure2(_box_0, complex1))) + continue $label0$0; + result.addFirst$1(complex1); + } + return result; + }, + _extension_store$_sourceSpecificityFor$1(compound) { + var t1, t2, t3, specificity, _i, t4; + for (t1 = compound.components, t2 = t1.length, t3 = this._extension_store$_sourceSpecificity, specificity = 0, _i = 0; _i < t2; ++_i) { + t4 = t3.$index(0, t1[_i]); + if (t4 == null) + t4 = 0; + specificity = Math.max(specificity, t4); + } + return specificity; + }, + clone$0() { + var t2, t3, t4, _this = this, + t1 = type$.SimpleSelector_2, + newSelectors = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.Set_ModifiableBox_SelectorList_2), + newMediaContexts = A.LinkedHashMap_LinkedHashMap$_empty(type$.ModifiableBox_SelectorList_2, type$.List_CssMediaQuery_2), + oldToNewSelectors = new A.JsIdentityLinkedHashMap(type$.JsIdentityLinkedHashMap_of_SelectorList_and_Box_SelectorList_2); + _this._extension_store$_selectors.forEach$1(0, new A.ExtensionStore_clone_closure0(_this, newSelectors, oldToNewSelectors, newMediaContexts)); + t2 = type$.Extension_2; + t3 = A.copyMapOfMap0(_this._extension_store$_extensions, t1, type$.ComplexSelector_2, t2); + t2 = A.copyMapOfList0(_this._extension_store$_extensionsByExtender, t1, t2); + t1 = new A.JsIdentityLinkedHashMap(type$.JsIdentityLinkedHashMap_SimpleSelector_int_2); + t1.addAll$1(0, _this._extension_store$_sourceSpecificity); + t4 = new A._LinkedIdentityHashSet(type$._LinkedIdentityHashSet_ComplexSelector_2); + t4.addAll$1(0, _this._extension_store$_originals); + return new A._Record_2(new A.ExtensionStore0(newSelectors, t3, t2, newMediaContexts, t1, t4, B.ExtendMode_normal_normal0), oldToNewSelectors); + }, + get$_extension_store$_extensions() { + return this._extension_store$_extensions; + }, + get$_extension_store$_sourceSpecificity() { + return this._extension_store$_sourceSpecificity; + } + }; + A.ExtensionStore_extensionsWhereTarget_closure0.prototype = { + call$1(extension) { + return !extension.isOptional; + }, + $signature: 465 + }; + A.ExtensionStore__registerSelector_closure0.prototype = { + call$0() { + return A.LinkedHashSet_LinkedHashSet$_empty(type$.ModifiableBox_SelectorList_2); + }, + $signature: 466 + }; + A.ExtensionStore_addExtension_closure2.prototype = { + call$0() { + return A.LinkedHashMap_LinkedHashMap$_empty(type$.ComplexSelector_2, type$.Extension_2); + }, + $signature: 131 + }; + A.ExtensionStore_addExtension_closure3.prototype = { + call$0() { + return A._setArrayType([], type$.JSArray_Extension_2); + }, + $signature: 244 + }; + A.ExtensionStore_addExtension_closure4.prototype = { + call$0() { + return this.complex.get$specificity(); + }, + $signature: 10 + }; + A.ExtensionStore__extendExistingExtensions_closure1.prototype = { + call$0() { + return A._setArrayType([], type$.JSArray_Extension_2); + }, + $signature: 244 + }; + A.ExtensionStore__extendExistingExtensions_closure2.prototype = { + call$0() { + return A.LinkedHashMap_LinkedHashMap$_empty(type$.ComplexSelector_2, type$.Extension_2); + }, + $signature: 131 + }; + A.ExtensionStore_addExtensions_closure0.prototype = { + call$0() { + return A.LinkedHashMap_LinkedHashMap$_empty(type$.ComplexSelector_2, type$.Extension_2); + }, + $signature: 131 + }; + A.ExtensionStore__extendComplex_closure0.prototype = { + call$1(path) { + var t1 = this.complex; + return J.map$1$1$ax(A.weave0(path, t1.span, t1.lineBreak), new A.ExtensionStore__extendComplex__closure0(this._box_0, this.$this, t1), type$.ComplexSelector_2); + }, + $signature: 469 + }; + A.ExtensionStore__extendComplex__closure0.prototype = { + call$1(outputComplex) { + var _this = this, + t1 = _this._box_0; + if (t1.first && _this.$this._extension_store$_originals.contains$1(0, _this.complex)) + _this.$this._extension_store$_originals.add$1(0, outputComplex); + t1.first = false; + return outputComplex; + }, + $signature: 58 + }; + A.ExtensionStore__extendCompound_closure2.prototype = { + call$1(extender) { + return B.JSArray_methods.get$last(extender.selector.components).selector.components; + }, + $signature: 471 + }; + A.ExtensionStore__extendCompound_closure3.prototype = { + call$1(_) { + return false; + }, + $signature: 21 + }; + A.ExtensionStore__extendCompound_closure4.prototype = { + call$1(complex) { + return complex.$eq(0, this.original); + }, + $signature: 21 + }; + A.ExtensionStore__extendSimple_withoutPseudo0.prototype = { + call$1(simple) { + var t1, t2, + extensionsForSimple = this.extensions.$index(0, simple); + if (extensionsForSimple == null) + return null; + t1 = this.targetsUsed; + if (t1 != null) + t1.add$1(0, simple); + t1 = A._setArrayType([], type$.JSArray_Extender_2); + t2 = this.$this; + if (t2._extension_store$_mode !== B.ExtendMode_replace_replace0) + t1.push(t2._extension_store$_extenderForSimple$1(simple)); + for (t2 = extensionsForSimple.get$values(extensionsForSimple), t2 = t2.get$iterator(t2); t2.moveNext$0();) + t1.push(t2.get$current(t2).extender); + return t1; + }, + $signature: 472 + }; + A.ExtensionStore__extendSimple_closure1.prototype = { + call$1(pseudo) { + var t1 = this.withoutPseudo.call$1(pseudo); + return t1 == null ? A._setArrayType([this.$this._extension_store$_extenderForSimple$1(pseudo)], type$.JSArray_Extender_2) : t1; + }, + $signature: 473 + }; + A.ExtensionStore__extendSimple_closure2.prototype = { + call$1(result) { + return A._setArrayType([result], type$.JSArray_List_Extender_2); + }, + $signature: 474 + }; + A.ExtensionStore__extendPseudo_closure4.prototype = { + call$1(complex) { + return complex.components.length > 1; + }, + $signature: 21 + }; + A.ExtensionStore__extendPseudo_closure5.prototype = { + call$1(complex) { + return complex.components.length === 1; + }, + $signature: 21 + }; + A.ExtensionStore__extendPseudo_closure6.prototype = { + call$1(complex) { + return complex.components.length <= 1; + }, + $signature: 21 + }; + A.ExtensionStore__extendPseudo_closure7.prototype = { + call$1(complex) { + var innerPseudo, innerSelector, + t1 = complex.get$singleCompound(); + if (t1 == null) + innerPseudo = null; + else { + t1 = t1.components; + innerPseudo = t1.length === 1 ? B.JSArray_methods.get$first(t1) : null; + } + if (!(innerPseudo instanceof A.PseudoSelector0)) + return A._setArrayType([complex], type$.JSArray_ComplexSelector_2); + innerSelector = innerPseudo.selector; + if (innerSelector == null) + return A._setArrayType([complex], type$.JSArray_ComplexSelector_2); + t1 = this.pseudo; + switch (t1.normalizedName) { + case "not": + if (!B.Set_0egh6.contains$1(0, innerPseudo.normalizedName)) + return A._setArrayType([], type$.JSArray_ComplexSelector_2); + return innerSelector.components; + case "is": + case "matches": + case "where": + case "any": + case "current": + case "nth-child": + case "nth-last-child": + if (innerPseudo.name !== t1.name) + return A._setArrayType([], type$.JSArray_ComplexSelector_2); + if (innerPseudo.argument != t1.argument) + return A._setArrayType([], type$.JSArray_ComplexSelector_2); + return innerSelector.components; + case "has": + case "host": + case "host-context": + case "slotted": + return A._setArrayType([complex], type$.JSArray_ComplexSelector_2); + default: + return A._setArrayType([], type$.JSArray_ComplexSelector_2); + } + }, + $signature: 475 + }; + A.ExtensionStore__extendPseudo_closure8.prototype = { + call$1(complex) { + return this.pseudo.withSelector$1(A.SelectorList$0(A._setArrayType([complex], type$.JSArray_ComplexSelector_2), this.selector.span)); + }, + $signature: 476 + }; + A.ExtensionStore__trim_closure1.prototype = { + call$1(complex2) { + return complex2.get$specificity() >= this._box_0.maxSpecificity && complex2.isSuperselector$1(this.complex1); + }, + $signature: 21 + }; + A.ExtensionStore__trim_closure2.prototype = { + call$1(complex2) { + return complex2.get$specificity() >= this._box_0.maxSpecificity && complex2.isSuperselector$1(this.complex1); + }, + $signature: 21 + }; + A.ExtensionStore_clone_closure0.prototype = { + call$2(simple, selectors) { + var t2, t3, t4, t5, t6, t7, newSelector, _0_0, _this = this, + t1 = type$.ModifiableBox_SelectorList_2, + newSelectorSet = A.LinkedHashSet_LinkedHashSet$_empty(t1); + _this.newSelectors.$indexSet(0, simple, newSelectorSet); + for (t2 = selectors.get$iterator(selectors), t3 = _this.oldToNewSelectors, t4 = type$.Box_SelectorList_2, t5 = _this.$this._extension_store$_mediaContexts, t6 = _this.newMediaContexts; t2.moveNext$0();) { + t7 = t2.get$current(t2); + newSelector = new A.ModifiableBox0(t7.value, t1); + newSelectorSet.add$1(0, newSelector); + t3.$indexSet(0, t7.value, new A.Box0(newSelector, t4)); + _0_0 = t5.$index(0, t7); + if (_0_0 != null) + t6.$indexSet(0, newSelector, _0_0); + } + }, + $signature: 477 + }; + A.FiberClass.prototype = {}; + A.Fiber.prototype = {}; + A.JSToDartFileImporter.prototype = { + canonicalize$1(_, url) { + var result, t1, resultUrl; + if (url.get$scheme() === "file") + return $.$get$FilesystemImporter_cwd0().canonicalize$1(0, url); + result = A.wrapJSExceptions(new A.JSToDartFileImporter_canonicalize_closure(this, url)); + if (result == null) + return null; + t1 = self.Promise; + if (result instanceof t1) + A.jsThrow(new self.Error("The findFileUrl() function can't return a Promise for synchron compile functions.")); + else { + t1 = self.URL; + if (!(result instanceof t1)) + A.jsThrow(new self.Error(string$.The_fie)); + } + resultUrl = A.Uri_parse(J.toString$0$(type$.JSUrl._as(result))); + if (resultUrl.get$scheme() !== "file") + A.jsThrow(new self.Error(string$.The_fiu + url.toString$0(0) + '".')); + return $.$get$FilesystemImporter_cwd0().canonicalize$1(0, resultUrl); + }, + load$1(_, url) { + return $.$get$FilesystemImporter_cwd0().load$1(0, url); + }, + isNonCanonicalScheme$1(scheme) { + return scheme !== "file"; + } + }; + A.JSToDartFileImporter_canonicalize_closure.prototype = { + call$0() { + return this.$this._file0$_findFileUrl.call$2(this.url.toString$0(0), A.canonicalizeContext0()); + }, + $signature: 36 + }; + A.FilesystemImporter0.prototype = { + canonicalize$1(_, url) { + var resolved; + if (url.get$scheme() === "file") + resolved = A.resolveImportPath0($.$get$context().style.pathFromUri$1(A._parseUri(url))); + else if (url.get$scheme() !== "") + return null; + else { + resolved = A.resolveImportPath0(A.join(this._filesystem$_loadPath, $.$get$context().style.pathFromUri$1(A._parseUri(url)), null)); + if (resolved != null && this._filesystem$_loadPathDeprecated) + A.warnForDeprecation0(string$.Using_t, B.Deprecation_Ds6); + } + return A.NullableExtension_andThen0(resolved, new A.FilesystemImporter_canonicalize_closure0()); + }, + load$1(_, url) { + var path = $.$get$context().style.pathFromUri$1(A._parseUri(url)); + return A.ImporterResult$(A.readFile0(path), url, A.Syntax_forPath0(path)); + }, + toString$0(_) { + return this._filesystem$_loadPath; + } + }; + A.FilesystemImporter_canonicalize_closure0.prototype = { + call$1(resolved) { + var t2, t0, _null = null, + t1 = A.isNodeJs() ? self.process : _null; + if (!J.$eq$(t1 == null ? _null : J.get$platform$x(t1), "win32")) { + t1 = A.isNodeJs() ? self.process : _null; + t1 = J.$eq$(t1 == null ? _null : J.get$platform$x(t1), "darwin"); + } else + t1 = true; + if (t1) { + t1 = A.absolute(resolved, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null); + t2 = $.$get$context(); + t1 = A._realCasePath0(t2.normalize$1(t1)); + } else { + t1 = $.$get$context(); + t2 = t1.canonicalize$1(0, resolved); + t0 = t2; + t2 = t1; + t1 = t0; + } + return t2.toUri$1(t1); + }, + $signature: 122 + }; + A.ForRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitForRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var _this = this, + t1 = _this.from.toString$0(0), + t2 = _this.isExclusive ? "to" : "through", + t3 = _this.children; + return "@for $" + _this.variable + " from " + t1 + " " + t2 + " " + _this.to.toString$0(0) + " {" + (t3 && B.JSArray_methods).join$1(t3, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.ForwardRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitForwardRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t2, prefix, _this = this, + t1 = "@forward " + A.StringExpression_quoteText0(_this.url.toString$0(0)), + shownMixinsAndFunctions = _this.shownMixinsAndFunctions, + hiddenMixinsAndFunctions = _this.hiddenMixinsAndFunctions; + if (shownMixinsAndFunctions != null) { + t2 = _this.shownVariables; + t2.toString; + t2 = t1 + " show " + _this._forward_rule0$_memberList$2(shownMixinsAndFunctions, t2); + t1 = t2; + } else if (hiddenMixinsAndFunctions != null && hiddenMixinsAndFunctions._base.get$isNotEmpty(0)) { + t2 = _this.hiddenVariables; + t2.toString; + t2 = t1 + " hide " + _this._forward_rule0$_memberList$2(hiddenMixinsAndFunctions, t2); + t1 = t2; + } + prefix = _this.prefix; + if (prefix != null) + t1 += " as " + prefix + "*"; + t2 = _this.configuration; + t1 = (t2.length !== 0 ? t1 + (" with (" + B.JSArray_methods.join$1(t2, ", ") + ")") : t1) + ";"; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _forward_rule0$_memberList$2(mixinsAndFunctions, variables) { + var t2, + t1 = A.List_List$of(mixinsAndFunctions, true, type$.String); + for (t2 = variables._base.get$iterator(0); t2.moveNext$0();) + t1.push("$" + t2.get$current(0)); + return B.JSArray_methods.join$1(t1, ", "); + }, + get$span(receiver) { + return this.span; + } + }; + A.ForwardedModuleView0.prototype = { + get$url(_) { + var t1 = this._forwarded_view0$_inner; + return t1.get$url(t1); + }, + get$upstream() { + return this._forwarded_view0$_inner.get$upstream(); + }, + get$extensionStore() { + return this._forwarded_view0$_inner.get$extensionStore(); + }, + get$css(_) { + var t1 = this._forwarded_view0$_inner; + return t1.get$css(t1); + }, + get$preModuleComments() { + return this._forwarded_view0$_inner.get$preModuleComments(); + }, + get$transitivelyContainsCss() { + return this._forwarded_view0$_inner.get$transitivelyContainsCss(); + }, + get$transitivelyContainsExtensions() { + return this._forwarded_view0$_inner.get$transitivelyContainsExtensions(); + }, + setVariable$3($name, value, nodeWithSpan) { + var t2, _1_0, _2_0, + _s19_ = "Undefined variable.", + t1 = this._forwarded_view0$_rule, + _0_0 = t1.shownVariables; + if (_0_0 != null) + t2 = !_0_0._base.contains$1(0, $name); + else + t2 = false; + if (t2) + throw A.wrapException(A.SassScriptException$0(_s19_, null)); + else { + _1_0 = t1.hiddenVariables; + if (_1_0 != null) + t2 = _1_0._base.contains$1(0, $name); + else + t2 = false; + if (t2) + throw A.wrapException(A.SassScriptException$0(_s19_, null)); + } + _2_0 = t1.prefix; + if (_2_0 != null) { + if (!B.JSString_methods.startsWith$1($name, _2_0)) + throw A.wrapException(A.SassScriptException$0(_s19_, null)); + $name = B.JSString_methods.substring$1($name, _2_0.length); + } + return this._forwarded_view0$_inner.setVariable$3($name, value, nodeWithSpan); + }, + variableIdentity$1($name) { + var _0_0 = this._forwarded_view0$_rule.prefix; + if (_0_0 != null) + $name = B.JSString_methods.substring$1($name, _0_0.length); + return this._forwarded_view0$_inner.variableIdentity$1($name); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.ForwardedModuleView0 && this._forwarded_view0$_inner.$eq(0, other._forwarded_view0$_inner) && this._forwarded_view0$_rule === other._forwarded_view0$_rule; + }, + get$hashCode(_) { + var t1 = this._forwarded_view0$_inner; + return (t1.get$hashCode(t1) ^ A.Primitives_objectHashCode(this._forwarded_view0$_rule)) >>> 0; + }, + cloneCss$0() { + return A.ForwardedModuleView$0(this._forwarded_view0$_inner.cloneCss$0(), this._forwarded_view0$_rule, this.$ti._precomputed1); + }, + toString$0(_) { + return "forwarded " + this._forwarded_view0$_inner.toString$0(0); + }, + $isModule1: 1, + get$variables() { + return this.variables; + }, + get$variableNodes() { + return this.variableNodes; + }, + get$functions(receiver) { + return this.functions; + }, + get$mixins() { + return this.mixins; + } + }; + A.FunctionExpression0.prototype = { + get$nameSpan() { + if (this.namespace == null) + return A.SpanExtensions_initialIdentifier0(this.span); + return A.SpanExtensions_initialIdentifier0(A.FileSpanExtension_subspan(A.SpanExtensions_withoutInitialIdentifier0(this.span), 1, null)); + }, + accept$1$1(visitor) { + return visitor.visitFunctionExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.namespace; + t1 = t1 != null ? "" + (t1 + ".") : ""; + t1 += this.originalName + this.$arguments.toString$0(0); + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + get$span(receiver) { + return this.span; + } + }; + A.JSFunction0.prototype = {}; + A.SupportsFunction0.prototype = { + toInterpolation$0() { + var t4, t5, + t1 = new A.StringBuffer(""), + t2 = new A.InterpolationBuffer0(t1, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)), + t3 = this.name; + t2.addInterpolation$1(t3); + t4 = this.$arguments; + t5 = t4.span; + t3 = A.SpanExtensions_between(t3.span, t5); + t3 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t3.file._decodedChars, t3._file$_start, t3._end), 0, null); + t1._contents += t3; + t2.addInterpolation$1(t4); + t4 = this.span; + t5 = A.SpanExtensions_after(t4, t5); + t5 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t5.file._decodedChars, t5._file$_start, t5._end), 0, null); + t1._contents += t5; + return t2.interpolation$1(t4); + }, + withSpan$1(span) { + return new A.SupportsFunction0(this.name, this.$arguments, span); + }, + toString$0(_) { + return this.name.toString$0(0) + "(" + this.$arguments.toString$0(0) + ")"; + }, + $isAstNode0: 1, + $isSassNode: 1, + $isSupportsCondition: 1, + get$span(receiver) { + return this.span; + } + }; + A.functionClass_closure.prototype = { + call$0() { + var t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.SassFunction", new A.functionClass__closure())); + A.JSClassExtension_injectSuperclass(t1._as(new A.SassFunction0(A.BuiltInCallable$function0("f", "", new A.functionClass__closure0(), null)).constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.functionClass__closure.prototype = { + call$3($self, signature, callback) { + var paren = B.JSString_methods.indexOf$1(signature, "("); + if (paren === -1 || !B.JSString_methods.endsWith$1(signature, ")")) + A.jsThrow(new self.Error('Invalid signature for new sass.SassFunction(): "' + signature + '"')); + return new A.SassFunction0(A.BuiltInCallable$function0(B.JSString_methods.substring$2(signature, 0, paren), B.JSString_methods.substring$2(signature, paren + 1, signature.length - 1), callback, null)); + }, + "call*": "call$3", + $requiredArgCount: 3, + $signature: 478 + }; + A.functionClass__closure0.prototype = { + call$1(_) { + return B.C__SassNull0; + }, + $signature: 3 + }; + A.SassFunction0.prototype = { + accept$1$1(visitor) { + var t1, t2; + if (!visitor._serialize0$_inspect) + A.throwExpression(A.SassScriptException$0(this.toString$0(0) + " isn't a valid CSS value.", null)); + t1 = visitor._serialize0$_buffer; + t1.write$1(0, "get-function("); + t2 = this.callable; + visitor._serialize0$_visitQuotedString$1(t2.get$name(t2)); + t1.writeCharCode$1(41); + return null; + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + assertFunction$1($name) { + return this; + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.SassFunction0 && this.callable.$eq(0, other.callable); + }, + get$hashCode(_) { + var t1 = this.callable; + return t1.get$hashCode(t1); + } + }; + A.FunctionRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitFunctionRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.children; + return "@function " + this.name + "(" + this.parameters.toString$0(0) + ") {" + (t1 && B.JSArray_methods).join$1(t1, " ") + "}"; + } + }; + A.unifyComplex_closure0.prototype = { + call$1(complex) { + return complex.lineBreak; + }, + $signature: 21 + }; + A._weaveParents_closure3.prototype = { + call$2(group1, group2) { + var t1, unified; + if (B.C_ListEquality.equals$2(0, group1, group2)) + return group1; + if (A._complexIsParentSuperselector0(group1, group2)) + return group2; + if (A._complexIsParentSuperselector0(group2, group1)) + return group1; + if (!A._mustUnify0(group1, group2)) + return null; + t1 = this.span; + unified = A.unifyComplex0(A._setArrayType([A.ComplexSelector$0(B.List_empty14, group1, t1, false), A.ComplexSelector$0(B.List_empty14, group2, t1, false)], type$.JSArray_ComplexSelector_2), t1); + if (unified == null) + t1 = null; + else { + t1 = A.IterableExtension_get_singleOrNull(unified); + t1 = t1 == null ? null : t1.components; + } + return t1; + }, + $signature: 479 + }; + A._weaveParents_closure4.prototype = { + call$1(sequence) { + return A._complexIsParentSuperselector0(sequence.get$first(sequence), this.group); + }, + $signature: 245 + }; + A._weaveParents_closure5.prototype = { + call$1(sequence) { + return sequence.get$length(0) === 0; + }, + $signature: 245 + }; + A._weaveParents_closure6.prototype = { + call$1(choice) { + return J.get$isNotEmpty$asx(choice); + }, + $signature: 481 + }; + A._mustUnify_closure0.prototype = { + call$1(component) { + return B.JSArray_methods.any$1(component.selector.components, new A._mustUnify__closure0(this.uniqueSelectors)); + }, + $signature: 57 + }; + A._mustUnify__closure0.prototype = { + call$1(simple) { + var t1; + if (!(simple instanceof A.IDSelector0)) + t1 = simple instanceof A.PseudoSelector0 && !simple.isClass; + else + t1 = true; + return t1 && this.uniqueSelectors.contains$1(0, simple); + }, + $signature: 14 + }; + A.paths_closure0.prototype = { + call$2(paths, choice) { + var t1 = this.T; + t1 = J.expand$1$1$ax(choice, new A.paths__closure0(paths, t1), t1._eval$1("List<0>")); + return A.List_List$of(t1, true, t1.$ti._eval$1("Iterable.E")); + }, + $signature() { + return this.T._eval$1("List>(List>,List<0>)"); + } + }; + A.paths__closure0.prototype = { + call$1(option) { + var t1 = this.T; + return J.map$1$1$ax(this.paths, new A.paths___closure0(option, t1), t1._eval$1("List<0>")); + }, + $signature() { + return this.T._eval$1("Iterable>(0)"); + } + }; + A.paths___closure0.prototype = { + call$1(path) { + var t1 = A.List_List$of(path, true, this.T); + t1.push(this.option); + return t1; + }, + $signature() { + return this.T._eval$1("List<0>(List<0>)"); + } + }; + A.listIsSuperselector_closure0.prototype = { + call$1(complex1) { + return B.JSArray_methods.any$1(this.list1, new A.listIsSuperselector__closure0(complex1)); + }, + $signature: 21 + }; + A.listIsSuperselector__closure0.prototype = { + call$1(complex2) { + return complex2.isSuperselector$1(this.complex1); + }, + $signature: 21 + }; + A.complexIsSuperselector_closure1.prototype = { + call$1($parent) { + return $parent.combinators.length > 1; + }, + $signature: 57 + }; + A.complexIsSuperselector_closure2.prototype = { + call$1(component) { + return A._isSupercombinator0(this.combinator1, A.IterableExtension_get_firstOrNull(component.combinators)); + }, + $signature: 57 + }; + A._compatibleWithPreviousCombinator_closure0.prototype = { + call$1(component) { + var t1 = component.combinators, + t2 = A.IterableExtension_get_firstOrNull(t1); + if (!J.$eq$(t2 == null ? null : t2.value, B.Combinator_55N0)) { + t1 = A.IterableExtension_get_firstOrNull(t1); + t1 = J.$eq$(t1 == null ? null : t1.value, B.Combinator_bOP0); + } else + t1 = true; + return t1; + }, + $signature: 57 + }; + A.compoundIsSuperselector_closure0.prototype = { + call$1(simple1) { + return B.JSArray_methods.any$1(this.compound2.components, simple1.get$isSuperselector()); + }, + $signature: 14 + }; + A._selectorPseudoIsSuperselector_closure6.prototype = { + call$1(selector2) { + return A.listIsSuperselector0(this.selector1.components, selector2.components); + }, + $signature: 76 + }; + A._selectorPseudoIsSuperselector_closure7.prototype = { + call$1(complex1) { + var t1, t2; + if (complex1.leadingCombinators.length === 0) { + t1 = A._setArrayType([], type$.JSArray_ComplexSelectorComponent_2); + t2 = this.parents; + if (t2 != null) + B.JSArray_methods.addAll$1(t1, t2); + t2 = this.compound2; + t1.push(new A.ComplexSelectorComponent0(t2, A.List_List$unmodifiable(B.List_empty14, type$.CssValue_Combinator_2), t2.span)); + t1 = A.complexIsSuperselector0(complex1.components, t1); + } else + t1 = false; + return t1; + }, + $signature: 21 + }; + A._selectorPseudoIsSuperselector_closure8.prototype = { + call$1(selector2) { + return A.listIsSuperselector0(this.selector1.components, selector2.components); + }, + $signature: 76 + }; + A._selectorPseudoIsSuperselector_closure9.prototype = { + call$1(selector2) { + return A.listIsSuperselector0(this.selector1.components, selector2.components); + }, + $signature: 76 + }; + A._selectorPseudoIsSuperselector_closure10.prototype = { + call$1(complex) { + if (complex.accept$1(B._IsBogusVisitor_true0)) + return false; + return B.JSArray_methods.any$1(this.compound2.components, new A._selectorPseudoIsSuperselector__closure0(complex, this.pseudo1)); + }, + $signature: 21 + }; + A._selectorPseudoIsSuperselector__closure0.prototype = { + call$1(simple2) { + var t1, selector2, _0_4, _this = this; + $label0$1: { + if (simple2 instanceof A.TypeSelector0) { + t1 = B.JSArray_methods.any$1(B.JSArray_methods.get$last(_this.complex.components).selector.components, new A._selectorPseudoIsSuperselector___closure1(simple2)); + break $label0$1; + } + if (simple2 instanceof A.IDSelector0) { + t1 = B.JSArray_methods.any$1(B.JSArray_methods.get$last(_this.complex.components).selector.components, new A._selectorPseudoIsSuperselector___closure2(simple2)); + break $label0$1; + } + selector2 = null; + t1 = false; + if (simple2 instanceof A.PseudoSelector0) { + _0_4 = simple2.selector; + if (_0_4 != null) { + selector2 = _0_4 == null ? type$.SelectorList_2._as(_0_4) : _0_4; + t1 = simple2.name === _this.pseudo1.name; + } + } + if (t1) { + t1 = A.listIsSuperselector0(selector2.components, A._setArrayType([_this.complex], type$.JSArray_ComplexSelector_2)); + break $label0$1; + } + t1 = false; + break $label0$1; + } + return t1; + }, + $signature: 14 + }; + A._selectorPseudoIsSuperselector___closure1.prototype = { + call$1(simple1) { + var t1; + if (simple1 instanceof A.TypeSelector0) { + t1 = this.simple2; + t1 = !(t1 instanceof A.TypeSelector0 && t1.name.$eq(0, simple1.name)); + } else + t1 = false; + return t1; + }, + $signature: 14 + }; + A._selectorPseudoIsSuperselector___closure2.prototype = { + call$1(simple1) { + var t1; + if (simple1 instanceof A.IDSelector0) { + t1 = this.simple2; + t1 = !(t1 instanceof A.IDSelector0 && t1.name === simple1.name); + } else + t1 = false; + return t1; + }, + $signature: 14 + }; + A._selectorPseudoIsSuperselector_closure11.prototype = { + call$1(selector2) { + var t1 = B.C_ListEquality.equals$2(0, this.selector1.components, selector2.components); + return t1; + }, + $signature: 76 + }; + A._selectorPseudoIsSuperselector_closure12.prototype = { + call$1(pseudo2) { + var t1, selector2; + if (!(pseudo2 instanceof A.PseudoSelector0)) + return false; + t1 = this.pseudo1; + if (pseudo2.name !== t1.name) + return false; + if (pseudo2.argument != t1.argument) + return false; + selector2 = pseudo2.selector; + if (selector2 == null) + return false; + return A.listIsSuperselector0(this.selector1.components, selector2.components); + }, + $signature: 14 + }; + A._selectorPseudoArgs_closure1.prototype = { + call$1(pseudo) { + return pseudo.isClass === this.isClass && pseudo.name === this.name; + }, + $signature: 483 + }; + A._selectorPseudoArgs_closure2.prototype = { + call$1(pseudo) { + return pseudo.selector; + }, + $signature: 484 + }; + A.globalFunctions_closure0.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return t1.$index($arguments, 0).get$isTruthy() ? t1.$index($arguments, 1) : t1.$index($arguments, 2); + }, + $signature: 3 + }; + A.GamutMapMethod0.prototype = { + toString$0(_) { + return this.name; + } + }; + A.HslColorSpace0.prototype = { + get$isBoundedInternal() { + return true; + }, + get$isLegacyInternal() { + return true; + }, + get$isPolarInternal() { + return true; + }, + convert$5(dest, hue, saturation, lightness, alpha) { + var t1 = hue == null, + scaledHue = B.JSNumber_methods.$mod((t1 ? 0 : hue) / 360, 1), + t2 = saturation == null, + scaledSaturation = (t2 ? 0 : saturation) / 100, + t3 = lightness == null, + scaledLightness = (t3 ? 0 : lightness) / 100, + m2 = scaledLightness <= 0.5 ? scaledLightness * (scaledSaturation + 1) : scaledLightness + scaledSaturation - scaledLightness * scaledSaturation, + m1 = scaledLightness * 2 - m2; + return B.SrgbColorSpace_thf0.convert$8$missingChroma$missingHue$missingLightness(dest, A.hueToRgb0(m1, m2, scaledHue + 0.3333333333333333), A.hueToRgb0(m1, m2, scaledHue), A.hueToRgb0(m1, m2, scaledHue - 0.3333333333333333), alpha, t2, t1, t3); + } + }; + A.HwbColorSpace0.prototype = { + get$isBoundedInternal() { + return true; + }, + get$isLegacyInternal() { + return true; + }, + get$isPolarInternal() { + return true; + }, + convert$5(dest, hue, whiteness, blackness, alpha) { + var t3, t1 = {}, + t2 = hue == null, + scaledHue = B.JSNumber_methods.$mod(t2 ? 0 : hue, 360) / 360, + scaledWhiteness = t1.scaledWhiteness = (whiteness == null ? 0 : whiteness) / 100, + scaledBlackness = (blackness == null ? 0 : blackness) / 100, + sum = scaledWhiteness + scaledBlackness; + if (sum > 1) { + t3 = t1.scaledWhiteness = scaledWhiteness / sum; + scaledBlackness /= sum; + } else + t3 = scaledWhiteness; + t3 = new A.HwbColorSpace_convert_toRgb0(t1, 1 - t3 - scaledBlackness); + return B.SrgbColorSpace_thf0.convert$6$missingHue(dest, t3.call$1(scaledHue + 0.3333333333333333), t3.call$1(scaledHue), t3.call$1(scaledHue - 0.3333333333333333), alpha, t2); + } + }; + A.HwbColorSpace_convert_toRgb0.prototype = { + call$1(hue) { + return A.hueToRgb0(0, 1, hue) * this.factor + this._box_0.scaledWhiteness; + }, + $signature: 16 + }; + A.IDSelector0.prototype = { + get$specificity() { + return A._asInt(Math.pow(A.SimpleSelector0.prototype.get$specificity.call(this), 2)); + }, + accept$1$1(visitor) { + return visitor.visitIDSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + addSuffix$1(suffix) { + return new A.IDSelector0(this.name + suffix, this.span); + }, + unify$1(compound) { + if (B.JSArray_methods.any$1(compound, new A.IDSelector_unify_closure0(this))) + return null; + return this.super$SimpleSelector$unify0(compound); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.IDSelector0 && other.name === this.name; + }, + get$hashCode(_) { + return B.JSString_methods.get$hashCode(this.name); + } + }; + A.IDSelector_unify_closure0.prototype = { + call$1(simple) { + var t1; + if (simple instanceof A.IDSelector0) + t1 = this.$this.name !== simple.name; + else + t1 = false; + return t1; + }, + $signature: 14 + }; + A.IfExpression0.prototype = { + accept$1$1(visitor) { + return visitor.visitIfExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "if" + this.$arguments.toString$0(0); + }, + get$span(receiver) { + return this.span; + } + }; + A.IfRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitIfRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var result = A.ListExtensions_mapIndexed(this.clauses, new A.IfRule_toString_closure0(), type$.IfClause_2, type$.String).join$1(0, " "), + lastClause = this.lastClause; + return lastClause != null ? result + (" " + lastClause.toString$0(0)) : result; + }, + get$span(receiver) { + return this.span; + } + }; + A.IfRule_toString_closure0.prototype = { + call$2(index, clause) { + var t1 = index === 0 ? "if" : "else if"; + return "@" + t1 + " " + clause.expression.toString$0(0) + " {" + B.JSArray_methods.join$1(clause.children, " ") + "}"; + }, + $signature: 485 + }; + A.IfRuleClause0.prototype = {}; + A.IfRuleClause$__closure0.prototype = { + call$1(child) { + var t1; + $label0$0: { + if (child instanceof A.VariableDeclaration0 || child instanceof A.FunctionRule0 || child instanceof A.MixinRule0) { + t1 = true; + break $label0$0; + } + if (child instanceof A.ImportRule0) { + t1 = B.JSArray_methods.any$1(child.imports, new A.IfRuleClause$___closure0()); + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + $signature: 246 + }; + A.IfRuleClause$___closure0.prototype = { + call$1($import) { + return $import instanceof A.DynamicImport0; + }, + $signature: 247 + }; + A.IfClause0.prototype = { + toString$0(_) { + return "@if " + this.expression.toString$0(0) + " {" + B.JSArray_methods.join$1(this.children, " ") + "}"; + } + }; + A.ElseClause0.prototype = { + toString$0(_) { + return "@else {" + B.JSArray_methods.join$1(this.children, " ") + "}"; + } + }; + A.ImmutableList0.prototype = {}; + A.ImmutableMap0.prototype = {}; + A.immutableMapToDartMap_closure.prototype = { + call$3(value, key, _) { + this.dartMap.$indexSet(0, key, value); + }, + "call*": "call$3", + $requiredArgCount: 3, + $signature: 488 + }; + A.NodeImporter.prototype = { + loadRelative$3(url, previous, forImport) { + var t1, t2, _null = null; + if ($.$get$url().style.rootLength$1(url) > 0) { + if (!B.JSString_methods.startsWith$1(url, "/") && !B.JSString_methods.startsWith$1(url, "file:")) + return _null; + return this._tryPath$2($.$get$context().style.pathFromUri$1(A._parseUri(url)), forImport); + } + if ((previous == null ? _null : previous.get$scheme()) !== "file") + return _null; + t1 = $.$get$context(); + previous.toString; + t2 = t1.style; + return this._tryPath$2(A.join(t1.dirname$1(t2.pathFromUri$1(A._parseUri(previous))), t2.pathFromUri$1(A._parseUri(url)), _null), forImport); + }, + load$3(_, url, previous, forImport) { + var t1, t2, _i, _0_0, _this = this, + previousString = _this._previousToString$1(previous); + for (t1 = _this._implementation$_importers, t2 = t1.length, _i = 0; _i < t2; ++_i) { + _0_0 = A.wrapJSExceptions(new A.NodeImporter_load_closure(_this, t1[_i], forImport, url, previousString)); + if (_0_0 != null) + return _this._handleImportResult$4(url, previous, _0_0, forImport); + } + return _this._resolveLoadPathFromUrl$2(A.Uri_parse(url), forImport); + }, + loadAsync$3(url, previous, forImport) { + return this.loadAsync$body$NodeImporter(url, previous, forImport); + }, + loadAsync$body$NodeImporter(url, previous, forImport) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Record_2_String_and_String), + $async$returnValue, $async$self = this, t1, t2, _i, _0_0, previousString; + var $async$loadAsync$3 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + previousString = $async$self._previousToString$1(previous); + t1 = $async$self._implementation$_importers, t2 = t1.length, _i = 0; + case 3: + // for condition + if (!(_i < t2)) { + // goto after for + $async$goto = 5; + break; + } + $async$goto = 6; + return A._asyncAwait($async$self._callImporterAsync$4(t1[_i], url, previousString, forImport), $async$loadAsync$3); + case 6: + // returning from await. + _0_0 = $async$result; + if (_0_0 != null) { + $async$returnValue = $async$self._handleImportResult$4(url, previous, _0_0, forImport); + // goto return + $async$goto = 1; + break; + } + case 4: + // for update + ++_i; + // goto for condition + $async$goto = 3; + break; + case 5: + // after for + $async$returnValue = $async$self._resolveLoadPathFromUrl$2(A.Uri_parse(url), forImport); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$loadAsync$3, $async$completer); + }, + _previousToString$1(previous) { + var t1; + $label0$0: { + if (previous == null) { + t1 = "stdin"; + break $label0$0; + } + if ("file" === previous.get$scheme()) { + t1 = $.$get$context().style.pathFromUri$1(A._parseUri(previous)); + break $label0$0; + } + t1 = previous.toString$0(0); + break $label0$0; + } + return t1; + }, + _resolveLoadPathFromUrl$2(url, forImport) { + return url.get$scheme() === "" || url.get$scheme() === "file" ? this._resolveLoadPath$2($.$get$context().style.pathFromUri$1(A._parseUri(url)), forImport) : null; + }, + _resolveLoadPath$2(path, forImport) { + var t1, t2, _i, t3, _1_0, _null = null, + _0_0 = this._tryPath$2(A.absolute(path, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null), forImport); + if (_0_0 != null) + return _0_0; + for (t1 = this._includePaths, t2 = t1.length, _i = 0; _i < t2; ++_i) { + t3 = A.join(t1[_i], path, _null); + _1_0 = this._tryPath$2($.$get$context().absolute$15(t3, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null), forImport); + if (_1_0 != null) + return _1_0; + } + return _null; + }, + _tryPath$2(path, forImport) { + var t1 = forImport ? A.inImportRule(new A.NodeImporter__tryPath_closure(path), type$.nullable_String) : A.resolveImportPath0(path); + return A.NullableExtension_andThen0(t1, new A.NodeImporter__tryPath_closure0()); + }, + _handleImportResult$4(url, previous, value, forImport) { + var t1, file, contents, t2, resolved; + if (value instanceof self.Error) + throw A.wrapException(value); + if (!type$.NodeImporterResult._is(value)) + return null; + t1 = J.getInterceptor$x(value); + file = t1.get$file(value); + contents = t1.get$contents(value); + t1 = contents == null; + t2 = !t1; + if (t2 && A._asString(new self.Function("value", "return typeof value").call$1(contents)) !== "string") + A.jsThrow(new A.ArgumentError(true, contents, "contents", "must be a string but was: " + A.jsType(contents))); + if (file == null) + return new A._Record_2(t1 ? "" : contents, url); + else if (t2) + return new A._Record_2(contents, $.$get$context().toUri$1(file).toString$0(0)); + else { + resolved = this.loadRelative$3($.$get$context().toUri$1(file).toString$0(0), previous, forImport); + if (resolved == null) + resolved = this._resolveLoadPath$2(file, forImport); + if (resolved != null) + return resolved; + throw A.wrapException("Can't find stylesheet to import."); + } + }, + _callImporterAsync$4(importer, url, previousString, forImport) { + return this._callImporterAsync$body$NodeImporter(importer, url, previousString, forImport); + }, + _callImporterAsync$body$NodeImporter(importer, url, previousString, forImport) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.nullable_Object), + $async$returnValue, $async$self = this, t1, result; + var $async$_callImporterAsync$4 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = new A._Future($.Zone__current, type$._Future_Object); + result = A.wrapJSExceptions(new A.NodeImporter__callImporterAsync_closure($async$self, importer, forImport, url, previousString, new A._AsyncCompleter(t1, type$._AsyncCompleter_Object))); + $async$goto = A._asBool($.$get$_isUndefined().call$1(result)) ? 3 : 4; + break; + case 3: + // then + $async$goto = 5; + return A._asyncAwait(t1, $async$_callImporterAsync$4); + case 5: + // returning from await. + $async$returnValue = $async$result; + // goto return + $async$goto = 1; + break; + case 4: + // join + $async$returnValue = result; + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$_callImporterAsync$4, $async$completer); + }, + _renderContext$1(fromImport) { + var context = {options: type$.RenderContextOptions._as(this._implementation$_options), fromImport: fromImport}; + J.set$context$x(J.get$options$x(context), context); + return context; + } + }; + A.NodeImporter_load_closure.prototype = { + call$0() { + var _this = this; + return J.apply$2$x(_this.importer, _this.$this._renderContext$1(_this.forImport), A._setArrayType([_this.url, _this.previousString], type$.JSArray_Object)); + }, + $signature: 36 + }; + A.NodeImporter__tryPath_closure.prototype = { + call$0() { + return A.resolveImportPath0(this.path); + }, + $signature: 47 + }; + A.NodeImporter__tryPath_closure0.prototype = { + call$1(resolved) { + return new A._Record_2(A.readFile0(resolved), $.$get$context().toUri$1(resolved).toString$0(0)); + }, + $signature: 489 + }; + A.NodeImporter__callImporterAsync_closure.prototype = { + call$0() { + var _this = this; + return J.apply$2$x(_this.importer, _this.$this._renderContext$1(_this.forImport), A._setArrayType([_this.url, _this.previousString, A.allowInterop(_this.completer.get$complete())], type$.JSArray_Object)); + }, + $signature: 36 + }; + A.ModifiableCssImport0.prototype = { + accept$1$1(visitor) { + return visitor.visitCssImport$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + get$span(receiver) { + return this.span; + } + }; + A.ImportCache0.prototype = { + canonicalize$4$baseImporter$baseUrl$forImport(_, url, baseImporter, baseUrl, forImport) { + var t1, resolvedUrl, key, relativeResult, t2, t3, t4, t5, t6, cacheable, i, importer, perImporterKey, t7, _1_0, _1_2_isSet, result, _1_2, _2_0, _2_1, _2_5_isSet, _2_5, _2_3, _2_3_isSet, j, _this = this, _null = null; + if (A.isBrowser()) + t1 = (baseImporter == null || baseImporter instanceof A.NoOpImporter0) && _this._import_cache$_importers.length === 0; + else + t1 = false; + if (t1) + throw A.wrapException(string$.Custom); + if (baseImporter != null && url.get$scheme() === "") { + resolvedUrl = baseUrl == null ? _null : baseUrl.resolveUri$1(url); + if (resolvedUrl == null) + resolvedUrl = url; + key = new A._Record_3_forImport(baseImporter, resolvedUrl, forImport); + relativeResult = _this._import_cache$_perImporterCanonicalizeCache.putIfAbsent$2(key, new A.ImportCache_canonicalize_closure0(_this, baseImporter, resolvedUrl, baseUrl, forImport, key, url)); + if (relativeResult != null) + return relativeResult; + } + key = new A._Record_2_forImport(url, forImport); + t1 = _this._import_cache$_canonicalizeCache; + if (t1.containsKey$1(key)) + return t1.$index(0, key); + for (t2 = _this._import_cache$_importers, t3 = type$.Record_1_nullable_Object, t4 = _this._import_cache$_perImporterCanonicalizeCache, t5 = type$.nullable_Record_3_Importer_and_Uri_and_Uri_originalUrl_2, t6 = type$.Record_3_Importer_and_Uri_and_Uri_originalUrl_2, cacheable = true, i = 0; i < t2.length; ++i) { + importer = t2[i]; + perImporterKey = new A._Record_3_forImport(importer, url, forImport); + if (t4.containsKey$1(perImporterKey)) { + t7 = t4.$index(0, perImporterKey); + _1_0 = new A._Record_1(t7 == null ? t5._as(t7) : t7); + } else + _1_0 = _null; + _1_2_isSet = t3._is(_1_0); + result = _null; + if (_1_2_isSet) { + _1_2 = _1_0._0; + t7 = _1_2 != null; + if (t7) { + t6._as(_1_2); + result = _1_2; + } + } else { + _1_2 = _null; + t7 = false; + } + if (t7) + return result; + if (_1_2_isSet) + t7 = _1_2 == null; + else + t7 = false; + if (t7) + continue; + $label0$1: { + _2_0 = _this._import_cache$_canonicalize$4(importer, url, baseUrl, forImport); + _2_1 = _2_0._0; + _2_5_isSet = _2_1 != null; + _2_5 = _null; + _2_3 = _null; + t7 = false; + if (_2_5_isSet) { + result = _2_1 == null ? t6._as(_2_1) : _2_1; + _2_3 = _2_0._1; + t7 = _2_3; + _2_5 = t7; + t7 = t7 && cacheable; + } else + result = _null; + if (t7) { + t1.$indexSet(0, key, result); + return result; + } + if (_2_5_isSet) { + t7 = _2_5; + _2_3_isSet = _2_5_isSet; + } else { + _2_3 = _2_0._1; + t7 = _2_3; + _2_3_isSet = true; + } + t7 = t7 && !cacheable; + if (t7) { + t4.$indexSet(0, perImporterKey, _2_1); + if (_2_1 != null) + return _2_1; + break $label0$1; + } + t7 = false === (_2_3_isSet ? _2_3 : _2_0._1); + if (t7) { + if (cacheable) { + for (j = 0; j < i; ++j) + t4.$indexSet(0, new A._Record_3_forImport(t2[j], url, forImport), _null); + cacheable = false; + } + if (_2_1 != null) + return _2_1; + } + } + } + if (cacheable) + t1.$indexSet(0, key, _null); + return _null; + }, + _import_cache$_canonicalize$4(importer, url, baseUrl, forImport) { + var passContainingUrl, canonicalizeContext, t1, result, cacheable; + if (baseUrl != null) + passContainingUrl = url.get$scheme() === "" || importer.isNonCanonicalScheme$1(url.get$scheme()); + else + passContainingUrl = false; + canonicalizeContext = new A.CanonicalizeContext0(forImport, passContainingUrl ? baseUrl : null); + t1 = type$.nullable_Object; + result = A.runZoned(new A.ImportCache__canonicalize_closure0(importer, url), A.LinkedHashMap_LinkedHashMap$_literal([B.Symbol__canonicalizeContext, canonicalizeContext], t1, t1), type$.nullable_Uri); + cacheable = !passContainingUrl || !canonicalizeContext._canonicalize_context$_wasContainingUrlAccessed; + if (result == null) + return new A._Record_2(null, cacheable); + if (result.get$scheme() !== "" && importer.isNonCanonicalScheme$1(result.get$scheme())) + throw A.wrapException("Importer " + importer.toString$0(0) + " canonicalized " + url.toString$0(0) + " to " + result.toString$0(0) + string$.x2c_whicu); + return new A._Record_2(new A._Record_3_originalUrl(importer, result, url), cacheable); + }, + importCanonical$3$originalUrl(importer, canonicalUrl, originalUrl) { + return this._import_cache$_importCache.putIfAbsent$2(canonicalUrl, new A.ImportCache_importCanonical_closure0(this, importer, canonicalUrl, originalUrl)); + }, + humanize$1(canonicalUrl) { + var t1 = this._import_cache$_canonicalizeCache, + t2 = type$.NonNullsIterable_Record_3_Importer_and_Uri_and_Uri_originalUrl_2; + t2 = A.NullableExtension_andThen0(A.minBy(new A.MappedIterable(new A.WhereIterable(new A.NonNullsIterable(new A.LinkedHashMapValuesIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapValuesIterable<2>")), t2), new A.ImportCache_humanize_closure3(canonicalUrl), t2._eval$1("WhereIterable")), new A.ImportCache_humanize_closure4(), t2._eval$1("MappedIterable")), new A.ImportCache_humanize_closure5()), new A.ImportCache_humanize_closure6(canonicalUrl)); + return t2 == null ? canonicalUrl : t2; + }, + sourceMapUrl$1(_, canonicalUrl) { + var t1 = this._import_cache$_resultsCache.$index(0, canonicalUrl); + t1 = t1 == null ? null : t1.get$sourceMapUrl(0); + return t1 == null ? canonicalUrl : t1; + } + }; + A.ImportCache_canonicalize_closure0.prototype = { + call$0() { + var _this = this, + t1 = _this.$this, + t2 = _this.baseUrl, + _0_0 = t1._import_cache$_canonicalize$4(_this.baseImporter, _this.resolvedUrl, t2, _this.forImport); + if (t2 != null) + t1._import_cache$_nonCanonicalRelativeUrls.$indexSet(0, _this.key, _this.url); + return _0_0._0; + }, + $signature: 490 + }; + A.ImportCache__canonicalize_closure0.prototype = { + call$0() { + return this.importer.canonicalize$1(0, this.url); + }, + $signature: 144 + }; + A.ImportCache_importCanonical_closure0.prototype = { + call$0() { + var t3, _this = this, + t1 = Date.now(), + t2 = _this.canonicalUrl, + result = _this.importer.load$1(0, t2); + if (result == null) + return null; + t3 = _this.$this; + t3._import_cache$_loadTimes.$indexSet(0, t2, new A.DateTime(t1, 0, false)); + t3._import_cache$_resultsCache.$indexSet(0, t2, result); + t3 = result.contents; + t1 = result.syntax; + t2 = _this.originalUrl.resolveUri$1(t2); + return A.Stylesheet_Stylesheet$parse0(t3, t1, t2); + }, + $signature: 491 + }; + A.ImportCache_humanize_closure3.prototype = { + call$1(result) { + return result._1.$eq(0, this.canonicalUrl); + }, + $signature: 492 + }; + A.ImportCache_humanize_closure4.prototype = { + call$1(result) { + return result._2; + }, + $signature: 493 + }; + A.ImportCache_humanize_closure5.prototype = { + call$1(url) { + return url.get$path(url).length; + }, + $signature: 80 + }; + A.ImportCache_humanize_closure6.prototype = { + call$1(url) { + var t1 = $.$get$url(), + t2 = this.canonicalUrl; + return url.resolve$1(0, A.ParsedPath_ParsedPath$parse(t2.get$path(t2), t1.style).get$basename()); + }, + $signature: 50 + }; + A.ImportRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitImportRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "@import " + B.JSArray_methods.join$1(this.imports, ", ") + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A.JSImporter.prototype = {}; + A.JSImporterResult.prototype = {}; + A.Importer0.prototype = { + isNonCanonicalScheme$1(scheme) { + return false; + } + }; + A.NodeImporterResult0.prototype = {}; + A.IncludeRule0.prototype = { + get$spanWithoutContent() { + var t2, t3, + t1 = this.span; + if (!(this.content == null)) { + t2 = t1.file; + t3 = this.$arguments.span; + t3 = A.SpanExtensions_trimRight0(A.SpanExtensions_trimLeft0(t2.span$2(0, A.FileLocation$_(t2, t1._file$_start).offset, t3.get$end(t3).offset))); + t1 = t3; + } + return t1; + }, + get$nameSpan() { + var startSpan, scanner, _null = null, + t1 = this.span, + t2 = t1._file$_start, + t3 = t1._end, + t4 = t1.file._decodedChars; + if (B.JSString_methods.startsWith$1(A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t4, t2, t3), 0, _null), "+")) + startSpan = A.SpanExtensions_trimLeft0(A.FileSpanExtension_subspan(t1, 1, _null)); + else { + scanner = A.StringScanner$(A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t4, t2, t3), 0, _null), _null, _null); + scanner.expectChar$1(64); + A._scanIdentifier0(scanner); + startSpan = A.SpanExtensions_trimLeft0(A.FileSpanExtension_subspan(t1, scanner._string_scanner$_position, _null)); + } + return A.SpanExtensions_initialIdentifier0(this.namespace != null ? A.FileSpanExtension_subspan(A.SpanExtensions_withoutInitialIdentifier0(startSpan), 1, _null) : startSpan); + }, + accept$1$1(visitor) { + return visitor.visitIncludeRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t2, _this = this, + t1 = _this.namespace; + t1 = t1 != null ? "@include " + (t1 + ".") : "@include "; + t1 += _this.name; + t2 = _this.$arguments; + if (!t2.get$isEmpty(0)) + t1 += "(" + t2.toString$0(0) + ")"; + t2 = _this.content; + t1 += t2 == null ? ";" : " " + t2.toString$0(0); + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + get$span(receiver) { + return this.span; + } + }; + A.InterpolatedFunctionExpression0.prototype = { + accept$1$1(visitor) { + return visitor.visitInterpolatedFunctionExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return this.name.toString$0(0) + this.$arguments.toString$0(0); + }, + get$span(receiver) { + return this.span; + } + }; + A.Interpolation0.prototype = { + get$asPlain() { + var _0_1, t1, _0_6_isSet, _0_6, _0_60, first, + _0_0 = this.contents; + $label0$0: { + _0_1 = _0_0.length; + if (_0_1 <= 0) { + t1 = ""; + break $label0$0; + } + _0_6_isSet = _0_1 === 1; + if (_0_6_isSet) { + _0_6 = _0_0[0]; + _0_60 = _0_6; + t1 = typeof _0_6 == "string"; + _0_6 = _0_60; + } else { + _0_6 = null; + t1 = false; + } + if (t1) { + first = A._asString(_0_6_isSet ? _0_6 : _0_0[0]); + t1 = first; + break $label0$0; + } + t1 = null; + break $label0$0; + } + return t1; + }, + get$initialPlain() { + var _0_4_isSet, _0_4, _0_40, t1, first, + _0_0 = this.contents; + $label0$0: { + _0_4_isSet = _0_0.length >= 1; + if (_0_4_isSet) { + _0_4 = _0_0[0]; + _0_40 = _0_4; + t1 = typeof _0_4 == "string"; + _0_4 = _0_40; + } else { + _0_4 = null; + t1 = false; + } + if (t1) { + first = A._asString(_0_4_isSet ? _0_4 : _0_0[0]); + t1 = first; + break $label0$0; + } + t1 = ""; + break $label0$0; + } + return t1; + }, + spanForElement$1(index) { + var t1, t2, t3, t4, _this = this; + $label0$0: { + if (typeof _this.contents[index] == "string") { + t1 = _this.span; + t2 = t1.get$file(t1); + if (index === 0) + t3 = t1.get$start(t1); + else { + t3 = _this.spans[index - 1]; + t3 = t3.get$end(t3); + } + t4 = _this.spans; + if (index === t4.length) + t1 = t1.get$end(t1); + else { + t1 = t4[index + 1]; + t1 = t1.get$start(t1); + } + t1 = t2.span$2(0, t3.offset, t1.offset); + break $label0$0; + } + t1 = _this.spans[index]; + t1.toString; + break $label0$0; + } + return t1; + }, + Interpolation$30(contents, spans, span) { + var t1, t2, t3, t4, i, t5, isString, _s5_ = "spans", + _s8_ = "contents"; + if (spans.length !== J.get$length$asx(contents)) + throw A.wrapException(A.ArgumentError$value(this.spans, _s5_, "Must be the same length as contents.")); + for (t1 = this.contents, t2 = t1.length, t3 = spans.length, t4 = this.spans, i = 0; i < t2; ++i) { + t5 = t1[i]; + isString = typeof t5 == "string"; + if (!isString && !(t5 instanceof A.Expression0)) + throw A.wrapException(A.ArgumentError$value(t1, _s8_, "May only contain Strings or Expressions.")); + else if (isString) { + if (i !== 0 && typeof t1[i - 1] == "string") + throw A.wrapException(A.ArgumentError$value(t1, _s8_, "May not contain adjacent Strings.")); + else if (i < t3 && t4[i] != null) + throw A.wrapException(A.ArgumentError$value(t4, _s5_, string$.May_no + i + ").")); + } else if (i >= t3 || t4[i] == null) + throw A.wrapException(A.ArgumentError$value(t4, _s5_, string$.Must_n + i + ").")); + } + }, + toString$0(_) { + var t1 = this.contents; + return new A.MappedListIterable(t1, new A.Interpolation_toString_closure0(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,String>")).join$0(0); + }, + $isAstNode0: 1, + $isSassNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.Interpolation_toString_closure0.prototype = { + call$1(value) { + return typeof value == "string" ? value : "#{" + A.S(value) + "}"; + }, + $signature: 132 + }; + A.SupportsInterpolation0.prototype = { + toInterpolation$0() { + var t1 = this.span; + return A.Interpolation$0(A._setArrayType([this.expression], type$.JSArray_Object), A._setArrayType([t1], type$.JSArray_nullable_FileSpan), t1); + }, + withSpan$1(span) { + return new A.SupportsInterpolation0(this.expression, span); + }, + toString$0(_) { + return "#{" + this.expression.toString$0(0) + "}"; + }, + $isAstNode0: 1, + $isSassNode: 1, + $isSupportsCondition: 1, + get$span(receiver) { + return this.span; + } + }; + A.InterpolationBuffer0.prototype = { + writeCharCode$1(character) { + var t1 = this._interpolation_buffer0$_text, + t2 = A.Primitives_stringFromCharCode(character); + t1._contents += t2; + return null; + }, + add$2(_, expression, span) { + this._interpolation_buffer0$_flushText$0(); + this._interpolation_buffer0$_contents.push(expression); + this._interpolation_buffer0$_spans.push(span); + }, + addInterpolation$1(interpolation) { + var spansToAdd, _0_4_isSet, _0_4, _0_40, first, rest, t2, t3, _this = this, + toAdd = interpolation.contents, + t1 = toAdd.length; + if (t1 === 0) + return; + spansToAdd = interpolation.spans; + _0_4_isSet = t1 >= 1; + if (_0_4_isSet) { + _0_4 = toAdd[0]; + _0_40 = _0_4; + t1 = typeof _0_4 == "string"; + _0_4 = _0_40; + } else { + _0_4 = null; + t1 = false; + } + if (t1) { + first = A._asString(_0_4_isSet ? _0_4 : toAdd[0]); + rest = B.JSArray_methods.sublist$1(toAdd, 1); + t1 = _this._interpolation_buffer0$_text; + t1._contents += first; + spansToAdd = A.SubListIterable$(spansToAdd, 1, null, A._arrayInstanceType(spansToAdd)._precomputed1); + toAdd = rest; + } + _this._interpolation_buffer0$_flushText$0(); + t1 = _this._interpolation_buffer0$_contents; + B.JSArray_methods.addAll$1(t1, toAdd); + t2 = _this._interpolation_buffer0$_spans; + B.JSArray_methods.addAll$1(t2, spansToAdd); + if (typeof B.JSArray_methods.get$last(t1) == "string") { + t3 = _this._interpolation_buffer0$_text; + t1 = A.S(t1.pop()); + t3._contents += t1; + t2.pop(); + } + }, + _interpolation_buffer0$_flushText$0() { + var t1 = this._interpolation_buffer0$_text, + t2 = t1._contents; + if (t2.length === 0) + return; + this._interpolation_buffer0$_contents.push(t2.charCodeAt(0) == 0 ? t2 : t2); + this._interpolation_buffer0$_spans.push(null); + t1._contents = ""; + }, + interpolation$1(span) { + var t1 = A.List_List$of(this._interpolation_buffer0$_contents, true, type$.Object), + t2 = this._interpolation_buffer0$_text, + t3 = t2._contents; + if (t3.length !== 0) + t1.push(t3.charCodeAt(0) == 0 ? t3 : t3); + t3 = A.List_List$of(this._interpolation_buffer0$_spans, true, type$.nullable_FileSpan); + if (t2._contents.length !== 0) + t3.push(null); + return A.Interpolation$0(t1, t3, span); + }, + toString$0(_) { + var t1, t2, _i, t3, element; + for (t1 = this._interpolation_buffer0$_contents, t2 = t1.length, _i = 0, t3 = ""; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + element = t1[_i]; + t3 = typeof element == "string" ? t3 + element : t3 + "#{" + A.S(element) + A.Primitives_stringFromCharCode(125); + } + t1 = t3 + this._interpolation_buffer0$_text.toString$0(0); + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + }; + A.InterpolationMap0.prototype = { + mapException$1(error) { + var source, startIndex, endIndex, t3, t4, _this = this, + target = error.get$span(error), + t1 = _this._interpolation_map$_interpolation, + t2 = t1.contents; + if (t2.length === 0) + return new A.SourceSpanFormatException(error.get$source(), error._span_exception$_message, t1.span); + source = _this.mapSpan$1(target); + startIndex = _this._interpolation_map$_indexInContents$1(target.get$start(target)); + endIndex = _this._interpolation_map$_indexInContents$1(target.get$end(target)); + t1 = error._span_exception$_message; + if (!A.SubListIterable$(t2, startIndex, null, A._arrayInstanceType(t2)._precomputed1).take$1(0, endIndex - startIndex + 1).any$1(0, new A.InterpolationMap_mapException_closure0())) + return new A.SourceSpanFormatException(error.get$source(), t1, source); + else { + t2 = type$.SourceSpan; + t3 = type$.String; + t4 = A.LinkedHashMap_LinkedHashMap$_literal([target, "error in interpolated output"], t2, t3); + return new A.MultiSourceSpanFormatException(error.get$source(), "", A.ConstantMap_ConstantMap$from(t4, t2, t3), t1, source); + } + }, + mapSpan$1(target) { + var _0_10, t1, _0_2_isSet, _0_20, t2, start, end, _this = this, _null = null, + _0_1 = _this._interpolation_map$_mapLocation$1(target.get$start(target)), + _0_2 = _this._interpolation_map$_mapLocation$1(target.get$end(target)); + $label0$0: { + _0_10 = _0_1; + t1 = type$.FileSpan; + _0_2_isSet = t1._is(_0_1); + _0_20 = _null; + t2 = false; + if (_0_2_isSet) { + t1._as(_0_10); + _0_20 = _0_2; + t2 = t1._is(_0_2); + start = _0_10; + _0_1 = start; + } else { + start = _null; + _0_1 = _0_10; + } + if (t2) { + t1 = start.expand$1(0, t1._as(_0_2_isSet ? _0_20 : _0_2)); + break $label0$0; + } + t2 = false; + if (t1._is(_0_1)) { + if (_0_2_isSet) + t2 = _0_20; + else { + t2 = _0_2; + _0_20 = t2; + _0_2_isSet = true; + } + t2 = t2 instanceof A.FileLocation; + start = _0_1; + } else + start = _null; + if (t2) { + t1 = _0_2_isSet ? _0_20 : _0_2; + type$.FileLocation._as(t1); + t2 = _this._interpolation_map$_interpolation.span; + t1 = t2.get$file(t2).span$2(0, _this._interpolation_map$_expandInterpolationSpanLeft$1(start.get$start(start)), t1.offset); + break $label0$0; + } + t2 = false; + if (_0_1 instanceof A.FileLocation) { + if (_0_2_isSet) + t2 = _0_20; + else { + t2 = _0_2; + _0_20 = t2; + _0_2_isSet = true; + } + t2 = t1._is(t2); + start = _0_1; + } else + start = _null; + if (t2) { + end = t1._as(_0_2_isSet ? _0_20 : _0_2); + t1 = _this._interpolation_map$_interpolation.span; + t1 = t1.get$file(t1).span$2(0, start.offset, _this._interpolation_map$_expandInterpolationSpanRight$1(end.get$end(end))); + break $label0$0; + } + t1 = false; + if (_0_1 instanceof A.FileLocation) { + if (_0_2_isSet) + t1 = _0_20; + else { + t1 = _0_2; + _0_20 = t1; + _0_2_isSet = true; + } + t1 = t1 instanceof A.FileLocation; + start = _0_1; + } else + start = _null; + if (t1) { + t1 = _0_2_isSet ? _0_20 : _0_2; + type$.FileLocation._as(t1); + t2 = _this._interpolation_map$_interpolation.span; + t1 = t2.get$file(t2).span$2(0, start.offset, t1.offset); + break $label0$0; + } + t1 = A.throwExpression("[BUG] Unreachable"); + } + return t1; + }, + _interpolation_map$_mapLocation$1(target) { + var index, _0_0, t3, previousLocation, _this = this, + t1 = _this._interpolation_map$_interpolation, + t2 = t1.contents; + if (t2.length === 0) + return t1.span; + index = _this._interpolation_map$_indexInContents$1(target); + _0_0 = t2[index]; + if (_0_0 instanceof A.Expression0) + return _0_0.get$span(_0_0); + t3 = index === 0; + t1 = t1.span; + if (t3) + previousLocation = t1.get$start(t1); + else { + t1 = t1.get$file(t1); + t2 = type$.Expression_2._as(t2[index - 1]); + t2 = t2.get$span(t2); + previousLocation = A.FileLocation$_(t1, _this._interpolation_map$_expandInterpolationSpanRight$1(t2.get$end(t2))); + } + t1 = t3 ? 0 : _this._interpolation_map$_targetLocations[index - 1].get$offset(); + return A.FileLocation$_(previousLocation.file, previousLocation.offset + (target.offset - t1)); + }, + _interpolation_map$_indexInContents$1(target) { + var t1, t2, t3, i; + for (t1 = this._interpolation_map$_targetLocations, t2 = t1.length, t3 = target.offset, i = 0; i < t2; ++i) + if (t3 < t1[i].get$offset()) + return i; + return this._interpolation_map$_interpolation.contents.length - 1; + }, + _interpolation_map$_expandInterpolationSpanLeft$1(start) { + var i0, prev, char, + source = start.file._decodedChars, + i = start.offset - 1; + for (; i >= 0;) { + i0 = i - 1; + prev = source[i]; + if (prev === 123) { + if (source[i0] === 35) { + i = i0; + break; + } + i = i0; + } else if (prev === 47) { + i = i0 - 1; + if (source[i0] === 42) + for (; true;) { + i0 = i - 1; + if (source[i] !== 42) { + i = i0; + continue; + } + i = i0; + do { + i0 = i - 1; + char = source[i]; + if (char === 42) { + i = i0; + continue; + } else + break; + } while (true); + if (char === 47) { + i = i0; + break; + } + i = i0; + } + } else + i = i0; + } + return i; + }, + _interpolation_map$_expandInterpolationSpanRight$1(end) { + var t1, i0, next, second, t2, char, + source = end.file._decodedChars, + i = end.offset; + for (t1 = source.length; i < t1;) { + i0 = i + 1; + next = source[i]; + if (next === 125) { + i = i0; + break; + } + if (next === 47) { + i = i0 + 1; + second = source[i0]; + if (second === 47) { + while (true) { + i0 = i + 1; + t2 = source[i]; + if (!!(t2 === 10 || t2 === 13 || t2 === 12)) + break; + i = i0; + } + i = i0; + } else if (second === 42) + for (; true;) { + i0 = i + 1; + if (source[i] !== 42) { + i = i0; + continue; + } + i = i0; + do { + i0 = i + 1; + char = source[i]; + if (char === 42) { + i = i0; + continue; + } else + break; + } while (true); + if (char === 47) { + i = i0; + break; + } + i = i0; + } + } else + i = i0; + } + return i; + } + }; + A.InterpolationMap_mapException_closure0.prototype = { + call$1($content) { + return $content instanceof A.Expression0; + }, + $signature: 77 + }; + A.InterpolationMethod0.prototype = { + toString$0(_) { + var t1 = this.hue; + t1 = t1 == null ? "" : " " + t1.toString$0(0) + " hue"; + return this.space.name + t1; + } + }; + A.HueInterpolationMethod0.prototype = { + _enumToString$0() { + return "HueInterpolationMethod." + this._name; + } + }; + A._realCasePath_helper0.prototype = { + call$2(path, realPath) { + var dirname = $.$get$context().dirname$1(path); + if (dirname === path) + return path; + return $._realCaseCache0.putIfAbsent$2(path, new A._realCasePath_helper_closure0(path, realPath, this, dirname)); + }, + call$1(path) { + return this.call$2(path, null); + }, + $signature: 149 + }; + A._realCasePath_helper_closure0.prototype = { + call$0() { + var realPathNonNull, realDirname, basename, matches, t1, _0_0, match, realPathNonNull0, exception, _this = this, + t2 = _this.path; + if (!A.linkExists0(t2)) { + realPathNonNull = null; + try { + realPathNonNull0 = _this.realPath; + realPathNonNull = realPathNonNull0 == null ? A.realpath0(t2) : realPathNonNull0; + } catch (exception) { + if (A.unwrapException(exception) instanceof A.FileSystemException0) + return t2; + else + throw exception; + } + t1 = realPathNonNull; + t2 = $.$get$context(); + return A.join(_this.helper.call$2(_this.dirname, t2.dirname$1(t1)), A.ParsedPath_ParsedPath$parse(realPathNonNull, t2.style).get$basename(), null); + } + realDirname = _this.helper.call$1(_this.dirname); + basename = A.ParsedPath_ParsedPath$parse(t2, $.$get$context().style).get$basename(); + try { + matches = J.where$1$ax(A.listDir0(realDirname), new A._realCasePath_helper__closure0(basename)).toList$0(0); + t1 = null; + _0_0 = matches; + $label0$0: { + match = null; + if (J.get$length$asx(_0_0) === 1) { + match = J.$index$asx(_0_0, 0); + t1 = match; + break $label0$0; + } + t1 = A.join(realDirname, basename, null); + break $label0$0; + } + t1 = t1; + return t1; + } catch (exception) { + if (A.unwrapException(exception) instanceof A.FileSystemException0) + return t2; + else + throw exception; + } + }, + $signature: 26 + }; + A._realCasePath_helper__closure0.prototype = { + call$1(realPath) { + return A.equalsIgnoreCase0(A.ParsedPath_ParsedPath$parse(realPath, $.$get$context().style).get$basename(), this.basename); + }, + $signature: 5 + }; + A.IsCalculationSafeVisitor0.prototype = { + visitBinaryOperationExpression$1(_, node) { + return B.Set_oQTdo0.contains$1(0, node.operator) && node.left.accept$1(this) && node.right.accept$1(this); + }, + visitBooleanExpression$1(_, node) { + return false; + }, + visitColorExpression$1(_, node) { + return false; + }, + visitFunctionExpression$1(_, node) { + return true; + }, + visitInterpolatedFunctionExpression$1(_, node) { + return true; + }, + visitIfExpression$1(_, node) { + return true; + }, + visitListExpression$1(_, node) { + var t1 = false; + if (node.separator === B.ListSeparator_qSL0) + if (!node.hasBrackets) { + t1 = node.contents; + t1 = t1.length > 1 && B.JSArray_methods.every$1(t1, new A.IsCalculationSafeVisitor_visitListExpression_closure0(this)); + } + return t1; + }, + visitMapExpression$1(_, node) { + return false; + }, + visitNullExpression$1(_, node) { + return false; + }, + visitNumberExpression$1(_, node) { + return true; + }, + visitParenthesizedExpression$1(_, node) { + return node.expression.accept$1(this); + }, + visitSelectorExpression$1(_, node) { + return false; + }, + visitStringExpression$1(_, node) { + var text, t1, t2; + if (node.hasQuotes) + return false; + text = node.text.get$initialPlain(); + t1 = false; + if (!B.JSString_methods.startsWith$1(text, "!")) + if (!B.JSString_methods.startsWith$1(text, "#")) { + t2 = text.length; + if ((1 >= t2 ? null : text.charCodeAt(1)) !== 43) + t1 = (3 >= t2 ? null : text.charCodeAt(3)) !== 40; + } + return t1; + }, + visitSupportsExpression$1(_, node) { + return false; + }, + visitUnaryOperationExpression$1(_, node) { + return false; + }, + visitValueExpression$1(_, node) { + return false; + }, + visitVariableExpression$1(_, node) { + return true; + }, + $isExpressionVisitor: 1 + }; + A.IsCalculationSafeVisitor_visitListExpression_closure0.prototype = { + call$1(expression) { + return expression.accept$1(this.$this); + }, + $signature: 140 + }; + A.FileSystemException0.prototype = { + toString$0(_) { + var t1 = $.$get$context(); + return t1.prettyUri$1(t1.toUri$1(this.path)) + ": " + this.message; + }, + get$message(receiver) { + return this.message; + } + }; + A._readFile_closure0.prototype = { + call$0() { + return J.readFileSync$2$x(A.fs(), this.path, this.encoding); + }, + $signature: 59 + }; + A.fileExists_closure0.prototype = { + call$0() { + var error, systemError, exception, + t1 = this.path; + if (!J.existsSync$1$x(A.fs(), t1)) + return false; + try { + t1 = J.isFile$0$x(J.statSync$1$x(A.fs(), t1)); + return t1; + } catch (exception) { + error = A.unwrapException(exception); + systemError = type$.JsSystemError._as(error); + if (J.$eq$(J.get$code$x(systemError), "ENOENT")) + return false; + throw exception; + } + }, + $signature: 19 + }; + A.dirExists_closure0.prototype = { + call$0() { + var error, systemError, exception, + t1 = this.path; + if (!J.existsSync$1$x(A.fs(), t1)) + return false; + try { + t1 = J.isDirectory$0$x(J.statSync$1$x(A.fs(), t1)); + return t1; + } catch (exception) { + error = A.unwrapException(exception); + systemError = type$.JsSystemError._as(error); + if (J.$eq$(J.get$code$x(systemError), "ENOENT")) + return false; + throw exception; + } + }, + $signature: 19 + }; + A.linkExists_closure0.prototype = { + call$0() { + var error, systemError, t1, exception; + try { + t1 = J.isSymbolicLink$0$x(J.lstatSync$1$x(A.fs(), this.path)); + return t1; + } catch (exception) { + error = A.unwrapException(exception); + systemError = type$.JsSystemError._as(error); + if (J.$eq$(J.get$code$x(systemError), "ENOENT")) + return false; + throw exception; + } + }, + $signature: 19 + }; + A.listDir_closure0.prototype = { + call$0() { + var t1 = this.path; + if (!this.recursive) + return J.map$1$1$ax(J.readdirSync$1$x(A.fs(), t1), new A.listDir__closure1(t1), type$.String).super$Iterable$where(0, new A.listDir__closure2()); + else + return new A.listDir_closure_list0().call$1(t1); + }, + $signature: 152 + }; + A.listDir__closure1.prototype = { + call$1(child) { + return A.join(this.path, A._asString(child), null); + }, + $signature: 134 + }; + A.listDir__closure2.prototype = { + call$1(child) { + return !A.dirExists0(child); + }, + $signature: 5 + }; + A.listDir_closure_list0.prototype = { + call$1($parent) { + return J.expand$1$1$ax(J.readdirSync$1$x(A.fs(), $parent), new A.listDir__list_closure0($parent, this), type$.String); + }, + $signature: 153 + }; + A.listDir__list_closure0.prototype = { + call$1(child) { + var path = A.join(this.parent, A._asString(child), null); + return A.dirExists0(path) ? this.list.call$1(path) : A._setArrayType([path], type$.JSArray_String); + }, + $signature: 154 + }; + A.realpath_closure0.prototype = { + call$0() { + return J.native$1$x(J.get$realpathSync$x(A.fs()), this.path); + }, + $signature: 26 + }; + A.main_closure.prototype = { + call$2(_, __) { + }, + $signature: 494 + }; + A.main_closure0.prototype = { + call$2(_, __) { + }, + $signature: 495 + }; + A.JSToDartLogger.prototype = { + internalWarn$4$deprecation$span$trace(message, deprecation, span, trace) { + var t2, t3, t4, + t1 = this._node, + _0_0 = t1 == null ? null : J.get$warn$x(t1); + if (_0_0 != null) { + t1 = span == null ? self.undefined : span; + t2 = J.toString$0$(trace); + t3 = deprecation == null; + t4 = $.$get$deprecations(); + _0_0.call$2(message, {deprecation: !t3, deprecationType: t4.$index(0, t3 ? null : deprecation.id), span: t1, stack: t2}); + } else + this._withAscii$1(new A.JSToDartLogger_internalWarn_closure(this, message, span, trace, deprecation)); + }, + debug$2(_, message, span) { + var t1 = this._node, + _0_0 = t1 == null ? null : J.get$debug$x(t1); + if (_0_0 != null) + _0_0.call$2(message, {span: span}); + else + this._withAscii$1(new A.JSToDartLogger_debug_closure(this, message, span)); + }, + _withAscii$1$1(callback) { + var t1, + wasAscii = $._glyphs === B.C_AsciiGlyphSet; + $._glyphs = this._ascii ? B.C_AsciiGlyphSet : B.C_UnicodeGlyphSet; + try { + t1 = callback.call$0(); + return t1; + } finally { + $._glyphs = wasAscii ? B.C_AsciiGlyphSet : B.C_UnicodeGlyphSet; + } + }, + _withAscii$1(callback) { + return this._withAscii$1$1(callback, type$.dynamic); + } + }; + A.JSToDartLogger_internalWarn_closure.prototype = { + call$0() { + var _this = this; + $label0$0: { + _this.$this._fallback.internalWarn$4$deprecation$span$trace(_this.message, _this.deprecation, _this.span, _this.trace); + break $label0$0; + } + }, + $signature: 1 + }; + A.JSToDartLogger_debug_closure.prototype = { + call$0() { + return this.$this._fallback.debug$2(0, this.message, this.span); + }, + $signature: 0 + }; + A.ModifiableCssKeyframeBlock0.prototype = { + accept$1$1(visitor) { + return visitor.visitCssKeyframeBlock$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + equalsIgnoringChildren$1(other) { + return other instanceof A.ModifiableCssKeyframeBlock0 && B.C_ListEquality.equals$2(0, this.selector.value, other.selector.value); + }, + copyWithoutChildren$0() { + return A.ModifiableCssKeyframeBlock$0(this.selector, this.span); + }, + get$span(receiver) { + return this.span; + } + }; + A.KeyframeSelectorParser0.prototype = { + parse$0(_) { + return this.wrapSpanFormatException$1(new A.KeyframeSelectorParser_parse_closure0(this)); + }, + _keyframe_selector$_percentage$0() { + var $self, _0_0, + t1 = this.scanner, + t2 = t1.scanChar$1(43) ? "" + A.Primitives_stringFromCharCode(43) : "", + second = t1.peekChar$0(); + if (!(second != null && second >= 48 && second <= 57) && second !== 46) + t1.error$1(0, "Expected number."); + while (true) { + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + break; + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + } + if (t1.peekChar$0() === 46) { + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + while (true) { + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + break; + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + } + } + if (this.scanIdentChar$1(101)) { + t2 += A.Primitives_stringFromCharCode(101); + _0_0 = t1.peekChar$0(); + if (43 === _0_0 || 45 === _0_0) + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + t1.error$1(0, "Expected digit."); + do { + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + $self = t1.peekChar$0(); + } while ($self != null && $self >= 48 && $self <= 57); + } + t1.expectChar$1(37); + t2 += A.Primitives_stringFromCharCode(37); + return t2.charCodeAt(0) == 0 ? t2 : t2; + } + }; + A.KeyframeSelectorParser_parse_closure0.prototype = { + call$0() { + var selectors = A._setArrayType([], type$.JSArray_String), + t1 = this.$this, + t2 = t1.scanner; + do { + t1.whitespace$1$consumeNewlines(true); + if (t1.lookingAtIdentifier$0()) + if (t1.scanIdentifier$1("from")) + selectors.push("from"); + else { + t1.expectIdentifier$2$name("to", '"to" or "from"'); + selectors.push("to"); + } + else + selectors.push(t1._keyframe_selector$_percentage$0()); + t1.whitespace$1$consumeNewlines(true); + } while (t2.scanChar$1(44)); + t2.expectDone$0(); + return selectors; + }, + $signature: 138 + }; + A.LabColorSpace0.prototype = { + get$isBoundedInternal() { + return false; + }, + convert$7$missingChroma$missingHue(dest, lightness, a, b, alpha, missingChroma, missingHue) { + var powerlessAB, t1, missingLightness, f1, t2, t3, t4; + switch (dest) { + case B.LabColorSpace_2nT0: + powerlessAB = lightness == null || A.fuzzyEquals0(lightness, 0); + t1 = a == null || powerlessAB ? null : a; + return A.SassColor$_forSpace0(B.LabColorSpace_2nT0, lightness, t1, b == null || powerlessAB ? null : b, alpha, null); + case B.LchColorSpace_Bpv0: + return A.labToLch0(dest, lightness, a, b, alpha, false, false); + default: + missingLightness = lightness == null; + if (missingLightness) + lightness = 0; + f1 = (lightness + 16) / 116; + t1 = a == null; + t2 = this._lab$_convertFToXorZ$1((t1 ? 0 : a) / 500 + f1); + t3 = lightness > 8 ? Math.pow(f1, 3) : lightness / 903.2962962962963; + t4 = b == null; + return B.XyzD50ColorSpace_2OB0.convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, t2 * 0.9642956764295677, t3, this._lab$_convertFToXorZ$1(f1 - (t4 ? 0 : b) / 200) * 0.8251046025104602, alpha, t1, t4, missingChroma, missingHue, missingLightness); + } + }, + convert$5(dest, lightness, a, b, alpha) { + return this.convert$7$missingChroma$missingHue(dest, lightness, a, b, alpha, false, false); + }, + _lab$_convertFToXorZ$1(component) { + var cubed = Math.pow(component, 3) + 0; + return cubed > 0.008856451679035631 ? cubed : (116 * component - 16) / 903.2962962962963; + } + }; + A.LazyFileSpan0.prototype = { + get$span(_) { + var t1 = this._lazy_file_span0$_span; + return t1 == null ? this._lazy_file_span0$_span = this._lazy_file_span0$_builder.call$0() : t1; + }, + compareTo$1(_, other) { + return this.get$span(0).compareTo$1(0, other); + }, + get$context(_) { + var t1 = this.get$span(0); + return t1.get$context(t1); + }, + get$end(_) { + var t1 = this.get$span(0); + return t1.get$end(t1); + }, + expand$1(_, other) { + return this.get$span(0).expand$1(0, other); + }, + get$file(_) { + var t1 = this.get$span(0); + return t1.get$file(t1); + }, + highlight$1$color(color) { + return this.get$span(0).highlight$1$color(color); + }, + get$length(_) { + var t1 = this.get$span(0); + return t1.get$length(t1); + }, + message$2$color(_, message, color) { + return this.get$span(0).message$2$color(0, message, color); + }, + message$1(_, message) { + return this.message$2$color(0, message, null); + }, + get$sourceUrl(_) { + var t1 = this.get$span(0); + return t1.get$sourceUrl(t1); + }, + get$start(_) { + var t1 = this.get$span(0); + return t1.get$start(t1); + }, + get$text() { + return this.get$span(0).get$text(); + }, + $isComparable: 1, + $isFileSpan: 1, + $isSourceSpan: 1, + $isSourceSpanWithContext: 1 + }; + A.LchColorSpace0.prototype = { + get$isBoundedInternal() { + return false; + }, + get$isPolarInternal() { + return true; + }, + convert$5(dest, lightness, chroma, hue, alpha) { + var t1 = hue == null, + hueRadians = (t1 ? 0 : hue) * 3.141592653589793 / 180, + t2 = chroma == null, + t3 = t2 ? 0 : chroma, + t4 = Math.cos(hueRadians), + t5 = t2 ? 0 : chroma; + return B.LabColorSpace_2nT0.convert$7$missingChroma$missingHue(dest, lightness, t3 * t4, t5 * Math.sin(hueRadians), alpha, t2, t1); + } + }; + A.render_closure.prototype = { + call$0() { + var error, exception; + try { + this.callback.call$2(null, A.renderSync(this.options)); + } catch (exception) { + error = A.unwrapException(exception); + this.callback.call$2(error, null); + } + return null; + }, + $signature: 1 + }; + A.render_closure0.prototype = { + call$1(result) { + this.callback.call$2(null, result); + }, + $signature: 586 + }; + A.render_closure1.prototype = { + call$2(error, stackTrace) { + var t2, t3, _null = null, + t1 = this.callback; + if (error instanceof A.SassException0) + t1.call$2(A._wrapException(error, stackTrace), _null); + else { + t2 = J.toString$0$(error); + t3 = A.getTrace0(error); + t1.call$2(A._newRenderError(t2, t3 == null ? stackTrace : t3, _null, _null, _null, 3), _null); + } + }, + $signature: 46 + }; + A._parseFunctions_closure.prototype = { + call$2(signature, callback) { + var _0_0, _this = this, + t1 = _this.options, + context = {options: A._contextOptions(t1, _this.start)}; + J.set$context$x(J.get$options$x(context), context); + _0_0 = J.get$fiber$x(t1); + t1 = {}; + t1.fiber = null; + if (_0_0 != null) { + t1.fiber = _0_0; + _this.result.push(A.Callable_Callable$fromSignature(B.JSString_methods.trimLeft$0(signature), new A._parseFunctions__closure(t1, callback, context), false)); + } else { + t1 = _this.result; + if (!_this.asynch) + t1.push(A.Callable_Callable$fromSignature(B.JSString_methods.trimLeft$0(signature), new A._parseFunctions__closure0(callback, context), false)); + else + t1.push(A.AsyncCallable_AsyncCallable$fromSignature(B.JSString_methods.trimLeft$0(signature), new A._parseFunctions__closure1(callback, context), false)); + } + }, + $signature: 126 + }; + A._parseFunctions__closure.prototype = { + call$1($arguments) { + var result, + t1 = this._box_0, + currentFiber = J.get$current$x(t1.fiber), + t2 = type$.Object; + t2 = A.List_List$of(J.map$1$1$ax($arguments, A.value0__wrapValue$closure(), t2), true, t2); + t2.push(A.allowInterop(new A._parseFunctions___closure2(currentFiber))); + result = A.wrapJSExceptions(new A._parseFunctions___closure3(this.callback, this.context, t2)); + return A.unwrapValue(A._asBool($.$get$_isUndefined().call$1(result)) ? A.runZoned(new A._parseFunctions___closure4(t1), null, type$.nullable_Object) : result); + }, + $signature: 3 + }; + A._parseFunctions___closure2.prototype = { + call$1(result) { + A.scheduleMicrotask(new A._parseFunctions____closure(this.currentFiber, result)); + }, + call$0() { + return this.call$1(null); + }, + "call*": "call$1", + $requiredArgCount: 0, + $defaultValues() { + return [null]; + }, + $signature: 91 + }; + A._parseFunctions____closure.prototype = { + call$0() { + return J.run$1$x(this.currentFiber, this.result); + }, + $signature: 0 + }; + A._parseFunctions___closure3.prototype = { + call$0() { + return J.apply$2$x(type$.JSFunction._as(this.callback), this.context, this.jsArguments); + }, + $signature: 36 + }; + A._parseFunctions___closure4.prototype = { + call$0() { + return J.yield$0$x(this._box_0.fiber); + }, + $signature: 84 + }; + A._parseFunctions__closure0.prototype = { + call$1($arguments) { + return A.unwrapValue(A.wrapJSExceptions(new A._parseFunctions___closure1(this.callback, this.context, $arguments))); + }, + $signature: 3 + }; + A._parseFunctions___closure1.prototype = { + call$0() { + var t1 = type$.JSFunction._as(this.callback), + t2 = J.map$1$1$ax(this.$arguments, A.value0__wrapValue$closure(), type$.Object); + return J.apply$2$x(t1, this.context, A.List_List$of(t2, true, t2.$ti._eval$1("ListIterable.E"))); + }, + $signature: 36 + }; + A._parseFunctions__closure1.prototype = { + call$1($arguments) { + return this.$call$body$_parseFunctions__closure($arguments); + }, + $call$body$_parseFunctions__closure($arguments) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.Value_2), + $async$returnValue, $async$self = this, result, t1, t2, $async$temp1; + var $async$call$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) + return A._asyncRethrow($async$result, $async$completer); + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = new A._Future($.Zone__current, type$._Future_nullable_Object); + t2 = type$.Object; + t2 = A.List_List$of(J.map$1$1$ax($arguments, A.value0__wrapValue$closure(), t2), true, t2); + t2.push(A.allowInterop(new A._parseFunctions___closure(new A._AsyncCompleter(t1, type$._AsyncCompleter_nullable_Object)))); + result = A.wrapJSExceptions(new A._parseFunctions___closure0($async$self.callback, $async$self.context, t2)); + $async$temp1 = A; + $async$goto = A._asBool($.$get$_isUndefined().call$1(result)) ? 3 : 5; + break; + case 3: + // then + $async$goto = 6; + return A._asyncAwait(t1, $async$call$1); + case 6: + // returning from await. + // goto join + $async$goto = 4; + break; + case 5: + // else + $async$result = result; + case 4: + // join + $async$returnValue = $async$temp1.unwrapValue($async$result); + // goto return + $async$goto = 1; + break; + case 1: + // return + return A._asyncReturn($async$returnValue, $async$completer); + } + }); + return A._asyncStartSync($async$call$1, $async$completer); + }, + $signature: 86 + }; + A._parseFunctions___closure.prototype = { + call$1(result) { + return this.completer.complete$1(result); + }, + call$0() { + return this.call$1(null); + }, + "call*": "call$1", + $requiredArgCount: 0, + $defaultValues() { + return [null]; + }, + $signature: 217 + }; + A._parseFunctions___closure0.prototype = { + call$0() { + return J.apply$2$x(type$.JSFunction._as(this.callback), this.context, this.jsArguments); + }, + $signature: 36 + }; + A._parseImporter_closure.prototype = { + call$1(importer) { + return type$.JSFunction._as(A.allowInteropCaptureThis(new A._parseImporter__closure(this._box_0, importer))); + }, + $signature: 497 + }; + A._parseImporter__closure.prototype = { + call$4(thisArg, url, previous, _) { + var t1 = this._box_0, + result = J.apply$2$x(this.importer, thisArg, A._setArrayType([url, previous, A.allowInterop(new A._parseImporter___closure(J.get$current$x(t1.fiber)))], type$.JSArray_Object)); + if (A._asBool($.$get$_isUndefined().call$1(result))) + return A.runZoned(new A._parseImporter___closure0(t1), null, type$.Object); + return result; + }, + call$3(thisArg, url, previous) { + return this.call$4(thisArg, url, previous, null); + }, + "call*": "call$4", + $requiredArgCount: 3, + $defaultValues() { + return [null]; + }, + $signature: 498 + }; + A._parseImporter___closure.prototype = { + call$1(result) { + A.scheduleMicrotask(new A._parseImporter____closure(this.currentFiber, result)); + }, + $signature: 499 + }; + A._parseImporter____closure.prototype = { + call$0() { + return J.run$1$x(this.currentFiber, this.result); + }, + $signature: 0 + }; + A._parseImporter___closure0.prototype = { + call$0() { + return J.yield$0$x(this._box_0.fiber); + }, + $signature: 84 + }; + A.LimitedMapView0.prototype = { + get$keys(_) { + return this._limited_map_view0$_keys; + }, + get$length(_) { + return this._limited_map_view0$_keys._collection$_length; + }, + get$isEmpty(_) { + return this._limited_map_view0$_keys._collection$_length === 0; + }, + get$isNotEmpty(_) { + return this._limited_map_view0$_keys._collection$_length !== 0; + }, + $index(_, key) { + return this._limited_map_view0$_keys.contains$1(0, key) ? this._limited_map_view0$_map.$index(0, key) : null; + }, + containsKey$1(key) { + return this._limited_map_view0$_keys.contains$1(0, key); + }, + remove$1(_, key) { + return this._limited_map_view0$_keys.contains$1(0, key) ? this._limited_map_view0$_map.remove$1(0, key) : null; + } + }; + A.ListExpression0.prototype = { + accept$1$1(visitor) { + return visitor.visitListExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t2, t3, t4, t5, _this = this, + t1 = _this.hasBrackets; + if (t1) + t2 = "" + A.Primitives_stringFromCharCode(91); + else { + t2 = _this.contents.length; + if (t2 !== 0) + t2 = t2 === 1 && _this.separator === B.ListSeparator_qVN0; + else + t2 = true; + t2 = t2 ? "" + A.Primitives_stringFromCharCode(40) : ""; + } + t3 = _this.contents; + t4 = _this.separator === B.ListSeparator_qVN0; + t5 = t4 ? ", " : " "; + t5 = t2 + new A.MappedListIterable(t3, new A.ListExpression_toString_closure0(_this), A._arrayInstanceType(t3)._eval$1("MappedListIterable<1,String>")).join$1(0, t5); + if (t1) + t1 = t5 + A.Primitives_stringFromCharCode(93); + else { + t1 = t3.length; + if (t1 === 0) + t1 = t5 + A.Primitives_stringFromCharCode(41); + else + t1 = t1 === 1 && t4 ? t5 + ",)" : t5; + } + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _list3$_elementNeedsParens$1(expression) { + var childSeparator, t1, _0_13; + $label0$0: { + if (expression instanceof A.ListExpression0 && expression.contents.length >= 2 && !expression.hasBrackets) { + childSeparator = expression.separator; + t1 = this.separator === B.ListSeparator_qVN0 ? childSeparator === B.ListSeparator_qVN0 : childSeparator !== B.ListSeparator_undecided_null_undecided0; + break $label0$0; + } + if (expression instanceof A.UnaryOperationExpression0) { + _0_13 = expression.operator; + if (B.UnaryOperator_Rbl0 !== _0_13) + t1 = B.UnaryOperator_UCP0 === _0_13; + else + t1 = true; + } else + t1 = false; + if (t1) { + t1 = this.separator === B.ListSeparator_qSL0; + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + get$span(receiver) { + return this.span; + } + }; + A.ListExpression_toString_closure0.prototype = { + call$1(element) { + return this.$this._list3$_elementNeedsParens$1(element) ? "(" + element.toString$0(0) + ")" : element.toString$0(0); + }, + $signature: 113 + }; + A._length_closure2.prototype = { + call$1($arguments) { + return A.SassNumber_SassNumber0(J.$index$asx($arguments, 0).get$asList().length, null); + }, + $signature: 22 + }; + A._nth_closure0.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + list = t1.$index($arguments, 0), + index = t1.$index($arguments, 1); + return list.get$asList()[list.sassIndexToListIndex$2(index, "n")]; + }, + $signature: 3 + }; + A._setNth_closure0.prototype = { + call$1($arguments) { + var newList, + t1 = J.getInterceptor$asx($arguments), + list = t1.$index($arguments, 0), + index = t1.$index($arguments, 1), + value = t1.$index($arguments, 2); + t1 = list.get$asList(); + newList = A._setArrayType(t1.slice(0), A._arrayInstanceType(t1)); + newList[list.sassIndexToListIndex$2(index, "n")] = value; + return list.withListContents$1(newList); + }, + $signature: 28 + }; + A._join_closure0.prototype = { + call$1($arguments) { + var _0_1, _0_4, _0_3, t2, t3, _0_40, separator, bracketed, _null = null, + t1 = J.getInterceptor$asx($arguments), + list1 = t1.$index($arguments, 0), + list2 = t1.$index($arguments, 1), + separatorParam = t1.$index($arguments, 2).assertString$1("separator"), + bracketedParam = t1.$index($arguments, 3), + _1_0 = separatorParam._string0$_text; + $label1$1: { + if ("auto" === _1_0) { + _0_1 = list1.get$separator(list1); + _0_4 = list2.get$separator(list2); + $label0$0: { + t1 = _null; + _0_3 = B.ListSeparator_undecided_null_undecided0 === _0_1; + t2 = _0_3; + if (t2) { + t3 = B.ListSeparator_undecided_null_undecided0 === _0_4; + _0_40 = _0_4; + } else { + _0_40 = _null; + t3 = false; + } + if (t3) { + t1 = B.ListSeparator_qSL0; + break $label0$0; + } + if (_0_3) + separator = t2 ? _0_40 : _0_4; + else + separator = t1; + if (!_0_3) + separator = _0_1; + t1 = separator; + break $label0$0; + } + break $label1$1; + } + if ("space" === _1_0) { + t1 = B.ListSeparator_qSL0; + break $label1$1; + } + if ("comma" === _1_0) { + t1 = B.ListSeparator_qVN0; + break $label1$1; + } + if ("slash" === _1_0) { + t1 = B.ListSeparator_bRz0; + break $label1$1; + } + t1 = A.throwExpression(A.SassScriptException$0(string$.x24separ, _null)); + } + bracketed = bracketedParam instanceof A.SassString0 && bracketedParam._string0$_text === "auto" ? list1.get$hasBrackets() : bracketedParam.get$isTruthy(); + t2 = A.List_List$of(list1.get$asList(), true, type$.Value_2); + B.JSArray_methods.addAll$1(t2, list2.get$asList()); + return A.SassList$0(t2, t1, bracketed); + }, + $signature: 28 + }; + A._append_closure2.prototype = { + call$1($arguments) { + var t2, + t1 = J.getInterceptor$asx($arguments), + list = t1.$index($arguments, 0), + value = t1.$index($arguments, 1), + _0_0 = t1.$index($arguments, 2).assertString$1("separator")._string0$_text; + $label0$0: { + if ("auto" === _0_0) { + t1 = list.get$separator(list) === B.ListSeparator_undecided_null_undecided0 ? B.ListSeparator_qSL0 : list.get$separator(list); + break $label0$0; + } + if ("space" === _0_0) { + t1 = B.ListSeparator_qSL0; + break $label0$0; + } + if ("comma" === _0_0) { + t1 = B.ListSeparator_qVN0; + break $label0$0; + } + if ("slash" === _0_0) { + t1 = B.ListSeparator_bRz0; + break $label0$0; + } + t1 = A.throwExpression(A.SassScriptException$0(string$.x24separ, null)); + } + t2 = A.List_List$of(list.get$asList(), true, type$.Value_2); + t2.push(value); + return list.withListContents$2$separator(t2, t1); + }, + $signature: 28 + }; + A._zip_closure0.prototype = { + call$1($arguments) { + var results, result, _box_0 = {}, + t1 = J.$index$asx($arguments, 0).get$asList(), + t2 = A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,List>"), + lists = A.List_List$of(new A.MappedListIterable(t1, new A._zip__closure2(), t2), true, t2._eval$1("ListIterable.E")); + if (lists.length === 0) + return B.SassList_BlY0; + _box_0.i = 0; + results = A._setArrayType([], type$.JSArray_SassList_2); + for (t1 = A._arrayInstanceType(lists)._eval$1("MappedListIterable<1,Value0>"), t2 = type$.Value_2; B.JSArray_methods.every$1(lists, new A._zip__closure3(_box_0));) { + result = A.List_List$from(new A.MappedListIterable(lists, new A._zip__closure4(_box_0), t1), false, t2); + result.$flags = 3; + results.push(new A.SassList0(result, B.ListSeparator_qSL0, false)); + ++_box_0.i; + } + return A.SassList$0(results, B.ListSeparator_qVN0, false); + }, + $signature: 28 + }; + A._zip__closure2.prototype = { + call$1(list) { + return list.get$asList(); + }, + $signature: 501 + }; + A._zip__closure3.prototype = { + call$1(list) { + return this._box_0.i !== J.get$length$asx(list); + }, + $signature: 502 + }; + A._zip__closure4.prototype = { + call$1(list) { + return J.$index$asx(list, this._box_0.i); + }, + $signature: 3 + }; + A._index_closure2.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + index = B.JSArray_methods.indexOf$1(t1.$index($arguments, 0).get$asList(), t1.$index($arguments, 1)); + return index === -1 ? B.C__SassNull0 : A.SassNumber_SassNumber0(index + 1, null); + }, + $signature: 3 + }; + A._separator_closure0.prototype = { + call$1($arguments) { + var t1 = J.$index$asx($arguments, 0), + _0_0 = t1.get$separator(t1); + $label0$0: { + if (B.ListSeparator_qVN0 === _0_0) { + t1 = new A.SassString0("comma", false); + break $label0$0; + } + if (B.ListSeparator_bRz0 === _0_0) { + t1 = new A.SassString0("slash", false); + break $label0$0; + } + t1 = new A.SassString0("space", false); + break $label0$0; + } + return t1; + }, + $signature: 18 + }; + A._isBracketed_closure0.prototype = { + call$1($arguments) { + return J.$index$asx($arguments, 0).get$hasBrackets() ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._slash_closure0.prototype = { + call$1($arguments) { + var list = J.$index$asx($arguments, 0).get$asList(); + if (list.length < 2) + throw A.wrapException(A.SassScriptException$0("At least two elements are required.", null)); + return A.SassList$0(list, B.ListSeparator_bRz0, false); + }, + $signature: 28 + }; + A.SelectorList0.prototype = { + get$asSassList() { + var t1 = this.components; + return A.SassList$0(new A.MappedListIterable(t1, new A.SelectorList_asSassList_closure0(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Value0>")), B.ListSeparator_qVN0, false); + }, + accept$1$1(visitor) { + return visitor.visitSelectorList$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + unify$1(other) { + var t3, t4, t5, t6, _i, complex1, t7, _i0, t8, + t1 = type$.JSArray_ComplexSelector_2, + t2 = A._setArrayType([], t1); + for (t3 = this.components, t4 = t3.length, t5 = other.components, t6 = t5.length, _i = 0; _i < t4; ++_i) { + complex1 = t3[_i]; + for (t7 = complex1.span, _i0 = 0; _i0 < t6; ++_i0) { + t8 = A.unifyComplex0(A._setArrayType([complex1, t5[_i0]], t1), t7); + if (t8 != null) + B.JSArray_methods.addAll$1(t2, t8); + } + } + return t2.length === 0 ? null : A.SelectorList$0(t2, this.span); + }, + nestWithin$3$implicitParent$preserveParentSelectors($parent, implicitParent, preserveParentSelectors) { + var parentSelector, t1, _this = this; + if ($parent == null) { + if (preserveParentSelectors) + return _this; + parentSelector = B.C__ParentSelectorVisitor0.visitSelectorList$1(_this); + if (parentSelector == null) + return _this; + throw A.wrapException(A.SassException$0(string$.Top_les, parentSelector.span, null)); + } + t1 = _this.components; + return A.SelectorList$0(A.flattenVertically0(new A.MappedListIterable(t1, new A.SelectorList_nestWithin_closure0(_this, preserveParentSelectors, implicitParent, $parent), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Iterable>")), type$.ComplexSelector_2), _this.span); + }, + nestWithin$1($parent) { + return this.nestWithin$3$implicitParent$preserveParentSelectors($parent, true, false); + }, + nestWithin$2$implicitParent($parent, implicitParent) { + return this.nestWithin$3$implicitParent$preserveParentSelectors($parent, implicitParent, false); + }, + _list2$_nestWithinCompound$2(component, $parent) { + var resolvedSimples, parentSelector, error, stackTrace, t2, resolvedSimples0, exception, + t1 = component.selector, + simples = t1.components, + containsSelectorPseudo = J.any$1$ax(simples, new A.SelectorList__nestWithinCompound_closure2()); + if (!containsSelectorPseudo && !(J.get$first$ax(simples) instanceof A.ParentSelector0)) + return null; + if (containsSelectorPseudo) { + t2 = simples; + resolvedSimples0 = new A.MappedListIterable(t2, new A.SelectorList__nestWithinCompound_closure3($parent), A._arrayInstanceType(t2)._eval$1("MappedListIterable<1,SimpleSelector0>")); + } else + resolvedSimples0 = simples; + resolvedSimples = resolvedSimples0; + parentSelector = J.get$first$ax(simples); + try { + if (!(parentSelector instanceof A.ParentSelector0)) { + t2 = component.span; + t2 = A._setArrayType([A.ComplexSelector$0(B.List_empty14, A._setArrayType([new A.ComplexSelectorComponent0(A.CompoundSelector$0(resolvedSimples, t1.span), A.List_List$unmodifiable(component.combinators, type$.CssValue_Combinator_2), t2)], type$.JSArray_ComplexSelectorComponent_2), t2, false)], type$.JSArray_ComplexSelector_2); + return t2; + } else if (J.get$length$asx(simples) === 1 && parentSelector.suffix == null) { + t1 = $parent.withAdditionalCombinators$1(component.combinators); + return t1.components; + } + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException0) { + error = t1; + stackTrace = A.getTraceFromException(exception); + A.throwWithTrace0(error.withAdditionalSpan$2(parentSelector.span, "parent selector"), error, stackTrace); + } else + throw exception; + } + t1 = $parent.components; + return new A.MappedListIterable(t1, new A.SelectorList__nestWithinCompound_closure4(parentSelector, resolvedSimples, component), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,ComplexSelector0>")); + }, + isSuperselector$1(other) { + return A.listIsSuperselector0(this.components, other.components); + }, + withAdditionalCombinators$1(combinators) { + var t1; + if (combinators.length === 0) + t1 = this; + else { + t1 = this.components; + t1 = A.SelectorList$0(new A.MappedListIterable(t1, new A.SelectorList_withAdditionalCombinators_closure0(combinators), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,ComplexSelector0>")), this.span); + } + return t1; + }, + get$hashCode(_) { + return B.C_ListEquality0.hash$1(this.components); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.SelectorList0 && B.C_ListEquality.equals$2(0, this.components, other.components); + } + }; + A.SelectorList_asSassList_closure0.prototype = { + call$1(complex) { + var t3, t4, _i, component, visitor, t5, t6, t7, _i0, _null = null, + t1 = type$.JSArray_Value_2, + t2 = A._setArrayType([], t1); + for (t3 = complex.leadingCombinators, t4 = t3.length, _i = 0; _i < t4; ++_i) + t2.push(new A.SassString0(J.toString$0$(t3[_i].value), false)); + for (t3 = complex.components, t4 = t3.length, _i = 0; _i < t4; ++_i) { + component = t3[_i]; + visitor = A._SerializeVisitor$0(_null, true, _null, _null, true, false, _null, true); + component.selector.accept$1(visitor); + t5 = A._setArrayType([new A.SassString0(visitor._serialize0$_buffer.toString$0(0), false)], t1); + for (t6 = component.combinators, t7 = t6.length, _i0 = 0; _i0 < t7; ++_i0) + t5.push(new A.SassString0(J.toString$0$(t6[_i0].value), false)); + B.JSArray_methods.addAll$1(t2, t5); + } + return A.SassList$0(t2, B.ListSeparator_qSL0, false); + }, + $signature: 503 + }; + A.SelectorList_nestWithin_closure0.prototype = { + call$1(complex) { + var t1, newComplexes, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, _i, component, resolved, i, t12, t13, t14, _i0, newComplex, t15, t16, _this = this; + if (_this.preserveParentSelectors || complex.accept$1(B.C__ParentSelectorVisitor0) == null) { + if (!_this.implicitParent) + return A._setArrayType([complex], type$.JSArray_ComplexSelector_2); + t1 = _this.parent.components; + return new A.MappedListIterable(t1, new A.SelectorList_nestWithin__closure1(complex), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,ComplexSelector0>")); + } + t1 = type$.JSArray_ComplexSelector_2; + newComplexes = A._setArrayType([], t1); + for (t2 = complex.components, t3 = t2.length, t4 = _this.$this, t5 = _this.parent, t6 = type$.ComplexSelector_2, t7 = complex.leadingCombinators, t8 = t7.length === 0, t9 = complex.span, t10 = type$.ComplexSelectorComponent_2, t11 = type$.JSArray_ComplexSelectorComponent_2, _i = 0; _i < t3; ++_i) { + component = t2[_i]; + resolved = t4._list2$_nestWithinCompound$2(component, t5); + if (resolved == null) + if (newComplexes.length === 0) + newComplexes.push(A.ComplexSelector$0(t7, A._setArrayType([component], t11), t9, false)); + else + for (i = 0; i < newComplexes.length; ++i) { + t12 = newComplexes[i]; + t13 = A.List_List$of(t12.components, true, t10); + t13.push(component); + newComplexes[i] = A.ComplexSelector$0(t12.leadingCombinators, t13, t9, t12.lineBreak); + } + else if (newComplexes.length === 0) + B.JSArray_methods.addAll$1(newComplexes, t8 ? resolved : J.map$1$1$ax(resolved, new A.SelectorList_nestWithin__closure2(complex), t6)); + else { + t12 = A._setArrayType([], t1); + for (t13 = newComplexes.length, t14 = J.getInterceptor$ax(resolved), _i0 = 0; _i0 < newComplexes.length; newComplexes.length === t13 || (0, A.throwConcurrentModificationError)(newComplexes), ++_i0) { + newComplex = newComplexes[_i0]; + for (t15 = t14.get$iterator(resolved), t16 = newComplex.span; t15.moveNext$0();) + t12.push(newComplex.concatenate$2(t15.get$current(t15), t16)); + } + newComplexes = t12; + } + } + return newComplexes; + }, + $signature: 504 + }; + A.SelectorList_nestWithin__closure1.prototype = { + call$1(parentComplex) { + var t1 = this.complex; + return parentComplex.concatenate$2(t1, t1.span); + }, + $signature: 58 + }; + A.SelectorList_nestWithin__closure2.prototype = { + call$1(resolvedComplex) { + var t1 = resolvedComplex.leadingCombinators, + t2 = this.complex, + t3 = t2.leadingCombinators; + if (t1.length === 0) + t1 = t3; + else { + t3 = A.List_List$of(t3, true, type$.CssValue_Combinator_2); + B.JSArray_methods.addAll$1(t3, t1); + t1 = t3; + } + return A.ComplexSelector$0(t1, resolvedComplex.components, t2.span, resolvedComplex.lineBreak); + }, + $signature: 58 + }; + A.SelectorList__nestWithinCompound_closure2.prototype = { + call$1(simple) { + var selector; + if (!(simple instanceof A.PseudoSelector0)) + return false; + selector = simple.selector; + return selector != null && selector.accept$1(B.C__ParentSelectorVisitor0) != null; + }, + $signature: 14 + }; + A.SelectorList__nestWithinCompound_closure3.prototype = { + call$1(simple) { + var selector, t1, _0_2; + $label0$0: { + selector = null; + t1 = false; + if (simple instanceof A.PseudoSelector0) { + _0_2 = simple.selector; + if (_0_2 != null) { + selector = _0_2 == null ? type$.SelectorList_2._as(_0_2) : _0_2; + t1 = selector.accept$1(B.C__ParentSelectorVisitor0) != null; + } + } + if (t1) { + t1 = simple.withSelector$1(selector.nestWithin$2$implicitParent(this.parent, false)); + break $label0$0; + } + t1 = simple; + break $label0$0; + } + return t1; + }, + $signature: 505 + }; + A.SelectorList__nestWithinCompound_closure4.prototype = { + call$1(complex) { + var lastComponent, suffix, lastSimples, t1, t2, last, t3, error, stackTrace, t4, t5, t6, t7, exception, _this = this; + try { + t4 = complex.components; + lastComponent = B.JSArray_methods.get$last(t4); + if (lastComponent.combinators.length !== 0) { + t1 = A.MultiSpanSassException$0('Selector "' + complex.toString$0(0) + string$.x22x20can_, A.SpanExtensions_trimRight0(lastComponent.span), "outer selector", A.LinkedHashMap_LinkedHashMap$_literal([_this.parentSelector.span, "parent selector"], type$.FileSpan, type$.String), null); + throw A.wrapException(t1); + } + suffix = _this.parentSelector.suffix; + lastSimples = lastComponent.selector.components; + t5 = type$.SimpleSelector_2; + t6 = _this.resolvedSimples; + t7 = J.getInterceptor$ax(t6); + if (suffix == null) { + t1 = A.List_List$of(lastSimples, true, t5); + J.addAll$1$ax(t1, t7.skip$1(t6, 1)); + t1 = t1; + } else { + t2 = A.List_List$of(A.IterableExtension_get_exceptLast0(lastSimples), true, t5); + J.add$1$ax(t2, J.get$last$ax(lastSimples).addSuffix$1(suffix)); + J.addAll$1$ax(t2, t7.skip$1(t6, 1)); + t1 = t2; + } + t2 = _this.component; + last = A.CompoundSelector$0(t1, t2.selector.span); + t3 = A.List_List$of(A.IterableExtension_get_exceptLast0(t4), true, type$.ComplexSelectorComponent_2); + t4 = t2.span; + J.add$1$ax(t3, new A.ComplexSelectorComponent0(last, A.List_List$unmodifiable(t2.combinators, type$.CssValue_Combinator_2), t4)); + t4 = A.ComplexSelector$0(complex.leadingCombinators, t3, t4, complex.lineBreak); + return t4; + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.SassException0) { + error = t1; + stackTrace = A.getTraceFromException(exception); + A.throwWithTrace0(error.withAdditionalSpan$2(_this.parentSelector.span, "parent selector"), error, stackTrace); + } else + throw exception; + } + }, + $signature: 58 + }; + A.SelectorList_withAdditionalCombinators_closure0.prototype = { + call$1(complex) { + return complex.withAdditionalCombinators$1(this.combinators); + }, + $signature: 58 + }; + A._ParentSelectorVisitor0.prototype = { + visitParentSelector$1(selector) { + return selector; + } + }; + A.__ParentSelectorVisitor_Object_SelectorSearchVisitor0.prototype = {}; + A.listClass_closure.prototype = { + call$0() { + var t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.SassList", new A.listClass__closure())); + J.get$$prototype$x(jsClass).get = A.allowInteropCaptureThisNamed("get", new A.listClass__closure0()); + A.JSClassExtension_injectSuperclass(t1._as(B.SassList_apG.constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.listClass__closure.prototype = { + call$3($self, contentsOrOptions, options) { + var contents, t1, t2; + if (self.immutable.isList(contentsOrOptions)) + contents = J.cast$1$0$ax(J.toArray$0$x(type$.ImmutableList._as(contentsOrOptions)), type$.Value_2); + else if (type$.List_dynamic._is(contentsOrOptions)) + contents = J.cast$1$0$ax(contentsOrOptions, type$.Value_2); + else { + contents = A._setArrayType([], type$.JSArray_Value_2); + type$.nullable__ConstructorOptions._as(contentsOrOptions); + options = contentsOrOptions; + } + t1 = options == null; + if (!t1) { + t2 = J.get$separator$x(options); + t2 = A._asBool($.$get$_isUndefined().call$1(t2)); + } else + t2 = true; + t2 = t2 ? B.ListSeparator_qVN0 : A.jsToDartSeparator(J.get$separator$x(options)); + t1 = t1 ? null : J.get$brackets$x(options); + return A.SassList$0(contents, t2, t1 == null ? false : t1); + }, + call$1($self) { + return this.call$3($self, null, null); + }, + call$2($self, contentsOrOptions) { + return this.call$3($self, contentsOrOptions, null); + }, + "call*": "call$3", + $requiredArgCount: 1, + $defaultValues() { + return [null, null]; + }, + $signature: 506 + }; + A.listClass__closure0.prototype = { + call$2($self, indexFloat) { + var index = B.JSNumber_methods.floor$0(indexFloat); + if (index < 0) + index = $self.get$asList().length + index; + if (index < 0 || index >= $self.get$asList().length) + return self.undefined; + return $self.get$asList()[index]; + }, + $signature: 248 + }; + A._ConstructorOptions.prototype = {}; + A._NodeSassList.prototype = {}; + A.legacyListClass_closure.prototype = { + call$4(thisArg, $length, commaSeparator, dartValue) { + var t1; + if (dartValue == null) { + $length.toString; + t1 = A.Iterable_Iterable$generate($length, new A.legacyListClass__closure(), type$.Value_2); + t1 = A.SassList$0(t1, commaSeparator !== false ? B.ListSeparator_qVN0 : B.ListSeparator_qSL0, false); + } else + t1 = dartValue; + J.set$dartValue$x(thisArg, t1); + }, + call$2(thisArg, $length) { + return this.call$4(thisArg, $length, null, null); + }, + call$3(thisArg, $length, commaSeparator) { + return this.call$4(thisArg, $length, commaSeparator, null); + }, + "call*": "call$4", + $requiredArgCount: 2, + $defaultValues() { + return [null, null]; + }, + $signature: 508 + }; + A.legacyListClass__closure.prototype = { + call$1(_) { + return B.C__SassNull0; + }, + $signature: 249 + }; + A.legacyListClass_closure0.prototype = { + call$2(thisArg, index) { + return A.wrapValue(J.get$dartValue$x(thisArg)._list1$_contents[index]); + }, + $signature: 510 + }; + A.legacyListClass_closure1.prototype = { + call$3(thisArg, index, value) { + var t1 = J.getInterceptor$x(thisArg), + t2 = t1.get$dartValue(thisArg)._list1$_contents, + mutable = A._setArrayType(t2.slice(0), A._arrayInstanceType(t2)); + mutable[index] = A.unwrapValue(value); + t1.set$dartValue(thisArg, t1.get$dartValue(thisArg).withListContents$1(mutable)); + }, + "call*": "call$3", + $requiredArgCount: 3, + $signature: 511 + }; + A.legacyListClass_closure2.prototype = { + call$1(thisArg) { + return J.get$dartValue$x(thisArg)._list1$_separator === B.ListSeparator_qVN0; + }, + $signature: 512 + }; + A.legacyListClass_closure3.prototype = { + call$2(thisArg, isComma) { + var t1 = J.getInterceptor$x(thisArg), + t2 = t1.get$dartValue(thisArg)._list1$_contents, + t3 = isComma ? B.ListSeparator_qVN0 : B.ListSeparator_qSL0; + t1.set$dartValue(thisArg, A.SassList$0(t2, t3, t1.get$dartValue(thisArg)._list1$_hasBrackets)); + }, + $signature: 513 + }; + A.legacyListClass_closure4.prototype = { + call$1(thisArg) { + return J.get$dartValue$x(thisArg)._list1$_contents.length; + }, + $signature: 514 + }; + A.SassList0.prototype = { + get$separator(_) { + return this._list1$_separator; + }, + get$hasBrackets() { + return this._list1$_hasBrackets; + }, + get$isBlank() { + return !this._list1$_hasBrackets && B.JSArray_methods.every$1(this._list1$_contents, new A.SassList_isBlank_closure0()); + }, + get$asList() { + return this._list1$_contents; + }, + get$lengthAsList() { + return this._list1$_contents.length; + }, + SassList$3$brackets0(contents, _separator, brackets) { + if (this._list1$_separator === B.ListSeparator_undecided_null_undecided0 && this._list1$_contents.length > 1) + throw A.wrapException(A.ArgumentError$(string$.A_list, null)); + }, + toString$0(_) { + var t2, _this = this, + t1 = true; + if (!_this._list1$_hasBrackets) { + t2 = _this._list1$_contents.length; + if (t2 !== 0) + t1 = t2 === 1 && _this._list1$_separator === B.ListSeparator_qVN0; + } + if (t1) + return _this.super$Value$toString0(0); + return "(" + _this.super$Value$toString0(0) + ")"; + }, + accept$1$1(visitor) { + return visitor.visitList$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + assertMap$1($name) { + return this._list1$_contents.length === 0 ? B.SassMap_Map_empty0 : this.super$Value$assertMap0($name); + }, + tryMap$0() { + return this._list1$_contents.length === 0 ? B.SassMap_Map_empty0 : null; + }, + $eq(_, other) { + var t1, _this = this; + if (other == null) + return false; + if (!(other instanceof A.SassList0 && other._list1$_separator === _this._list1$_separator && other._list1$_hasBrackets === _this._list1$_hasBrackets && B.C_ListEquality.equals$2(0, other._list1$_contents, _this._list1$_contents))) + t1 = _this._list1$_contents.length === 0 && other instanceof A.SassMap0 && other.get$asList().length === 0; + else + t1 = true; + return t1; + }, + get$hashCode(_) { + return B.C_ListEquality0.hash$1(this._list1$_contents); + } + }; + A.SassList_isBlank_closure0.prototype = { + call$1(element) { + return element.get$isBlank(); + }, + $signature: 54 + }; + A.ListSeparator0.prototype = { + _enumToString$0() { + return "ListSeparator." + this._name; + }, + toString$0(_) { + return this._list1$_name; + } + }; + A.LmsColorSpace0.prototype = { + get$isBoundedInternal() { + return false; + }, + convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, long, medium, short, alpha, missingA, missingB, missingChroma, missingHue, missingLightness) { + var t1, longScaled, mediumScaled, shortScaled, lightness, t2, t3, _null = null; + switch (dest) { + case B.OklabColorSpace_5400: + t1 = long == null ? 0 : long; + longScaled = Math.pow(Math.abs(t1), 0.3333333333333333) * J.get$sign$in(t1); + t1 = medium == null ? 0 : medium; + mediumScaled = Math.pow(Math.abs(t1), 0.3333333333333333) * J.get$sign$in(t1); + t1 = short == null ? 0 : short; + shortScaled = Math.pow(Math.abs(t1), 0.3333333333333333) * J.get$sign$in(t1); + t1 = $.$get$lmsToOklab0(); + lightness = t1[0] * longScaled + t1[1] * mediumScaled + t1[2] * shortScaled; + t2 = missingLightness ? _null : lightness; + t3 = missingA ? _null : t1[3] * longScaled + t1[4] * mediumScaled + t1[5] * shortScaled; + return A.SassColor$_forSpace0(B.OklabColorSpace_5400, t2, t3, missingB ? _null : t1[6] * longScaled + t1[7] * mediumScaled + t1[8] * shortScaled, alpha, _null); + case B.OklchColorSpace_9Gj0: + t1 = long == null ? 0 : long; + longScaled = Math.pow(Math.abs(t1), 0.3333333333333333) * J.get$sign$in(t1); + t1 = medium == null ? 0 : medium; + mediumScaled = Math.pow(Math.abs(t1), 0.3333333333333333) * J.get$sign$in(t1); + t1 = short == null ? 0 : short; + shortScaled = Math.pow(Math.abs(t1), 0.3333333333333333) * J.get$sign$in(t1); + if (missingLightness) + t1 = _null; + else { + t1 = $.$get$lmsToOklab0(); + t1 = t1[0] * longScaled + t1[1] * mediumScaled + t1[2] * shortScaled; + } + t2 = $.$get$lmsToOklab0(); + return A.labToLch0(dest, t1, t2[3] * longScaled + t2[4] * mediumScaled + t2[5] * shortScaled, t2[6] * longScaled + t2[7] * mediumScaled + t2[8] * shortScaled, alpha, missingChroma, missingHue); + default: + return this.super$ColorSpace$convertLinear0(dest, long, medium, short, alpha, missingA, missingB, missingChroma, missingHue, missingLightness); + } + }, + convert$5(dest, long, medium, short, alpha) { + return this.convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, long, medium, short, alpha, false, false, false, false, false); + }, + toLinear$1(channel) { + return channel; + }, + fromLinear$1(channel) { + return channel; + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.SrgbLinearColorSpace_kUj0 === dest || B.SrgbColorSpace_thf0 === dest || B.RgbColorSpace_i0P0 === dest) { + t1 = $.$get$lmsToLinearSrgb0(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf20 === dest) { + t1 = $.$get$lmsToLinearA98Rgb0(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz0 === dest) { + t1 = $.$get$lmsToLinearProphotoRgb0(); + break $label0$0; + } + if (B.DisplayP3ColorSpace_MmT0 === dest) { + t1 = $.$get$lmsToLinearDisplayP30(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo0 === dest) { + t1 = $.$get$lmsToLinearRec20200(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ0 === dest) { + t1 = $.$get$lmsToXyzD650(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB0 === dest) { + t1 = $.$get$lmsToXyzD500(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix0(dest); + break $label0$0; + } + return t1; + } + }; + A.LocalMindeGamutMap0.prototype = { + map$1(_, color) { + var clipped, max, min, minInGamut, chroma, current, e, + originOklch = color.toSpace$1(B.OklchColorSpace_9Gj0), + lightness = originOklch.channel0OrNull, + hue = originOklch.channel2OrNull, + alpha = originOklch.alphaOrNull, + t1 = lightness == null, + t2 = t1 ? 0 : lightness; + if (t2 > 1 || A.fuzzyEquals0(t2, 1)) { + t1 = color._color0$_space; + t2 = color.alphaOrNull; + return t1.get$isLegacyInternal() ? A.SassColor_SassColor$rgbInternal0(255, 255, 255, t2, null).toSpace$1(t1) : A.SassColor_SassColor$forSpaceInternal0(t1, 1, 1, 1, t2); + } else { + t1 = t1 ? 0 : lightness; + if (t1 < 0 || A.fuzzyEquals0(t1, 0)) + return A.SassColor_SassColor$rgbInternal0(0, 0, 0, color.alphaOrNull, null).toSpace$1(color._color0$_space); + } + clipped = color.get$isInGamut() ? color : B.ClipGamutMap_clip0.map$1(0, color); + if (this._local_minde$_deltaEOK$2(clipped, color) < 0.02) + return clipped; + max = originOklch.channel1OrNull; + if (max == null) + max = 0; + for (t1 = color._color0$_space, min = 0, minInGamut = true; max - min > 0.0001;) { + chroma = (min + max) / 2; + current = B.OklchColorSpace_9Gj0.convert$5(t1, lightness, chroma, hue, alpha); + if (minInGamut && current.get$isInGamut()) { + min = chroma; + continue; + } + clipped = current.get$isInGamut() ? current : B.ClipGamutMap_clip0.map$1(0, current); + e = this._local_minde$_deltaEOK$2(clipped, current); + if (e < 0.02) { + if (0.02 - e < 0.0001) + return clipped; + min = chroma; + minInGamut = false; + } else + max = chroma; + } + return clipped; + }, + _local_minde$_deltaEOK$2(color1, color2) { + var t2, t3, t4, + lab1 = color1.toSpace$1(B.OklabColorSpace_5400), + lab2 = color2.toSpace$1(B.OklabColorSpace_5400), + t1 = lab1.channel0OrNull; + if (t1 == null) + t1 = 0; + t2 = lab2.channel0OrNull; + t1 = Math.pow(t1 - (t2 == null ? 0 : t2), 2); + t2 = lab1.channel1OrNull; + if (t2 == null) + t2 = 0; + t3 = lab2.channel1OrNull; + t2 = Math.pow(t2 - (t3 == null ? 0 : t3), 2); + t3 = lab1.channel2OrNull; + if (t3 == null) + t3 = 0; + t4 = lab2.channel2OrNull; + return Math.sqrt(t1 + t2 + Math.pow(t3 - (t4 == null ? 0 : t4), 2)); + } + }; + A.JSLogger.prototype = {}; + A.WarnOptions.prototype = {}; + A.DebugOptions.prototype = {}; + A.LoggerWithDeprecationType0.prototype = {}; + A.LoudComment0.prototype = { + get$span(_) { + return this.text.span; + }, + accept$1$1(visitor) { + return visitor.visitLoudComment$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return this.text.toString$0(0); + } + }; + A.MapExpression0.prototype = { + accept$1$1(visitor) { + return visitor.visitMapExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t2, t3, _i, t4, + t1 = A._setArrayType([], type$.JSArray_String); + for (t2 = this.pairs, t3 = t2.length, _i = 0; _i < t3; ++_i) { + t4 = t2[_i]; + t1.push(t4._0.toString$0(0) + ": " + t4._1.toString$0(0)); + } + return "(" + B.JSArray_methods.join$1(t1, ", ") + ")"; + }, + get$span(receiver) { + return this.span; + } + }; + A._get_closure0.prototype = { + call$1($arguments) { + var value, + t1 = J.getInterceptor$asx($arguments), + map = t1.$index($arguments, 0).assertMap$1("map"), + t2 = A._setArrayType([t1.$index($arguments, 1)], type$.JSArray_Value_2); + B.JSArray_methods.addAll$1(t2, t1.$index($arguments, 2).get$asList()); + for (t1 = A.IterableExtension_get_exceptLast0(t2), t1 = t1.get$iterator(t1); t1.moveNext$0(); map = value) { + value = map._map0$_contents.$index(0, t1.get$current(t1)); + if (!(value instanceof A.SassMap0)) + return B.C__SassNull0; + } + t1 = map._map0$_contents.$index(0, B.JSArray_methods.get$last(t2)); + return t1 == null ? B.C__SassNull0 : t1; + }, + $signature: 3 + }; + A._set_closure1.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return A._modify0(t1.$index($arguments, 0).assertMap$1("map"), A._setArrayType([t1.$index($arguments, 1)], type$.JSArray_Value_2), new A._set__closure2($arguments), true); + }, + $signature: 3 + }; + A._set__closure2.prototype = { + call$1(_) { + return J.$index$asx(this.$arguments, 2); + }, + $signature: 43 + }; + A._set_closure2.prototype = { + call$1($arguments) { + var keys, t2, t3, + t1 = J.getInterceptor$asx($arguments), + map = t1.$index($arguments, 0).assertMap$1("map"), + _0_0 = t1.$index($arguments, 1).get$asList(), + _0_1 = _0_0.length; + if (_0_1 <= 0) + throw A.wrapException(A.SassScriptException$0("Expected $args to contain a key.", null)); + if (_0_1 === 1) + throw A.wrapException(A.SassScriptException$0("Expected $args to contain a value.", null)); + t1 = {}; + keys = t1.value = null; + t2 = _0_1 >= 1; + if (t2) { + t3 = _0_1 - 1; + keys = B.JSArray_methods.sublist$2(_0_0, 0, t3); + t1.value = _0_0[t3]; + } + if (t2) + return A._modify0(map, keys, new A._set__closure1(t1), true); + throw A.wrapException("[BUG] Unreachable code"); + }, + $signature: 3 + }; + A._set__closure1.prototype = { + call$1(_) { + return this._box_0.value; + }, + $signature: 43 + }; + A._merge_closure1.prototype = { + call$1($arguments) { + var t2, + t1 = J.getInterceptor$asx($arguments), + map1 = t1.$index($arguments, 0).assertMap$1("map1"), + map2 = t1.$index($arguments, 1).assertMap$1("map2"); + t1 = type$.Value_2; + t2 = A.LinkedHashMap_LinkedHashMap$of(map1._map0$_contents, t1, t1); + t2.addAll$1(0, map2._map0$_contents); + return new A.SassMap0(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 37 + }; + A._merge_closure2.prototype = { + call$1($arguments) { + var last, t2, keys, _null = null, + t1 = J.getInterceptor$asx($arguments), + map1 = t1.$index($arguments, 0).assertMap$1("map1"), + _0_0 = t1.$index($arguments, 1).get$asList(), + _0_1 = _0_0.length; + if (_0_1 <= 0) + throw A.wrapException(A.SassScriptException$0("Expected $args to contain a key.", _null)); + if (_0_1 === 1) + throw A.wrapException(A.SassScriptException$0("Expected $args to contain a map.", _null)); + t1 = _0_1 >= 1; + last = _null; + if (t1) { + t2 = _0_1 - 1; + keys = B.JSArray_methods.sublist$2(_0_0, 0, t2); + last = _0_0[t2]; + } else + keys = _null; + if (t1) + return A._modify0(map1, keys, new A._merge__closure0(last.assertMap$1("map2")), true); + throw A.wrapException("[BUG] Unreachable code"); + }, + $signature: 3 + }; + A._merge__closure0.prototype = { + call$1(oldValue) { + var t1, t2, + nestedMap = oldValue.tryMap$0(); + if (nestedMap == null) + return this.map2; + t1 = type$.Value_2; + t2 = A.LinkedHashMap_LinkedHashMap$of(nestedMap._map0$_contents, t1, t1); + t2.addAll$1(0, this.map2._map0$_contents); + return new A.SassMap0(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + }, + $signature: 515 + }; + A._deepMerge_closure0.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return A._deepMergeImpl0(t1.$index($arguments, 0).assertMap$1("map1"), t1.$index($arguments, 1).assertMap$1("map2")); + }, + $signature: 37 + }; + A._deepRemove_closure0.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + map = t1.$index($arguments, 0).assertMap$1("map"), + t2 = A._setArrayType([t1.$index($arguments, 1)], type$.JSArray_Value_2); + B.JSArray_methods.addAll$1(t2, t1.$index($arguments, 2).get$asList()); + return A._modify0(map, A.IterableExtension_get_exceptLast0(t2), new A._deepRemove__closure0(t2), false); + }, + $signature: 3 + }; + A._deepRemove__closure0.prototype = { + call$1(value) { + var t1, nestedMap, t2, + _0_0 = value.tryMap$0(); + if (_0_0 != null) { + t1 = _0_0._map0$_contents.containsKey$1(B.JSArray_methods.get$last(this.keys)); + nestedMap = _0_0; + } else { + nestedMap = null; + t1 = false; + } + if (t1) { + t1 = type$.Value_2; + t2 = A.LinkedHashMap_LinkedHashMap$of(nestedMap._map0$_contents, t1, t1); + t2.remove$1(0, B.JSArray_methods.get$last(this.keys)); + return new A.SassMap0(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + } + return value; + }, + $signature: 43 + }; + A._remove_closure1.prototype = { + call$1($arguments) { + return J.$index$asx($arguments, 0).assertMap$1("map"); + }, + $signature: 37 + }; + A._remove_closure2.prototype = { + call$1($arguments) { + var mutableMap, t3, _i, + t1 = J.getInterceptor$asx($arguments), + map = t1.$index($arguments, 0).assertMap$1("map"), + t2 = A._setArrayType([t1.$index($arguments, 1)], type$.JSArray_Value_2); + B.JSArray_methods.addAll$1(t2, t1.$index($arguments, 2).get$asList()); + t1 = type$.Value_2; + mutableMap = A.LinkedHashMap_LinkedHashMap$of(map._map0$_contents, t1, t1); + for (t3 = t2.length, _i = 0; _i < t2.length; t2.length === t3 || (0, A.throwConcurrentModificationError)(t2), ++_i) + mutableMap.remove$1(0, t2[_i]); + return new A.SassMap0(A.ConstantMap_ConstantMap$from(mutableMap, t1, t1)); + }, + $signature: 37 + }; + A._keys_closure0.prototype = { + call$1($arguments) { + var t1 = J.$index$asx($arguments, 0).assertMap$1("map")._map0$_contents; + return A.SassList$0(t1.get$keys(t1), B.ListSeparator_qVN0, false); + }, + $signature: 28 + }; + A._values_closure0.prototype = { + call$1($arguments) { + var t1 = J.$index$asx($arguments, 0).assertMap$1("map")._map0$_contents; + return A.SassList$0(t1.get$values(t1), B.ListSeparator_qVN0, false); + }, + $signature: 28 + }; + A._hasKey_closure0.prototype = { + call$1($arguments) { + var value, + t1 = J.getInterceptor$asx($arguments), + map = t1.$index($arguments, 0).assertMap$1("map"), + t2 = A._setArrayType([t1.$index($arguments, 1)], type$.JSArray_Value_2); + B.JSArray_methods.addAll$1(t2, t1.$index($arguments, 2).get$asList()); + for (t1 = A.IterableExtension_get_exceptLast0(t2), t1 = t1.get$iterator(t1); t1.moveNext$0(); map = value) { + value = map._map0$_contents.$index(0, t1.get$current(t1)); + if (!(value instanceof A.SassMap0)) + return B.SassBoolean_false0; + } + return map._map0$_contents.containsKey$1(B.JSArray_methods.get$last(t2)) ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._modify_modifyNestedMap0.prototype = { + call$1(map) { + var nestedMap, _this = this, + t1 = type$.Value_2, + mutableMap = A.LinkedHashMap_LinkedHashMap$of(map._map0$_contents, t1, t1), + t2 = _this.keyIterator, + key = t2.get$current(t2); + if (!t2.moveNext$0()) { + t2 = mutableMap.$index(0, key); + if (t2 == null) + t2 = B.C__SassNull0; + mutableMap.$indexSet(0, key, _this.modify.call$1(t2)); + return new A.SassMap0(A.ConstantMap_ConstantMap$from(mutableMap, t1, t1)); + } + t2 = mutableMap.$index(0, key); + nestedMap = t2 == null ? null : t2.tryMap$0(); + t2 = nestedMap == null; + if (t2 && !_this.addNesting) + return new A.SassMap0(A.ConstantMap_ConstantMap$from(mutableMap, t1, t1)); + mutableMap.$indexSet(0, key, _this.call$1(t2 ? B.SassMap_Map_empty0 : nestedMap)); + return new A.SassMap0(A.ConstantMap_ConstantMap$from(mutableMap, t1, t1)); + }, + $signature: 516 + }; + A.MapExtensions_get_pairs_closure0.prototype = { + call$1(e) { + return new A._Record_2(e.key, e.value); + }, + $signature() { + return this.K._eval$1("@<0>")._bind$1(this.V)._eval$1("+(1,2)(MapEntry<1,2>)"); + } + }; + A.mapClass_closure.prototype = { + call$0() { + var t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.SassMap", new A.mapClass__closure())), + t2 = J.getInterceptor$x(jsClass); + A.defineGetter(t2.get$$prototype(jsClass), "contents", new A.mapClass__closure0(), null); + t2.get$$prototype(jsClass).get = A.allowInteropCaptureThisNamed("get", new A.mapClass__closure1()); + A.JSClassExtension_injectSuperclass(t1._as(B.SassMap_Map_empty0.constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.mapClass__closure.prototype = { + call$2($self, contents) { + var t1; + if (contents == null) + t1 = B.SassMap_Map_empty0; + else { + t1 = type$.Value_2; + t1 = new A.SassMap0(A.ConstantMap_ConstantMap$from(A.immutableMapToDartMap(contents).cast$2$0(0, t1, t1), t1, t1)); + } + return t1; + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 517 + }; + A.mapClass__closure0.prototype = { + call$1($self) { + return A.dartMapToImmutableMap($self._map0$_contents); + }, + $signature: 518 + }; + A.mapClass__closure1.prototype = { + call$2($self, indexOrKey) { + var index, t1, _0_0; + if (typeof indexOrKey == "number") { + index = B.JSNumber_methods.floor$0(indexOrKey); + if (index < 0) { + t1 = $self._map0$_contents; + index = t1.get$length(t1) + index; + } + if (index >= 0) { + t1 = $self._map0$_contents; + t1 = index >= t1.get$length(t1); + } else + t1 = true; + if (t1) + return self.undefined; + t1 = type$.Value_2; + _0_0 = A.MapExtensions_get_pairs0($self._map0$_contents, t1, t1).elementAt$1(0, index); + return A.SassList$0(A._setArrayType([_0_0._0, _0_0._1], type$.JSArray_Value_2), B.ListSeparator_qSL0, false); + } else { + t1 = $self._map0$_contents.$index(0, indexOrKey); + return t1 == null ? self.undefined : t1; + } + }, + $signature: 519 + }; + A._NodeSassMap.prototype = {}; + A.legacyMapClass_closure.prototype = { + call$3(thisArg, $length, dartValue) { + var t1, t2, t3, map; + if (dartValue == null) { + $length.toString; + t1 = type$.Value_2; + t2 = A.Iterable_Iterable$generate($length, new A.legacyMapClass__closure(), t1); + t3 = A.Iterable_Iterable$generate($length, new A.legacyMapClass__closure0(), t1); + map = A.LinkedHashMap_LinkedHashMap(null, null, null, t1, t1); + A.MapBase__fillMapWithIterables(map, t2, t3); + t1 = new A.SassMap0(A.ConstantMap_ConstantMap$from(map, t1, t1)); + } else + t1 = dartValue; + J.set$dartValue$x(thisArg, t1); + }, + call$2(thisArg, $length) { + return this.call$3(thisArg, $length, null); + }, + "call*": "call$3", + $requiredArgCount: 2, + $defaultValues() { + return [null]; + }, + $signature: 520 + }; + A.legacyMapClass__closure.prototype = { + call$1(i) { + return A.SassNumber_SassNumber0(i, null); + }, + $signature: 521 + }; + A.legacyMapClass__closure0.prototype = { + call$1(_) { + return B.C__SassNull0; + }, + $signature: 249 + }; + A.legacyMapClass_closure0.prototype = { + call$2(thisArg, index) { + var t1 = J.get$dartValue$x(thisArg)._map0$_contents; + return A.wrapValue(J.elementAt$1$ax(t1.get$keys(t1), index)); + }, + $signature: 250 + }; + A.legacyMapClass_closure1.prototype = { + call$2(thisArg, index) { + var t1 = J.get$dartValue$x(thisArg)._map0$_contents; + t1 = t1.get$values(t1); + return A.wrapValue(t1.elementAt$1(t1, index)); + }, + $signature: 250 + }; + A.legacyMapClass_closure2.prototype = { + call$1(thisArg) { + var t1 = J.get$dartValue$x(thisArg)._map0$_contents; + return t1.get$length(t1); + }, + $signature: 523 + }; + A.legacyMapClass_closure3.prototype = { + call$3(thisArg, index, key) { + var newKey, t2, newMap, t3, i, t4, oldKey, oldValue, + t1 = J.getInterceptor$x(thisArg), + oldMap = t1.get$dartValue(thisArg)._map0$_contents, + $length = oldMap.get$length(oldMap); + A.IndexError_check(index, $length, oldMap, null, "index"); + newKey = A.unwrapValue(key); + t2 = type$.Value_2; + newMap = A.LinkedHashMap_LinkedHashMap$_empty(t2, t2); + for (t3 = A.MapExtensions_get_pairs0(t1.get$dartValue(thisArg)._map0$_contents, t2, t2), t3 = t3.get$iterator(t3), i = 0; t3.moveNext$0();) { + t4 = t3.get$current(t3); + oldKey = t4._0; + oldValue = t4._1; + if (i === index) + newMap.$indexSet(0, newKey, oldValue); + else { + if (newKey.$eq(0, oldKey)) + throw A.wrapException(A.ArgumentError$value(key, "key", "is already in the map")); + newMap.$indexSet(0, oldKey, oldValue); + } + ++i; + } + t1.set$dartValue(thisArg, new A.SassMap0(A.ConstantMap_ConstantMap$from(newMap, t2, t2))); + }, + "call*": "call$3", + $requiredArgCount: 3, + $signature: 251 + }; + A.legacyMapClass_closure4.prototype = { + call$3(thisArg, index, value) { + var t3, + t1 = J.getInterceptor$x(thisArg), + t2 = t1.get$dartValue(thisArg)._map0$_contents, + key = J.elementAt$1$ax(t2.get$keys(t2), index); + t2 = type$.Value_2; + t3 = A.LinkedHashMap_LinkedHashMap$of(t1.get$dartValue(thisArg)._map0$_contents, t2, t2); + t3.$indexSet(0, key, A.unwrapValue(value)); + t1.set$dartValue(thisArg, new A.SassMap0(A.ConstantMap_ConstantMap$from(t3, t2, t2))); + }, + "call*": "call$3", + $requiredArgCount: 3, + $signature: 251 + }; + A.SassMap0.prototype = { + get$separator(_) { + var t1 = this._map0$_contents; + return t1.get$isEmpty(t1) ? B.ListSeparator_undecided_null_undecided0 : B.ListSeparator_qVN0; + }, + get$asList() { + var t3, t4, t5, result, + t1 = type$.JSArray_Value_2, + t2 = A._setArrayType([], t1); + for (t3 = type$.Value_2, t4 = A.MapExtensions_get_pairs0(this._map0$_contents, t3, t3), t4 = t4.get$iterator(t4); t4.moveNext$0();) { + t5 = t4.get$current(t4); + result = A.List_List$from(A._setArrayType([t5._0, t5._1], t1), false, t3); + result.$flags = 3; + t2.push(new A.SassList0(result, B.ListSeparator_qSL0, false)); + } + return t2; + }, + get$lengthAsList() { + var t1 = this._map0$_contents; + return t1.get$length(t1); + }, + accept$1$1(visitor) { + return visitor.visitMap$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + assertMap$1($name) { + return this; + }, + tryMap$0() { + return this; + }, + $eq(_, other) { + var t1; + if (other == null) + return false; + if (!(other instanceof A.SassMap0 && B.C_MapEquality.equals$2(0, other._map0$_contents, this._map0$_contents))) { + t1 = this._map0$_contents; + t1 = t1.get$isEmpty(t1) && other instanceof A.SassList0 && other._list1$_contents.length === 0; + } else + t1 = true; + return t1; + }, + get$hashCode(_) { + var t1 = this._map0$_contents; + return t1.get$isEmpty(t1) ? B.C_ListEquality0.hash$1(B.List_empty20) : B.C_MapEquality.hash$1(t1); + } + }; + A.global_closure43.prototype = { + call$1($arguments) { + var t1, + number = J.$index$asx($arguments, 0).assertNumber$1("number"); + if (number.hasUnit$1("%")) + A.warnForDeprecation0(string$.Passinp + number.toString$0(0) + ")\nTo emit a CSS abs() now: abs(#{" + number.toString$0(0) + string$.x7d__Mor, B.Deprecation_UYp); + else + A.warnForDeprecation0(string$.Globalm, B.Deprecation_ZDV); + t1 = number.get$numeratorUnits(number); + return A.SassNumber_SassNumber$withUnits0(Math.abs(number._number1$_value), number.get$denominatorUnits(number), t1); + }, + $signature: 22 + }; + A.module_closure26.prototype = { + call$1(value) { + return Math.abs(value); + }, + $signature: 16 + }; + A._ceil_closure0.prototype = { + call$1(value) { + return B.JSNumber_methods.ceil$0(value); + }, + $signature: 16 + }; + A._clamp_closure0.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + min = t1.$index($arguments, 0).assertNumber$1("min"), + number = t1.$index($arguments, 1).assertNumber$1("number"), + max = t1.$index($arguments, 2).assertNumber$1("max"); + number.convertValueToMatch$3(min, "number", "min"); + max.convertValueToMatch$3(min, "max", "min"); + if (min.greaterThanOrEquals$1(max).value) + return min; + if (min.greaterThanOrEquals$1(number).value) + return min; + if (number.greaterThanOrEquals$1(max).value) + return max; + return number; + }, + $signature: 22 + }; + A._floor_closure0.prototype = { + call$1(value) { + return B.JSNumber_methods.floor$0(value); + }, + $signature: 16 + }; + A._max_closure0.prototype = { + call$1($arguments) { + var t1, t2, max, _i, number; + for (t1 = J.$index$asx($arguments, 0).get$asList(), t2 = t1.length, max = null, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + number = t1[_i].assertNumber$0(); + if (max == null || max.lessThan$1(number).value) + max = number; + } + if (max != null) + return max; + throw A.wrapException(A.SassScriptException$0("At least one argument must be passed.", null)); + }, + $signature: 22 + }; + A._min_closure0.prototype = { + call$1($arguments) { + var t1, t2, min, _i, number; + for (t1 = J.$index$asx($arguments, 0).get$asList(), t2 = t1.length, min = null, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + number = t1[_i].assertNumber$0(); + if (min == null || min.greaterThan$1(number).value) + min = number; + } + if (min != null) + return min; + throw A.wrapException(A.SassScriptException$0("At least one argument must be passed.", null)); + }, + $signature: 22 + }; + A._round_closure0.prototype = { + call$1(number) { + return B.JSNumber_methods.round$0(number); + }, + $signature: 16 + }; + A._hypot_closure0.prototype = { + call$1($arguments) { + var subtotal, i, i0, t3, + t1 = J.$index$asx($arguments, 0).get$asList(), + t2 = A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,SassNumber0>"), + numbers = A.List_List$of(new A.MappedListIterable(t1, new A._hypot__closure0(), t2), true, t2._eval$1("ListIterable.E")); + t1 = numbers.length; + if (t1 === 0) + throw A.wrapException(A.SassScriptException$0("At least one argument must be passed.", null)); + for (subtotal = 0, i = 0; i < t1; i = i0) { + i0 = i + 1; + subtotal += Math.pow(numbers[i].convertValueToMatch$3(numbers[0], "numbers[" + i0 + "]", "numbers[1]"), 2); + } + t1 = Math.sqrt(subtotal); + t2 = numbers[0]; + t3 = t2.get$numeratorUnits(t2); + return A.SassNumber_SassNumber$withUnits0(t1, t2.get$denominatorUnits(t2), t3); + }, + $signature: 22 + }; + A._hypot__closure0.prototype = { + call$1(argument) { + return argument.assertNumber$0(); + }, + $signature: 525 + }; + A._log_closure0.prototype = { + call$1($arguments) { + var base, + _s18_ = " to have no units.", + _null = null, + t1 = J.getInterceptor$asx($arguments), + number = t1.$index($arguments, 0).assertNumber$1("number"); + if (number.get$hasUnits()) + throw A.wrapException(A.SassScriptException$0("$number: Expected " + number.toString$0(0) + _s18_, _null)); + else if (t1.$index($arguments, 1).$eq(0, B.C__SassNull0)) + return A.SassNumber_SassNumber0(Math.log(number._number1$_value), _null); + base = t1.$index($arguments, 1).assertNumber$1("base"); + if (base.get$hasUnits()) + throw A.wrapException(A.SassScriptException$0("$base: Expected " + base.toString$0(0) + _s18_, _null)); + else + return A.SassNumber_SassNumber0(Math.log(number._number1$_value) / Math.log(base._number1$_value), _null); + }, + $signature: 22 + }; + A._pow_closure0.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return A.pow1(t1.$index($arguments, 0).assertNumber$1("base"), t1.$index($arguments, 1).assertNumber$1("exponent")); + }, + $signature: 22 + }; + A._atan2_closure0.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + y = t1.$index($arguments, 0).assertNumber$1("y"); + return A.SassNumber_SassNumber$withUnits0(Math.atan2(y._number1$_value, t1.$index($arguments, 1).assertNumber$1("x").convertValueToMatch$3(y, "x", "y")) * 57.29577951308232, null, A._setArrayType(["deg"], type$.JSArray_String)); + }, + $signature: 22 + }; + A._compatible_closure0.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments); + return t1.$index($arguments, 0).assertNumber$1("number1").isComparableTo$1(t1.$index($arguments, 1).assertNumber$1("number2")) ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._isUnitless_closure0.prototype = { + call$1($arguments) { + return !J.$index$asx($arguments, 0).assertNumber$1("number").get$hasUnits() ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._unit_closure0.prototype = { + call$1($arguments) { + return new A.SassString0(J.$index$asx($arguments, 0).assertNumber$1("number").get$unitString(), true); + }, + $signature: 18 + }; + A._percentage_closure0.prototype = { + call$1($arguments) { + var number = J.$index$asx($arguments, 0).assertNumber$1("number"); + number.assertNoUnits$1("number"); + return A.SassNumber_SassNumber0(number._number1$_value * 100, "%"); + }, + $signature: 22 + }; + A._randomFunction_closure0.prototype = { + call$1($arguments) { + var limit, limitScalar, + t1 = J.getInterceptor$asx($arguments); + if (t1.$index($arguments, 0).$eq(0, B.C__SassNull0)) + return A.SassNumber_SassNumber0($.$get$_random2().nextDouble$0(), null); + limit = t1.$index($arguments, 0).assertNumber$1("limit"); + if (limit.get$hasUnits()) + A.warnForDeprecation0(string$.math_r + limit.toString$0(0) + string$.x29x20in_a + limit.get$unitString() + ")) * 1" + limit.get$unitString() + string$.x0a_To_p + limit.get$unitString() + string$.x29x29__Mo, B.Deprecation_vn5); + limitScalar = limit.assertInt$1("limit"); + if (limitScalar < 1) + throw A.wrapException(A.SassScriptException$0("$limit: Must be greater than 0, was " + limit.toString$0(0) + ".", null)); + return A.SassNumber_SassNumber0($.$get$_random2().nextInt$1(limitScalar) + 1, null); + }, + $signature: 22 + }; + A._div_closure0.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + number1 = t1.$index($arguments, 0), + number2 = t1.$index($arguments, 1); + if (!(number1 instanceof A.SassNumber0) || !(number2 instanceof A.SassNumber0)) + A.warn0(string$.math_d); + return number1.dividedBy$1(number2); + }, + $signature: 3 + }; + A._singleArgumentMathFunc_closure0.prototype = { + call$1($arguments) { + return this.mathFunc.call$1(J.$index$asx($arguments, 0).assertNumber$1("number")); + }, + $signature: 22 + }; + A._numberFunction_closure0.prototype = { + call$1($arguments) { + var number = J.$index$asx($arguments, 0).assertNumber$1("number"), + t1 = this.transform.call$1(number._number1$_value), + t2 = number.get$numeratorUnits(number); + return A.SassNumber_SassNumber$withUnits0(t1, number.get$denominatorUnits(number), t2); + }, + $signature: 22 + }; + A.CssMediaQuery0.prototype = { + merge$1(other) { + var t1, ourModifier, t2, t3, ourType, t4, theirModifier, t5, t6, theirType, t7, t8, negativeConditions, conditions, type, modifier, fewerConditions, fewerConditions0, moreConditions, _this = this, _null = null, _s3_ = "all"; + if (!_this.conjunction || !other.conjunction) + return B._SingletonCssMediaQueryMergeResult_10; + t1 = _this.modifier; + ourModifier = t1 == null ? _null : t1.toLowerCase(); + t2 = _this.type; + t3 = t2 == null; + ourType = t3 ? _null : t2.toLowerCase(); + t4 = other.modifier; + theirModifier = t4 == null ? _null : t4.toLowerCase(); + t5 = other.type; + t6 = t5 == null; + theirType = t6 ? _null : t5.toLowerCase(); + t7 = ourType == null; + if (t7 && theirType == null) { + t1 = A.List_List$of(_this.conditions, true, type$.String); + B.JSArray_methods.addAll$1(t1, other.conditions); + return new A.MediaQuerySuccessfulMergeResult0(A.CssMediaQuery$condition0(t1, true)); + } + t8 = ourModifier === "not"; + if (t8 !== (theirModifier === "not")) { + if (ourType == theirType) { + negativeConditions = t8 ? _this.conditions : other.conditions; + if (B.JSArray_methods.every$1(negativeConditions, B.JSArray_methods.get$contains(t8 ? other.conditions : _this.conditions))) + return B._SingletonCssMediaQueryMergeResult_00; + else + return B._SingletonCssMediaQueryMergeResult_10; + } else if (t3 || A.equalsIgnoreCase0(t2, _s3_) || t6 || A.equalsIgnoreCase0(t5, _s3_)) + return B._SingletonCssMediaQueryMergeResult_10; + if (t8) { + conditions = other.conditions; + type = theirType; + modifier = theirModifier; + } else { + conditions = _this.conditions; + type = ourType; + modifier = ourModifier; + } + } else if (t8) { + if (ourType != theirType) + return B._SingletonCssMediaQueryMergeResult_10; + fewerConditions = _this.conditions; + fewerConditions0 = other.conditions; + t3 = fewerConditions.length > fewerConditions0.length; + moreConditions = t3 ? fewerConditions : fewerConditions0; + if (t3) + fewerConditions = fewerConditions0; + if (!B.JSArray_methods.every$1(fewerConditions, B.JSArray_methods.get$contains(moreConditions))) + return B._SingletonCssMediaQueryMergeResult_10; + conditions = moreConditions; + type = ourType; + modifier = ourModifier; + } else if (t3 || A.equalsIgnoreCase0(t2, _s3_)) { + type = (t6 || A.equalsIgnoreCase0(t5, _s3_)) && t7 ? _null : theirType; + t3 = A.List_List$of(_this.conditions, true, type$.String); + B.JSArray_methods.addAll$1(t3, other.conditions); + conditions = t3; + modifier = theirModifier; + } else { + if (t6 || A.equalsIgnoreCase0(t5, _s3_)) { + t3 = A.List_List$of(_this.conditions, true, type$.String); + B.JSArray_methods.addAll$1(t3, other.conditions); + conditions = t3; + modifier = ourModifier; + } else { + if (ourType != theirType) + return B._SingletonCssMediaQueryMergeResult_00; + else { + modifier = ourModifier == null ? theirModifier : ourModifier; + t3 = A.List_List$of(_this.conditions, true, type$.String); + B.JSArray_methods.addAll$1(t3, other.conditions); + } + conditions = t3; + } + type = ourType; + } + t2 = type == ourType ? t2 : t5; + return new A.MediaQuerySuccessfulMergeResult0(A.CssMediaQuery$type0(t2, conditions, modifier == ourModifier ? t1 : t4)); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.CssMediaQuery0 && other.modifier == this.modifier && other.type == this.type && B.C_ListEquality.equals$2(0, other.conditions, this.conditions); + }, + get$hashCode(_) { + return J.get$hashCode$(this.modifier) ^ J.get$hashCode$(this.type) ^ B.C_ListEquality0.hash$1(this.conditions); + }, + toString$0(_) { + var t2, _this = this, + t1 = _this.modifier; + t1 = t1 != null ? "" + (t1 + " ") : ""; + t2 = _this.type; + if (t2 != null) { + t1 += t2; + if (_this.conditions.length !== 0) + t1 += " and "; + } + t2 = _this.conjunction ? " and " : " or "; + t2 = t1 + B.JSArray_methods.join$1(_this.conditions, t2); + return t2.charCodeAt(0) == 0 ? t2 : t2; + } + }; + A._SingletonCssMediaQueryMergeResult0.prototype = { + _enumToString$0() { + return "_SingletonCssMediaQueryMergeResult." + this._name; + } + }; + A.MediaQuerySuccessfulMergeResult0.prototype = { + toString$0(_) { + return this.query.toString$0(0); + } + }; + A.MediaQueryParser0.prototype = { + parse$0(_) { + return this.wrapSpanFormatException$1(new A.MediaQueryParser_parse_closure0(this)); + }, + _media_query$_mediaQuery$0() { + var conditions, conjunction, t1, identifier1, identifier2, type, modifier, _this = this, _null = null, _s3_ = "and"; + if (_this.scanner.peekChar$0() === 40) { + conditions = A._setArrayType([_this._media_query$_mediaInParens$0()], type$.JSArray_String); + _this.whitespace$1$consumeNewlines(true); + if (_this.scanIdentifier$1(_s3_)) { + _this.expectWhitespace$0(); + B.JSArray_methods.addAll$1(conditions, _this._media_query$_mediaLogicSequence$1(_s3_)); + conjunction = true; + } else { + t1 = _this.scanIdentifier$1("or"); + if (t1) { + _this.expectWhitespace$0(); + B.JSArray_methods.addAll$1(conditions, _this._media_query$_mediaLogicSequence$1("or")); + } + conjunction = !t1; + } + return A.CssMediaQuery$condition0(conditions, conjunction); + } + identifier1 = _this.identifier$0(); + if (A.equalsIgnoreCase0(identifier1, "not")) { + _this.expectWhitespace$0(); + if (!_this.lookingAtIdentifier$0()) + return A.CssMediaQuery$condition0(A._setArrayType(["(not " + _this._media_query$_mediaInParens$0() + ")"], type$.JSArray_String), _null); + } + _this.whitespace$1$consumeNewlines(true); + if (!_this.lookingAtIdentifier$0()) + return A.CssMediaQuery$type0(identifier1, _null, _null); + identifier2 = _this.identifier$0(); + if (A.equalsIgnoreCase0(identifier2, _s3_)) { + _this.expectWhitespace$0(); + type = identifier1; + modifier = _null; + } else { + _this.whitespace$1$consumeNewlines(true); + if (_this.scanIdentifier$1(_s3_)) + _this.expectWhitespace$0(); + else + return A.CssMediaQuery$type0(identifier2, _null, identifier1); + type = identifier2; + modifier = identifier1; + } + if (_this.scanIdentifier$1("not")) { + _this.expectWhitespace$0(); + return A.CssMediaQuery$type0(type, A._setArrayType(["(not " + _this._media_query$_mediaInParens$0() + ")"], type$.JSArray_String), modifier); + } + return A.CssMediaQuery$type0(type, _this._media_query$_mediaLogicSequence$1(_s3_), modifier); + }, + _media_query$_mediaLogicSequence$1(operator) { + var t1, t2, _this = this, + result = A._setArrayType([], type$.JSArray_String); + for (t1 = _this.scanner; true;) { + t1.expectChar$2$name(40, "media condition in parentheses"); + t2 = _this.declarationValue$0(); + t1.expectChar$1(41); + result.push("(" + t2 + ")"); + _this.whitespace$1$consumeNewlines(true); + if (!_this.scanIdentifier$1(operator)) + return result; + _this.expectWhitespace$0(); + } + }, + _media_query$_mediaInParens$0() { + var t2, + t1 = this.scanner; + t1.expectChar$2$name(40, "media condition in parentheses"); + t2 = this.declarationValue$0(); + t1.expectChar$1(41); + return "(" + t2 + ")"; + } + }; + A.MediaQueryParser_parse_closure0.prototype = { + call$0() { + var queries = A._setArrayType([], type$.JSArray_CssMediaQuery_2), + t1 = this.$this, + t2 = t1.scanner; + do { + t1.whitespace$1$consumeNewlines(true); + queries.push(t1._media_query$_mediaQuery$0()); + t1.whitespace$1$consumeNewlines(true); + } while (t2.scanChar$1(44)); + t2.expectDone$0(); + return queries; + }, + $signature: 526 + }; + A.ModifiableCssMediaRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitCssMediaRule$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + equalsIgnoringChildren$1(other) { + return other instanceof A.ModifiableCssMediaRule0 && B.C_ListEquality.equals$2(0, this.queries, other.queries); + }, + copyWithoutChildren$0() { + return A.ModifiableCssMediaRule$0(this.queries, this.span); + }, + get$span(receiver) { + return this.span; + } + }; + A.MediaRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitMediaRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.children; + return "@media " + this.query.toString$0(0) + " {" + (t1 && B.JSArray_methods).join$1(t1, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.MergedExtension0.prototype = { + unmerge$0() { + return new A._SyncStarIterable(this.unmerge$body$MergedExtension0(), type$._SyncStarIterable_Extension_2); + }, + unmerge$body$MergedExtension0() { + var $async$self = this; + return function() { + var $async$goto = 0, $async$handler = 1, $async$errorStack = [], right, left; + return function $async$unmerge$0($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + left = $async$self.left; + $async$goto = left instanceof A.MergedExtension0 ? 2 : 4; + break; + case 2: + // then + $async$goto = 5; + return $async$iterator._yieldStar$1(left.unmerge$0()); + case 5: + // after yield + // goto join + $async$goto = 3; + break; + case 4: + // else + $async$goto = 6; + return $async$iterator._async$_current = left, 1; + case 6: + // after yield + case 3: + // join + right = $async$self.right; + $async$goto = right instanceof A.MergedExtension0 ? 7 : 9; + break; + case 7: + // then + $async$goto = 10; + return $async$iterator._yieldStar$1(right.unmerge$0()); + case 10: + // after yield + // goto join + $async$goto = 8; + break; + case 9: + // else + $async$goto = 11; + return $async$iterator._async$_current = right, 1; + case 11: + // after yield + case 8: + // join + // implicit return + return 0; + case 1: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + } + }; + A.MergedMapView0.prototype = { + get$keys(_) { + var t1 = this._merged_map_view$_mapsByKey; + return new A.LinkedHashMapKeysIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapKeysIterable<1>")); + }, + get$length(_) { + return this._merged_map_view$_mapsByKey.__js_helper$_length; + }, + get$isEmpty(_) { + return this._merged_map_view$_mapsByKey.__js_helper$_length === 0; + }, + get$isNotEmpty(_) { + return this._merged_map_view$_mapsByKey.__js_helper$_length !== 0; + }, + MergedMapView$10(maps, $K, $V) { + var t1, t2, t3, _i, map, t4, t5; + for (t1 = maps.length, t2 = this._merged_map_view$_mapsByKey, t3 = $K._eval$1("@<0>")._bind$1($V)._eval$1("MergedMapView0<1,2>"), _i = 0; _i < maps.length; maps.length === t1 || (0, A.throwConcurrentModificationError)(maps), ++_i) { + map = maps[_i]; + if (t3._is(map)) + for (t4 = map._merged_map_view$_mapsByKey, t4 = new A.LinkedHashMapValueIterator(t4, t4.__js_helper$_modifications, t4.__js_helper$_first); t4.moveNext$0();) { + t5 = t4.__js_helper$_current; + A.setAll0(t2, t5.get$keys(t5), t5); + } + else + A.setAll0(t2, map.get$keys(map), map); + } + }, + $index(_, key) { + var t1 = this._merged_map_view$_mapsByKey.$index(0, this.$ti._precomputed1._as(key)); + return t1 == null ? null : t1.$index(0, key); + }, + $indexSet(_, key, value) { + var _0_0 = this._merged_map_view$_mapsByKey.$index(0, key); + if (_0_0 != null) + _0_0.$indexSet(0, key, value); + else + throw A.wrapException(A.UnsupportedError$(string$.New_en)); + }, + remove$1(_, key) { + throw A.wrapException(A.UnsupportedError$(string$.Entrie)); + }, + containsKey$1(key) { + return this._merged_map_view$_mapsByKey.containsKey$1(key); + } + }; + A._shared_closure3.prototype = { + call$1($arguments) { + A.warnForDeprecation0(string$.The_fe, B.Deprecation_HIp); + return $._features0.contains$1(0, J.$index$asx($arguments, 0).assertString$1("feature")._string0$_text) ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._shared_closure4.prototype = { + call$1($arguments) { + return new A.SassString0(A.serializeValue0(J.get$first$ax($arguments), true, true), false); + }, + $signature: 18 + }; + A._shared_closure5.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + _0_0 = t1.$index($arguments, 0); + $label0$0: { + if (_0_0 instanceof A.SassArgumentList0) { + t1 = "arglist"; + break $label0$0; + } + if (_0_0 instanceof A.SassBoolean0) { + t1 = "bool"; + break $label0$0; + } + if (_0_0 instanceof A.SassColor0) { + t1 = "color"; + break $label0$0; + } + if (_0_0 instanceof A.SassList0) { + t1 = "list"; + break $label0$0; + } + if (_0_0 instanceof A.SassMap0) { + t1 = "map"; + break $label0$0; + } + if (B.C__SassNull0 === _0_0) { + t1 = "null"; + break $label0$0; + } + if (_0_0 instanceof A.SassNumber0) { + t1 = "number"; + break $label0$0; + } + if (_0_0 instanceof A.SassFunction0) { + t1 = "function"; + break $label0$0; + } + if (_0_0 instanceof A.SassMixin0) { + t1 = "mixin"; + break $label0$0; + } + if (_0_0 instanceof A.SassCalculation0) { + t1 = "calculation"; + break $label0$0; + } + if (_0_0 instanceof A.SassString0) { + t1 = "string"; + break $label0$0; + } + t1 = A.throwExpression("[BUG] Unknown value type " + t1.$index($arguments, 0).toString$0(0)); + } + return new A.SassString0(t1, false); + }, + $signature: 18 + }; + A._shared_closure6.prototype = { + call$1($arguments) { + var t2, t3, t4, + t1 = J.getInterceptor$asx($arguments), + _1_0 = t1.$index($arguments, 0); + if (_1_0 instanceof A.SassArgumentList0) { + _1_0._argument_list$_wereKeywordsAccessed = true; + t1 = type$.Value_2; + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t3 = A.MapExtensions_get_pairs0(_1_0._argument_list$_keywords, type$.String, t1), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t4 = t3.get$current(t3); + t2.$indexSet(0, new A.SassString0(t4._0, false), t4._1); + } + return new A.SassMap0(A.ConstantMap_ConstantMap$from(t2, t1, t1)); + } else + throw A.wrapException("$args: " + t1.$index($arguments, 0).toString$0(0) + " is not an argument list."); + }, + $signature: 37 + }; + A.moduleFunctions_closure2.prototype = { + call$1($arguments) { + return new A.SassString0(J.$index$asx($arguments, 0).assertCalculation$1("calc").name, true); + }, + $signature: 18 + }; + A.moduleFunctions_closure3.prototype = { + call$1($arguments) { + var t1 = J.$index$asx($arguments, 0).assertCalculation$1("calc").$arguments; + return A.SassList$0(new A.MappedListIterable(t1, new A.moduleFunctions__closure0(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Value0>")), B.ListSeparator_qVN0, false); + }, + $signature: 28 + }; + A.moduleFunctions__closure0.prototype = { + call$1(argument) { + return argument instanceof A.Value0 ? argument : new A.SassString0(J.toString$0$(argument), false); + }, + $signature: 527 + }; + A.moduleFunctions_closure4.prototype = { + call$1($arguments) { + var _0_2_isSet, _0_2, acceptsContent, t1, _0_5_isSet, _0_5, hasContent, + mixin = J.$index$asx($arguments, 0).assertMixin$1("mixin"), + _0_0 = mixin.callable; + $label0$0: { + _0_2_isSet = type$.AsyncBuiltInCallable_2._is(_0_0); + if (_0_2_isSet) { + _0_2 = _0_0.get$acceptsContent(); + acceptsContent = _0_2; + } else + acceptsContent = null; + if (!_0_2_isSet) { + _0_2_isSet = _0_0 instanceof A.BuiltInCallable0; + if (_0_2_isSet) { + _0_2 = _0_0.acceptsContent; + acceptsContent = _0_2; + } + t1 = _0_2_isSet; + } else + t1 = true; + if (t1) { + t1 = acceptsContent; + break $label0$0; + } + _0_5_isSet = _0_0 instanceof A.UserDefinedCallable0; + if (_0_5_isSet) { + _0_5 = _0_0.declaration; + t1 = _0_5 instanceof A.MixinRule0; + } else { + _0_5 = null; + t1 = false; + } + if (t1) { + t1 = _0_5_isSet ? _0_5 : _0_0.declaration; + hasContent = type$.MixinRule_2._as(t1).get$hasContent(); + t1 = hasContent; + break $label0$0; + } + t1 = A.throwExpression(A.UnsupportedError$("Unknown callable type " + mixin.toString$0(0) + ".")); + } + return t1 ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A.mixinClass_closure.prototype = { + call$0() { + var t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.SassMixin", new A.mixinClass__closure())); + A.JSClassExtension_injectSuperclass(t1._as(new A.SassMixin0(A.BuiltInCallable$function0("f", "", new A.mixinClass__closure0(), null)).constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.mixinClass__closure.prototype = { + call$1($self) { + A.jsThrow(new self.Error("It is not possible to construct a SassMixin through the JavaScript API")); + }, + $signature: 528 + }; + A.mixinClass__closure0.prototype = { + call$1(_) { + return B.C__SassNull0; + }, + $signature: 3 + }; + A.SassMixin0.prototype = { + accept$1$1(visitor) { + var t1, t2; + if (!visitor._serialize0$_inspect) + A.throwExpression(A.SassScriptException$0(this.toString$0(0) + " isn't a valid CSS value.", null)); + t1 = visitor._serialize0$_buffer; + t1.write$1(0, "get-mixin("); + t2 = this.callable; + visitor._serialize0$_visitQuotedString$1(t2.get$name(t2)); + t1.writeCharCode$1(41); + return null; + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + assertMixin$1($name) { + return this; + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.SassMixin0 && this.callable.$eq(0, other.callable); + }, + get$hashCode(_) { + var t1 = this.callable; + return t1.get$hashCode(t1); + } + }; + A.MixinRule0.prototype = { + get$hasContent() { + var result, _this = this, + value = _this._mixin_rule$__MixinRule_hasContent_FI; + if (value === $) { + result = J.$eq$(B.C__HasContentVisitor0.visitChildren$1(_this.children), true); + _this._mixin_rule$__MixinRule_hasContent_FI !== $ && A.throwUnnamedLateFieldADI(); + _this._mixin_rule$__MixinRule_hasContent_FI = result; + value = result; + } + return value; + }, + accept$1$1(visitor) { + return visitor.visitMixinRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = "@mixin " + this.name, + t2 = this.parameters; + if (!(t2.parameters.length === 0 && t2.restParameter == null)) + t1 += "(" + t2.toString$0(0) + ")"; + t2 = this.children; + t2 = t1 + (" {" + (t2 && B.JSArray_methods).join$1(t2, " ") + "}"); + return t2.charCodeAt(0) == 0 ? t2 : t2; + } + }; + A._HasContentVisitor0.prototype = { + visitContentRule$1(_, _0) { + return true; + }, + $isStatementVisitor: 1 + }; + A.__HasContentVisitor_Object_StatementSearchVisitor0.prototype = {}; + A.ExtendMode0.prototype = { + _enumToString$0() { + return "ExtendMode." + this._name; + }, + toString$0(_) { + return this.name; + } + }; + A.JSModule0.prototype = {}; + A.JSModuleRequire0.prototype = {}; + A.MultiSpan0.prototype = { + get$start(_) { + var t1 = this._multi_span0$_primary; + return t1.get$start(t1); + }, + get$end(_) { + var t1 = this._multi_span0$_primary; + return t1.get$end(t1); + }, + get$text() { + return this._multi_span0$_primary.get$text(); + }, + get$context(_) { + var t1 = this._multi_span0$_primary; + return t1.get$context(t1); + }, + get$file(_) { + var t1 = this._multi_span0$_primary; + return t1.get$file(t1); + }, + get$length(_) { + var t1 = this._multi_span0$_primary; + return t1.get$length(t1); + }, + get$sourceUrl(_) { + var t1 = this._multi_span0$_primary; + return t1.get$sourceUrl(t1); + }, + compareTo$1(_, other) { + return this._multi_span0$_primary.compareTo$1(0, other); + }, + toString$0(_) { + return this._multi_span0$_primary.toString$0(0); + }, + expand$1(_, other) { + return new A.MultiSpan0(this._multi_span0$_primary.expand$1(0, other), this.primaryLabel, this.secondarySpans); + }, + highlight$1$color(color) { + return A.Highlighter$multiple(this._multi_span0$_primary, this.primaryLabel, this.secondarySpans, color === true, null, null).highlight$0(); + }, + message$2$color(_, message, color) { + var t1 = J.$eq$(color, true) || typeof color == "string", + t2 = typeof color == "string" ? color : null; + return A.SourceSpanExtension_messageMultiple(this._multi_span0$_primary, message, this.primaryLabel, this.secondarySpans, t1, t2, null); + }, + message$1(_, message) { + return this.message$2$color(0, message, null); + }, + $isComparable: 1, + $isFileSpan: 1, + $isSourceSpan: 1, + $isSourceSpanWithContext: 1 + }; + A.SupportsNegation0.prototype = { + toInterpolation$0() { + var t1 = new A.StringBuffer(""), + t2 = new A.InterpolationBuffer0(t1, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)), + t3 = this.span, + t4 = this.condition, + t5 = A.SpanExtensions_before(t3, t4.get$span(t4)); + t5 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t5.file._decodedChars, t5._file$_start, t5._end), 0, null); + t1._contents += t5; + t2.addInterpolation$1(t4.toInterpolation$0()); + t4 = A.SpanExtensions_after(t3, t4.get$span(t4)); + t4 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t4.file._decodedChars, t4._file$_start, t4._end), 0, null); + t1._contents += t4; + return t2.interpolation$1(t3); + }, + withSpan$1(span) { + return new A.SupportsNegation0(this.condition, span); + }, + toString$0(_) { + var t1 = this.condition; + if (t1 instanceof A.SupportsNegation0 || t1 instanceof A.SupportsOperation0) + return "not (" + t1.toString$0(0) + ")"; + else + return "not " + t1.toString$0(0); + }, + $isAstNode0: 1, + $isSassNode: 1, + $isSupportsCondition: 1, + get$span(receiver) { + return this.span; + } + }; + A.NoOpImporter0.prototype = { + canonicalize$1(_, url) { + return null; + }, + load$1(_, url) { + return null; + }, + toString$0(_) { + return "(unknown)"; + } + }; + A.NoSourceMapBuffer0.prototype = { + get$length(_) { + return this._no_source_map_buffer0$_buffer._contents.length; + }, + forSpan$1$2(span, callback) { + return callback.call$0(); + }, + forSpan$2(span, callback) { + return this.forSpan$1$2(span, callback, type$.dynamic); + }, + write$1(_, object) { + var t1 = this._no_source_map_buffer0$_buffer, + t2 = A.S(object); + t1._contents += t2; + return null; + }, + writeCharCode$1(charCode) { + var t1 = this._no_source_map_buffer0$_buffer, + t2 = A.Primitives_stringFromCharCode(charCode); + t1._contents += t2; + return null; + }, + toString$0(_) { + var t1 = this._no_source_map_buffer0$_buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + buildSourceMap$1$prefix(prefix) { + return A.throwExpression(A.UnsupportedError$(string$.NoSour)); + } + }; + A._FakeAstNode0.prototype = { + get$span(_) { + return this._node0$_callback.call$0(); + }, + $isAstNode0: 1 + }; + A.CssNode0.prototype = { + toString$0(_) { + var _null = null; + return A.serialize0(this, true, _null, true, _null, _null, false, _null, true)._0; + }, + $isAstNode0: 1 + }; + A.CssParentNode0.prototype = {}; + A._IsInvisibleVisitor1.prototype = { + visitCssAtRule$1(rule) { + return false; + }, + visitCssComment$1(comment) { + return this.includeComments && comment.text.charCodeAt(2) !== 33; + }, + visitCssStyleRule$1(rule) { + var t1 = rule._style_rule0$_selector._box0$_inner; + return (this.includeBogus ? t1.value.accept$1(B._IsInvisibleVisitor_true0) : t1.value.accept$1(B._IsInvisibleVisitor_false0)) || this.super$EveryCssVisitor$visitCssStyleRule0(rule); + } + }; + A.__IsInvisibleVisitor_Object_EveryCssVisitor0.prototype = {}; + A.ModifiableCssNode0.prototype = { + get$parent(_) { + return this._node$_parent; + }, + get$hasFollowingSibling() { + var t2, + t1 = this._node$_parent; + if (t1 == null) + t1 = null; + else { + t1 = t1.children; + t2 = this._node$_indexInParent; + t2.toString; + t1 = A.SubListIterable$(t1, t2 + 1, null, t1.$ti._eval$1("ListBase.E")).any$1(0, new A.ModifiableCssNode_hasFollowingSibling_closure0()); + } + return t1 === true; + }, + get$isGroupEnd() { + return this.isGroupEnd; + } + }; + A.ModifiableCssNode_hasFollowingSibling_closure0.prototype = { + call$1(sibling) { + return !sibling.accept$1(B._IsInvisibleVisitor_true_false0); + }, + $signature: 529 + }; + A.ModifiableCssParentNode0.prototype = { + get$isChildless() { + return false; + }, + addChild$1(child) { + var t1; + child._node$_parent = this; + t1 = this._node$_children; + child._node$_indexInParent = t1.length; + t1.push(child); + }, + clearChildren$0() { + var t1, t2, _i, child; + for (t1 = this._node$_children, t2 = t1.length, _i = 0; _i < t2; ++_i) { + child = t1[_i]; + child._node$_indexInParent = child._node$_parent = null; + } + B.JSArray_methods.clear$0(t1); + }, + $isCssParentNode0: 1, + get$children(receiver) { + return this.children; + } + }; + A.NodePackageImporter0.prototype = { + isNonCanonicalScheme$1(scheme) { + return scheme === "pkg"; + }, + canonicalize$1(_, url) { + var packageName, jsonPath, jsonString, packageManifest, e, t1, t2, t3, t4, baseDirectory, parts, t5, $name, subpath, packageRoot, exception, _1_0, rootPath, subpathInRoot, _this = this, _null = null; + if (url.get$scheme() === "file") + return $.$get$FilesystemImporter_cwd0().canonicalize$1(0, url); + if (url.get$scheme() !== "pkg") + return _null; + if (url.get$hasAuthority()) + throw A.wrapException(string$.A_pkg_h); + else { + t1 = $.$get$url(); + t2 = t1.style; + if (t2.rootLength$1(url.get$path(url)) > 0) + throw A.wrapException("A pkg: URL's path must not begin with /."); + else if (url.get$path(url).length === 0) + throw A.wrapException("A pkg: URL must not have an empty path."); + else if (url.get$hasQuery() || url.get$hasFragment()) + throw A.wrapException(string$.A_pkg_q); + } + t3 = A.canonicalizeContext0(); + t3._canonicalize_context$_wasContainingUrlAccessed = true; + t3 = t3._canonicalize_context$_containingUrl; + if ((t3 == null ? _null : t3.get$scheme()) === "file") { + t3 = A.canonicalizeContext0(); + t3._canonicalize_context$_wasContainingUrlAccessed = true; + t3 = t3._canonicalize_context$_containingUrl; + t3.toString; + t4 = $.$get$context(); + baseDirectory = t4.dirname$1(t4.style.pathFromUri$1(A._parseUri(t3))); + } else { + t3 = _this._node_package$__NodePackageImporter__entryPointDirectory_F; + t3 === $ && A.throwUnnamedLateFieldNI(); + baseDirectory = t3; + } + packageName = null; + parts = t1.split$1(0, url.get$path(url)); + t3 = B.JSArray_methods.removeAt$1(parts, 0); + t4 = $.$get$context(); + t3.toString; + t5 = t4.style; + $name = t5.pathFromUri$1(A._parseUri(t3)); + if (B.JSString_methods.startsWith$1($name, "@")) + $name = parts.length !== 0 ? t1.join$2(0, $name, B.JSArray_methods.removeAt$1(parts, 0)) : $name; + subpath = parts.length !== 0 ? t5.pathFromUri$1(A._parseUri(t1.joinAll$1(parts))) : _null; + packageName = $name; + t1 = true; + if (!J.startsWith$1$s(packageName, ".")) + if (!J.contains$1$asx(packageName, "\\")) + if (!J.contains$1$asx(packageName, "%")) + t1 = J.startsWith$1$s(packageName, "@") && !J.contains$1$asx(packageName, t2.get$separator(t2)); + if (t1) + return _null; + packageRoot = _this._node_package$_resolvePackageRoot$2(packageName, baseDirectory); + if (packageRoot == null) + return _null; + jsonPath = A.join(packageRoot, "package.json", _null); + jsonString = A.readFile0(jsonPath); + packageManifest = null; + try { + packageManifest = type$.Map_String_dynamic._as(B.C_JsonCodec.decode$1(jsonString)); + } catch (exception) { + e = A.unwrapException(exception); + t1 = A.S(jsonPath); + t2 = A.S(packageName); + t3 = A.S(e); + throw A.wrapException("Failed to parse " + t1 + ' for "pkg:' + t2 + '": ' + t3); + } + _1_0 = _this._node_package$_resolvePackageExports$4(packageRoot, subpath, packageManifest, packageName); + if (_1_0 != null) + if (B.Set_FTDN4.contains$1(0, A.ParsedPath_ParsedPath$parse(_1_0, t5)._splitExtension$1(1)[1])) + return t4.toUri$1(t4.canonicalize$1(0, _1_0)); + else { + t1 = subpath == null ? "root" : subpath; + throw A.wrapException("The export for '" + t1 + "' in '" + A.S(packageName) + "' resolved to '" + _1_0 + string$.x27x2c_whi); + } + if (subpath == null) { + rootPath = _this._node_package$_resolvePackageRootValues$2(packageRoot, packageManifest); + return rootPath != null ? t4.toUri$1(t4.canonicalize$1(0, rootPath)) : _null; + } + subpathInRoot = A.join(packageRoot, subpath, _null); + return $.$get$FilesystemImporter_cwd0().canonicalize$1(0, t4.toUri$1(subpathInRoot)); + }, + load$1(_, url) { + return $.$get$FilesystemImporter_cwd0().load$1(0, url); + }, + _node_package$_resolvePackageRoot$2(packageName, baseDirectory) { + var potentialPackage, t1; + for (; true;) { + potentialPackage = A.join(baseDirectory, "node_modules", packageName); + if (A.dirExists0(potentialPackage)) + return potentialPackage; + t1 = $.$get$context(); + if (t1.split$1(0, baseDirectory).length === 1) + return null; + baseDirectory = t1.dirname$1(baseDirectory); + } + }, + _node_package$_resolvePackageRootValues$2(packageRoot, packageManifest) { + var t1, sassValue, _1_0, styleValue, _null = null, + _0_0 = packageManifest.$index(0, "sass"); + if (typeof _0_0 == "string") { + t1 = B.Set_FTDN4.contains$1(0, A.ParsedPath_ParsedPath$parse(_0_0, $.$get$url().style)._splitExtension$1(1)[1]); + sassValue = _0_0; + } else { + sassValue = _null; + t1 = false; + } + if (t1) + return A.join(packageRoot, sassValue, _null); + else { + _1_0 = packageManifest.$index(0, "style"); + if (typeof _1_0 == "string") { + t1 = B.Set_FTDN4.contains$1(0, A.ParsedPath_ParsedPath$parse(_1_0, $.$get$url().style)._splitExtension$1(1)[1]); + styleValue = _1_0; + } else { + styleValue = _null; + t1 = false; + } + if (t1) + return A.join(packageRoot, styleValue, _null); + } + return A.resolveImportPath0(A.join(packageRoot, "index", _null)); + }, + _node_package$_resolvePackageExports$4(packageRoot, subpath, packageManifest, packageName) { + var _0_0, _1_0, _this = this, + exports = packageManifest.$index(0, "exports"); + if (exports == null) + return null; + _0_0 = _this._node_package$_nodePackageExportsResolve$5(packageRoot, _this._node_package$_exportsToCheck$1(subpath), exports, subpath, packageName); + if (_0_0 != null) + return _0_0; + if (subpath != null && A.ParsedPath_ParsedPath$parse(subpath, $.$get$url().style)._splitExtension$1(1)[1].length !== 0) + return null; + _1_0 = _this._node_package$_nodePackageExportsResolve$5(packageRoot, _this._node_package$_exportsToCheck$2$addIndex(subpath, true), exports, subpath, packageName); + if (_1_0 != null) + return _1_0; + return null; + }, + _node_package$_nodePackageExportsResolve$5(packageRoot, subpathVariants, exports, subpath, packageName) { + var t1, matches, _1_1, path; + if (type$.Map_String_dynamic._is(exports) && J.any$1$ax(exports.get$keys(exports), new A.NodePackageImporter__nodePackageExportsResolve_closure3()) && J.any$1$ax(exports.get$keys(exports), new A.NodePackageImporter__nodePackageExportsResolve_closure4())) + throw A.wrapException("`exports` in " + packageName + string$.x20can_n + J.map$1$1$ax(J.get$keys$z(exports), new A.NodePackageImporter__nodePackageExportsResolve_closure5(), type$.String).join$1(0, ",") + " in " + A.join(packageRoot, "package.json", null) + "."); + t1 = type$.NonNullsIterable_String; + matches = A.List_List$of(new A.NonNullsIterable(new A.MappedListIterable(subpathVariants, new A.NodePackageImporter__nodePackageExportsResolve_closure6(this, exports, packageRoot), A._arrayInstanceType(subpathVariants)._eval$1("MappedListIterable<1,String?>")), t1), true, t1._eval$1("Iterable.E")); + $label0$1: { + _1_1 = matches.length; + if (_1_1 === 1) { + path = matches[0]; + t1 = path; + break $label0$1; + } + if (_1_1 <= 0) { + t1 = null; + break $label0$1; + } + t1 = subpath == null ? "root" : subpath; + t1 = A.throwExpression(string$.Unable + t1 + " in " + packageName + " should be used. \n\nFound:\n" + B.JSArray_methods.join$1(matches, "\n")); + } + return t1; + }, + _node_package$_compareExpansionKeys$2(keyA, keyB) { + var t1 = B.JSString_methods.contains$1(keyA, "*"), + baseLengthA = t1 ? B.JSString_methods.indexOf$1(keyA, "*") + 1 : keyA.length, + t2 = B.JSString_methods.contains$1(keyB, "*"), + baseLengthB = t2 ? B.JSString_methods.indexOf$1(keyB, "*") + 1 : keyB.length; + if (baseLengthA > baseLengthB) + return -1; + if (baseLengthB > baseLengthA) + return 1; + if (!t1) + return 1; + if (!t2) + return -1; + t1 = keyA.length; + t2 = keyB.length; + if (t1 > t2) + return -1; + if (t2 > t1) + return 1; + return 0; + }, + _node_package$_packageTargetResolve$4(subpath, exports, packageRoot, patternMatch) { + var t2, string, path, map, key, value, _1_0, array, _2_0, _null = null, + t1 = typeof exports == "string"; + if (t1) { + t2 = !B.JSString_methods.startsWith$1(exports, "./"); + string = exports; + } else { + string = _null; + t2 = false; + } + if (t2) + throw A.wrapException("Export '" + A.S(string) + string$.x27x20must + packageRoot + "'."); + if (t1) { + t2 = patternMatch != null; + string = exports; + } else { + string = _null; + t2 = false; + } + if (t2) { + t1 = J.replaceFirst$2$s(string, "*", patternMatch); + t2 = $.$get$context(); + path = t2.normalize$1(A.join(packageRoot, t2.style.pathFromUri$1(A._parseUri(t1)), _null)); + return A.fileExists0(path) ? path : _null; + } + string = t1 ? exports : _null; + if (t1) { + t1 = $.$get$context(); + string.toString; + return A.join(packageRoot, t1.style.pathFromUri$1(A._parseUri(string)), _null); + } + t1 = type$.Map_String_dynamic._is(exports); + map = t1 ? exports : _null; + if (t1) { + for (t1 = A.MapExtensions_get_pairs(map, type$.String, type$.dynamic), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t2 = t1.get$current(t1); + key = t2._0; + value = t2._1; + if (!B.Set_8229z.contains$1(0, key)) + continue; + if (value == null) + continue; + _1_0 = this._node_package$_packageTargetResolve$4(subpath, value, packageRoot, patternMatch); + if (_1_0 != null) + return _1_0; + } + return _null; + } + if (type$.List_nullable_Object._is(exports) && J.get$length$asx(exports) <= 0) + return _null; + t1 = type$.List_dynamic._is(exports); + array = t1 ? exports : _null; + if (t1) { + for (t1 = J.get$iterator$ax(array); t1.moveNext$0();) { + value = t1.get$current(t1); + if (value == null) + continue; + _2_0 = this._node_package$_packageTargetResolve$4(subpath, value, packageRoot, patternMatch); + if (_2_0 != null) + return _2_0; + } + return _null; + } + throw A.wrapException("Invalid 'exports' value " + A.S(exports) + " in " + A.join(packageRoot, "package.json", _null) + "."); + }, + _node_package$_packageTargetResolve$3(subpath, exports, packageRoot) { + return this._node_package$_packageTargetResolve$4(subpath, exports, packageRoot, null); + }, + _node_package$_getMainExport$1(exports) { + var t1, t2, t3, map, _0_4, t4, $export; + $label0$0: { + t1 = null; + if (typeof exports == "string") { + t1 = exports; + break $label0$0; + } + if (type$.List_String._is(exports)) { + t1 = exports; + break $label0$0; + } + t2 = type$.Map_String_dynamic._is(exports); + if (t2) { + t3 = !J.any$1$ax(exports.get$keys(exports), new A.NodePackageImporter__getMainExport_closure0()); + map = exports; + } else { + map = t1; + t3 = false; + } + if (t3) { + t1 = map; + break $label0$0; + } + t3 = false; + if (t2) { + _0_4 = exports.$index(0, "."); + if (_0_4 == null) + t4 = exports.containsKey$1("."); + else + t4 = true; + if (t4) + t3 = _0_4 != null; + } else + _0_4 = null; + if (t3) { + $export = t2 ? _0_4 : J.$index$asx(exports, "."); + t1 = $export; + break $label0$0; + } + break $label0$0; + } + return t1; + }, + _node_package$_exportsToCheck$2$addIndex(subpath, addIndex) { + var basename, dirname, t3, t4, _i, path, + t1 = type$.JSArray_String, + paths = A._setArrayType([], t1), + t2 = subpath == null; + if (t2 && addIndex) + subpath = "index"; + else if (!t2 && addIndex) + subpath = A.join(subpath, "index", null); + if (subpath == null) + return A._setArrayType([null], type$.JSArray_nullable_String); + if (B.Set_FTDN4.contains$1(0, A.ParsedPath_ParsedPath$parse(subpath, $.$get$url().style)._splitExtension$1(1)[1])) + paths.push(subpath); + else + B.JSArray_methods.addAll$1(paths, A._setArrayType([subpath, subpath + ".scss", subpath + ".sass", subpath + ".css"], t1)); + t1 = $.$get$context(); + t2 = t1.style; + basename = A.ParsedPath_ParsedPath$parse(subpath, t2).get$basename(); + dirname = t1.dirname$1(subpath); + if (B.JSString_methods.startsWith$1(basename, "_")) + return paths; + t1 = A.List_List$of(paths, true, type$.nullable_String); + for (t3 = paths.length, t4 = dirname === ".", _i = 0; _i < paths.length; paths.length === t3 || (0, A.throwConcurrentModificationError)(paths), ++_i) { + path = paths[_i]; + if (t4) + t1.push("_" + A.ParsedPath_ParsedPath$parse(path, t2).get$basename()); + else + t1.push(A.join(dirname, "_" + A.ParsedPath_ParsedPath$parse(path, t2).get$basename(), null)); + } + return t1; + }, + _node_package$_exportsToCheck$1(subpath) { + return this._node_package$_exportsToCheck$2$addIndex(subpath, false); + } + }; + A.NodePackageImporter__nodePackageExportsResolve_closure3.prototype = { + call$1(key) { + return B.JSString_methods.startsWith$1(key, "."); + }, + $signature: 5 + }; + A.NodePackageImporter__nodePackageExportsResolve_closure4.prototype = { + call$1(key) { + return !B.JSString_methods.startsWith$1(key, "."); + }, + $signature: 5 + }; + A.NodePackageImporter__nodePackageExportsResolve_closure5.prototype = { + call$1(key) { + return '"' + key + '"'; + }, + $signature: 6 + }; + A.NodePackageImporter__nodePackageExportsResolve_closure6.prototype = { + call$1(variant) { + var t1, matchKey, t2, t3, t4, t5, t6, _i, expansionKey, _0_0, t7, patternBase, patternTrailer, t8, target, _this = this, _null = null; + if (variant == null) { + t1 = _this.$this; + return A.NullableExtension_andThen(t1._node_package$_getMainExport$1(_this.exports), new A.NodePackageImporter__nodePackageExportsResolve__closure1(t1, variant, _this.packageRoot)); + } else { + t1 = _this.exports; + if (!type$.Map_String_dynamic._is(t1) || J.every$1$ax(t1.get$keys(t1), new A.NodePackageImporter__nodePackageExportsResolve__closure2())) + return _null; + } + matchKey = "./" + $.$get$context().toUri$1(variant).toString$0(0); + if (t1.containsKey$1(matchKey) && J.$index$asx(t1, matchKey) != null && !B.JSString_methods.contains$1(matchKey, "*")) { + t1 = J.$index$asx(t1, matchKey); + if (t1 == null) + t1 = type$.Object._as(t1); + return _this.$this._node_package$_packageTargetResolve$3(matchKey, t1, _this.packageRoot); + } + t2 = A._setArrayType([], type$.JSArray_String); + for (t3 = J.getInterceptor$z(t1), t4 = J.get$iterator$ax(t3.get$keys(t1)); t4.moveNext$0();) { + t5 = t4.get$current(t4); + if (B.JSString_methods.allMatches$1("*", t5).get$length(0) === 1) + t2.push(t5); + } + t4 = _this.$this; + B.JSArray_methods.sort$1(t2, t4.get$_node_package$_compareExpansionKeys()); + for (t5 = t2.length, t6 = matchKey.length, _i = 0; _i < t2.length; t2.length === t5 || (0, A.throwConcurrentModificationError)(t2), ++_i) { + expansionKey = t2[_i]; + _0_0 = expansionKey.split("*"); + t7 = _0_0.length === 2; + if (t7) { + patternBase = _0_0[0]; + patternTrailer = _0_0[1]; + } else { + patternTrailer = _null; + patternBase = patternTrailer; + } + if (!t7) + throw A.wrapException(A.StateError$("Pattern matching error")); + if (!B.JSString_methods.startsWith$1(matchKey, patternBase)) + continue; + if (matchKey === patternBase) + continue; + t7 = patternTrailer.length; + if (t7 !== 0) + t8 = B.JSString_methods.endsWith$1(matchKey, patternTrailer) && t6 >= expansionKey.length; + else + t8 = true; + if (t8) { + target = t3.$index(t1, expansionKey); + if (target == null) + continue; + return t4._node_package$_packageTargetResolve$4(variant, target, _this.packageRoot, B.JSString_methods.substring$2(matchKey, patternBase.length, t6 - t7)); + } + } + return _null; + }, + $signature: 147 + }; + A.NodePackageImporter__nodePackageExportsResolve__closure1.prototype = { + call$1(mainExport) { + return this.$this._node_package$_packageTargetResolve$3(this.variant, mainExport, this.packageRoot); + }, + $signature: 148 + }; + A.NodePackageImporter__nodePackageExportsResolve__closure2.prototype = { + call$1(key) { + return !B.JSString_methods.startsWith$1(key, "."); + }, + $signature: 5 + }; + A.NodePackageImporter__getMainExport_closure0.prototype = { + call$1(key) { + return B.JSString_methods.startsWith$1(key, "."); + }, + $signature: 5 + }; + A.NullExpression0.prototype = { + accept$1$1(visitor) { + return visitor.visitNullExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "null"; + }, + get$span(receiver) { + return this.span; + } + }; + A.legacyNullClass_closure.prototype = { + call$0() { + var t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.types.Null", new A.legacyNullClass__closure())); + jsClass.NULL = B.C__SassNull0; + A.JSClassExtension_injectSuperclass(t1._as(B.C__SassNull0.constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.legacyNullClass__closure.prototype = { + call$2(_, __) { + throw A.wrapException("new sass.types.Null() isn't allowed. Use sass.types.Null.NULL instead."); + }, + call$1(_) { + return this.call$2(_, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 222 + }; + A._SassNull0.prototype = { + get$isTruthy() { + return false; + }, + get$isBlank() { + return true; + }, + get$realNull() { + return null; + }, + accept$1$1(visitor) { + if (visitor._serialize0$_inspect) + visitor._serialize0$_buffer.write$1(0, "null"); + return null; + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + unaryNot$0() { + return B.SassBoolean_true0; + } + }; + A.NumberExpression0.prototype = { + accept$1$1(visitor) { + return visitor.visitNumberExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return A.serializeValue0(A.SassNumber_SassNumber0(this.value, this.unit), true, true); + }, + get$span(receiver) { + return this.span; + } + }; + A.numberClass_closure.prototype = { + call$0() { + var t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.SassNumber", new A.numberClass__closure())), + t2 = type$.String, + t3 = type$.Function; + A.LinkedHashMap_LinkedHashMap$_literal(["value", new A.numberClass__closure0(), "isInt", new A.numberClass__closure1(), "asInt", new A.numberClass__closure2(), "numeratorUnits", new A.numberClass__closure3(), "denominatorUnits", new A.numberClass__closure4(), "hasUnits", new A.numberClass__closure5()], t2, t3).forEach$1(0, A.JSClassExtension_get_defineGetter(jsClass)); + A.LinkedHashMap_LinkedHashMap$_literal(["assertInt", new A.numberClass__closure6(), "assertInRange", new A.numberClass__closure7(), "assertNoUnits", new A.numberClass__closure8(), "assertUnit", new A.numberClass__closure9(), "hasUnit", new A.numberClass__closure10(), "compatibleWithUnit", new A.numberClass__closure11(), "convert", new A.numberClass__closure12(), "convertToMatch", new A.numberClass__closure13(), "convertValue", new A.numberClass__closure14(), "convertValueToMatch", new A.numberClass__closure15(), "coerce", new A.numberClass__closure16(), "coerceToMatch", new A.numberClass__closure17(), "coerceValue", new A.numberClass__closure18(), "coerceValueToMatch", new A.numberClass__closure19()], t2, t3).forEach$1(0, A.JSClassExtension_get_defineMethod(jsClass)); + A.JSClassExtension_injectSuperclass(t1._as(self.Object.getPrototypeOf(J.get$$prototype$x(t1._as(A.SassNumber_SassNumber0(0, null).constructor))).constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.numberClass__closure.prototype = { + call$3($self, value, unitOrOptions) { + var t1, t2, _null = null; + if (typeof unitOrOptions == "string") + return A.SassNumber_SassNumber0(value, unitOrOptions); + type$.nullable__ConstructorOptions_2._as(unitOrOptions); + t1 = unitOrOptions == null; + if (t1) + t2 = _null; + else { + t2 = A.NullableExtension_andThen0(J.get$numeratorUnits$x(unitOrOptions), A.immutable__jsToDartList$closure()); + t2 = t2 == null ? _null : J.cast$1$0$ax(t2, type$.String); + } + if (t1) + t1 = _null; + else { + t1 = A.NullableExtension_andThen0(J.get$denominatorUnits$x(unitOrOptions), A.immutable__jsToDartList$closure()); + t1 = t1 == null ? _null : J.cast$1$0$ax(t1, type$.String); + } + return A.SassNumber_SassNumber$withUnits0(value, t1, t2); + }, + call$2($self, value) { + return this.call$3($self, value, null); + }, + "call*": "call$3", + $requiredArgCount: 2, + $defaultValues() { + return [null]; + }, + $signature: 530 + }; + A.numberClass__closure0.prototype = { + call$1($self) { + return $self._number1$_value; + }, + $signature: 89 + }; + A.numberClass__closure1.prototype = { + call$1($self) { + return A.fuzzyIsInt0($self._number1$_value); + }, + $signature: 252 + }; + A.numberClass__closure2.prototype = { + call$1($self) { + return A.fuzzyAsInt0($self._number1$_value); + }, + $signature: 532 + }; + A.numberClass__closure3.prototype = { + call$1($self) { + return new self.immutable.List($self.get$numeratorUnits($self)); + }, + $signature: 253 + }; + A.numberClass__closure4.prototype = { + call$1($self) { + return new self.immutable.List($self.get$denominatorUnits($self)); + }, + $signature: 253 + }; + A.numberClass__closure5.prototype = { + call$1($self) { + return $self.get$hasUnits(); + }, + $signature: 252 + }; + A.numberClass__closure6.prototype = { + call$2($self, $name) { + return $self.assertInt$1($name); + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 534 + }; + A.numberClass__closure7.prototype = { + call$4($self, min, max, $name) { + return $self.valueInRange$3(min, max, $name); + }, + call$3($self, min, max) { + return this.call$4($self, min, max, null); + }, + "call*": "call$4", + $requiredArgCount: 3, + $defaultValues() { + return [null]; + }, + $signature: 535 + }; + A.numberClass__closure8.prototype = { + call$2($self, $name) { + $self.assertNoUnits$1($name); + return $self; + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 536 + }; + A.numberClass__closure9.prototype = { + call$3($self, unit, $name) { + $self.assertUnit$2(unit, $name); + return $self; + }, + call$2($self, unit) { + return this.call$3($self, unit, null); + }, + "call*": "call$3", + $requiredArgCount: 2, + $defaultValues() { + return [null]; + }, + $signature: 537 + }; + A.numberClass__closure10.prototype = { + call$2($self, unit) { + return $self.hasUnit$1(unit); + }, + $signature: 254 + }; + A.numberClass__closure11.prototype = { + call$2($self, unit) { + return $self.get$hasUnits() && $self.compatibleWithUnit$1(unit); + }, + $signature: 254 + }; + A.numberClass__closure12.prototype = { + call$4($self, numeratorUnits, denominatorUnits, $name) { + var t1 = self.immutable.isOrderedMap(numeratorUnits) ? J.toArray$0$x(type$.ImmutableList._as(numeratorUnits)) : type$.List_dynamic._as(numeratorUnits), + t2 = type$.String; + t1 = J.cast$1$0$ax(t1, t2); + t2 = J.cast$1$0$ax(self.immutable.isOrderedMap(denominatorUnits) ? J.toArray$0$x(type$.ImmutableList._as(denominatorUnits)) : type$.List_dynamic._as(denominatorUnits), t2); + return A.SassNumber_SassNumber$withUnits0($self._number1$_coerceOrConvertValue$4$coerceUnitless$name(t1, t2, false, $name), t2, t1); + }, + call$3($self, numeratorUnits, denominatorUnits) { + return this.call$4($self, numeratorUnits, denominatorUnits, null); + }, + "call*": "call$4", + $requiredArgCount: 3, + $defaultValues() { + return [null]; + }, + $signature: 255 + }; + A.numberClass__closure13.prototype = { + call$4($self, other, $name, otherName) { + return $self.convertToMatch$3(other, $name, otherName); + }, + call$2($self, other) { + return this.call$4($self, other, null, null); + }, + call$3($self, other, $name) { + return this.call$4($self, other, $name, null); + }, + "call*": "call$4", + $requiredArgCount: 2, + $defaultValues() { + return [null, null]; + }, + $signature: 256 + }; + A.numberClass__closure14.prototype = { + call$4($self, numeratorUnits, denominatorUnits, $name) { + var t1 = self.immutable.isOrderedMap(numeratorUnits) ? J.toArray$0$x(type$.ImmutableList._as(numeratorUnits)) : type$.List_dynamic._as(numeratorUnits), + t2 = type$.String; + t1 = J.cast$1$0$ax(t1, t2); + return $self._number1$_coerceOrConvertValue$4$coerceUnitless$name(t1, J.cast$1$0$ax(self.immutable.isOrderedMap(denominatorUnits) ? J.toArray$0$x(type$.ImmutableList._as(denominatorUnits)) : type$.List_dynamic._as(denominatorUnits), t2), false, $name); + }, + call$3($self, numeratorUnits, denominatorUnits) { + return this.call$4($self, numeratorUnits, denominatorUnits, null); + }, + "call*": "call$4", + $requiredArgCount: 3, + $defaultValues() { + return [null]; + }, + $signature: 257 + }; + A.numberClass__closure15.prototype = { + call$4($self, other, $name, otherName) { + return $self.convertValueToMatch$3(other, $name, otherName); + }, + call$2($self, other) { + return this.call$4($self, other, null, null); + }, + call$3($self, other, $name) { + return this.call$4($self, other, $name, null); + }, + "call*": "call$4", + $requiredArgCount: 2, + $defaultValues() { + return [null, null]; + }, + $signature: 258 + }; + A.numberClass__closure16.prototype = { + call$4($self, numeratorUnits, denominatorUnits, $name) { + var t1 = self.immutable.isOrderedMap(numeratorUnits) ? J.toArray$0$x(type$.ImmutableList._as(numeratorUnits)) : type$.List_dynamic._as(numeratorUnits), + t2 = type$.String; + t1 = J.cast$1$0$ax(t1, t2); + return $self.coerce$3(t1, J.cast$1$0$ax(self.immutable.isOrderedMap(denominatorUnits) ? J.toArray$0$x(type$.ImmutableList._as(denominatorUnits)) : type$.List_dynamic._as(denominatorUnits), t2), $name); + }, + call$3($self, numeratorUnits, denominatorUnits) { + return this.call$4($self, numeratorUnits, denominatorUnits, null); + }, + "call*": "call$4", + $requiredArgCount: 3, + $defaultValues() { + return [null]; + }, + $signature: 255 + }; + A.numberClass__closure17.prototype = { + call$4($self, other, $name, otherName) { + return $self.coerceToMatch$3(other, $name, otherName); + }, + call$2($self, other) { + return this.call$4($self, other, null, null); + }, + call$3($self, other, $name) { + return this.call$4($self, other, $name, null); + }, + "call*": "call$4", + $requiredArgCount: 2, + $defaultValues() { + return [null, null]; + }, + $signature: 256 + }; + A.numberClass__closure18.prototype = { + call$4($self, numeratorUnits, denominatorUnits, $name) { + var t1 = self.immutable.isOrderedMap(numeratorUnits) ? J.toArray$0$x(type$.ImmutableList._as(numeratorUnits)) : type$.List_dynamic._as(numeratorUnits), + t2 = type$.String; + t1 = J.cast$1$0$ax(t1, t2); + return $self.coerceValue$3(t1, J.cast$1$0$ax(self.immutable.isOrderedMap(denominatorUnits) ? J.toArray$0$x(type$.ImmutableList._as(denominatorUnits)) : type$.List_dynamic._as(denominatorUnits), t2), $name); + }, + call$3($self, numeratorUnits, denominatorUnits) { + return this.call$4($self, numeratorUnits, denominatorUnits, null); + }, + "call*": "call$4", + $requiredArgCount: 3, + $defaultValues() { + return [null]; + }, + $signature: 257 + }; + A.numberClass__closure19.prototype = { + call$4($self, other, $name, otherName) { + return $self.coerceValueToMatch$3(other, $name, otherName); + }, + call$2($self, other) { + return this.call$4($self, other, null, null); + }, + call$3($self, other, $name) { + return this.call$4($self, other, $name, null); + }, + "call*": "call$4", + $requiredArgCount: 2, + $defaultValues() { + return [null, null]; + }, + $signature: 258 + }; + A._ConstructorOptions0.prototype = {}; + A._NodeSassNumber.prototype = {}; + A.legacyNumberClass_closure.prototype = { + call$4(thisArg, value, unit, dartValue) { + var t1; + if (dartValue == null) { + value.toString; + t1 = A._parseNumber(value, unit); + } else + t1 = dartValue; + J.set$dartValue$x(thisArg, t1); + }, + call$2(thisArg, value) { + return this.call$4(thisArg, value, null, null); + }, + call$3(thisArg, value, unit) { + return this.call$4(thisArg, value, unit, null); + }, + "call*": "call$4", + $requiredArgCount: 2, + $defaultValues() { + return [null, null]; + }, + $signature: 543 + }; + A.legacyNumberClass_closure0.prototype = { + call$1(thisArg) { + return J.get$dartValue$x(thisArg)._number1$_value; + }, + $signature: 544 + }; + A.legacyNumberClass_closure1.prototype = { + call$2(thisArg, value) { + var t1 = J.getInterceptor$x(thisArg), + t2 = J.get$numeratorUnits$x(t1.get$dartValue(thisArg)); + t1.set$dartValue(thisArg, A.SassNumber_SassNumber$withUnits0(value, J.get$denominatorUnits$x(t1.get$dartValue(thisArg)), t2)); + }, + $signature: 545 + }; + A.legacyNumberClass_closure2.prototype = { + call$1(thisArg) { + var t1 = J.getInterceptor$x(thisArg), + t2 = B.JSArray_methods.join$1(J.get$numeratorUnits$x(t1.get$dartValue(thisArg)), "*"), + t3 = J.get$denominatorUnits$x(t1.get$dartValue(thisArg)).length === 0 ? "" : "/"; + return t2 + t3 + B.JSArray_methods.join$1(J.get$denominatorUnits$x(t1.get$dartValue(thisArg)), "*"); + }, + $signature: 546 + }; + A.legacyNumberClass_closure3.prototype = { + call$2(thisArg, unit) { + var t1 = J.getInterceptor$x(thisArg); + t1.set$dartValue(thisArg, A._parseNumber(t1.get$dartValue(thisArg)._number1$_value, unit)); + }, + $signature: 547 + }; + A._parseNumber_closure.prototype = { + call$1(unit) { + return unit.length === 0; + }, + $signature: 5 + }; + A._parseNumber_closure0.prototype = { + call$1(unit) { + return unit.length === 0; + }, + $signature: 5 + }; + A.SassNumber0.prototype = { + get$unitString() { + var _this = this; + return _this.get$hasUnits() ? _this._number1$_unitString$2(_this.get$numeratorUnits(_this), _this.get$denominatorUnits(_this)) : ""; + }, + accept$1$1(visitor) { + return visitor.visitNumber$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + withoutSlash$0() { + var _this = this; + return _this.asSlash == null ? _this : _this.withValue$1(_this._number1$_value); + }, + assertNumber$1($name) { + return this; + }, + assertNumber$0() { + return this.assertNumber$1(null); + }, + assertInt$1($name) { + var _0_0 = A.fuzzyAsInt0(this._number1$_value); + if (_0_0 != null) + return _0_0; + throw A.wrapException(A.SassScriptException$0(this.toString$0(0) + " is not an int.", $name)); + }, + assertInt$0() { + return this.assertInt$1(null); + }, + valueInRange$3(min, max, $name) { + var _this = this, + _0_0 = A.fuzzyCheckRange0(_this._number1$_value, min, max); + if (_0_0 != null) + return _0_0; + throw A.wrapException(A.SassScriptException$0("Expected " + _this.toString$0(0) + " to be within " + A.S(min) + _this.get$unitString() + " and " + A.S(max) + _this.get$unitString() + ".", $name)); + }, + valueInRangeWithUnit$4(min, max, $name, unit) { + var _0_0 = A.fuzzyCheckRange0(this._number1$_value, min, max); + if (_0_0 != null) + return _0_0; + throw A.wrapException(A.SassScriptException$0("Expected " + this.toString$0(0) + " to be within " + min + unit + " and " + max + unit + ".", $name)); + }, + hasCompatibleUnits$1(other) { + var _this = this; + if (_this.get$numeratorUnits(_this).length !== other.get$numeratorUnits(other).length) + return false; + if (_this.get$denominatorUnits(_this).length !== other.get$denominatorUnits(other).length) + return false; + return _this.isComparableTo$1(other); + }, + assertUnit$2(unit, $name) { + if (this.hasUnit$1(unit)) + return; + throw A.wrapException(A.SassScriptException$0("Expected " + this.toString$0(0) + ' to have unit "' + unit + '".', $name)); + }, + assertNoUnits$1($name) { + if (!this.get$hasUnits()) + return; + throw A.wrapException(A.SassScriptException$0("Expected " + this.toString$0(0) + " to have no units.", $name)); + }, + assertNoUnits$0() { + return this.assertNoUnits$1(null); + }, + convertToMatch$3(other, $name, otherName) { + var t1 = this.convertValueToMatch$3(other, $name, otherName), + t2 = other.get$numeratorUnits(other); + return A.SassNumber_SassNumber$withUnits0(t1, other.get$denominatorUnits(other), t2); + }, + convertValueToMatch$3(other, $name, otherName) { + return this._number1$_coerceOrConvertValue$6$coerceUnitless$name$other$otherName(other.get$numeratorUnits(other), other.get$denominatorUnits(other), false, $name, other, otherName); + }, + convertValueToMatch$1(other) { + return this.convertValueToMatch$3(other, null, null); + }, + coerce$3(newNumerators, newDenominators, $name) { + return A.SassNumber_SassNumber$withUnits0(this.coerceValue$3(newNumerators, newDenominators, $name), newDenominators, newNumerators); + }, + coerce$2(newNumerators, newDenominators) { + return this.coerce$3(newNumerators, newDenominators, null); + }, + coerceValue$3(newNumerators, newDenominators, $name) { + return this._number1$_coerceOrConvertValue$4$coerceUnitless$name(newNumerators, newDenominators, true, $name); + }, + coerceValueToUnit$2(unit, $name) { + var t1 = type$.JSArray_String; + return this.coerceValue$3(A._setArrayType([unit], t1), A._setArrayType([], t1), $name); + }, + coerceValueToUnit$1(unit) { + return this.coerceValueToUnit$2(unit, null); + }, + coerceToMatch$3(other, $name, otherName) { + var t1 = this.coerceValueToMatch$3(other, $name, otherName), + t2 = other.get$numeratorUnits(other); + return A.SassNumber_SassNumber$withUnits0(t1, other.get$denominatorUnits(other), t2); + }, + coerceValueToMatch$3(other, $name, otherName) { + return this._number1$_coerceOrConvertValue$6$coerceUnitless$name$other$otherName(other.get$numeratorUnits(other), other.get$denominatorUnits(other), true, $name, other, otherName); + }, + coerceValueToMatch$1(other) { + return this.coerceValueToMatch$3(other, null, null); + }, + _number1$_coerceOrConvertValue$6$coerceUnitless$name$other$otherName(newNumerators, newDenominators, coerceUnitless, $name, other, otherName) { + var t1, otherHasUnits, t2, compatibilityException, oldNumerators, oldDenominators, _this = this, _box_0 = {}; + if (B.C_ListEquality.equals$2(0, _this.get$numeratorUnits(_this), newNumerators) && B.C_ListEquality.equals$2(0, _this.get$denominatorUnits(_this), newDenominators)) + return _this._number1$_value; + t1 = J.getInterceptor$asx(newNumerators); + otherHasUnits = t1.get$isNotEmpty(newNumerators) || J.get$isNotEmpty$asx(newDenominators); + if (coerceUnitless) + t2 = !_this.get$hasUnits() || !otherHasUnits; + else + t2 = false; + if (t2) + return _this._number1$_value; + compatibilityException = new A.SassNumber__coerceOrConvertValue_compatibilityException0(_this, other, otherName, otherHasUnits, $name, newNumerators, newDenominators); + _box_0.value = _this._number1$_value; + t2 = _this.get$numeratorUnits(_this); + oldNumerators = A._setArrayType(t2.slice(0), A._arrayInstanceType(t2)); + for (t1 = t1.get$iterator(newNumerators); t1.moveNext$0();) + A.removeFirstWhere0(oldNumerators, new A.SassNumber__coerceOrConvertValue_closure3(_box_0, t1.get$current(t1)), new A.SassNumber__coerceOrConvertValue_closure4(compatibilityException)); + t1 = _this.get$denominatorUnits(_this); + oldDenominators = A._setArrayType(t1.slice(0), A._arrayInstanceType(t1)); + for (t1 = J.get$iterator$ax(newDenominators); t1.moveNext$0();) + A.removeFirstWhere0(oldDenominators, new A.SassNumber__coerceOrConvertValue_closure5(_box_0, t1.get$current(t1)), new A.SassNumber__coerceOrConvertValue_closure6(compatibilityException)); + if (oldNumerators.length !== 0 || oldDenominators.length !== 0) + throw A.wrapException(compatibilityException.call$0()); + return _box_0.value; + }, + _number1$_coerceOrConvertValue$4$coerceUnitless$name(newNumerators, newDenominators, coerceUnitless, $name) { + return this._number1$_coerceOrConvertValue$6$coerceUnitless$name$other$otherName(newNumerators, newDenominators, coerceUnitless, $name, null, null); + }, + isComparableTo$1(other) { + var exception; + if (!this.get$hasUnits() || !other.get$hasUnits()) + return true; + try { + this.greaterThan$1(other); + return true; + } catch (exception) { + if (A.unwrapException(exception) instanceof A.SassScriptException0) + return false; + else + throw exception; + } + }, + greaterThan$1(other) { + if (other instanceof A.SassNumber0) + return this._number1$_coerceUnits$2(other, A.number2__fuzzyGreaterThan$closure()) ? B.SassBoolean_true0 : B.SassBoolean_false0; + throw A.wrapException(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " > " + other.toString$0(0) + '".', null)); + }, + greaterThanOrEquals$1(other) { + if (other instanceof A.SassNumber0) + return this._number1$_coerceUnits$2(other, A.number2__fuzzyGreaterThanOrEquals$closure()) ? B.SassBoolean_true0 : B.SassBoolean_false0; + throw A.wrapException(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " >= " + other.toString$0(0) + '".', null)); + }, + lessThan$1(other) { + if (other instanceof A.SassNumber0) + return this._number1$_coerceUnits$2(other, A.number2__fuzzyLessThan$closure()) ? B.SassBoolean_true0 : B.SassBoolean_false0; + throw A.wrapException(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " < " + other.toString$0(0) + '".', null)); + }, + lessThanOrEquals$1(other) { + if (other instanceof A.SassNumber0) + return this._number1$_coerceUnits$2(other, A.number2__fuzzyLessThanOrEquals$closure()) ? B.SassBoolean_true0 : B.SassBoolean_false0; + throw A.wrapException(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " <= " + other.toString$0(0) + '".', null)); + }, + modulo$1(other) { + if (other instanceof A.SassNumber0) + return this.withValue$1(this._number1$_coerceUnits$2(other, A.number2__moduloLikeSass$closure())); + throw A.wrapException(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " % " + other.toString$0(0) + '".', null)); + }, + plus$1(other) { + var _this = this; + if (other instanceof A.SassNumber0) + return _this.withValue$1(_this._number1$_coerceUnits$2(other, new A.SassNumber_plus_closure0())); + if (!(other instanceof A.SassColor0)) + return _this.super$Value$plus0(other); + throw A.wrapException(A.SassScriptException$0('Undefined operation "' + _this.toString$0(0) + " + " + other.toString$0(0) + '".', null)); + }, + minus$1(other) { + var _this = this; + if (other instanceof A.SassNumber0) + return _this.withValue$1(_this._number1$_coerceUnits$2(other, new A.SassNumber_minus_closure0())); + if (!(other instanceof A.SassColor0)) + return _this.super$Value$minus0(other); + throw A.wrapException(A.SassScriptException$0('Undefined operation "' + _this.toString$0(0) + " - " + other.toString$0(0) + '".', null)); + }, + times$1(other) { + var _this = this; + if (other instanceof A.SassNumber0) { + if (!other.get$hasUnits()) + return _this.withValue$1(_this._number1$_value * other._number1$_value); + return _this.multiplyUnits$3(_this._number1$_value * other._number1$_value, other.get$numeratorUnits(other), other.get$denominatorUnits(other)); + } + throw A.wrapException(A.SassScriptException$0('Undefined operation "' + _this.toString$0(0) + " * " + other.toString$0(0) + '".', null)); + }, + dividedBy$1(other) { + var _this = this; + if (other instanceof A.SassNumber0) { + if (!other.get$hasUnits()) + return _this.withValue$1(_this._number1$_value / other._number1$_value); + return _this.multiplyUnits$3(_this._number1$_value / other._number1$_value, other.get$denominatorUnits(other), other.get$numeratorUnits(other)); + } + return _this.super$Value$dividedBy0(other); + }, + unaryPlus$0() { + return this; + }, + _number1$_coerceUnits$1$2(other, operation) { + var t1, exception; + try { + t1 = operation.call$2(this._number1$_value, other.coerceValueToMatch$1(this)); + return t1; + } catch (exception) { + if (A.unwrapException(exception) instanceof A.SassScriptException0) { + this.coerceValueToMatch$1(other); + throw exception; + } else + throw exception; + } + }, + _number1$_coerceUnits$2(other, operation) { + return this._number1$_coerceUnits$1$2(other, operation, type$.dynamic); + }, + multiplyUnits$3(value, otherNumerators, otherDenominators) { + var t1, _0_1, _0_6, _0_3, _0_9, _0_9_isSet, _0_7, _0_7_isSet, t2, _0_2, denominators_case_0, _0_11_isSet, _0_11, _0_13, _0_13_isSet, _0_10, numerators_case_0, t4, t3, t5, t6, t7, numerators_case_1, denominators_case_1, t0, newNumerators, mutableOtherDenominators, _i, numerator, mutableDenominatorUnits, _this = this, _null = null, _box_0 = {}; + _box_0.value = value; + t1 = [_this.get$numeratorUnits(_this), _this.get$denominatorUnits(_this), otherNumerators, otherDenominators]; + _0_1 = t1[0]; + _0_6 = _null; + _0_3 = _null; + _0_9 = _null; + _0_9_isSet = false; + _0_7 = _null; + _0_7_isSet = false; + t2 = false; + _0_2 = t1[1]; + _0_3 = t1[2]; + _0_6 = _0_3.length <= 0; + _0_7_isSet = _0_6; + if (_0_7_isSet) { + _0_7 = t1[3]; + _0_9 = _0_7.length <= 0; + t2 = _0_9; + } + _0_9_isSet = _0_7_isSet; + denominators_case_0 = _0_2; + _0_11_isSet = !t2; + _0_11 = _null; + _0_13 = _null; + if (_0_11_isSet) { + _0_11 = _0_1.length <= 0; + _0_13_isSet = _0_11; + _0_10 = _0_1; + if (_0_13_isSet) { + _0_13 = _0_2.length <= 0; + t2 = _0_13; + if (t2) { + if (_0_7_isSet) + denominators_case_0 = _0_7; + else { + _0_7 = t1[3]; + denominators_case_0 = _0_7; + _0_7_isSet = true; + } + numerators_case_0 = _0_3; + } else + numerators_case_0 = _0_1; + } else { + numerators_case_0 = _0_1; + t2 = false; + } + _0_1 = _0_10; + } else { + numerators_case_0 = _0_1; + _0_13_isSet = false; + t2 = true; + } + if (t2) { + t4 = denominators_case_0; + t3 = numerators_case_0; + } else { + t4 = _null; + t3 = t4; + } + if (!t2) { + t2 = _null; + t5 = _null; + if (_0_11_isSet) + t6 = _0_11; + else { + _0_11 = _0_1.length <= 0; + t6 = _0_11; + } + t7 = false; + if (t6) { + if (_0_9_isSet) + t2 = _0_9; + else { + if (_0_7_isSet) + t2 = _0_7; + else { + _0_7 = t1[3]; + t2 = _0_7; + _0_7_isSet = true; + } + _0_9 = t2.length <= 0; + t2 = _0_9; + } + numerators_case_1 = _0_3; + denominators_case_1 = _0_2; + } else { + numerators_case_1 = t2; + t2 = t7; + denominators_case_1 = t5; + } + if (!t2) { + t2 = false; + if (_0_13_isSet) + t5 = _0_13; + else { + _0_13 = _0_2.length <= 0; + t5 = _0_13; + } + if (t5) { + if (_0_6) + denominators_case_1 = _0_7_isSet ? _0_7 : t1[3]; + t1 = _0_6; + } else + t1 = t2; + numerators_case_1 = _0_1; + } else + t1 = true; + if (t1) { + t1 = !_this._number1$_areAnyConvertible$2(numerators_case_1, denominators_case_1); + if (t1) { + t3 = denominators_case_1; + t2 = numerators_case_1; + } else { + t2 = t3; + t3 = t4; + } + t0 = t3; + t3 = t1; + t1 = t2; + t2 = t0; + } else { + t2 = t4; + t1 = t3; + t3 = false; + } + } else { + t2 = t4; + t1 = t3; + t3 = true; + } + if (t3) + return A.SassNumber_SassNumber$withUnits0(value, t2, t1); + newNumerators = A._setArrayType([], type$.JSArray_String); + mutableOtherDenominators = A._setArrayType(otherDenominators.slice(0), A._arrayInstanceType(otherDenominators)); + for (t1 = _this.get$numeratorUnits(_this), t2 = t1.length, _i = 0; _i < t2; ++_i) { + numerator = t1[_i]; + A.removeFirstWhere0(mutableOtherDenominators, new A.SassNumber_multiplyUnits_closure3(_box_0, numerator), new A.SassNumber_multiplyUnits_closure4(newNumerators, numerator)); + } + t1 = _this.get$denominatorUnits(_this); + mutableDenominatorUnits = A._setArrayType(t1.slice(0), A._arrayInstanceType(t1)); + for (t1 = otherNumerators.length, _i = 0; _i < t1; ++_i) { + numerator = otherNumerators[_i]; + A.removeFirstWhere0(mutableDenominatorUnits, new A.SassNumber_multiplyUnits_closure5(_box_0, numerator), new A.SassNumber_multiplyUnits_closure6(newNumerators, numerator)); + } + t1 = _box_0.value; + B.JSArray_methods.addAll$1(mutableDenominatorUnits, mutableOtherDenominators); + return A.SassNumber_SassNumber$withUnits0(t1, mutableDenominatorUnits, newNumerators); + }, + _number1$_areAnyConvertible$2(units1, units2) { + return B.JSArray_methods.any$1(units1, new A.SassNumber__areAnyConvertible_closure0(units2)); + }, + _number1$_unitString$2(numerators, denominators) { + var _0_4, _0_7, _0_6, _0_5, t1, _0_9, _0_6_isSet, _0_5_isSet, _0_10, denominator, _null = null; + $label0$0: { + _0_4 = J.get$length$asx(numerators) <= 0; + _0_7 = _null; + _0_6 = _null; + _0_5 = _null; + if (_0_4) { + _0_6 = J.get$length$asx(denominators); + t1 = _0_6; + _0_7 = t1 <= 0; + t1 = _0_7; + _0_5 = denominators; + } else + t1 = false; + if (t1) { + t1 = "no units"; + break $label0$0; + } + _0_9 = _null; + if (_0_4) { + _0_9 = _0_6 === 1; + t1 = _0_9; + _0_6_isSet = true; + _0_5_isSet = true; + } else { + _0_5_isSet = _0_4; + _0_6_isSet = _0_5_isSet; + t1 = false; + } + if (t1) { + _0_10 = J.$index$asx(_0_5_isSet ? _0_5 : denominators, 0); + denominator = _0_10; + t1 = denominator + "^-1"; + break $label0$0; + } + if (_0_4) { + t1 = "(" + J.join$1$ax(denominators, "*") + ")^-1"; + break $label0$0; + } + if (_0_6_isSet) + t1 = _0_6; + else { + if (_0_5_isSet) + t1 = _0_5; + else { + t1 = denominators; + _0_5 = t1; + _0_5_isSet = true; + } + _0_6 = J.get$length$asx(t1); + t1 = _0_6; + _0_6_isSet = true; + } + _0_7 = t1 <= 0; + t1 = _0_7; + if (t1) { + t1 = J.join$1$ax(numerators, "*"); + break $label0$0; + } + if (_0_6_isSet) + t1 = _0_6; + else { + if (_0_5_isSet) + t1 = _0_5; + else { + t1 = denominators; + _0_5 = t1; + _0_5_isSet = true; + } + _0_6 = J.get$length$asx(t1); + t1 = _0_6; + } + _0_9 = t1 === 1; + t1 = _0_9; + if (t1) { + _0_10 = J.$index$asx(_0_5_isSet ? _0_5 : denominators, 0); + denominator = _0_10; + t1 = J.join$1$ax(numerators, "*") + "/" + denominator; + break $label0$0; + } + t1 = J.join$1$ax(numerators, "*") + "/(" + J.join$1$ax(denominators, "*") + ")"; + break $label0$0; + } + return t1; + }, + $eq(_, other) { + var _this = this; + if (other == null) + return false; + if (!(other instanceof A.SassNumber0)) + return false; + if (_this.get$numeratorUnits(_this).length !== other.get$numeratorUnits(other).length || _this.get$denominatorUnits(_this).length !== other.get$denominatorUnits(other).length) + return false; + if (!_this.get$hasUnits()) + return A.fuzzyEquals0(_this._number1$_value, other._number1$_value); + if (!B.C_ListEquality.equals$2(0, _this._number1$_canonicalizeUnitList$1(_this.get$numeratorUnits(_this)), _this._number1$_canonicalizeUnitList$1(other.get$numeratorUnits(other))) || !B.C_ListEquality.equals$2(0, _this._number1$_canonicalizeUnitList$1(_this.get$denominatorUnits(_this)), _this._number1$_canonicalizeUnitList$1(other.get$denominatorUnits(other)))) + return false; + return A.fuzzyEquals0(_this._number1$_value * _this._number1$_canonicalMultiplier$1(_this.get$numeratorUnits(_this)) / _this._number1$_canonicalMultiplier$1(_this.get$denominatorUnits(_this)), other._number1$_value * _this._number1$_canonicalMultiplier$1(other.get$numeratorUnits(other)) / _this._number1$_canonicalMultiplier$1(other.get$denominatorUnits(other))); + }, + get$hashCode(_) { + var _this = this, + t1 = _this.hashCache; + return t1 == null ? _this.hashCache = A.fuzzyHashCode0(_this._number1$_value * _this._number1$_canonicalMultiplier$1(_this.get$numeratorUnits(_this)) / _this._number1$_canonicalMultiplier$1(_this.get$denominatorUnits(_this))) : t1; + }, + _number1$_canonicalizeUnitList$1(units) { + var type, + t1 = units.length; + if (t1 === 0) + return units; + if (t1 === 1) { + type = $.$get$_typesByUnit0().$index(0, B.JSArray_methods.get$first(units)); + if (type == null) + t1 = units; + else { + t1 = B.Map_Sr65K.$index(0, type); + t1.toString; + t1 = A._setArrayType([B.JSArray_methods.get$first(t1)], type$.JSArray_String); + } + return t1; + } + t1 = A._arrayInstanceType(units)._eval$1("MappedListIterable<1,String>"); + t1 = A.List_List$of(new A.MappedListIterable(units, new A.SassNumber__canonicalizeUnitList_closure0(), t1), true, t1._eval$1("ListIterable.E")); + B.JSArray_methods.sort$0(t1); + return t1; + }, + _number1$_canonicalMultiplier$1(units) { + return B.JSArray_methods.fold$2(units, 1, new A.SassNumber__canonicalMultiplier_closure0(this)); + }, + canonicalMultiplierForUnit$1(unit) { + var t1, + innerMap = B.Map_NtHoP.$index(0, unit); + if (innerMap == null) + t1 = 1; + else { + t1 = innerMap.get$values(innerMap); + t1 = 1 / t1.get$first(t1); + } + return t1; + }, + unitSuggestion$2($name, unit) { + var t2, t3, result, _this = this, + t1 = _this.get$denominatorUnits(_this); + t1 = new A.MappedListIterable(t1, new A.SassNumber_unitSuggestion_closure1(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,String>")).join$0(0); + t2 = _this.get$numeratorUnits(_this); + t2 = new A.MappedListIterable(t2, new A.SassNumber_unitSuggestion_closure2(), A._arrayInstanceType(t2)._eval$1("MappedListIterable<1,String>")).join$0(0); + t3 = unit == null ? "" : " * 1" + unit; + result = "$" + $name + t1 + t2 + t3; + return _this.get$numeratorUnits(_this).length === 0 ? result : "calc(" + result + ")"; + }, + unitSuggestion$1($name) { + return this.unitSuggestion$2($name, null); + } + }; + A.SassNumber__coerceOrConvertValue_compatibilityException0.prototype = { + call$0() { + var t2, t3, message, t4, type, unit, _this = this, + t1 = _this.other; + if (t1 != null) { + t2 = _this.$this; + t3 = t2.toString$0(0) + " and"; + message = new A.StringBuffer(t3); + t4 = _this.otherName; + if (t4 != null) + t3 = message._contents = t3 + (" $" + t4 + ":"); + t1 = t3 + (" " + t1.toString$0(0) + " have incompatible units"); + message._contents = t1; + if (!t2.get$hasUnits() || !_this.otherHasUnits) + message._contents = t1 + " (one has units and the other doesn't)"; + t1 = message.toString$0(0) + "."; + t2 = _this.name; + return new A.SassScriptException0(t2 == null ? t1 : "$" + t2 + ": " + t1); + } else if (!_this.otherHasUnits) { + t1 = "Expected " + _this.$this.toString$0(0) + " to have no units."; + t2 = _this.name; + return new A.SassScriptException0(t2 == null ? t1 : "$" + t2 + ": " + t1); + } else { + t1 = _this.newNumerators; + t2 = J.getInterceptor$asx(t1); + if (t2.get$length(t1) === 1 && J.get$isEmpty$asx(_this.newDenominators)) { + type = $.$get$_typesByUnit0().$index(0, t2.get$first(t1)); + if (type != null) { + t1 = _this.$this.toString$0(0); + t2 = B.JSArray_methods.contains$1(A._setArrayType([97, 101, 105, 111, 117], type$.JSArray_int), type.charCodeAt(0)) ? "an " + type : "a " + type; + t3 = B.Map_Sr65K.$index(0, type); + t3.toString; + t3 = "Expected " + t1 + " to have " + t2 + " unit (" + B.JSArray_methods.join$1(t3, ", ") + ")."; + t2 = _this.name; + return new A.SassScriptException0(t2 == null ? t3 : "$" + t2 + ": " + t3); + } + } + t3 = _this.newDenominators; + unit = A.pluralize0("unit", t2.get$length(t1) + J.get$length$asx(t3), null); + t2 = _this.$this; + t3 = "Expected " + t2.toString$0(0) + " to have " + unit + " " + t2._number1$_unitString$2(t1, t3) + "."; + t1 = _this.name; + return new A.SassScriptException0(t1 == null ? t3 : "$" + t1 + ": " + t3); + } + }, + $signature: 548 + }; + A.SassNumber__coerceOrConvertValue_closure3.prototype = { + call$1(oldNumerator) { + var factor = A.conversionFactor0(this.newNumerator, oldNumerator); + if (factor == null) + return false; + this._box_0.value *= factor; + return true; + }, + $signature: 5 + }; + A.SassNumber__coerceOrConvertValue_closure4.prototype = { + call$0() { + return A.throwExpression(this.compatibilityException.call$0()); + }, + $signature: 0 + }; + A.SassNumber__coerceOrConvertValue_closure5.prototype = { + call$1(oldDenominator) { + var factor = A.conversionFactor0(this.newDenominator, oldDenominator); + if (factor == null) + return false; + this._box_0.value /= factor; + return true; + }, + $signature: 5 + }; + A.SassNumber__coerceOrConvertValue_closure6.prototype = { + call$0() { + return A.throwExpression(this.compatibilityException.call$0()); + }, + $signature: 0 + }; + A.SassNumber_plus_closure0.prototype = { + call$2(num1, num2) { + return num1 + num2; + }, + $signature: 61 + }; + A.SassNumber_minus_closure0.prototype = { + call$2(num1, num2) { + return num1 - num2; + }, + $signature: 61 + }; + A.SassNumber_multiplyUnits_closure3.prototype = { + call$1(denominator) { + var factor = A.conversionFactor0(this.numerator, denominator); + if (factor == null) + return false; + this._box_0.value /= factor; + return true; + }, + $signature: 5 + }; + A.SassNumber_multiplyUnits_closure4.prototype = { + call$0() { + return this.newNumerators.push(this.numerator); + }, + $signature: 0 + }; + A.SassNumber_multiplyUnits_closure5.prototype = { + call$1(denominator) { + var factor = A.conversionFactor0(this.numerator, denominator); + if (factor == null) + return false; + this._box_0.value /= factor; + return true; + }, + $signature: 5 + }; + A.SassNumber_multiplyUnits_closure6.prototype = { + call$0() { + return this.newNumerators.push(this.numerator); + }, + $signature: 0 + }; + A.SassNumber__areAnyConvertible_closure0.prototype = { + call$1(unit1) { + var t1, + _0_0 = B.Map_NtHoP.$index(0, unit1); + $label0$0: { + if (_0_0 != null) { + t1 = B.JSArray_methods.any$1(this.units2, _0_0.get$containsKey()); + break $label0$0; + } + t1 = B.JSArray_methods.contains$1(this.units2, unit1); + break $label0$0; + } + return t1; + }, + $signature: 5 + }; + A.SassNumber__canonicalizeUnitList_closure0.prototype = { + call$1(unit) { + var t1, + type = $.$get$_typesByUnit0().$index(0, unit); + if (type == null) + t1 = unit; + else { + t1 = B.Map_Sr65K.$index(0, type); + t1.toString; + t1 = B.JSArray_methods.get$first(t1); + } + return t1; + }, + $signature: 6 + }; + A.SassNumber__canonicalMultiplier_closure0.prototype = { + call$2(multiplier, unit) { + return multiplier * this.$this.canonicalMultiplierForUnit$1(unit); + }, + $signature: 165 + }; + A.SassNumber_unitSuggestion_closure1.prototype = { + call$1(unit) { + return " * 1" + unit; + }, + $signature: 6 + }; + A.SassNumber_unitSuggestion_closure2.prototype = { + call$1(unit) { + return " / 1" + unit; + }, + $signature: 6 + }; + A.OklabColorSpace0.prototype = { + get$isBoundedInternal() { + return false; + }, + convert$7$missingChroma$missingHue(dest, lightness, a, b, alpha, missingChroma, missingHue) { + var missingLightness, missingA, missingB, t1; + if (dest === B.OklchColorSpace_9Gj0) + return A.labToLch0(dest, lightness, a, b, alpha, missingChroma, missingHue); + missingLightness = lightness == null; + missingA = a == null; + missingB = b == null; + if (missingLightness) + lightness = 0; + if (missingA) + a = 0; + if (missingB) + b = 0; + t1 = $.$get$oklabToLms0(); + return B.LmsColorSpace_Os30.convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, Math.pow(t1[0] * lightness + t1[1] * a + t1[2] * b, 3) + 0, Math.pow(t1[3] * lightness + t1[4] * a + t1[5] * b, 3) + 0, Math.pow(t1[6] * lightness + t1[7] * a + t1[8] * b, 3) + 0, alpha, missingA, missingB, missingChroma, missingHue, missingLightness); + }, + convert$5(dest, lightness, a, b, alpha) { + return this.convert$7$missingChroma$missingHue(dest, lightness, a, b, alpha, false, false); + } + }; + A.OklchColorSpace0.prototype = { + get$isBoundedInternal() { + return false; + }, + get$isPolarInternal() { + return true; + }, + convert$5(dest, lightness, chroma, hue, alpha) { + var t1 = hue == null, + hueRadians = (t1 ? 0 : hue) * 3.141592653589793 / 180, + t2 = chroma == null, + t3 = t2 ? 0 : chroma, + t4 = Math.cos(hueRadians), + t5 = t2 ? 0 : chroma; + return B.OklabColorSpace_5400.convert$7$missingChroma$missingHue(dest, lightness, t3 * t4, t5 * Math.sin(hueRadians), alpha, t2, t1); + } + }; + A.SupportsOperation0.prototype = { + toInterpolation$0() { + var t1 = new A.StringBuffer(""), + t2 = new A.InterpolationBuffer0(t1, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)), + t3 = this.span, + t4 = this.left, + t5 = A.SpanExtensions_before(t3, t4.get$span(t4)); + t5 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t5.file._decodedChars, t5._file$_start, t5._end), 0, null); + t1._contents += t5; + t2.addInterpolation$1(t4.toInterpolation$0()); + t5 = this.right; + t4 = A.SpanExtensions_between(t4.get$span(t4), t5.get$span(t5)); + t4 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t4.file._decodedChars, t4._file$_start, t4._end), 0, null); + t1._contents += t4; + t2.addInterpolation$1(t5.toInterpolation$0()); + t5 = A.SpanExtensions_after(t3, t5.get$span(t5)); + t5 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t5.file._decodedChars, t5._file$_start, t5._end), 0, null); + t1._contents += t5; + return t2.interpolation$1(t3); + }, + withSpan$1(span) { + return A.SupportsOperation$0(this.left, this.right, this.operator, span); + }, + toString$0(_) { + var _this = this; + return _this._operation$_parenthesize$1(_this.left) + " " + _this.operator + " " + _this._operation$_parenthesize$1(_this.right); + }, + _operation$_parenthesize$1(condition) { + var t1; + if (!(condition instanceof A.SupportsNegation0)) + t1 = condition instanceof A.SupportsOperation0 && condition.operator === this.operator; + else + t1 = true; + return t1 ? "(" + condition.toString$0(0) + ")" : condition.toString$0(0); + }, + $isAstNode0: 1, + $isSassNode: 1, + $isSupportsCondition: 1, + get$span(receiver) { + return this.span; + } + }; + A.Parameter0.prototype = { + toString$0(_) { + var t1 = this.defaultValue, + t2 = this.name; + return t1 == null ? t2 : t2 + ": " + t1.toString$0(0); + }, + $isAstNode0: 1, + $isSassNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.ParameterList0.prototype = { + get$spanWithName() { + var t3, t4, + t1 = this.span, + t2 = t1.file, + text = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t2._decodedChars, 0, null), 0, null), + i = A.FileLocation$_(t2, t1._file$_start).offset - 1; + while (true) { + if (i > 0) { + t3 = text.charCodeAt(i); + t3 = t3 === 32 || t3 === 9 || t3 === 10 || t3 === 13 || t3 === 12; + } else + t3 = false; + if (!t3) + break; + --i; + } + t3 = text.charCodeAt(i); + if (!(t3 === 95 || A.CharacterExtension_get_isAlphabetic0(t3) || t3 >= 128)) + t3 = t3 >= 48 && t3 <= 57 || t3 === 45; + else + t3 = true; + if (!t3) + return t1; + --i; + while (true) { + if (i >= 0) { + t3 = text.charCodeAt(i); + if (t3 !== 95) { + if (!(t3 >= 97 && t3 <= 122)) + t4 = t3 >= 65 && t3 <= 90; + else + t4 = true; + t4 = t4 || t3 >= 128; + } else + t4 = true; + if (!t4) + t3 = t3 >= 48 && t3 <= 57 || t3 === 45; + else + t3 = true; + } else + t3 = false; + if (!t3) + break; + --i; + } + t3 = i + 1; + t4 = text.charCodeAt(t3); + if (!(t4 === 95 || A.CharacterExtension_get_isAlphabetic0(t4) || t4 >= 128)) + return t1; + return A.SpanExtensions_trimRight0(A.SpanExtensions_trimLeft0(t2.span$2(0, t3, A.FileLocation$_(t2, t1._end).offset))); + }, + verify$2(positional, names) { + var t1, t2, t3, namedUsed, i, parameter, t4, unknownNames, _this = this, + _s10_ = "invocation"; + for (t1 = _this.parameters, t2 = t1.length, t3 = names._baseMap, namedUsed = 0, i = 0; i < t2; ++i) { + parameter = t1[i]; + if (i < positional) { + t4 = parameter.name; + if (t3.containsKey$1(t4)) + throw A.wrapException(A.SassScriptException$0("Argument " + _this._parameter_list$_originalParameterName$1(t4) + string$.x20was_p, null)); + } else { + t4 = parameter.name; + if (t3.containsKey$1(t4)) + ++namedUsed; + else if (parameter.defaultValue == null) + throw A.wrapException(A.MultiSpanSassScriptException$0("Missing argument " + _this._parameter_list$_originalParameterName$1(t4) + ".", _s10_, A.LinkedHashMap_LinkedHashMap$_literal([_this.get$spanWithName(), "declaration"], type$.FileSpan, type$.String))); + } + } + if (_this.restParameter != null) + return; + if (positional > t2) { + t1 = names.get$isEmpty(0) ? "" : "positional "; + throw A.wrapException(A.MultiSpanSassScriptException$0("Only " + t2 + " " + t1 + A.pluralize0("argument", t2, null) + " allowed, but " + positional + " " + A.pluralize0("was", positional, "were") + " passed.", _s10_, A.LinkedHashMap_LinkedHashMap$_literal([_this.get$spanWithName(), "declaration"], type$.FileSpan, type$.String))); + } + if (namedUsed < t3.get$length(t3)) { + t2 = type$.String; + unknownNames = A.LinkedHashSet_LinkedHashSet$of(names, t2); + unknownNames.removeAll$1(new A.MappedListIterable(t1, new A.ParameterList_verify_closure1(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Object?>"))); + throw A.wrapException(A.MultiSpanSassScriptException$0("No " + A.pluralize0("parameter", unknownNames._collection$_length, null) + " named " + A.toSentence0(unknownNames.map$1$1(0, new A.ParameterList_verify_closure2(), type$.Object), "or") + ".", _s10_, A.LinkedHashMap_LinkedHashMap$_literal([_this.get$spanWithName(), "declaration"], type$.FileSpan, t2))); + } + }, + _parameter_list$_originalParameterName$1($name) { + var t1, text, t2, _i, parameter, t3, end; + if ($name === this.restParameter) { + t1 = this.span; + text = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1.file._decodedChars, t1._file$_start, t1._end), 0, null); + return B.JSString_methods.substring$2(B.JSString_methods.substring$1(text, B.JSString_methods.lastIndexOf$1(text, "$")), 0, B.JSString_methods.indexOf$1(text, ".")); + } + for (t1 = this.parameters, t2 = t1.length, _i = 0; _i < t2; ++_i) { + parameter = t1[_i]; + if (parameter.name === $name) { + t1 = parameter.span; + if (parameter.defaultValue == null) { + t2 = t1._file$_start; + t3 = t1.file._decodedChars; + t3 = A.String_String$fromCharCodes(new Uint32Array(t3.subarray(t2, A._checkValidRange(t2, t1._end, t3.length))), 0, null); + t1 = t3; + } else { + text = t1.get$text(); + t1 = B.JSString_methods.substring$2(text, 0, B.JSString_methods.indexOf$1(text, ":")); + end = A._lastNonWhitespace0(t1, false); + t1 = end == null ? "" : B.JSString_methods.substring$2(t1, 0, end + 1); + } + return t1; + } + } + throw A.wrapException(A.ArgumentError$(string$.This_d + $name + '".', null)); + }, + matches$2(positional, names) { + var t1, t2, t3, namedUsed, i, parameter; + for (t1 = this.parameters, t2 = t1.length, t3 = names._baseMap, namedUsed = 0, i = 0; i < t2; ++i) { + parameter = t1[i]; + if (i < positional) { + if (t3.containsKey$1(parameter.name)) + return false; + } else if (t3.containsKey$1(parameter.name)) + ++namedUsed; + else if (parameter.defaultValue == null) + return false; + } + if (this.restParameter != null) + return true; + if (positional > t2) + return false; + if (namedUsed < t3.get$length(t3)) + return false; + return true; + }, + toString$0(_) { + var t2, t3, _i, + t1 = A._setArrayType([], type$.JSArray_String); + for (t2 = this.parameters, t3 = t2.length, _i = 0; _i < t3; ++_i) + t1.push("$" + t2[_i].toString$0(0)); + t2 = this.restParameter; + if (t2 != null) + t1.push("$" + t2 + "..."); + return B.JSArray_methods.join$1(t1, ", "); + }, + $isAstNode0: 1, + $isSassNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.ParameterList_verify_closure1.prototype = { + call$1(parameter) { + return parameter.name; + }, + $signature: 549 + }; + A.ParameterList_verify_closure2.prototype = { + call$1($name) { + return "$" + $name; + }, + $signature: 6 + }; + A.ParentSelector0.prototype = { + accept$1$1(visitor) { + return visitor.visitParentSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + unify$1(compound) { + return A.throwExpression(A.UnsupportedError$("& doesn't support unification.")); + } + }; + A.ParentStatement0.prototype = {}; + A.ParentStatement_closure0.prototype = { + call$1(child) { + var t1; + $label0$0: { + if (child instanceof A.VariableDeclaration0 || child instanceof A.FunctionRule0 || child instanceof A.MixinRule0) { + t1 = true; + break $label0$0; + } + if (child instanceof A.ImportRule0) { + t1 = B.JSArray_methods.any$1(child.imports, new A.ParentStatement__closure0()); + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + $signature: 246 + }; + A.ParentStatement__closure0.prototype = { + call$1($import) { + return $import instanceof A.DynamicImport0; + }, + $signature: 247 + }; + A.ParenthesizedExpression0.prototype = { + accept$1$1(visitor) { + return visitor.visitParenthesizedExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "(" + this.expression.toString$0(0) + ")"; + }, + get$span(receiver) { + return this.span; + } + }; + A.ParserExports.prototype = {}; + A.loadParserExports_closure.prototype = { + call$1(inner) { + return new A.JSExpressionVisitor(inner); + }, + $signature: 550 + }; + A.loadParserExports_closure0.prototype = { + call$1(inner) { + return new A.JSStatementVisitor(inner); + }, + $signature: 551 + }; + A.loadParserExports_closure1.prototype = { + call$1(set) { + return new self.Set(A.List_List$of(set, true, type$.nullable_Object)); + }, + $signature: 552 + }; + A._updateAstPrototypes_closure.prototype = { + call$3($self, start, end) { + return A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2($self._decodedChars, start, end), 0, null); + }, + call$2($self, start) { + return this.call$3($self, start, null); + }, + "call*": "call$3", + $requiredArgCount: 2, + $defaultValues() { + return [null]; + }, + $signature: 553 + }; + A._updateAstPrototypes_closure0.prototype = { + call$1($self) { + return $self._decodedChars; + }, + $signature: 554 + }; + A._updateAstPrototypes_closure1.prototype = { + call$1($self) { + return $self.get$asPlain(); + }, + $signature: 555 + }; + A._updateAstPrototypes_closure2.prototype = { + call$2($self, visitor) { + return $self.accept$1(visitor); + }, + $signature: 556 + }; + A._updateAstPrototypes_closure3.prototype = { + call$2($self, visitor) { + return $self.accept$1(visitor); + }, + $signature: 557 + }; + A._updateAstPrototypes_closure4.prototype = { + call$1($self) { + return $self.$arguments; + }, + $signature: 558 + }; + A._updateAstPrototypes_closure5.prototype = { + call$1($self) { + return $self.$arguments; + }, + $signature: 559 + }; + A._updateAstPrototypes_closure6.prototype = { + call$1($self) { + return $self.$arguments; + }, + $signature: 560 + }; + A._updateAstPrototypes_closure7.prototype = { + call$1($self) { + return $self.$arguments; + }, + $signature: 561 + }; + A._updateAstPrototypes_closure8.prototype = { + call$1($self) { + return $self.$arguments; + }, + $signature: 562 + }; + A._updateAstPrototypes_closure9.prototype = { + call$1($self) { + return $self.get$span($self); + }, + $signature: 563 + }; + A._addSupportsConditionToInterpolation_closure.prototype = { + call$1($self) { + return $self.toInterpolation$0(); + }, + $signature: 564 + }; + A.Parser1.prototype = { + _parser1$_parseIdentifier$0() { + return this.wrapSpanFormatException$1(new A.Parser__parseIdentifier_closure0(this)); + }, + whitespace$1$consumeNewlines(consumeNewlines) { + do + this.whitespaceWithoutComments$1$consumeNewlines(consumeNewlines); + while (this.scanComment$0()); + }, + whitespaceWithoutComments$1$consumeNewlines(consumeNewlines) { + var t3, + t1 = this.scanner, + t2 = t1.string.length; + while (true) { + if (t1._string_scanner$_position !== t2) { + t3 = t1.peekChar$0(); + t3 = t3 === 32 || t3 === 9 || t3 === 10 || t3 === 13 || t3 === 12; + } else + t3 = false; + if (!t3) + break; + t1.readChar$0(); + } + }, + spaces$0() { + var t3, + t1 = this.scanner, + t2 = t1.string.length; + while (true) { + if (t1._string_scanner$_position !== t2) { + t3 = t1.peekChar$0(); + t3 = t3 === 32 || t3 === 9; + } else + t3 = false; + if (!t3) + break; + t1.readChar$0(); + } + }, + scanComment$0() { + var _0_0, + t1 = this.scanner; + if (t1.peekChar$0() !== 47) + return false; + _0_0 = t1.peekChar$1(1); + if (47 === _0_0) + return this.silentComment$0(); + if (42 === _0_0) { + this.loudComment$0(); + return true; + } + return false; + }, + expectWhitespace$1$consumeNewlines(consumeNewlines) { + var t2, t3, + t1 = this.scanner; + if (t1._string_scanner$_position !== t1.string.length) { + t2 = t1.peekChar$0(); + t3 = !(t2 === 32 || t2 === 9 || t2 === 10 || t2 === 13 || t2 === 12 || this.scanComment$0()); + t2 = t3; + } else + t2 = true; + if (t2) + t1.error$1(0, "Expected whitespace."); + this.whitespace$1$consumeNewlines(consumeNewlines); + }, + expectWhitespace$0() { + return this.expectWhitespace$1$consumeNewlines(false); + }, + silentComment$0() { + var t2, t3, + t1 = this.scanner; + t1.expect$1("//"); + t2 = t1.string.length; + while (true) { + if (t1._string_scanner$_position !== t2) { + t3 = t1.peekChar$0(); + t3 = !(t3 === 10 || t3 === 13 || t3 === 12); + } else + t3 = false; + if (!t3) + break; + t1.readChar$0(); + } + return true; + }, + loudComment$0() { + var next, + t1 = this.scanner; + t1.expect$1("/*"); + for (; true;) { + if (t1.readChar$0() !== 42) + continue; + do + next = t1.readChar$0(); + while (next === 42); + if (next === 47) + break; + } + }, + identifier$2$normalize$unit(normalize, unit) { + var t2, _0_0, _this = this, + _s20_ = "Expected identifier.", + text = new A.StringBuffer(""), + t1 = _this.scanner; + if (t1.scanChar$1(45)) { + t2 = text._contents = "" + A.Primitives_stringFromCharCode(45); + if (t1.scanChar$1(45)) { + text._contents = t2 + A.Primitives_stringFromCharCode(45); + _this._parser1$_identifierBody$3$normalize$unit(text, normalize, unit); + t1 = text._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + } else + t2 = ""; + $label0$0: { + _0_0 = t1.peekChar$0(); + if (_0_0 == null) + t1.error$1(0, _s20_); + if (95 === _0_0 && normalize) { + t1.readChar$0(); + text._contents = t2 + A.Primitives_stringFromCharCode(45); + break $label0$0; + } + if (_0_0 === 95 || A.CharacterExtension_get_isAlphabetic0(_0_0) || _0_0 >= 128) { + text._contents = t2 + A.Primitives_stringFromCharCode(t1.readChar$0()); + break $label0$0; + } + if (92 === _0_0) { + text._contents = t2 + _this.escape$1$identifierStart(true); + break $label0$0; + } + t1.error$1(0, _s20_); + } + _this._parser1$_identifierBody$3$normalize$unit(text, normalize, unit); + t1 = text._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + identifier$0() { + return this.identifier$2$normalize$unit(false, false); + }, + identifier$1$normalize(normalize) { + return this.identifier$2$normalize$unit(normalize, false); + }, + identifier$1$unit(unit) { + return this.identifier$2$normalize$unit(false, unit); + }, + _parser1$_identifierBody$3$normalize$unit(text, normalize, unit) { + var t1, _1_0, _0_0, t2; + for (t1 = this.scanner; true;) { + _1_0 = t1.peekChar$0(); + if (_1_0 == null) + break; + if (45 === _1_0 && unit) { + _0_0 = t1.peekChar$1(1); + if (46 !== _0_0) + t2 = A._isInt(_0_0) && _0_0 >= 48 && _0_0 <= 57; + else + t2 = true; + if (t2) + break; + t2 = A.Primitives_stringFromCharCode(t1.readChar$0()); + text._contents += t2; + continue; + } + if (95 === _1_0 && normalize) { + t1.readChar$0(); + t2 = A.Primitives_stringFromCharCode(45); + text._contents += t2; + continue; + } + if (_1_0 !== 95) { + if (!(_1_0 >= 97 && _1_0 <= 122)) + t2 = _1_0 >= 65 && _1_0 <= 90; + else + t2 = true; + t2 = t2 || _1_0 >= 128; + } else + t2 = true; + if (!t2) + t2 = _1_0 >= 48 && _1_0 <= 57 || _1_0 === 45; + else + t2 = true; + if (t2) { + t2 = A.Primitives_stringFromCharCode(t1.readChar$0()); + text._contents += t2; + continue; + } + if (92 === _1_0) { + t2 = this.escape$0(); + text._contents += t2; + continue; + } + break; + } + }, + _parser1$_identifierBody$1(text) { + return this._parser1$_identifierBody$3$normalize$unit(text, false, false); + }, + string$0() { + var buffer, _0_0, t2, + t1 = this.scanner, + quote = t1.readChar$0(); + if (quote !== 39 && quote !== 34) + t1.error$2$position(0, "Expected string.", t1._string_scanner$_position - 1); + buffer = new A.StringBuffer(""); + for (; true;) { + _0_0 = t1.peekChar$0(); + if (_0_0 === quote) { + t1.readChar$0(); + break; + } + if (_0_0 == null || _0_0 === 10 || _0_0 === 13 || _0_0 === 12) + t1.error$1(0, "Expected " + A.Primitives_stringFromCharCode(quote) + "."); + if (92 === _0_0) { + t2 = t1.peekChar$1(1); + if (t2 === 10 || t2 === 13 || t2 === 12) { + t1.readChar$0(); + t1.readChar$0(); + } else { + t2 = A.Primitives_stringFromCharCode(A.consumeEscapedCharacter0(t1)); + buffer._contents += t2; + } + continue; + } + t2 = A.Primitives_stringFromCharCode(t1.readChar$0()); + buffer._contents += t2; + } + t1 = buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + declarationValue$1$allowEmpty(allowEmpty) { + var t1, t2, t3, wroteNewline, next, wroteNewline0, t4, start, end, _0_0, _this = this, + buffer = new A.StringBuffer(""), + brackets = A._setArrayType([], type$.JSArray_int); + for (t1 = _this.scanner, t2 = _this.get$loudComment(), t3 = _this.get$string(), wroteNewline = false; true;) { + next = t1.peekChar$0(); + if (next == null) + break; + wroteNewline0 = false; + if (92 === next) { + t4 = _this.escape$1$identifierStart(true); + buffer._contents += t4; + wroteNewline = wroteNewline0; + continue; + } + if (34 === next || 39 === next) { + start = t1._string_scanner$_position; + t3.call$0(); + end = t1._string_scanner$_position; + buffer._contents += B.JSString_methods.substring$2(t1.string, start, end); + wroteNewline = wroteNewline0; + continue; + } + if (47 === next) { + if (t1.peekChar$1(1) === 42) { + start = t1._string_scanner$_position; + t2.call$0(); + end = t1._string_scanner$_position; + buffer._contents += B.JSString_methods.substring$2(t1.string, start, end); + } else { + t4 = A.Primitives_stringFromCharCode(t1.readChar$0()); + buffer._contents += t4; + } + wroteNewline = wroteNewline0; + continue; + } + if (32 === next || 9 === next) { + if (!wroteNewline) { + t4 = t1.peekChar$1(1); + t4 = !(t4 === 32 || t4 === 9 || t4 === 10 || t4 === 13 || t4 === 12); + } else + t4 = true; + if (t4) { + t4 = A.Primitives_stringFromCharCode(32); + buffer._contents += t4; + } + t1.readChar$0(); + continue; + } + if (10 === next || 13 === next || 12 === next) { + t4 = t1.peekChar$1(-1); + if (!(t4 === 10 || t4 === 13 || t4 === 12)) + buffer._contents += "\n"; + t1.readChar$0(); + wroteNewline = true; + continue; + } + if (40 === next || 123 === next || 91 === next) { + t4 = A.Primitives_stringFromCharCode(next); + buffer._contents += t4; + brackets.push(A.opposite0(t1.readChar$0())); + wroteNewline = wroteNewline0; + continue; + } + if (41 === next || 125 === next || 93 === next) { + if (brackets.length === 0) + break; + t4 = A.Primitives_stringFromCharCode(next); + buffer._contents += t4; + t1.expectChar$1(brackets.pop()); + wroteNewline = wroteNewline0; + continue; + } + if (59 === next) { + if (brackets.length === 0) + break; + t4 = A.Primitives_stringFromCharCode(t1.readChar$0()); + buffer._contents += t4; + continue; + } + if (117 === next || 85 === next) { + _0_0 = _this.tryUrl$0(); + if (_0_0 != null) + buffer._contents += _0_0; + else { + t4 = A.Primitives_stringFromCharCode(t1.readChar$0()); + buffer._contents += t4; + } + wroteNewline = wroteNewline0; + continue; + } + if (_this.lookingAtIdentifier$0()) { + t4 = _this.identifier$0(); + buffer._contents += t4; + } else { + t4 = A.Primitives_stringFromCharCode(t1.readChar$0()); + buffer._contents += t4; + } + wroteNewline = wroteNewline0; + } + if (brackets.length !== 0) + t1.expectChar$1(B.JSArray_methods.get$last(brackets)); + if (!allowEmpty && buffer._contents.length === 0) + t1.error$1(0, "Expected token."); + t1 = buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + declarationValue$0() { + return this.declarationValue$1$allowEmpty(false); + }, + tryUrl$0() { + var buffer, _0_0, t2, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + if (!_this.scanIdentifier$1("url")) + return null; + if (!t1.scanChar$1(40)) { + t1.set$state(start); + return null; + } + _this.whitespace$1$consumeNewlines(true); + buffer = new A.StringBuffer(""); + buffer._contents = "" + "url("; + for (; true;) { + _0_0 = t1.peekChar$0(); + if (_0_0 == null) + break; + if (92 === _0_0) { + t2 = _this.escape$0(); + buffer._contents += t2; + continue; + } + t2 = true; + if (37 !== _0_0) + if (38 !== _0_0) + if (35 !== _0_0) + t2 = _0_0 >= 42 && _0_0 <= 126 || _0_0 >= 128; + if (t2) { + t2 = A.Primitives_stringFromCharCode(t1.readChar$0()); + buffer._contents += t2; + continue; + } + if (_0_0 === 32 || _0_0 === 9 || _0_0 === 10 || _0_0 === 13 || _0_0 === 12) { + _this.whitespace$1$consumeNewlines(true); + if (t1.peekChar$0() !== 41) + break; + continue; + } + if (41 === _0_0) { + t2 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2 = buffer._contents += t2; + return t2.charCodeAt(0) == 0 ? t2 : t2; + } + break; + } + t1.set$state(start); + return null; + }, + variableName$0() { + this.scanner.expectChar$1(36); + return this.identifier$1$normalize(true); + }, + escape$1$identifierStart(identifierStart) { + var value, _0_0, i, next, t2, exception, + _s25_ = "Expected escape sequence.", + t1 = this.scanner, + start = t1._string_scanner$_position; + t1.expectChar$1(92); + value = 0; + $label0$1: { + _0_0 = t1.peekChar$0(); + if (_0_0 == null) + t1.error$1(0, _s25_); + if (_0_0 === 10 || _0_0 === 13 || _0_0 === 12) + t1.error$1(0, _s25_); + if (A.CharacterExtension_get_isHex0(_0_0)) { + for (i = 0; i < 6; ++i) { + next = t1.peekChar$0(); + if (next != null) { + t2 = true; + if (!(next >= 48 && next <= 57)) + if (!(next >= 97 && next <= 102)) + t2 = next >= 65 && next <= 70; + t2 = !t2; + } else + t2 = true; + if (t2) + break; + value *= 16; + value += A.asHex0(t1.readChar$0()); + } + this.scanCharIf$1(new A.Parser_escape_closure0()); + break $label0$1; + } + value = t1.readChar$0(); + } + if (identifierStart) { + t2 = value; + t2 = t2 === 95 || A.CharacterExtension_get_isAlphabetic0(t2) || t2 >= 128; + } else { + t2 = value; + if (!(t2 === 95 || A.CharacterExtension_get_isAlphabetic0(t2) || t2 >= 128)) + t2 = t2 >= 48 && t2 <= 57 || t2 === 45; + else + t2 = true; + } + if (t2) + try { + t2 = A.Primitives_stringFromCharCode(value); + return t2; + } catch (exception) { + if (type$.RangeError._is(A.unwrapException(exception))) + t1.error$3$length$position(0, "Invalid Unicode code point.", t1._string_scanner$_position - start, start); + else + throw exception; + } + else { + t1 = true; + if (!(value <= 31)) + if (!J.$eq$(value, 127)) + if (identifierStart) { + t1 = value; + t1 = t1 >= 48 && t1 <= 57; + } else + t1 = false; + if (t1) { + t1 = "" + A.Primitives_stringFromCharCode(92); + if (value > 15) + t1 += A.Primitives_stringFromCharCode(A.hexCharFor0(B.JSNumber_methods._shrOtherPositive$1(value, 4))); + t1 = t1 + A.Primitives_stringFromCharCode(A.hexCharFor0(value & 15)) + A.Primitives_stringFromCharCode(32); + return t1.charCodeAt(0) == 0 ? t1 : t1; + } else + return A.String_String$fromCharCodes(A._setArrayType([92, value], type$.JSArray_int), 0, null); + } + }, + escape$0() { + return this.escape$1$identifierStart(false); + }, + scanCharIf$1(condition) { + var t1 = this.scanner; + if (!condition.call$1(t1.peekChar$0())) + return false; + t1.readChar$0(); + return true; + }, + scanIdentChar$2$caseSensitive(char, caseSensitive) { + var t3, + t1 = new A.Parser_scanIdentChar_matches0(caseSensitive, char), + t2 = this.scanner, + _0_0 = t2.peekChar$0(); + if (_0_0 != null) { + t3 = t1.call$1(_0_0); + t3 = t3; + } else + t3 = false; + if (t3) { + t2.readChar$0(); + return true; + } + if (92 === _0_0) { + t3 = t2._string_scanner$_position; + if (t1.call$1(A.consumeEscapedCharacter0(t2))) + return true; + t2.set$state(new A._SpanScannerState(t2, t3)); + } + return false; + }, + scanIdentChar$1(char) { + return this.scanIdentChar$2$caseSensitive(char, false); + }, + expectIdentChar$1(letter) { + var t1; + if (this.scanIdentChar$2$caseSensitive(letter, false)) + return; + t1 = this.scanner; + t1.error$2$position(0, 'Expected "' + A.Primitives_stringFromCharCode(letter) + '".', t1._string_scanner$_position); + }, + lookingAtIdentifier$1($forward) { + var t1, _1_0, t2, _0_0; + if ($forward == null) + $forward = 0; + t1 = this.scanner; + _1_0 = t1.peekChar$1($forward); + $label0$0: { + if (A._isInt(_1_0)) + t2 = _1_0 === 95 || A.CharacterExtension_get_isAlphabetic0(_1_0) || _1_0 >= 128; + else + t2 = false; + if (t2 || 92 === _1_0) { + t1 = true; + break $label0$0; + } + if (45 === _1_0) { + _0_0 = t1.peekChar$1($forward + 1); + $label1$1: { + if (A._isInt(_0_0)) + t1 = _0_0 === 95 || A.CharacterExtension_get_isAlphabetic0(_0_0) || _0_0 >= 128; + else + t1 = false; + t1 = t1 || 92 === _0_0 || 45 === _0_0; + if (t1) + break $label1$1; + break $label1$1; + } + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + lookingAtIdentifier$0() { + return this.lookingAtIdentifier$1(null); + }, + lookingAtIdentifierBody$0() { + var t1, + next = this.scanner.peekChar$0(); + if (next != null) { + if (!(next === 95 || A.CharacterExtension_get_isAlphabetic0(next) || next >= 128)) + t1 = next >= 48 && next <= 57 || next === 45; + else + t1 = true; + t1 = t1 || next === 92; + } else + t1 = false; + return t1; + }, + scanIdentifier$2$caseSensitive(text, caseSensitive) { + var t1, t2, _this = this; + if (!_this.lookingAtIdentifier$0()) + return false; + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + if (_this._parser1$_consumeIdentifier$2(text, caseSensitive) && !_this.lookingAtIdentifierBody$0()) + return true; + else { + t1.set$state(new A._SpanScannerState(t1, t2)); + return false; + } + }, + scanIdentifier$1(text) { + return this.scanIdentifier$2$caseSensitive(text, false); + }, + _parser1$_consumeIdentifier$2(text, caseSensitive) { + var t1, t2, t3; + for (t1 = new A.CodeUnits(text), t2 = type$.CodeUnits, t1 = new A.ListIterator(t1, t1.get$length(0), t2._eval$1("ListIterator")), t2 = t2._eval$1("ListBase.E"); t1.moveNext$0();) { + t3 = t1.__internal$_current; + if (!this.scanIdentChar$2$caseSensitive(t3 == null ? t2._as(t3) : t3, caseSensitive)) + return false; + } + return true; + }, + expectIdentifier$2$name(text, $name) { + var t1, start, t2, t3, t4, t5, t6; + if ($name == null) + $name = '"' + text + '"'; + t1 = this.scanner; + start = t1._string_scanner$_position; + for (t2 = new A.CodeUnits(text), t3 = type$.CodeUnits, t2 = new A.ListIterator(t2, t2.get$length(0), t3._eval$1("ListIterator")), t4 = "Expected " + $name, t5 = t4 + ".", t3 = t3._eval$1("ListBase.E"); t2.moveNext$0();) { + t6 = t2.__internal$_current; + if (this.scanIdentChar$2$caseSensitive(t6 == null ? t3._as(t6) : t6, false)) + continue; + t1.error$2$position(0, t5, start); + } + if (!this.lookingAtIdentifierBody$0()) + return; + t1.error$2$position(0, t4, start); + }, + expectIdentifier$1(text) { + return this.expectIdentifier$2$name(text, null); + }, + rawText$1(consumer) { + var t1 = this.scanner, + start = t1._string_scanner$_position; + consumer.call$0(); + return t1.substring$1(0, start); + }, + spanFrom$1(state) { + var span = this.scanner.spanFrom$1(state); + return this._parser1$_interpolationMap == null ? span : new A.LazyFileSpan0(new A.Parser_spanFrom_closure0(this, span)); + }, + error$3(_, message, span, trace) { + var exception = new A.StringScannerException(this.scanner.string, message, span); + if (trace == null) + throw A.wrapException(exception); + else + A.throwWithTrace0(exception, this.get$error(this), trace); + }, + error$2(_, message, span) { + return this.error$3(0, message, span, null); + }, + withErrorMessage$1$2(message, callback) { + var error, stackTrace, t1, exception; + try { + t1 = callback.call$0(); + return t1; + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.SourceSpanFormatException._is(t1)) { + error = t1; + stackTrace = A.getTraceFromException(exception); + t1 = J.get$span$z(error); + A.throwWithTrace0(new A.SourceSpanFormatException(error.get$source(), message, t1), error, stackTrace); + } else + throw exception; + } + }, + withErrorMessage$2(message, callback) { + return this.withErrorMessage$1$2(message, callback, type$.dynamic); + }, + wrapSpanFormatException$1$1(callback) { + var error, stackTrace, map, error0, stackTrace0, span, secondarySpans, t1, t2, span0, description, _0_0, error1, stackTrace1, span1, t3, exception, t4, _this = this, + _s8_ = "expected"; + try { + try { + t3 = callback.call$0(); + return t3; + } catch (exception) { + t3 = A.unwrapException(exception); + if (type$.SourceSpanFormatException._is(t3)) { + error = t3; + stackTrace = A.getTraceFromException(exception); + map = _this._parser1$_interpolationMap; + if (map == null) + throw exception; + A.throwWithTrace0(map.mapException$1(error), error, stackTrace); + } else + throw exception; + } + } catch (exception) { + t3 = A.unwrapException(exception); + if (type$.MultiSourceSpanFormatException._is(t3)) { + error0 = t3; + stackTrace0 = A.getTraceFromException(exception); + span = J.get$span$z(error0); + t3 = type$.FileSpan; + t4 = type$.String; + secondarySpans = error0.get$secondarySpans().cast$2$0(0, t3, t4); + if (A.startsWithIgnoreCase0(error0._span_exception$_message, _s8_)) { + span = _this._parser1$_adjustExceptionSpan$1(span); + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t3, t4); + for (t3 = A.MapExtensions_get_pairs0(secondarySpans, t3, t4), t3 = t3.get$iterator(t3); t3.moveNext$0();) { + t2 = t3.get$current(t3); + span0 = null; + description = null; + _0_0 = t2; + span0 = _0_0._0; + description = _0_0._1; + J.$indexSet$ax(t1, _this._parser1$_adjustExceptionSpan$1(span0), description); + } + secondarySpans = t1; + } + A.throwWithTrace0(A.MultiSpanSassFormatException$0(error0._span_exception$_message, span, error0.get$primaryLabel(), secondarySpans, null), error0, stackTrace0); + } else if (type$.SourceSpanFormatException._is(t3)) { + error1 = t3; + stackTrace1 = A.getTraceFromException(exception); + span1 = J.get$span$z(error1); + if (A.startsWithIgnoreCase0(error1._span_exception$_message, _s8_)) + span1 = _this._parser1$_adjustExceptionSpan$1(span1); + t1 = error1._span_exception$_message; + t2 = span1; + A.throwWithTrace0(new A.SassFormatException0(B.Set_empty, t1, t2), error1, stackTrace1); + } else + throw exception; + } + }, + wrapSpanFormatException$1(callback) { + return this.wrapSpanFormatException$1$1(callback, type$.dynamic); + }, + _parser1$_adjustExceptionSpan$1(span) { + var start, t1; + if (span.get$length(span) > 0) + return span; + start = this._parser1$_firstNewlineBefore$1(span.get$start(span)); + if (start.$eq(0, span.get$start(span))) + t1 = span; + else { + t1 = start.offset; + t1 = A._FileSpan$(start.file, t1, t1); + } + return t1; + }, + _parser1$_firstNewlineBefore$1($location) { + var lastNewline, codeUnit, + t1 = $location.file, + t2 = $location.offset, + text = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1._decodedChars, 0, t2), 0, null), + index = t2 - 1; + for (lastNewline = null; index >= 0;) { + codeUnit = text.charCodeAt(index); + if (!(codeUnit === 32 || codeUnit === 9 || codeUnit === 10 || codeUnit === 13 || codeUnit === 12)) { + if (lastNewline == null) + t1 = $location; + else { + t2 = new A.FileLocation(t1, lastNewline); + t2.FileLocation$_$2(t1, lastNewline); + t1 = t2; + } + return t1; + } + if (codeUnit === 10 || codeUnit === 13 || codeUnit === 12) + lastNewline = index; + --index; + } + return $location; + } + }; + A.Parser__parseIdentifier_closure0.prototype = { + call$0() { + var t1 = this.$this, + result = t1.identifier$0(); + t1.scanner.expectDone$0(); + return result; + }, + $signature: 26 + }; + A.Parser_escape_closure0.prototype = { + call$1(char) { + return char === 32 || char === 9 || char === 10 || char === 13 || char === 12; + }, + $signature: 30 + }; + A.Parser_scanIdentChar_matches0.prototype = { + call$1(actual) { + var t1 = this.char; + return this.caseSensitive ? actual === t1 : A.characterEqualsIgnoreCase0(t1, actual); + }, + $signature: 48 + }; + A.Parser_spanFrom_closure0.prototype = { + call$0() { + var t1 = this.$this._parser1$_interpolationMap; + if (t1 == null) + t1 = type$.InterpolationMap_2._as(t1); + return t1.mapSpan$1(this.span); + }, + $signature: 29 + }; + A.PlaceholderSelector0.prototype = { + accept$1$1(visitor) { + return visitor.visitPlaceholderSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + addSuffix$1(suffix) { + return new A.PlaceholderSelector0(this.name + suffix, this.span); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.PlaceholderSelector0 && other.name === this.name; + }, + get$hashCode(_) { + return B.JSString_methods.get$hashCode(this.name); + } + }; + A.PlainCssCallable0.prototype = { + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.PlainCssCallable0 && this.name === other.name; + }, + get$hashCode(_) { + return B.JSString_methods.get$hashCode(this.name); + }, + $isAsyncCallable0: 1, + $isCallable: 1, + get$name(receiver) { + return this.name; + } + }; + A.PrefixedMapView0.prototype = { + get$keys(_) { + return new A._PrefixedKeys0(this); + }, + get$length(_) { + var t1 = this._prefixed_map_view0$_map; + return t1.get$length(t1); + }, + get$isEmpty(_) { + var t1 = this._prefixed_map_view0$_map; + return t1.get$isEmpty(t1); + }, + get$isNotEmpty(_) { + var t1 = this._prefixed_map_view0$_map; + return t1.get$isNotEmpty(t1); + }, + $index(_, key) { + return typeof key == "string" && B.JSString_methods.startsWith$1(key, this._prefixed_map_view0$_prefix) ? this._prefixed_map_view0$_map.$index(0, J.substring$1$s(key, this._prefixed_map_view0$_prefix.length)) : null; + }, + containsKey$1(key) { + return typeof key == "string" && B.JSString_methods.startsWith$1(key, this._prefixed_map_view0$_prefix) && this._prefixed_map_view0$_map.containsKey$1(J.substring$1$s(key, this._prefixed_map_view0$_prefix.length)); + } + }; + A._PrefixedKeys0.prototype = { + get$length(_) { + var t1 = this._prefixed_map_view0$_view._prefixed_map_view0$_map; + return t1.get$length(t1); + }, + get$iterator(_) { + var t1 = this._prefixed_map_view0$_view._prefixed_map_view0$_map; + t1 = J.map$1$1$ax(t1.get$keys(t1), new A._PrefixedKeys_iterator_closure0(this), type$.String); + return t1.get$iterator(t1); + }, + contains$1(_, key) { + return this._prefixed_map_view0$_view.containsKey$1(key); + } + }; + A._PrefixedKeys_iterator_closure0.prototype = { + call$1(key) { + return this.$this._prefixed_map_view0$_view._prefixed_map_view0$_prefix + key; + }, + $signature: 6 + }; + A.ProphotoRgbColorSpace0.prototype = { + get$isBoundedInternal() { + return true; + }, + toLinear$1(channel) { + var abs = Math.abs(channel); + return abs <= 0.03125 ? channel / 16 : J.get$sign$in(channel) * Math.pow(abs, 1.8); + }, + fromLinear$1(channel) { + var abs = Math.abs(channel); + return abs >= 0.001953125 ? J.get$sign$in(channel) * Math.pow(abs, 0.5555555555555556) : 16 * channel; + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.SrgbLinearColorSpace_kUj0 === dest || B.SrgbColorSpace_thf0 === dest || B.RgbColorSpace_i0P0 === dest) { + t1 = $.$get$linearProphotoRgbToLinearSrgb0(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf20 === dest) { + t1 = $.$get$linearProphotoRgbToLinearA98Rgb0(); + break $label0$0; + } + if (B.DisplayP3ColorSpace_MmT0 === dest) { + t1 = $.$get$linearProphotoRgbToLinearDisplayP30(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo0 === dest) { + t1 = $.$get$linearProphotoRgbToLinearRec20200(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ0 === dest) { + t1 = $.$get$linearProphotoRgbToXyzD650(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB0 === dest) { + t1 = $.$get$linearProphotoRgbToXyzD500(); + break $label0$0; + } + if (B.LmsColorSpace_Os30 === dest) { + t1 = $.$get$linearProphotoRgbToLms0(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix0(dest); + break $label0$0; + } + return t1; + } + }; + A.PseudoSelector0.prototype = { + get$isHostContext() { + return this.isClass && this.name === "host-context" && this.selector != null; + }, + get$hasComplicatedSuperselectorSemantics() { + return !this.isClass || this.selector != null; + }, + get$specificity() { + var result, _this = this, + value = _this._pseudo$__PseudoSelector_specificity_FI; + if (value === $) { + result = new A.PseudoSelector_specificity_closure0(_this).call$0(); + _this._pseudo$__PseudoSelector_specificity_FI !== $ && A.throwUnnamedLateFieldADI(); + _this._pseudo$__PseudoSelector_specificity_FI = result; + value = result; + } + return value; + }, + withSelector$1(selector) { + var _this = this; + return A.PseudoSelector$0(_this.name, _this.span, _this.argument, !_this.isClass, selector); + }, + addSuffix$1(suffix) { + var _this = this; + if (_this.argument != null || _this.selector != null) + _this.super$SimpleSelector$addSuffix0(suffix); + return A.PseudoSelector$0(_this.name + suffix, _this.span, null, !_this.isClass, null); + }, + unify$1(compound) { + var other, result, t2, addedThis, _i, simple, _this = this, + t1 = _this.name; + if (t1 === "host" || t1 === "host-context") { + if (!B.JSArray_methods.every$1(compound, new A.PseudoSelector_unify_closure0())) + return null; + } else { + t1 = false; + if (compound.length === 1) { + other = compound[0]; + if (!(other instanceof A.UniversalSelector0)) { + if (other instanceof A.PseudoSelector0) + t1 = other.isClass && other.name === "host" || other.get$isHostContext(); + } else + t1 = true; + } else + other = null; + if (t1) + return other.unify$1(A._setArrayType([_this], type$.JSArray_SimpleSelector_2)); + } + if (B.JSArray_methods.contains$1(compound, _this)) + return compound; + result = A._setArrayType([], type$.JSArray_SimpleSelector_2); + for (t1 = compound.length, t2 = !_this.isClass, addedThis = false, _i = 0; _i < compound.length; compound.length === t1 || (0, A.throwConcurrentModificationError)(compound), ++_i) { + simple = compound[_i]; + if (simple instanceof A.PseudoSelector0 && !simple.isClass) { + if (t2) + return null; + result.push(_this); + addedThis = true; + } + result.push(simple); + } + if (!addedThis) + result.push(_this); + return result; + }, + isSuperselector$1(other) { + var selector, t1, t2, _this = this; + if (_this.super$SimpleSelector$isSuperselector0(other)) + return true; + selector = _this.selector; + if (selector == null) + return _this.$eq(0, other); + if (other instanceof A.PseudoSelector0 && !_this.isClass && !other.isClass && _this.normalizedName === "slotted" && other.name === _this.name) { + t1 = A.NullableExtension_andThen0(other.selector, selector.get$isSuperselector()); + return t1 == null ? false : t1; + } + t1 = type$.JSArray_SimpleSelector_2; + t2 = _this.span; + return A.compoundIsSuperselector0(A.CompoundSelector$0(A._setArrayType([_this], t1), t2), A.CompoundSelector$0(A._setArrayType([other], t1), t2), null); + }, + accept$1$1(visitor) { + return visitor.visitPseudoSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + $eq(_, other) { + var _this = this; + if (other == null) + return false; + return other instanceof A.PseudoSelector0 && other.name === _this.name && other.isClass === _this.isClass && other.argument == _this.argument && J.$eq$(other.selector, _this.selector); + }, + get$hashCode(_) { + var _this = this, + t1 = B.JSString_methods.get$hashCode(_this.name), + t2 = !_this.isClass ? 519018 : 218159; + return t1 ^ t2 ^ J.get$hashCode$(_this.argument) ^ J.get$hashCode$(_this.selector); + } + }; + A.PseudoSelector_specificity_closure0.prototype = { + call$0() { + var selector, t2, + t1 = this.$this; + if (!t1.isClass) + return 1; + selector = t1.selector; + if (selector == null) + return A.SimpleSelector0.prototype.get$specificity.call(t1); + switch (t1.normalizedName) { + case "where": + return 0; + case "is": + case "not": + case "has": + case "matches": + t1 = selector.components; + return A.IterableIntegerExtension_get_max(new A.MappedListIterable(t1, new A.PseudoSelector_specificity__closure1(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,int>"))); + case "nth-child": + case "nth-last-child": + t1 = A.SimpleSelector0.prototype.get$specificity.call(t1); + t2 = selector.components; + return t1 + A.IterableIntegerExtension_get_max(new A.MappedListIterable(t2, new A.PseudoSelector_specificity__closure2(), A._arrayInstanceType(t2)._eval$1("MappedListIterable<1,int>"))); + default: + return A.SimpleSelector0.prototype.get$specificity.call(t1); + } + }, + $signature: 10 + }; + A.PseudoSelector_specificity__closure1.prototype = { + call$1(component) { + return component.get$specificity(); + }, + $signature: 259 + }; + A.PseudoSelector_specificity__closure2.prototype = { + call$1(component) { + return component.get$specificity(); + }, + $signature: 259 + }; + A.PseudoSelector_unify_closure0.prototype = { + call$1(simple) { + var t1; + if (simple instanceof A.PseudoSelector0) + t1 = simple.isClass && simple.name === "host" || simple.selector != null; + else + t1 = false; + return t1; + }, + $signature: 14 + }; + A.PublicMemberMapView0.prototype = { + get$keys(_) { + var t1 = this._public_member_map_view0$_inner; + return J.where$1$ax(t1.get$keys(t1), A.utils1__isPublic$closure()); + }, + containsKey$1(key) { + return typeof key == "string" && A.isPublic0(key) && this._public_member_map_view0$_inner.containsKey$1(key); + }, + $index(_, key) { + if (typeof key == "string" && A.isPublic0(key)) + return this._public_member_map_view0$_inner.$index(0, key); + return null; + } + }; + A.QualifiedName0.prototype = { + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.QualifiedName0 && other.name === this.name && other.namespace == this.namespace; + }, + get$hashCode(_) { + return B.JSString_methods.get$hashCode(this.name) ^ J.get$hashCode$(this.namespace); + }, + toString$0(_) { + var t1 = this.namespace, + t2 = this.name; + return t1 == null ? t2 : t1 + "|" + t2; + } + }; + A.Rec2020ColorSpace0.prototype = { + get$isBoundedInternal() { + return true; + }, + toLinear$1(channel) { + var abs = Math.abs(channel); + return abs < 0.08124285829863151 ? channel / 4.5 : J.get$sign$in(channel) * Math.pow((abs + 1.09929682680944 - 1) / 1.09929682680944, 2.2222222222222223); + }, + fromLinear$1(channel) { + var abs = Math.abs(channel); + return abs > 0.018053968510807 ? J.get$sign$in(channel) * (1.09929682680944 * Math.pow(abs, 0.45) - 0.09929682680944008) : 4.5 * channel; + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.SrgbLinearColorSpace_kUj0 === dest || B.SrgbColorSpace_thf0 === dest || B.RgbColorSpace_i0P0 === dest) { + t1 = $.$get$linearRec2020ToLinearSrgb0(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf20 === dest) { + t1 = $.$get$linearRec2020ToLinearA98Rgb0(); + break $label0$0; + } + if (B.DisplayP3ColorSpace_MmT0 === dest) { + t1 = $.$get$linearRec2020ToLinearDisplayP30(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz0 === dest) { + t1 = $.$get$linearRec2020ToLinearProphotoRgb0(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ0 === dest) { + t1 = $.$get$linearRec2020ToXyzD650(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB0 === dest) { + t1 = $.$get$linearRec2020ToXyzD500(); + break $label0$0; + } + if (B.LmsColorSpace_Os30 === dest) { + t1 = $.$get$linearRec2020ToLms0(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix0(dest); + break $label0$0; + } + return t1; + } + }; + A.JSClass0.prototype = {}; + A.JSClassExtension_setCustomInspect_closure.prototype = { + call$4($self, _, __, ___) { + return this.inspect.call$1($self); + }, + call$3($self, _, __) { + return this.call$4($self, _, __, null); + }, + "call*": "call$4", + $requiredArgCount: 3, + $defaultValues() { + return [null]; + }, + $signature: 566 + }; + A.JSClassExtension_get_defineStaticMethod_closure.prototype = { + call$2($name, body) { + this._this[$name] = A.allowInteropNamed($name, body); + return null; + }, + $signature: 135 + }; + A.JSClassExtension_get_defineMethod_closure.prototype = { + call$2($name, body) { + J.get$$prototype$x(this._this)[$name] = A.allowInteropCaptureThisNamed($name, body); + return null; + }, + $signature: 135 + }; + A.JSClassExtension_get_defineGetter_closure.prototype = { + call$2($name, body) { + A.defineGetter(J.get$$prototype$x(this._this), $name, body, null); + return null; + }, + $signature: 135 + }; + A.RenderContext0.prototype = {}; + A.RenderContextOptions0.prototype = {}; + A.RenderContextResult0.prototype = {}; + A.RenderContextResultStats0.prototype = {}; + A.RenderOptions.prototype = {}; + A.RenderResult.prototype = {}; + A.RenderResultStats.prototype = {}; + A.ReplaceExpressionVisitor0.prototype = { + visitBinaryOperationExpression$1(_, node) { + return new A.BinaryOperationExpression0(node.operator, node.left.accept$1(this), node.right.accept$1(this), false); + }, + visitBooleanExpression$1(_, node) { + return node; + }, + visitColorExpression$1(_, node) { + return node; + }, + visitFunctionExpression$1(_, node) { + var t1 = node.originalName, + t2 = this.visitArgumentList$1(node.$arguments); + return new A.FunctionExpression0(node.namespace, A.stringReplaceAllUnchecked(t1, "_", "-"), t1, t2, node.span); + }, + visitInterpolatedFunctionExpression$1(_, node) { + return new A.InterpolatedFunctionExpression0(this.visitInterpolation$1(node.name), this.visitArgumentList$1(node.$arguments), node.span); + }, + visitIfExpression$1(_, node) { + return new A.IfExpression0(this.visitArgumentList$1(node.$arguments), node.span); + }, + visitListExpression$1(_, node) { + var t1 = node.contents; + return new A.ListExpression0(A.List_List$unmodifiable(new A.MappedListIterable(t1, new A.ReplaceExpressionVisitor_visitListExpression_closure0(this), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Expression0>")), type$.Expression_2), node.separator, node.hasBrackets, node.span); + }, + visitMapExpression$1(_, node) { + var t2, t3, _i, t4, + t1 = A._setArrayType([], type$.JSArray_Record_2_Expression_and_Expression_2); + for (t2 = node.pairs, t3 = t2.length, _i = 0; _i < t3; ++_i) { + t4 = t2[_i]; + t1.push(new A._Record_2(t4._0.accept$1(this), t4._1.accept$1(this))); + } + return new A.MapExpression0(A.List_List$unmodifiable(t1, type$.Record_2_Expression_and_Expression_2), node.span); + }, + visitNullExpression$1(_, node) { + return node; + }, + visitNumberExpression$1(_, node) { + return node; + }, + visitParenthesizedExpression$1(_, node) { + return new A.ParenthesizedExpression0(node.expression.accept$1(this), node.span); + }, + visitSelectorExpression$1(_, node) { + return node; + }, + visitStringExpression$1(_, node) { + return new A.StringExpression0(this.visitInterpolation$1(node.text), node.hasQuotes); + }, + visitSupportsExpression$1(_, node) { + return new A.SupportsExpression0(this.visitSupportsCondition$1(node.condition)); + }, + visitUnaryOperationExpression$1(_, node) { + return new A.UnaryOperationExpression0(node.operator, node.operand.accept$1(this), node.span); + }, + visitValueExpression$1(_, node) { + return node; + }, + visitVariableExpression$1(_, node) { + return node; + }, + visitArgumentList$1(invocation) { + var t5, t6, _this = this, + t1 = invocation.positional, + t2 = type$.String, + t3 = type$.Expression_2, + t4 = A.LinkedHashMap_LinkedHashMap$_empty(t2, t3); + for (t5 = A.MapExtensions_get_pairs0(invocation.named, t2, t3), t5 = t5.get$iterator(t5); t5.moveNext$0();) { + t6 = t5.get$current(t5); + t4.$indexSet(0, t6._0, t6._1.accept$1(_this)); + } + t5 = invocation.rest; + t5 = t5 == null ? null : t5.accept$1(_this); + t6 = invocation.keywordRest; + t6 = t6 == null ? null : t6.accept$1(_this); + return new A.ArgumentList0(A.List_List$unmodifiable(new A.MappedListIterable(t1, new A.ReplaceExpressionVisitor_visitArgumentList_closure0(_this), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Expression0>")), t3), A.ConstantMap_ConstantMap$from(t4, t2, t3), t5, t6, invocation.span); + }, + visitSupportsCondition$1(condition) { + var _this = this; + if (condition instanceof A.SupportsOperation0) + return A.SupportsOperation$0(_this.visitSupportsCondition$1(condition.left), _this.visitSupportsCondition$1(condition.right), condition.operator, condition.span); + else if (condition instanceof A.SupportsNegation0) + return new A.SupportsNegation0(_this.visitSupportsCondition$1(condition.condition), condition.span); + else if (condition instanceof A.SupportsInterpolation0) + return new A.SupportsInterpolation0(condition.expression.accept$1(_this), condition.span); + else if (condition instanceof A.SupportsDeclaration0) + return new A.SupportsDeclaration0(condition.name.accept$1(_this), condition.value.accept$1(_this), condition.span); + else + throw A.wrapException(A.SassException$0("BUG: Unknown SupportsCondition " + condition.toString$0(0) + ".", condition.get$span(condition), null)); + }, + visitInterpolation$1(interpolation) { + var t1 = interpolation.contents; + return A.Interpolation$0(new A.MappedListIterable(t1, new A.ReplaceExpressionVisitor_visitInterpolation_closure0(this), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Object>")), interpolation.spans, interpolation.span); + } + }; + A.ReplaceExpressionVisitor_visitListExpression_closure0.prototype = { + call$1(item) { + return item.accept$1(this.$this); + }, + $signature: 260 + }; + A.ReplaceExpressionVisitor_visitArgumentList_closure0.prototype = { + call$1(expression) { + return expression.accept$1(this.$this); + }, + $signature: 260 + }; + A.ReplaceExpressionVisitor_visitInterpolation_closure0.prototype = { + call$1(node) { + return node instanceof A.Expression0 ? node.accept$1(this.$this) : node; + }, + $signature: 79 + }; + A.ImporterResult0.prototype = { + get$sourceMapUrl(_) { + var t1 = this._result$_sourceMapUrl; + return t1 == null ? A.Uri_Uri$dataFromString(this.contents, B.C_Utf8Codec, null) : t1; + } + }; + A.ReturnRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitReturnRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "@return " + this.expression.toString$0(0) + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A.RgbColorSpace0.prototype = { + get$isBoundedInternal() { + return true; + }, + get$isLegacyInternal() { + return true; + }, + convert$5(dest, red, green, blue, alpha) { + var t1 = red == null ? null : red / 255, + t2 = green == null ? null : green / 255; + return B.SrgbColorSpace_thf0.convert$5(dest, t1, t2, blue == null ? null : blue / 255, alpha); + }, + toLinear$1(channel) { + return A.srgbAndDisplayP3ToLinear0(channel / 255); + }, + fromLinear$1(channel) { + return A.srgbAndDisplayP3FromLinear0(channel) * 255; + } + }; + A.SassParser0.prototype = { + get$currentIndentation() { + return this._sass0$_currentIndentation; + }, + get$indented() { + return true; + }, + styleRuleSelector$0() { + var t4, + t1 = this.scanner, + t2 = t1._string_scanner$_position, + t3 = new A.StringBuffer(""), + buffer = new A.InterpolationBuffer0(t3, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + do { + buffer.addInterpolation$1(this.almostAnyValue$1$omitComments(true)); + t4 = A.Primitives_stringFromCharCode(10); + t4 = t3._contents += t4; + } while (B.JSString_methods.endsWith$1(B.JSString_methods.trimRight$0(t4.charCodeAt(0) == 0 ? t4 : t4), ",") && this.scanCharIf$1(new A.SassParser_styleRuleSelector_closure0())); + return buffer.interpolation$1(t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + expectStatementSeparator$1($name) { + var t1, _this = this, + trailingSemicolon = _this._sass0$_tryTrailingSemicolon$0(); + if (!_this.atEndOfStatement$0()) + _this._sass0$_expectNewline$1$trailingSemicolon(trailingSemicolon); + if (_this._sass0$_peekIndentation$0() <= _this._sass0$_currentIndentation) + return; + t1 = $name == null ? "here" : "beneath a " + $name; + _this.scanner.error$2$position(0, "Nothing may be indented " + t1 + ".", _this._sass0$_nextIndentationEnd.position); + }, + expectStatementSeparator$0() { + return this.expectStatementSeparator$1(null); + }, + atEndOfStatement$0() { + var t1 = this.scanner.peekChar$0(); + if (t1 == null) + t1 = null; + else + t1 = t1 === 10 || t1 === 13 || t1 === 12; + return t1 !== false; + }, + lookingAtChildren$0() { + return this.atEndOfStatement$0() && this._sass0$_peekIndentation$0() > this._sass0$_currentIndentation; + }, + importArgument$0() { + var url, span, innerError, stackTrace, t1, _0_0, start, next, t2, exception, _this = this; + $label0$0: { + t1 = _this.scanner; + _0_0 = t1.peekChar$0(); + if (117 === _0_0 || 85 === _0_0) { + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + if (_this.scanIdentifier$1("url")) + if (t1.scanChar$1(40)) { + t1.set$state(start); + return _this.super$StylesheetParser$importArgument0(); + } else + t1.set$state(start); + break $label0$0; + } + if (39 === _0_0 || 34 === _0_0) + return _this.super$StylesheetParser$importArgument0(); + } + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + next = t1.peekChar$0(); + while (true) { + t2 = false; + if (next != null) + if (next !== 44) + if (next !== 59) + t2 = !(next === 10 || next === 13 || next === 12); + if (!t2) + break; + t1.readChar$0(); + next = t1.peekChar$0(); + } + url = t1.substring$1(0, start.position); + span = t1.spanFrom$1(start); + if (_this.isPlainImportUrl$1(url)) + return new A.StaticImport0(new A.Interpolation0(A.List_List$unmodifiable([A.serializeValue0(new A.SassString0(url, true), true, true)], type$.Object), B.List_null, span), null, span); + else + try { + t1 = _this.parseImportUrl$1(url); + return new A.DynamicImport0(t1, span); + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.FormatException._is(t1)) { + innerError = t1; + stackTrace = A.getTraceFromException(exception); + _this.error$3(0, "Invalid URL: " + J.get$message$x(innerError), span, stackTrace); + } else + throw exception; + } + }, + scanElse$1(ifIndentation) { + var t1, t2, startIndentation, startNextIndentation, startNextIndentationEnd, _this = this; + if (_this._sass0$_peekIndentation$0() !== ifIndentation) + return false; + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + startIndentation = _this._sass0$_currentIndentation; + startNextIndentation = _this._sass0$_nextIndentation; + startNextIndentationEnd = _this._sass0$_nextIndentationEnd; + _this._sass0$_readIndentation$0(); + if (t1.scanChar$1(64) && _this.scanIdentifier$1("else")) + return true; + t1.set$state(new A._SpanScannerState(t1, t2)); + _this._sass0$_currentIndentation = startIndentation; + _this._sass0$_nextIndentation = startNextIndentation; + _this._sass0$_nextIndentationEnd = startNextIndentationEnd; + return false; + }, + children$1(_, child) { + var children = A._setArrayType([], type$.JSArray_Statement_2); + this._sass0$_whileIndentedLower$1(new A.SassParser_children_closure0(this, child, children)); + return children; + }, + statements$1(statement) { + var statements, t2, _1_0, + t1 = this.scanner, + _0_0 = t1.peekChar$0(); + if (9 === _0_0 || 32 === _0_0) + t1.error$3$length$position(0, string$.Indent, t1._string_scanner$_position, 0); + statements = A._setArrayType([], type$.JSArray_Statement_2); + for (t2 = t1.string.length; t1._string_scanner$_position !== t2;) { + _1_0 = this._sass0$_child$1(statement); + if (_1_0 != null) + statements.push(_1_0); + this._sass0$_readIndentation$0(); + } + return statements; + }, + _sass0$_child$1(child) { + var _0_0, _this = this, + t1 = _this.scanner, + _1_0 = t1.peekChar$0(); + $label0$0: { + if (13 === _1_0 || 10 === _1_0 || 12 === _1_0) { + t1 = null; + break $label0$0; + } + if (36 === _1_0) { + t1 = _this.variableDeclarationWithoutNamespace$0(); + break $label0$0; + } + if (47 === _1_0) { + _0_0 = t1.peekChar$1(1); + $label1$1: { + if (47 === _0_0) { + t1 = _this._sass0$_silentComment$0(); + break $label1$1; + } + if (42 === _0_0) { + t1 = _this._sass0$_loudComment$0(); + break $label1$1; + } + t1 = child.call$0(); + break $label1$1; + } + break $label0$0; + } + t1 = child.call$0(); + break $label0$0; + } + return t1; + }, + _sass0$_silentComment$0() { + var buffer, parentIndentation, t3, t4, t5, commentPrefix, i, t6, i0, t7, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position; + t1.expect$1("//"); + buffer = new A.StringBuffer(""); + parentIndentation = _this._sass0$_currentIndentation; + t3 = t1.string.length; + t4 = 1 + parentIndentation; + t5 = 2 + parentIndentation; + $label0$0: + do { + commentPrefix = t1.scanChar$1(47) ? "///" : "//"; + for (i = commentPrefix.length; true;) { + t6 = buffer._contents += commentPrefix; + for (i0 = i; i0 < _this._sass0$_currentIndentation - parentIndentation; ++i0) { + t6 += A.Primitives_stringFromCharCode(32); + buffer._contents = t6; + } + while (true) { + if (t1._string_scanner$_position !== t3) { + t7 = t1.peekChar$0(); + t7 = !(t7 === 10 || t7 === 13 || t7 === 12); + } else + t7 = false; + if (!t7) + break; + t6 += A.Primitives_stringFromCharCode(t1.readChar$0()); + buffer._contents = t6; + } + buffer._contents = t6 + "\n"; + if (_this._sass0$_peekIndentation$0() < parentIndentation) + break $label0$0; + if (_this._sass0$_peekIndentation$0() === parentIndentation) { + if (t1.peekChar$1(t4) === 47 && t1.peekChar$1(t5) === 47) + _this._sass0$_readIndentation$0(); + break; + } + _this._sass0$_readIndentation$0(); + } + } while (t1.scan$1("//")); + t3 = buffer._contents; + return _this.lastSilentComment = new A.SilentComment0(t3.charCodeAt(0) == 0 ? t3 : t3, t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + _sass0$_loudComment$0() { + var t2, t3, t4, buffer, parentIndentation, t5, t6, first, beginningOfComment, t7, end, i, _1_0, _0_0, endPosition, span, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expect$1("/*"); + t2 = new A.StringBuffer(""); + t3 = A._setArrayType([], type$.JSArray_Object); + t4 = A._setArrayType([], type$.JSArray_nullable_FileSpan); + buffer = new A.InterpolationBuffer0(t2, t3, t4); + t2._contents = "" + "/*"; + parentIndentation = _this._sass0$_currentIndentation; + for (t5 = t1.string, t6 = t5.length, first = true; true; first = false) { + if (first) { + beginningOfComment = t1._string_scanner$_position; + _this.spaces$0(); + t7 = t1.peekChar$0(); + if (t7 === 10 || t7 === 13 || t7 === 12) { + _this._sass0$_readIndentation$0(); + t7 = A.Primitives_stringFromCharCode(32); + t2._contents += t7; + } else { + end = t1._string_scanner$_position; + t2._contents += B.JSString_methods.substring$2(t5, beginningOfComment, end); + } + } else { + t7 = t2._contents += "\n"; + t2._contents = t7 + " * "; + } + for (i = 3; i < _this._sass0$_currentIndentation - parentIndentation; ++i) { + t7 = A.Primitives_stringFromCharCode(32); + t2._contents += t7; + } + for (; t1._string_scanner$_position !== t6;) { + _1_0 = t1.peekChar$0(); + if (10 === _1_0 || 13 === _1_0 || 12 === _1_0) + break; + if (35 === _1_0) { + if (t1.peekChar$1(1) === 123) { + _0_0 = _this.singleInterpolation$0(); + buffer._interpolation_buffer0$_flushText$0(); + t3.push(_0_0._0); + t4.push(_0_0._1); + } else { + t7 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t7; + } + continue; + } + if (42 === _1_0) { + if (t1.peekChar$1(1) === 47) { + t3 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t3; + t3 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t3; + endPosition = t1._string_scanner$_position; + t2 = t1._sourceFile; + t3 = start.position; + span = new A._FileSpan(t2, t3, endPosition); + span._FileSpan$3(t2, t3, endPosition); + _this.whitespace$1$consumeNewlines(false); + while (true) { + t2 = t1.peekChar$0(); + if (!((t2 === 10 || t2 === 13 || t2 === 12) && _this._sass0$_peekIndentation$0() > parentIndentation)) + break; + for (; _this._sass0$_lookingAtDoubleNewline$0();) + _this._sass0$_expectNewline$0(); + _this._sass0$_readIndentation$0(); + _this.whitespace$1$consumeNewlines(false); + } + if (t1._string_scanner$_position !== t6) { + t2 = t1.peekChar$0(); + t2 = !(t2 === 10 || t2 === 13 || t2 === 12); + } else + t2 = false; + if (t2) { + t2 = t1._string_scanner$_position; + while (true) { + if (t1._string_scanner$_position !== t6) { + t3 = t1.peekChar$0(); + t3 = !(t3 === 10 || t3 === 13 || t3 === 12); + } else + t3 = false; + if (!t3) + break; + t1.readChar$0(); + } + throw A.wrapException(A.MultiSpanSassFormatException$0("Unexpected text after end of comment", t1.spanFrom$1(new A._SpanScannerState(t1, t2)), "extra text", A.LinkedHashMap_LinkedHashMap$_literal([span, "comment"], type$.FileSpan, type$.String), null)); + } else + return new A.LoudComment0(buffer.interpolation$1(span)); + } else { + t7 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t7; + } + continue; + } + t7 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t7; + } + if (_this._sass0$_peekIndentation$0() <= parentIndentation) + break; + for (; _this._sass0$_lookingAtDoubleNewline$0();) { + _this._sass0$_expectNewline$0(); + t7 = t2._contents += "\n"; + t2._contents = t7 + " *"; + } + _this._sass0$_readIndentation$0(); + } + return new A.LoudComment0(buffer.interpolation$1(t1.spanFrom$1(start))); + }, + whitespaceWithoutComments$1$consumeNewlines(consumeNewlines) { + var t1, t2, next, t3; + for (t1 = this.scanner, t2 = t1.string.length; t1._string_scanner$_position !== t2;) { + next = t1.peekChar$0(); + if (consumeNewlines) + t3 = !(next === 32 || next === 9 || next === 10 || next === 13 || next === 12); + else + t3 = !(next === 32 || next === 9); + if (t3) + break; + t1.readChar$0(); + } + }, + _sass0$_expectNewline$1$trailingSemicolon(trailingSemicolon) { + var t1 = this.scanner, + _0_0 = t1.peekChar$0(); + if (13 === _0_0) { + t1.readChar$0(); + if (t1.peekChar$0() === 10) + t1.readChar$0(); + return; + } + if (10 === _0_0 || 12 === _0_0) { + t1.readChar$0(); + return; + } + t1.error$1(0, trailingSemicolon ? string$.multip : "expected newline."); + }, + _sass0$_expectNewline$0() { + return this._sass0$_expectNewline$1$trailingSemicolon(false); + }, + _sass0$_lookingAtDoubleNewline$0() { + var t2, _0_0, + t1 = this.scanner, + _1_0 = t1.peekChar$0(); + $label1$1: { + t2 = false; + if (13 === _1_0) { + _0_0 = t1.peekChar$1(1); + $label0$0: { + if (10 === _0_0) { + t1 = t1.peekChar$1(2); + t1 = t1 === 10 || t1 === 13 || t1 === 12; + break $label0$0; + } + if (13 === _0_0 || 12 === _0_0) { + t1 = true; + break $label0$0; + } + t1 = t2; + break $label0$0; + } + break $label1$1; + } + if (10 === _1_0 || 12 === _1_0) { + t1 = t1.peekChar$1(1); + t1 = t1 === 10 || t1 === 13 || t1 === 12; + break $label1$1; + } + t1 = t2; + break $label1$1; + } + return t1; + }, + _sass0$_whileIndentedLower$1(body) { + var t1, t2, childIndentation, indentation, t3, t4, _this = this, + parentIndentation = _this._sass0$_currentIndentation; + for (t1 = _this.scanner, t2 = t1._sourceFile, childIndentation = null; _this._sass0$_peekIndentation$0() > parentIndentation;) { + indentation = _this._sass0$_readIndentation$0(); + if (childIndentation == null) + childIndentation = indentation; + if (childIndentation !== indentation) { + t3 = t1._string_scanner$_position; + t4 = t2.getColumn$1(t3); + t1.error$3$length$position(0, "Inconsistent indentation, expected " + childIndentation + " spaces.", t2.getColumn$1(t1._string_scanner$_position), t3 - t4); + } + body.call$0(); + } + }, + _sass0$_readIndentation$0() { + var t1, _this = this, + currentIndentation = _this._sass0$_nextIndentation; + if (currentIndentation == null) + currentIndentation = _this._sass0$_nextIndentation = _this._sass0$_peekIndentation$0(); + _this._sass0$_currentIndentation = currentIndentation; + t1 = _this._sass0$_nextIndentationEnd; + t1.toString; + _this.scanner.set$state(t1); + _this._sass0$_nextIndentationEnd = _this._sass0$_nextIndentation = null; + return currentIndentation; + }, + _sass0$_peekIndentation$0() { + var t1, t2, t3, start, containsTab, containsSpace, nextIndentation, _1_0, t4, _this = this, + _0_0 = _this._sass0$_nextIndentation; + if (_0_0 != null) + return _0_0; + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + t3 = t1.string.length; + if (t2 === t3) { + _this._sass0$_nextIndentation = 0; + _this._sass0$_nextIndentationEnd = new A._SpanScannerState(t1, t2); + return 0; + } + start = new A._SpanScannerState(t1, t2); + if (!_this.scanCharIf$1(new A.SassParser__peekIndentation_closure1())) + t1.error$2$position(0, "Expected newline.", t1._string_scanner$_position); + containsTab = A._Cell$(); + containsSpace = A._Cell$(); + nextIndentation = A._Cell$(); + do { + containsSpace.__late_helper$_value = containsTab.__late_helper$_value = false; + nextIndentation.__late_helper$_value = 0; + for (; true;) { + $label0$0: { + _1_0 = t1.peekChar$0(); + if (32 === _1_0) { + containsSpace.__late_helper$_value = true; + break $label0$0; + } + if (9 === _1_0) { + containsTab.__late_helper$_value = true; + break $label0$0; + } + break; + } + t2 = nextIndentation.__late_helper$_value; + if (t2 === nextIndentation) + A.throwExpression(A.LateError$localNI("")); + nextIndentation.__late_helper$_value = t2 + 1; + t1.readChar$0(); + } + t2 = t1._string_scanner$_position; + if (t2 === t3) { + _this._sass0$_nextIndentation = 0; + _this._sass0$_nextIndentationEnd = new A._SpanScannerState(t1, t2); + t1.set$state(start); + return 0; + } + } while (_this.scanCharIf$1(new A.SassParser__peekIndentation_closure2())); + t2 = containsTab._readLocal$0(); + t3 = containsSpace._readLocal$0(); + if (t2) { + if (t3) { + t2 = t1._string_scanner$_position; + t3 = t1._sourceFile; + t4 = t3.getColumn$1(t2); + t1.error$3$length$position(0, "Tabs and spaces may not be mixed.", t3.getColumn$1(t1._string_scanner$_position), t2 - t4); + } else if (_this._sass0$_spaces === true) { + t2 = t1._string_scanner$_position; + t3 = t1._sourceFile; + t4 = t3.getColumn$1(t2); + t1.error$3$length$position(0, "Expected spaces, was tabs.", t3.getColumn$1(t1._string_scanner$_position), t2 - t4); + } + } else if (t3 && _this._sass0$_spaces === false) { + t2 = t1._string_scanner$_position; + t3 = t1._sourceFile; + t4 = t3.getColumn$1(t2); + t1.error$3$length$position(0, "Expected tabs, was spaces.", t3.getColumn$1(t1._string_scanner$_position), t2 - t4); + } + _this._sass0$_nextIndentation = nextIndentation._readLocal$0(); + if (nextIndentation._readLocal$0() > 0) + if (_this._sass0$_spaces == null) + _this._sass0$_spaces = containsSpace._readLocal$0(); + _this._sass0$_nextIndentationEnd = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.set$state(start); + return nextIndentation._readLocal$0(); + }, + _sass0$_tryTrailingSemicolon$0() { + if (this.scanCharIf$1(new A.SassParser__tryTrailingSemicolon_closure0())) { + this.whitespace$1$consumeNewlines(false); + return true; + } + return false; + } + }; + A.SassParser_styleRuleSelector_closure0.prototype = { + call$1(char) { + return char === 10 || char === 13 || char === 12; + }, + $signature: 30 + }; + A.SassParser_children_closure0.prototype = { + call$0() { + var _0_0 = this.$this._sass0$_child$1(this.child); + if (_0_0 != null) + this.children.push(_0_0); + }, + $signature: 0 + }; + A.SassParser__peekIndentation_closure1.prototype = { + call$1(char) { + return char === 10 || char === 13 || char === 12; + }, + $signature: 30 + }; + A.SassParser__peekIndentation_closure2.prototype = { + call$1(char) { + return char === 10 || char === 13 || char === 12; + }, + $signature: 30 + }; + A.SassParser__tryTrailingSemicolon_closure0.prototype = { + call$1(char) { + return char === 59; + }, + $signature: 30 + }; + A._Exports.prototype = {}; + A._wrapMain_closure.prototype = { + call$1(_) { + return A._translateReturnValue(this.main.call$0()); + }, + $signature: 90 + }; + A._wrapMain_closure0.prototype = { + call$1(args) { + return A._translateReturnValue(this.main.call$1(A.List_List$from(type$.List_dynamic._as(args), true, type$.String))); + }, + $signature: 90 + }; + A.ScssParser0.prototype = { + get$indented() { + return false; + }, + get$currentIndentation() { + return 0; + }, + styleRuleSelector$0() { + return this.almostAnyValue$0(); + }, + expectStatementSeparator$1($name) { + var t1, _0_0; + this.whitespaceWithoutComments$1$consumeNewlines(true); + t1 = this.scanner; + if (t1._string_scanner$_position === t1.string.length) + return; + _0_0 = t1.peekChar$0(); + if (59 === _0_0 || 125 === _0_0) + return; + t1.expectChar$1(59); + }, + expectStatementSeparator$0() { + return this.expectStatementSeparator$1(null); + }, + atEndOfStatement$0() { + var next = this.scanner.peekChar$0(); + return next == null || next === 59 || next === 125 || next === 123; + }, + lookingAtChildren$0() { + return this.scanner.peekChar$0() === 123; + }, + scanElse$1(ifIndentation) { + var t3, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position; + _this.whitespace$1$consumeNewlines(true); + t3 = t1._string_scanner$_position; + if (t1.scanChar$1(64)) { + if (_this.scanIdentifier$2$caseSensitive("else", true)) + return true; + if (_this.scanIdentifier$2$caseSensitive("elseif", true)) { + _this.warnings.push(new A._Record_3_deprecation_message_span(B.Deprecation_8ki, string$.x40elsei, t1.spanFrom$1(new A._SpanScannerState(t1, t3)))); + t1.set$position(t1._string_scanner$_position - 2); + return true; + } + } + t1.set$state(new A._SpanScannerState(t1, t2)); + return false; + }, + children$1(_, child) { + var children, _this = this, + t1 = _this.scanner; + t1.expectChar$1(123); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + children = A._setArrayType([], type$.JSArray_Statement_2); + for (; true;) + switch (t1.peekChar$0()) { + case 36: + children.push(_this.variableDeclarationWithoutNamespace$0()); + break; + case 47: + switch (t1.peekChar$1(1)) { + case 47: + children.push(_this._scss0$_silentComment$0()); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + break; + case 42: + children.push(_this._scss0$_loudComment$0()); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + break; + default: + children.push(child.call$0()); + } + break; + case 59: + t1.readChar$0(); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + break; + case 125: + t1.expectChar$1(125); + return children; + default: + children.push(child.call$0()); + } + }, + statements$1(statement) { + var t1, t2, _0_0, _1_0, _this = this, + statements = A._setArrayType([], type$.JSArray_Statement_2); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + for (t1 = _this.scanner, t2 = t1.string.length; t1._string_scanner$_position !== t2;) + switch (t1.peekChar$0()) { + case 36: + statements.push(_this.variableDeclarationWithoutNamespace$0()); + break; + case 47: + switch (t1.peekChar$1(1)) { + case 47: + statements.push(_this._scss0$_silentComment$0()); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + break; + case 42: + statements.push(_this._scss0$_loudComment$0()); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + break; + default: + _0_0 = statement.call$0(); + if (_0_0 != null) + statements.push(_0_0); + } + break; + case 59: + t1.readChar$0(); + _this.whitespaceWithoutComments$1$consumeNewlines(true); + break; + default: + _1_0 = statement.call$0(); + if (_1_0 != null) + statements.push(_1_0); + } + return statements; + }, + _scss0$_silentComment$0() { + var t2, t3, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expect$1("//"); + t2 = t1.string.length; + do { + while (true) { + if (t1._string_scanner$_position !== t2) { + t3 = t1.readChar$0(); + t3 = !(t3 === 10 || t3 === 13 || t3 === 12); + } else + t3 = false; + if (!t3) + break; + } + if (t1._string_scanner$_position === t2) + break; + _this.spaces$0(); + } while (t1.scan$1("//")); + if (_this.get$plainCss()) + _this.error$2(0, string$.Silent, t1.spanFrom$1(start)); + return _this.lastSilentComment = new A.SilentComment0(t1.substring$1(0, start.position), t1.spanFrom$1(start)); + }, + _scss0$_loudComment$0() { + var t3, t4, t5, buffer, _0_0, t6, endPosition, + t1 = this.scanner, + t2 = t1._string_scanner$_position; + t1.expect$1("/*"); + t3 = new A.StringBuffer(""); + t4 = A._setArrayType([], type$.JSArray_Object); + t5 = A._setArrayType([], type$.JSArray_nullable_FileSpan); + buffer = new A.InterpolationBuffer0(t3, t4, t5); + t3._contents = "" + "/*"; + $label0$1: + for (; true;) + switch (t1.peekChar$0()) { + case 35: + if (t1.peekChar$1(1) === 123) { + _0_0 = this.singleInterpolation$0(); + buffer._interpolation_buffer0$_flushText$0(); + t4.push(_0_0._0); + t5.push(_0_0._1); + } else { + t6 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t6; + } + break; + case 42: + t6 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t6; + if (t1.peekChar$0() !== 47) + continue $label0$1; + t4 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t4; + endPosition = t1._string_scanner$_position; + t3 = t1._sourceFile; + t4 = new A._SpanScannerState(t1, t2).position; + t1 = new A._FileSpan(t3, t4, endPosition); + t1._FileSpan$3(t3, t4, endPosition); + return new A.LoudComment0(buffer.interpolation$1(t1)); + case 13: + t1.readChar$0(); + if (t1.peekChar$0() !== 10) { + t6 = A.Primitives_stringFromCharCode(10); + t3._contents += t6; + } + break; + case 12: + t1.readChar$0(); + t6 = A.Primitives_stringFromCharCode(10); + t3._contents += t6; + break; + default: + t6 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t6; + } + } + }; + A.Selector0.prototype = { + assertNotBogus$1$name($name) { + if (!this.accept$1(B._IsBogusVisitor_true0)) + return; + A.warnForDeprecation0("$" + $name + ": " + (this.toString$0(0) + string$.x20is_nov), B.Deprecation_SHb); + }, + toString$0(_) { + var _null = null, + visitor = A._SerializeVisitor$0(_null, true, _null, _null, true, false, _null, true); + this.accept$1(visitor); + return visitor._serialize0$_buffer.toString$0(0); + }, + $isAstNode0: 1, + get$span(receiver) { + return this.span; + } + }; + A._IsInvisibleVisitor2.prototype = { + visitSelectorList$1(list) { + return B.JSArray_methods.every$1(list.components, this.get$visitComplexSelector()); + }, + visitComplexSelector$1(complex) { + var t1; + if (!this.super$AnySelectorVisitor$visitComplexSelector0(complex)) + t1 = this.includeBogus && complex.accept$1(B._IsBogusVisitor_false0); + else + t1 = true; + return t1; + }, + visitPlaceholderSelector$1(placeholder) { + return true; + }, + visitPseudoSelector$1(pseudo) { + var t1, + _0_0 = pseudo.selector; + if (_0_0 != null) { + if (pseudo.name === "not") + t1 = this.includeBogus && _0_0.accept$1(B._IsBogusVisitor_true0); + else + t1 = this.visitSelectorList$1(_0_0); + return t1; + } else + return false; + } + }; + A._IsBogusVisitor0.prototype = { + visitComplexSelector$1(complex) { + var t2, + t1 = complex.components; + if (t1.length === 0) + return complex.leadingCombinators.length !== 0; + else { + t2 = this.includeLeadingCombinator ? 0 : 1; + return complex.leadingCombinators.length > t2 || B.JSArray_methods.get$last(t1).combinators.length !== 0 || B.JSArray_methods.any$1(t1, new A._IsBogusVisitor_visitComplexSelector_closure0(this)); + } + }, + visitPseudoSelector$1(pseudo) { + var selector = pseudo.selector; + if (selector == null) + return false; + return pseudo.name === "has" ? selector.accept$1(B._IsBogusVisitor_false0) : selector.accept$1(B._IsBogusVisitor_true0); + } + }; + A._IsBogusVisitor_visitComplexSelector_closure0.prototype = { + call$1(component) { + return component.combinators.length > 1 || this.$this.visitCompoundSelector$1(component.selector); + }, + $signature: 57 + }; + A._IsUselessVisitor0.prototype = { + visitComplexSelector$1(complex) { + return complex.leadingCombinators.length > 1 || B.JSArray_methods.any$1(complex.components, new A._IsUselessVisitor_visitComplexSelector_closure0(this)); + }, + visitPseudoSelector$1(pseudo) { + return pseudo.accept$1(B._IsBogusVisitor_true0); + } + }; + A._IsUselessVisitor_visitComplexSelector_closure0.prototype = { + call$1(component) { + return component.combinators.length > 1 || this.$this.visitCompoundSelector$1(component.selector); + }, + $signature: 57 + }; + A.__IsBogusVisitor_Object_AnySelectorVisitor0.prototype = {}; + A.__IsInvisibleVisitor_Object_AnySelectorVisitor0.prototype = {}; + A.__IsUselessVisitor_Object_AnySelectorVisitor0.prototype = {}; + A.SelectorExpression0.prototype = { + accept$1$1(visitor) { + return visitor.visitSelectorExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "&"; + }, + get$span(receiver) { + return this.span; + } + }; + A._nest_closure0.prototype = { + call$1($arguments) { + var t1 = {}, + selectors = J.$index$asx($arguments, 0).get$asList(); + if (selectors.length === 0) + throw A.wrapException(A.SassScriptException$0(string$.x24selec, null)); + t1.first = true; + return new A.MappedListIterable(selectors, new A._nest__closure1(t1), A._arrayInstanceType(selectors)._eval$1("MappedListIterable<1,SelectorList0>")).reduce$1(0, new A._nest__closure2()).get$asSassList(); + }, + $signature: 28 + }; + A._nest__closure1.prototype = { + call$1(selector) { + var t1 = this._box_0, + result = A.SassApiValue_assertSelector0(selector, !t1.first, null); + t1.first = false; + return result; + }, + $signature: 261 + }; + A._nest__closure2.prototype = { + call$2($parent, child) { + return child.nestWithin$1($parent); + }, + $signature: 262 + }; + A._append_closure1.prototype = { + call$1($arguments) { + var t1, + selectors = J.$index$asx($arguments, 0).get$asList(); + if (selectors.length === 0) + throw A.wrapException(A.SassScriptException$0(string$.x24selec, null)); + t1 = A.EvaluationContext_currentOrNull0(); + return new A.MappedListIterable(selectors, new A._append__closure1(), A._arrayInstanceType(selectors)._eval$1("MappedListIterable<1,SelectorList0>")).reduce$1(0, new A._append__closure2((t1 == null ? A.throwExpression(A.StateError$(string$.No_Sass)) : t1).get$currentCallableSpan())).get$asSassList(); + }, + $signature: 28 + }; + A._append__closure1.prototype = { + call$1(selector) { + return A.SassApiValue_assertSelector0(selector, false, null); + }, + $signature: 261 + }; + A._append__closure2.prototype = { + call$2($parent, child) { + var t1 = child.components, + t2 = this.span; + return A.SelectorList$0(new A.MappedListIterable(t1, new A._append___closure0($parent, t2), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,ComplexSelector0>")), t2).nestWithin$1($parent); + }, + $signature: 262 + }; + A._append___closure0.prototype = { + call$1(complex) { + var _0_0, t1, component, rest, newCompound, t2, _null = null; + if (complex.leadingCombinators.length !== 0) + throw A.wrapException(A.SassScriptException$0("Can't append " + complex.toString$0(0) + " to " + this.parent.toString$0(0) + ".", _null)); + _0_0 = complex.components; + t1 = _0_0.length >= 1; + if (t1) { + component = _0_0[0]; + rest = B.JSArray_methods.sublist$1(_0_0, 1); + } else { + rest = _null; + component = rest; + } + if (!t1) + throw A.wrapException(A.StateError$("Pattern matching error")); + newCompound = A._prependParent0(component.selector); + if (newCompound == null) + throw A.wrapException(A.SassScriptException$0("Can't append " + complex.toString$0(0) + " to " + this.parent.toString$0(0) + ".", _null)); + t1 = this.span; + t2 = A._setArrayType([new A.ComplexSelectorComponent0(newCompound, A.List_List$unmodifiable(component.combinators, type$.CssValue_Combinator_2), t1)], type$.JSArray_ComplexSelectorComponent_2); + B.JSArray_methods.addAll$1(t2, rest); + return A.ComplexSelector$0(B.List_empty14, t2, t1, false); + }, + $signature: 58 + }; + A._extend_closure0.prototype = { + call$1($arguments) { + var target, source, + _s8_ = "selector", + _s8_0 = "extendee", + _s8_1 = "extender", + t1 = J.getInterceptor$asx($arguments), + selector = A.SassApiValue_assertSelector0(t1.$index($arguments, 0), false, _s8_); + selector.assertNotBogus$1$name(_s8_); + target = A.SassApiValue_assertSelector0(t1.$index($arguments, 1), false, _s8_0); + target.assertNotBogus$1$name(_s8_0); + source = A.SassApiValue_assertSelector0(t1.$index($arguments, 2), false, _s8_1); + source.assertNotBogus$1$name(_s8_1); + t1 = A.EvaluationContext_currentOrNull0(); + return A.ExtensionStore__extendOrReplace0(selector, source, target, B.ExtendMode_allTargets_allTargets0, (t1 == null ? A.throwExpression(A.StateError$(string$.No_Sass)) : t1).get$currentCallableSpan()).get$asSassList(); + }, + $signature: 28 + }; + A._replace_closure0.prototype = { + call$1($arguments) { + var target, source, + _s8_ = "selector", + _s8_0 = "original", + _s11_ = "replacement", + t1 = J.getInterceptor$asx($arguments), + selector = A.SassApiValue_assertSelector0(t1.$index($arguments, 0), false, _s8_); + selector.assertNotBogus$1$name(_s8_); + target = A.SassApiValue_assertSelector0(t1.$index($arguments, 1), false, _s8_0); + target.assertNotBogus$1$name(_s8_0); + source = A.SassApiValue_assertSelector0(t1.$index($arguments, 2), false, _s11_); + source.assertNotBogus$1$name(_s11_); + t1 = A.EvaluationContext_currentOrNull0(); + return A.ExtensionStore__extendOrReplace0(selector, source, target, B.ExtendMode_replace_replace0, (t1 == null ? A.throwExpression(A.StateError$(string$.No_Sass)) : t1).get$currentCallableSpan()).get$asSassList(); + }, + $signature: 28 + }; + A._unify_closure0.prototype = { + call$1($arguments) { + var selector2, + _s9_ = "selector1", + _s9_0 = "selector2", + t1 = J.getInterceptor$asx($arguments), + selector1 = A.SassApiValue_assertSelector0(t1.$index($arguments, 0), false, _s9_); + selector1.assertNotBogus$1$name(_s9_); + selector2 = A.SassApiValue_assertSelector0(t1.$index($arguments, 1), false, _s9_0); + selector2.assertNotBogus$1$name(_s9_0); + t1 = selector1.unify$1(selector2); + t1 = t1 == null ? null : t1.get$asSassList(); + return t1 == null ? B.C__SassNull0 : t1; + }, + $signature: 3 + }; + A._isSuperselector_closure0.prototype = { + call$1($arguments) { + var selector2, + t1 = J.getInterceptor$asx($arguments), + selector1 = A.SassApiValue_assertSelector0(t1.$index($arguments, 0), false, "super"); + selector1.assertNotBogus$1$name("super"); + selector2 = A.SassApiValue_assertSelector0(t1.$index($arguments, 1), false, "sub"); + selector2.assertNotBogus$1$name("sub"); + return A.listIsSuperselector0(selector1.components, selector2.components) ? B.SassBoolean_true0 : B.SassBoolean_false0; + }, + $signature: 11 + }; + A._simpleSelectors_closure0.prototype = { + call$1($arguments) { + var t1 = A.SassApiValue_assertCompoundSelector0(J.$index$asx($arguments, 0), "selector").components; + return A.SassList$0(new A.MappedListIterable(t1, new A._simpleSelectors__closure0(), A._arrayInstanceType(t1)._eval$1("MappedListIterable<1,Value0>")), B.ListSeparator_qVN0, false); + }, + $signature: 28 + }; + A._simpleSelectors__closure0.prototype = { + call$1(simple) { + return new A.SassString0(A.serializeSelector0(simple, true), false); + }, + $signature: 571 + }; + A._parse_closure0.prototype = { + call$1($arguments) { + return A.SassApiValue_assertSelector0(J.$index$asx($arguments, 0), false, "selector").get$asSassList(); + }, + $signature: 28 + }; + A.SelectorParser0.prototype = { + parse$0(_) { + return this.wrapSpanFormatException$1(new A.SelectorParser_parse_closure0(this)); + }, + parseCompoundSelector$0() { + return this.wrapSpanFormatException$1(new A.SelectorParser_parseCompoundSelector_closure0(this)); + }, + _selector$_selectorList$0() { + var t4, t5, lineBreak, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + t3 = t1._sourceFile, + previousLine = t3.getLine$1(t2), + components = A._setArrayType([_this._selector$_complexSelector$0()], type$.JSArray_ComplexSelector_2); + _this.whitespace$1$consumeNewlines(true); + for (t4 = t1.string.length; t1.scanChar$1(44);) { + _this.whitespace$1$consumeNewlines(true); + if (t1.peekChar$0() === 44) + continue; + t5 = t1._string_scanner$_position; + if (t5 === t4) + break; + lineBreak = t3.getLine$1(t5) !== previousLine; + if (lineBreak) + previousLine = t3.getLine$1(t1._string_scanner$_position); + components.push(_this._selector$_complexSelector$1$lineBreak(lineBreak)); + } + return A.SelectorList$0(components, _this.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + _selector$_complexSelector$1$lineBreak(lineBreak) { + var t4, lastCompound, initialCombinators, _0_0, t5, result, _this = this, + _s18_ = "expected selector.", + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + componentStart = new A._SpanScannerState(t1, t2), + t3 = type$.JSArray_CssValue_Combinator_2, + combinators = A._setArrayType([], t3), + components = A._setArrayType([], type$.JSArray_ComplexSelectorComponent_2); + for (t4 = type$.CssValue_Combinator_2, lastCompound = null, initialCombinators = null; true;) { + _this.whitespace$1$consumeNewlines(true); + _0_0 = t1.peekChar$0(); + if (43 === _0_0) { + t5 = t1._string_scanner$_position; + t1.readChar$0(); + combinators.push(new A.CssValue0(B.Combinator_bOP0, _this.spanFrom$1(new A._SpanScannerState(t1, t5)), t4)); + continue; + } + if (62 === _0_0) { + t5 = t1._string_scanner$_position; + t1.readChar$0(); + combinators.push(new A.CssValue0(B.Combinator_0mp0, _this.spanFrom$1(new A._SpanScannerState(t1, t5)), t4)); + continue; + } + if (126 === _0_0) { + t5 = t1._string_scanner$_position; + t1.readChar$0(); + combinators.push(new A.CssValue0(B.Combinator_55N0, _this.spanFrom$1(new A._SpanScannerState(t1, t5)), t4)); + continue; + } + if (_0_0 == null) + break; + t5 = true; + if (91 !== _0_0) + if (46 !== _0_0) + if (35 !== _0_0) + if (37 !== _0_0) + if (58 !== _0_0) + if (38 !== _0_0) + if (42 !== _0_0) + if (124 !== _0_0) + t5 = _this.lookingAtIdentifier$0(); + if (t5) { + if (lastCompound != null) { + t5 = _this.spanFrom$1(componentStart); + result = A.List_List$from(combinators, false, t4); + result.$flags = 3; + components.push(new A.ComplexSelectorComponent0(lastCompound, result, t5)); + } else if (combinators.length !== 0) { + componentStart = new A._SpanScannerState(t1, t1._string_scanner$_position); + initialCombinators = combinators; + } + lastCompound = _this._selector$_compoundSelector$0(); + combinators = A._setArrayType([], t3); + if (t1.peekChar$0() === 38) + t1.error$1(0, string$.x22x26__ma); + continue; + } + break; + } + t3 = combinators.length !== 0; + if (t3 && _this._selector$_plainCss) + t1.error$1(0, _s18_); + else if (lastCompound != null) { + t3 = _this.spanFrom$1(componentStart); + components.push(new A.ComplexSelectorComponent0(lastCompound, A.List_List$unmodifiable(combinators, t4), t3)); + } else if (t3) + initialCombinators = combinators; + else + t1.error$1(0, _s18_); + t3 = initialCombinators == null ? B.List_empty14 : initialCombinators; + return A.ComplexSelector$0(t3, components, _this.spanFrom$1(new A._SpanScannerState(t1, t2)), lineBreak); + }, + _selector$_complexSelector$0() { + return this._selector$_complexSelector$1$lineBreak(false); + }, + _selector$_compoundSelector$0() { + var t3, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + components = A._setArrayType([_this._selector$_simpleSelector$0()], type$.JSArray_SimpleSelector_2); + for (t3 = _this._selector$_plainCss; _this._selector$_isSimpleSelectorStart$1(t1.peekChar$0());) + components.push(_this._selector$_simpleSelector$1$allowParent(t3)); + return A.CompoundSelector$0(components, _this.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + _selector$_simpleSelector$1$allowParent(allowParent) { + var t2, $name, text, t3, suffix, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + if (allowParent == null) + allowParent = _this._selector$_allowParent; + switch (t1.peekChar$0()) { + case 91: + return _this._selector$_attributeSelector$0(); + case 46: + t2 = t1._string_scanner$_position; + t1.expectChar$1(46); + return new A.ClassSelector0(_this.identifier$0(), _this.spanFrom$1(new A._SpanScannerState(t1, t2))); + case 35: + t2 = t1._string_scanner$_position; + t1.expectChar$1(35); + return new A.IDSelector0(_this.identifier$0(), _this.spanFrom$1(new A._SpanScannerState(t1, t2))); + case 37: + t2 = t1._string_scanner$_position; + t1.expectChar$1(37); + $name = _this.identifier$0(); + t2 = _this.spanFrom$1(new A._SpanScannerState(t1, t2)); + if (_this._selector$_plainCss) + _this.error$2(0, string$.Placeh, t1.spanFrom$1(start)); + return new A.PlaceholderSelector0($name, t2); + case 58: + return _this._selector$_pseudoSelector$0(); + case 38: + t2 = t1._string_scanner$_position; + t1.expectChar$1(38); + if (_this.lookingAtIdentifierBody$0()) { + text = new A.StringBuffer(""); + _this._parser1$_identifierBody$1(text); + if (text._contents.length === 0) + t1.error$1(0, "Expected identifier body."); + t3 = text._contents; + suffix = t3.charCodeAt(0) == 0 ? t3 : t3; + } else + suffix = null; + if (_this._selector$_plainCss && suffix != null) + t1.error$3$length$position(0, string$.Parent, t1._string_scanner$_position - t2, t2); + t2 = _this.spanFrom$1(new A._SpanScannerState(t1, t2)); + if (!allowParent) + _this.error$2(0, "Parent selectors aren't allowed here.", t1.spanFrom$1(start)); + return new A.ParentSelector0(suffix, t2); + default: + return _this._selector$_typeOrUniversalSelector$0(); + } + }, + _selector$_simpleSelector$0() { + return this._selector$_simpleSelector$1$allowParent(null); + }, + _selector$_attributeSelector$0() { + var $name, operator, next, value, modifier, _this = this, _null = null, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expectChar$1(91); + _this.whitespace$1$consumeNewlines(true); + $name = _this._selector$_attributeName$0(); + _this.whitespace$1$consumeNewlines(true); + if (t1.scanChar$1(93)) + return new A.AttributeSelector0($name, _null, _null, _null, _this.spanFrom$1(start)); + operator = _this._selector$_attributeOperator$0(); + _this.whitespace$1$consumeNewlines(true); + next = t1.peekChar$0(); + value = next === 39 || next === 34 ? _this.string$0() : _this.identifier$0(); + _this.whitespace$1$consumeNewlines(true); + next = t1.peekChar$0(); + modifier = next != null && A.CharacterExtension_get_isAlphabetic0(next) ? A.Primitives_stringFromCharCode(t1.readChar$0()) : _null; + t1.expectChar$1(93); + return new A.AttributeSelector0($name, operator, value, modifier, _this.spanFrom$1(start)); + }, + _selector$_attributeName$0() { + var nameOrNamespace, _this = this, + t1 = _this.scanner; + if (t1.scanChar$1(42)) { + t1.expectChar$1(124); + return new A.QualifiedName0(_this.identifier$0(), "*"); + } + if (t1.scanChar$1(124)) + return new A.QualifiedName0(_this.identifier$0(), ""); + nameOrNamespace = _this.identifier$0(); + if (t1.peekChar$0() !== 124 || t1.peekChar$1(1) === 61) + return new A.QualifiedName0(nameOrNamespace, null); + t1.readChar$0(); + return new A.QualifiedName0(_this.identifier$0(), nameOrNamespace); + }, + _selector$_attributeOperator$0() { + var t1 = this.scanner, + t2 = t1._string_scanner$_position; + switch (t1.readChar$0()) { + case 61: + return B.AttributeOperator_Lvy0; + case 126: + t1.expectChar$1(61); + return B.AttributeOperator_fp20; + case 124: + t1.expectChar$1(61); + return B.AttributeOperator_iyP0; + case 94: + t1.expectChar$1(61); + return B.AttributeOperator_JzP0; + case 36: + t1.expectChar$1(61); + return B.AttributeOperator_U1W0; + case 42: + t1.expectChar$1(61); + return B.AttributeOperator_GWq0; + default: + t1.error$2$position(0, 'Expected "]".', t2); + } + }, + _selector$_pseudoSelector$0() { + var element, $name, unvendored, argument, selector, t2, _this = this, _null = null, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expectChar$1(58); + element = t1.scanChar$1(58); + $name = _this.identifier$0(); + if (!t1.scanChar$1(40)) + return A.PseudoSelector$0($name, _this.spanFrom$1(start), _null, element, _null); + _this.whitespace$1$consumeNewlines(true); + unvendored = A.unvendor0($name); + argument = _null; + selector = _null; + if (element) + if ($._selectorPseudoElements0.contains$1(0, unvendored)) + selector = _this._selector$_selectorList$0(); + else + argument = _this.declarationValue$1$allowEmpty(true); + else if ($._selectorPseudoClasses0.contains$1(0, unvendored)) + selector = _this._selector$_selectorList$0(); + else if (unvendored === "nth-child" || unvendored === "nth-last-child") { + argument = _this._selector$_aNPlusB$0(); + _this.whitespace$1$consumeNewlines(true); + t2 = t1.peekChar$1(-1); + if ((t2 === 32 || t2 === 9 || t2 === 10 || t2 === 13 || t2 === 12) && t1.peekChar$0() !== 41) { + _this.expectIdentifier$1("of"); + argument += " of"; + _this.whitespace$1$consumeNewlines(true); + selector = _this._selector$_selectorList$0(); + } + } else + argument = B.JSString_methods.trimRight$0(_this.declarationValue$1$allowEmpty(true)); + t1.expectChar$1(41); + return A.PseudoSelector$0($name, _this.spanFrom$1(start), argument, element, selector); + }, + _selector$_aNPlusB$0() { + var t1, _0_0, t2, $self, next, _this = this; + $label0$0: { + t1 = _this.scanner; + _0_0 = t1.peekChar$0(); + if (101 === _0_0 || 69 === _0_0) { + _this.expectIdentifier$1("even"); + return "even"; + } + if (111 === _0_0 || 79 === _0_0) { + _this.expectIdentifier$1("odd"); + return "odd"; + } + if (43 === _0_0 || 45 === _0_0) { + t2 = "" + A.Primitives_stringFromCharCode(t1.readChar$0()); + break $label0$0; + } + t2 = ""; + } + $self = t1.peekChar$0(); + if ($self != null && $self >= 48 && $self <= 57) { + do { + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + $self = t1.peekChar$0(); + } while ($self != null && $self >= 48 && $self <= 57); + _this.whitespace$1$consumeNewlines(true); + if (!_this.scanIdentChar$1(110)) + return t2.charCodeAt(0) == 0 ? t2 : t2; + } else + _this.expectIdentChar$1(110); + t2 += A.Primitives_stringFromCharCode(110); + _this.whitespace$1$consumeNewlines(true); + next = t1.peekChar$0(); + if (next !== 43 && next !== 45) + return t2.charCodeAt(0) == 0 ? t2 : t2; + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + _this.whitespace$1$consumeNewlines(true); + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + t1.error$1(0, "Expected a number."); + do { + t2 += A.Primitives_stringFromCharCode(t1.readChar$0()); + $self = t1.peekChar$0(); + } while ($self != null && $self >= 48 && $self <= 57); + return t2.charCodeAt(0) == 0 ? t2 : t2; + }, + _selector$_typeOrUniversalSelector$0() { + var nameOrNamespace, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + if (t1.scanChar$1(42)) { + if (!t1.scanChar$1(124)) + return new A.UniversalSelector0(null, _this.spanFrom$1(start)); + return t1.scanChar$1(42) ? new A.UniversalSelector0("*", _this.spanFrom$1(start)) : new A.TypeSelector0(new A.QualifiedName0(_this.identifier$0(), "*"), _this.spanFrom$1(start)); + } else if (t1.scanChar$1(124)) + return t1.scanChar$1(42) ? new A.UniversalSelector0("", _this.spanFrom$1(start)) : new A.TypeSelector0(new A.QualifiedName0(_this.identifier$0(), ""), _this.spanFrom$1(start)); + nameOrNamespace = _this.identifier$0(); + if (!t1.scanChar$1(124)) + return new A.TypeSelector0(new A.QualifiedName0(nameOrNamespace, null), _this.spanFrom$1(start)); + else if (t1.scanChar$1(42)) + return new A.UniversalSelector0(nameOrNamespace, _this.spanFrom$1(start)); + else + return new A.TypeSelector0(new A.QualifiedName0(_this.identifier$0(), nameOrNamespace), _this.spanFrom$1(start)); + }, + _selector$_isSimpleSelectorStart$1(character) { + var t1; + $label0$0: { + if (42 === character || 91 === character || 46 === character || 35 === character || 37 === character || 58 === character) { + t1 = true; + break $label0$0; + } + if (38 === character) { + t1 = this._selector$_plainCss; + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + } + }; + A.SelectorParser_parse_closure0.prototype = { + call$0() { + var t1 = this.$this, + selector = t1._selector$_selectorList$0(); + t1 = t1.scanner; + if (t1._string_scanner$_position !== t1.string.length) + t1.error$1(0, "expected selector."); + return selector; + }, + $signature: 572 + }; + A.SelectorParser_parseCompoundSelector_closure0.prototype = { + call$0() { + var t1 = this.$this, + compound = t1._selector$_compoundSelector$0(); + t1 = t1.scanner; + if (t1._string_scanner$_position !== t1.string.length) + t1.error$1(0, "expected selector."); + return compound; + }, + $signature: 573 + }; + A.SelectorSearchVisitor0.prototype = { + visitAttributeSelector$1(attribute) { + return null; + }, + visitClassSelector$1(klass) { + return null; + }, + visitIDSelector$1(id) { + return null; + }, + visitParentSelector$1(placeholder) { + return null; + }, + visitPlaceholderSelector$1(placeholder) { + return null; + }, + visitTypeSelector$1(type) { + return null; + }, + visitUniversalSelector$1(universal) { + return null; + }, + visitComplexSelector$1(complex) { + return A.IterableExtension_search0(complex.components, new A.SelectorSearchVisitor_visitComplexSelector_closure0(this)); + }, + visitCompoundSelector$1(compound) { + return A.IterableExtension_search0(compound.components, new A.SelectorSearchVisitor_visitCompoundSelector_closure0(this)); + }, + visitPseudoSelector$1(pseudo) { + return A.NullableExtension_andThen0(pseudo.selector, this.get$visitSelectorList()); + }, + visitSelectorList$1(list) { + return A.IterableExtension_search0(list.components, this.get$visitComplexSelector()); + } + }; + A.SelectorSearchVisitor_visitComplexSelector_closure0.prototype = { + call$1(component) { + return this.$this.visitCompoundSelector$1(component.selector); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("SelectorSearchVisitor0.T?(ComplexSelectorComponent0)"); + } + }; + A.SelectorSearchVisitor_visitCompoundSelector_closure0.prototype = { + call$1(simple) { + return simple.accept$1(this.$this); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("SelectorSearchVisitor0.T?(SimpleSelector0)"); + } + }; + A.serialize_closure0.prototype = { + call$1(codeUnit) { + return codeUnit > 127; + }, + $signature: 48 + }; + A._SerializeVisitor0.prototype = { + visitCssStylesheet$1(node) { + var t1, t2, t3, t4, t5, t6, t7, previous, previous0, t8, _this = this; + for (t1 = J.get$iterator$ax(node.get$children(node)), t2 = !_this._serialize0$_inspect, t3 = _this._serialize0$_style === B.OutputStyle_10, t4 = !t3, t5 = type$.CssParentNode_2, t6 = _this._serialize0$_buffer, t7 = _this._lineFeed.text, previous = null; t1.moveNext$0();) { + previous0 = t1.get$current(t1); + if (t2) + t8 = t3 ? previous0.accept$1(B._IsInvisibleVisitor_true_true0) : previous0.accept$1(B._IsInvisibleVisitor_true_false0); + else + t8 = false; + if (t8) + continue; + if (previous != null) { + if (t5._is(previous) ? previous.get$isChildless() : !(previous instanceof A.ModifiableCssComment0)) + t6.writeCharCode$1(59); + if (_this._serialize0$_isTrailingComment$2(previous0, previous)) { + if (t4) + t6.writeCharCode$1(32); + } else { + if (t4) + t6.write$1(0, t7); + if (previous.get$isGroupEnd()) + if (t4) + t6.write$1(0, t7); + } + } + previous0.accept$1(_this); + previous = previous0; + } + if (previous != null) + t1 = (t5._is(previous) ? previous.get$isChildless() : !(previous instanceof A.ModifiableCssComment0)) && t4; + else + t1 = false; + if (t1) + t6.writeCharCode$1(59); + }, + visitCssComment$1(node) { + this._serialize0$_buffer.forSpan$2(node.span, new A._SerializeVisitor_visitCssComment_closure0(this, node)); + }, + visitCssAtRule$1(node) { + var t1, _this = this; + _this._serialize0$_writeIndentation$0(); + t1 = _this._serialize0$_buffer; + t1.forSpan$2(node.span, new A._SerializeVisitor_visitCssAtRule_closure0(_this, node)); + if (!node.isChildless) { + if (_this._serialize0$_style !== B.OutputStyle_10) + t1.writeCharCode$1(32); + _this._serialize0$_visitChildren$1(node); + } + }, + visitCssMediaRule$1(node) { + var t1, _this = this; + _this._serialize0$_writeIndentation$0(); + t1 = _this._serialize0$_buffer; + t1.forSpan$2(node.span, new A._SerializeVisitor_visitCssMediaRule_closure0(_this, node)); + if (_this._serialize0$_style !== B.OutputStyle_10) + t1.writeCharCode$1(32); + _this._serialize0$_visitChildren$1(node); + }, + visitCssImport$1(node) { + this._serialize0$_writeIndentation$0(); + this._serialize0$_buffer.forSpan$2(node.span, new A._SerializeVisitor_visitCssImport_closure0(this, node)); + }, + _serialize0$_writeImportUrl$1(url) { + var urlContents, maybeQuote, _this = this; + if (_this._serialize0$_style !== B.OutputStyle_10 || url.charCodeAt(0) !== 117) { + _this._serialize0$_buffer.write$1(0, url); + return; + } + urlContents = B.JSString_methods.substring$2(url, 4, url.length - 1); + maybeQuote = urlContents.charCodeAt(0); + if (maybeQuote === 39 || maybeQuote === 34) + _this._serialize0$_buffer.write$1(0, urlContents); + else + _this._serialize0$_visitQuotedString$1(urlContents); + }, + visitCssKeyframeBlock$1(node) { + var t1, _this = this; + _this._serialize0$_writeIndentation$0(); + t1 = _this._serialize0$_buffer; + t1.forSpan$2(node.selector.span, new A._SerializeVisitor_visitCssKeyframeBlock_closure0(_this, node)); + if (_this._serialize0$_style !== B.OutputStyle_10) + t1.writeCharCode$1(32); + _this._serialize0$_visitChildren$1(node); + }, + _serialize0$_visitMediaQuery$1(query) { + var t1, _1_0, _2_0, condition, operator, t2, _this = this, + _0_0 = query.modifier; + if (_0_0 != null) { + t1 = _this._serialize0$_buffer; + t1.write$1(0, _0_0); + t1.writeCharCode$1(32); + } + _1_0 = query.type; + if (_1_0 != null) { + t1 = _this._serialize0$_buffer; + t1.write$1(0, _1_0); + if (query.conditions.length !== 0) + t1.write$1(0, " and "); + } + _2_0 = query.conditions; + if (_2_0.length === 1) + t1 = B.JSString_methods.startsWith$1(_2_0[0], "(not "); + else + t1 = false; + if (t1) { + t1 = _this._serialize0$_buffer; + t1.write$1(0, "not "); + condition = B.JSArray_methods.get$first(_2_0); + t1.write$1(0, B.JSString_methods.substring$2(condition, 5, condition.length - 1)); + } else { + operator = query.conjunction ? "and" : "or"; + t1 = _this._serialize0$_style === B.OutputStyle_10 ? operator + " " : " " + operator + " "; + t2 = _this._serialize0$_buffer; + _this._serialize0$_writeBetween$3(_2_0, t1, t2.get$write(t2)); + } + }, + visitCssStyleRule$1(node) { + var t1, _this = this; + _this._serialize0$_writeIndentation$0(); + t1 = _this._serialize0$_buffer; + t1.forSpan$2(node._style_rule0$_selector._box0$_inner.value.span, new A._SerializeVisitor_visitCssStyleRule_closure0(_this, node)); + if (_this._serialize0$_style !== B.OutputStyle_10) + t1.writeCharCode$1(32); + _this._serialize0$_visitChildren$1(node); + }, + visitCssSupportsRule$1(node) { + var t1, _this = this; + _this._serialize0$_writeIndentation$0(); + t1 = _this._serialize0$_buffer; + t1.forSpan$2(node.span, new A._SerializeVisitor_visitCssSupportsRule_closure0(_this, node)); + if (_this._serialize0$_style !== B.OutputStyle_10) + t1.writeCharCode$1(32); + _this._serialize0$_visitChildren$1(node); + }, + visitCssDeclaration$1(node) { + var error, stackTrace, error0, stackTrace0, t3, declSpecificities, t4, t5, t6, t7, _i, rule, ruleSpecificities, exception, _this = this, + t1 = node.interleavedRules, + t2 = t1.length; + if (t2 !== 0) { + t3 = node._node$_parent; + t3.toString; + declSpecificities = _this._serialize0$_specificities$1(t3); + for (t3 = _this._serialize0$_logger, t4 = node.span, t5 = type$.SourceSpan, t6 = type$.String, t7 = node.trace, _i = 0; _i < t2; ++_i) { + rule = t1[_i]; + ruleSpecificities = _this._serialize0$_specificities$1(rule); + if (!declSpecificities.any$1(0, ruleSpecificities.get$contains(ruleSpecificities))) + continue; + A.WarnForDeprecation_warnForDeprecation0(t3, B.Deprecation_MSr, string$.Sassx27s, new A.MultiSpan0(t4, "declaration", A.ConstantMap_ConstantMap$from(A.LinkedHashMap_LinkedHashMap$_literal([rule.span, "nested rule"], t5, t6), t5, t6)), t7); + } + } + _this._serialize0$_writeIndentation$0(); + t1 = node.name; + _this._serialize0$_write$1(t1); + t2 = _this._serialize0$_buffer; + t2.writeCharCode$1(58); + if (J.startsWith$1$s(t1.value, "--") && node.parsedAsCustomProperty) + t2.forSpan$2(node.value.span, new A._SerializeVisitor_visitCssDeclaration_closure1(_this, node)); + else { + if (_this._serialize0$_style !== B.OutputStyle_10) + t2.writeCharCode$1(32); + try { + t2.forSpan$2(node.valueSpanForMap, new A._SerializeVisitor_visitCssDeclaration_closure2(_this, node)); + } catch (exception) { + t1 = A.unwrapException(exception); + if (t1 instanceof A.MultiSpanSassScriptException0) { + error = t1; + stackTrace = A.getTraceFromException(exception); + A.throwWithTrace0(A.MultiSpanSassException$0(error.message, node.value.span, error.primaryLabel, error.secondarySpans, null), error, stackTrace); + } else if (t1 instanceof A.SassScriptException0) { + error0 = t1; + stackTrace0 = A.getTraceFromException(exception); + t1 = error0.message; + A.throwWithTrace0(new A.SassException0(B.Set_empty, t1, node.value.span), error0, stackTrace0); + } else + throw exception; + } + } + }, + _serialize0$_specificities$1(node) { + var $parent, t2, t3, _i, + t1 = this.get$_serialize0$_specificities(); + if (node instanceof A.ModifiableCssStyleRule0) { + t1 = A.NullableExtension_andThen0(node._node$_parent, t1); + $parent = t1 == null ? null : A.IterableIntegerExtension_get_max(t1); + if ($parent == null) + $parent = 0; + t1 = A.LinkedHashSet_LinkedHashSet$_empty(type$.int); + for (t2 = node._style_rule0$_selector._box0$_inner.value.components, t3 = t2.length, _i = 0; _i < t3; ++_i) + t1.add$1(0, $parent + t2[_i].get$specificity()); + return t1; + } else { + t1 = A.NullableExtension_andThen0(node.get$parent(node), t1); + return t1 == null ? B.Set_WDSXk : t1; + } + }, + _serialize0$_writeFoldedValue$1(node) { + var t1, t2, next, t3, + scanner = A.StringScanner$(type$.SassString_2._as(node.value.value)._string0$_text, null, null); + for (t1 = scanner.string.length, t2 = this._serialize0$_buffer; scanner._string_scanner$_position !== t1;) { + next = scanner.readChar$0(); + if (next !== 10) { + t2.writeCharCode$1(next); + continue; + } + t2.writeCharCode$1(32); + while (true) { + t3 = scanner.peekChar$0(); + if (!(t3 === 32 || t3 === 9 || t3 === 10 || t3 === 13 || t3 === 12)) + break; + scanner.readChar$0(); + } + } + }, + _serialize0$_writeReindentedValue$1(node) { + var _0_0, t1, _this = this, + value = type$.SassString_2._as(node.value.value)._string0$_text; + $label0$0: { + _0_0 = _this._serialize0$_minimumIndentation$1(value); + if (_0_0 == null) { + _this._serialize0$_buffer.write$1(0, value); + break $label0$0; + } + if (-1 === _0_0) { + t1 = _this._serialize0$_buffer; + t1.write$1(0, A.trimAsciiRight0(value, true)); + t1.writeCharCode$1(32); + break $label0$0; + } + t1 = node.name.span; + t1 = t1.get$start(t1); + _this._serialize0$_writeWithIndent$2(value, Math.min(_0_0, t1.file.getColumn$1(t1.offset))); + } + }, + _serialize0$_minimumIndentation$1(text) { + var character, t2, min, next, min0, + scanner = A.LineScanner$(text), + t1 = scanner.string.length; + while (true) { + if (scanner._string_scanner$_position !== t1) { + character = scanner.super$StringScanner$readChar(); + scanner._adjustLineAndColumn$1(character); + t2 = character !== 10; + } else + t2 = false; + if (!t2) + break; + } + if (scanner._string_scanner$_position === t1) + return scanner.peekChar$1(-1) === 10 ? -1 : null; + for (min = null; scanner._string_scanner$_position !== t1;) { + for (; scanner._string_scanner$_position !== t1;) { + next = scanner.peekChar$0(); + if (next !== 32 && next !== 9) + break; + scanner._adjustLineAndColumn$1(scanner.super$StringScanner$readChar()); + } + if (scanner._string_scanner$_position === t1 || scanner.scanChar$1(10)) + continue; + min0 = scanner._line_scanner$_column; + min = min == null ? min0 : Math.min(min, min0); + while (true) { + if (scanner._string_scanner$_position !== t1) { + character = scanner.super$StringScanner$readChar(); + scanner._adjustLineAndColumn$1(character); + t2 = character !== 10; + } else + t2 = false; + if (!t2) + break; + } + } + return min == null ? -1 : min; + }, + _serialize0$_writeWithIndent$2(text, minimumIndentation) { + var t1, t2, t3, character, lineStart, newlines, end, + scanner = A.LineScanner$(text); + for (t1 = scanner.string, t2 = t1.length, t3 = this._serialize0$_buffer; scanner._string_scanner$_position !== t2;) { + character = scanner.super$StringScanner$readChar(); + scanner._adjustLineAndColumn$1(character); + if (character === 10) + break; + t3.writeCharCode$1(character); + } + for (; true;) { + lineStart = scanner._string_scanner$_position; + for (newlines = 1; true;) { + if (scanner._string_scanner$_position === t2) { + t3.writeCharCode$1(32); + return; + } + $label0$2: { + character = scanner.super$StringScanner$readChar(); + scanner._adjustLineAndColumn$1(character); + if (32 === character || 9 === character) + continue; + if (10 === character) { + lineStart = scanner._string_scanner$_position; + ++newlines; + break $label0$2; + } + break; + } + } + this._serialize0$_writeTimes$2(10, newlines); + this._serialize0$_writeIndentation$0(); + end = scanner._string_scanner$_position; + t3.write$1(0, B.JSString_methods.substring$2(t1, lineStart + minimumIndentation, end)); + for (; true;) { + if (scanner._string_scanner$_position === t2) + return; + character = scanner.super$StringScanner$readChar(); + scanner._adjustLineAndColumn$1(character); + if (character === 10) + break; + t3.writeCharCode$1(character); + } + } + }, + visitCalculation$1(value) { + var t2, _this = this, + t1 = _this._serialize0$_buffer; + t1.write$1(0, value.name); + t1.writeCharCode$1(40); + t2 = _this._serialize0$_style === B.OutputStyle_10 ? "," : ", "; + _this._serialize0$_writeBetween$3(value.$arguments, t2, _this.get$_serialize0$_writeCalculationValue()); + t1.writeCharCode$1(41); + }, + _serialize0$_writeCalculationValue$1(value) { + var _2_4_isSet, _2_4, t1, _0_0, _1_0, first, rest, left, right, operator, parenthesizeLeft, operatorWhitespace, parenthesizeRight, t2, _this = this, _null = null; + $label1$1: { + _2_4_isSet = value instanceof A.SassNumber0; + if (_2_4_isSet) { + _2_4 = value.get$hasComplexUnits(); + t1 = _2_4 && !_this._serialize0$_inspect; + } else { + _2_4 = _null; + t1 = false; + } + if (t1) + throw A.wrapException(A.SassScriptException$0(A.S(value) + " isn't a valid CSS value.", _null)); + if (_2_4_isSet && !isFinite(value._number1$_value)) { + $label0$0: { + _0_0 = value._number1$_value; + if (1 / 0 === _0_0) { + _this._serialize0$_buffer.write$1(0, "infinity"); + break $label0$0; + } + if (-1 / 0 === _0_0) { + _this._serialize0$_buffer.write$1(0, "-infinity"); + break $label0$0; + } + if (isNaN(_0_0)) + _this._serialize0$_buffer.write$1(0, "NaN"); + } + t1 = J.getInterceptor$x(value); + _this._serialize0$_writeCalculationUnits$2(t1.get$numeratorUnits(value), t1.get$denominatorUnits(value)); + break $label1$1; + } + if (_2_4_isSet) + t1 = _2_4; + else + t1 = false; + if (t1) { + _this._serialize0$_writeNumber$1(value._number1$_value); + t1 = J.getInterceptor$x(value); + _1_0 = t1.get$numeratorUnits(value); + if (_1_0.length >= 1) { + first = _1_0[0]; + rest = B.JSArray_methods.sublist$1(_1_0, 1); + _this._serialize0$_buffer.write$1(0, first); + _this._serialize0$_writeCalculationUnits$2(rest, t1.get$denominatorUnits(value)); + } else + _this._serialize0$_writeCalculationUnits$2(A._setArrayType([], type$.JSArray_String), t1.get$denominatorUnits(value)); + break $label1$1; + } + if (value instanceof A.Value0) { + value.accept$1(_this); + break $label1$1; + } + t1 = value instanceof A.CalculationOperation0; + left = _null; + right = _null; + if (t1) { + operator = value._calculation0$_operator; + left = value._calculation0$_left; + right = value._calculation0$_right; + right = right; + } else + operator = _null; + if (t1) { + parenthesizeLeft = left instanceof A.CalculationOperation0 && left._calculation0$_operator.precedence < operator.precedence; + if (parenthesizeLeft) + _this._serialize0$_buffer.writeCharCode$1(40); + _this._serialize0$_writeCalculationValue$1(left); + if (parenthesizeLeft) + _this._serialize0$_buffer.writeCharCode$1(41); + operatorWhitespace = _this._serialize0$_style !== B.OutputStyle_10 || operator.precedence === 1; + if (operatorWhitespace) + _this._serialize0$_buffer.writeCharCode$1(32); + t1 = _this._serialize0$_buffer; + t1.write$1(0, operator.operator); + if (operatorWhitespace) + t1.writeCharCode$1(32); + if (!(right instanceof A.CalculationOperation0 && _this._serialize0$_parenthesizeCalculationRhs$2(operator, right._calculation0$_operator))) { + parenthesizeRight = false; + if (operator === B.CalculationOperator_bo50) { + if (right instanceof A.SassNumber0) + t2 = isFinite(right._number1$_value) ? right.get$hasComplexUnits() : right.get$hasUnits(); + else + t2 = parenthesizeRight; + parenthesizeRight = t2; + } + } else + parenthesizeRight = true; + if (parenthesizeRight) + t1.writeCharCode$1(40); + _this._serialize0$_writeCalculationValue$1(right); + if (parenthesizeRight) + t1.writeCharCode$1(41); + } + } + }, + _serialize0$_writeCalculationUnits$2(numeratorUnits, denominatorUnits) { + var t1, t2, t3, t4; + for (t1 = J.get$iterator$ax(numeratorUnits), t2 = this._serialize0$_buffer, t3 = this._serialize0$_style !== B.OutputStyle_10; t1.moveNext$0();) { + t4 = t1.get$current(t1); + if (t3) + t2.writeCharCode$1(32); + t2.writeCharCode$1(42); + if (t3) + t2.writeCharCode$1(32); + t2.writeCharCode$1(49); + t2.write$1(0, t4); + } + for (t1 = J.get$iterator$ax(denominatorUnits); t1.moveNext$0();) { + t4 = t1.get$current(t1); + if (t3) + t2.writeCharCode$1(32); + t2.writeCharCode$1(47); + if (t3) + t2.writeCharCode$1(32); + t2.writeCharCode$1(49); + t2.write$1(0, t4); + } + }, + _serialize0$_parenthesizeCalculationRhs$2(outer, right) { + var t1; + $label0$0: { + if (B.CalculationOperator_bo50 === outer) { + t1 = true; + break $label0$0; + } + if (B.CalculationOperator_F7i0 === outer) { + t1 = false; + break $label0$0; + } + t1 = right === B.CalculationOperator_F7i0 || right === B.CalculationOperator_oum0; + break $label0$0; + } + return t1; + }, + visitColor$1(value) { + var _0_0, _0_2, _0_6, t1, _0_4, _0_6_isSet, t2, _0_10_isSet, _0_10, _0_12_isSet, _0_14, _0_12, _0_14_isSet, t3, _0_10_isSet0, polar, t4, t5, _this = this, _null = null; + $label0$0: { + _0_0 = value._color0$_space; + _0_2 = B.RgbColorSpace_i0P0 === _0_0; + _0_6 = _null; + t1 = true; + if (!_0_2) { + _0_4 = B.HslColorSpace_JQ20 === _0_0; + _0_6_isSet = !_0_4; + if (_0_6_isSet) { + _0_6 = B.HwbColorSpace_guQ0 === _0_0; + t1 = _0_6; + } + } else { + _0_4 = _null; + _0_6_isSet = false; + } + if (t1 && value.channel0OrNull != null && value.channel1OrNull != null && value.channel2OrNull != null && value.alphaOrNull != null) { + _this._serialize0$_writeLegacyColor$1(value); + break $label0$0; + } + if (_0_2) { + t1 = _this._serialize0$_buffer; + t1.write$1(0, "rgb("); + _this._serialize0$_writeChannel$1(value.channel0OrNull); + t1.writeCharCode$1(32); + _this._serialize0$_writeChannel$1(value.channel1OrNull); + t1.writeCharCode$1(32); + _this._serialize0$_writeChannel$1(value.channel2OrNull); + _this._serialize0$_maybeWriteSlashAlpha$1(value); + t1.writeCharCode$1(41); + break $label0$0; + } + if (!_0_4) + t1 = _0_6_isSet ? _0_6 : B.HwbColorSpace_guQ0 === _0_0; + else + t1 = true; + if (t1) { + t1 = _this._serialize0$_buffer; + t1.write$1(0, _0_0); + t1.writeCharCode$1(40); + t2 = _this._serialize0$_style === B.OutputStyle_10 ? _null : "deg"; + _this._serialize0$_writeChannel$2(value.channel0OrNull, t2); + t1.writeCharCode$1(32); + _this._serialize0$_writeChannel$2(value.channel1OrNull, "%"); + t1.writeCharCode$1(32); + _this._serialize0$_writeChannel$2(value.channel2OrNull, "%"); + _this._serialize0$_maybeWriteSlashAlpha$1(value); + t1.writeCharCode$1(41); + break $label0$0; + } + _0_10_isSet = B.LabColorSpace_2nT0 !== _0_0; + if (_0_10_isSet) { + _0_10 = B.LchColorSpace_Bpv0 === _0_0; + t1 = _0_10; + } else { + _0_10 = _null; + t1 = true; + } + t2 = false; + if (t1) + if (!_this._serialize0$_inspect) { + t1 = value.channel0OrNull; + if (t1 == null) + t1 = 0; + if (t1 > 0 || A.fuzzyEquals0(t1, 0)) + t1 = t1 < 100 || A.fuzzyEquals0(t1, 100); + else + t1 = false; + t1 = !t1 && value.channel1OrNull != null && value.channel2OrNull != null; + } else + t1 = t2; + else + t1 = t2; + _0_12_isSet = !t1; + _0_14 = _null; + if (_0_12_isSet) { + _0_12 = B.OklabColorSpace_5400 === _0_0; + t1 = false; + _0_14_isSet = !_0_12; + if (_0_14_isSet) { + _0_14 = B.OklchColorSpace_9Gj0 === _0_0; + t2 = _0_14; + } else + t2 = true; + t3 = false; + if (t2) + if (!_this._serialize0$_inspect) { + t2 = value.channel0OrNull; + if (t2 == null) + t2 = 0; + if (t2 > 0 || A.fuzzyEquals0(t2, 0)) + t2 = t2 < 1 || A.fuzzyEquals0(t2, 1); + else + t2 = false; + t2 = !t2 && value.channel1OrNull != null && value.channel2OrNull != null; + } else + t2 = t3; + else + t2 = t3; + if (!t2) { + if (_0_10_isSet) { + t2 = _0_10; + _0_10_isSet0 = _0_10_isSet; + } else { + _0_10 = B.LchColorSpace_Bpv0 === _0_0; + t2 = _0_10; + _0_10_isSet0 = true; + } + if (!t2) + if (_0_14_isSet) + t2 = _0_14; + else { + _0_14 = B.OklchColorSpace_9Gj0 === _0_0; + t2 = _0_14; + _0_14_isSet = true; + } + else + t2 = true; + if (t2) + if (!_this._serialize0$_inspect) { + t1 = value.channel1OrNull; + t2 = t1 == null; + if (t2) + t1 = 0; + t1 = t1 < 0 && !A.fuzzyEquals0(t1, 0) && value.channel0OrNull != null && !t2; + } + } else { + _0_10_isSet0 = _0_10_isSet; + t1 = true; + } + } else { + _0_12 = _null; + _0_10_isSet0 = _0_10_isSet; + _0_14_isSet = false; + t1 = true; + } + if (t1) { + t1 = _this._serialize0$_buffer; + t1.write$1(0, "color-mix(in "); + t1.write$1(0, _0_0); + t2 = _this._serialize0$_style === B.OutputStyle_10; + t1.write$1(0, t2 ? "," : ", "); + _this._serialize0$_writeColorFunction$1(value.toSpace$1(B.XyzD65ColorSpace_WiJ0)); + if (!t2) + t1.writeCharCode$1(32); + t1.write$1(0, "100%"); + t1.write$1(0, t2 ? "," : ", "); + t1.write$1(0, t2 ? "red" : "black"); + t1.writeCharCode$1(41); + break $label0$0; + } + t1 = true; + if (_0_10_isSet) + if (!(_0_12_isSet ? _0_12 : B.OklabColorSpace_5400 === _0_0)) + if (!(_0_10_isSet0 ? _0_10 : B.LchColorSpace_Bpv0 === _0_0)) + t1 = _0_14_isSet ? _0_14 : B.OklchColorSpace_9Gj0 === _0_0; + if (t1) { + t1 = _this._serialize0$_buffer; + t1.write$1(0, _0_0); + t1.writeCharCode$1(40); + t2 = _0_0._space$_channels; + polar = t2[2].isPolarAngle; + t3 = false; + if (!_this._serialize0$_inspect) { + t4 = value.channel0OrNull; + if (t4 == null) + t4 = 0; + if (t4 > 0 || A.fuzzyEquals0(t4, 0)) + t4 = t4 < 100 || A.fuzzyEquals0(t4, 100); + else + t4 = false; + if (t4) { + if (polar) { + t3 = value.channel1OrNull; + if (t3 == null) + t3 = 0; + t3 = t3 < 0 && !A.fuzzyEquals0(t3, 0); + } + } else + t3 = true; + } + if (t3) { + t1.write$1(0, "from "); + t1.write$1(0, _this._serialize0$_style === B.OutputStyle_10 ? "red" : "black"); + t1.writeCharCode$1(32); + } + t3 = _this._serialize0$_style !== B.OutputStyle_10; + t4 = t3 && value.channel0OrNull != null; + t5 = value.channel0OrNull; + if (t4) { + t2 = type$.LinearChannel_2._as(t2[0]); + _this._serialize0$_writeNumber$1((t5 == null ? 0 : t5) * 100 / t2.max); + t1.writeCharCode$1(37); + } else + _this._serialize0$_writeChannel$1(t5); + t1.writeCharCode$1(32); + _this._serialize0$_writeChannel$1(value.channel1OrNull); + t1.writeCharCode$1(32); + t2 = polar && t3 ? "deg" : _null; + _this._serialize0$_writeChannel$2(value.channel2OrNull, t2); + _this._serialize0$_maybeWriteSlashAlpha$1(value); + t1.writeCharCode$1(41); + break $label0$0; + } + _this._serialize0$_writeColorFunction$1(value); + } + }, + _serialize0$_writeChannel$2(channel, unit) { + var _this = this; + if (channel == null) + _this._serialize0$_buffer.write$1(0, "none"); + else if (isFinite(channel)) { + _this._serialize0$_writeNumber$1(channel); + if (unit != null) + _this._serialize0$_buffer.write$1(0, unit); + } else + _this.visitNumber$1(A.SassNumber_SassNumber0(channel, unit)); + }, + _serialize0$_writeChannel$1(channel) { + return this._serialize0$_writeChannel$2(channel, null); + }, + _serialize0$_writeLegacyColor$1(color) { + var rgb, t3, red, green, blue, hsl, hue, saturation, lightness, hwb, _0_0, format, _1_0, _this = this, + t1 = color.alphaOrNull, + t2 = t1 == null, + opaque = A.fuzzyEquals0(t2 ? 0 : t1, 1); + if (!color.get$isInGamut() && !_this._serialize0$_inspect) { + _this._serialize0$_writeHsl$1(color); + return; + } + if (_this._serialize0$_style === B.OutputStyle_10) { + rgb = color.toSpace$1(B.RgbColorSpace_i0P0); + if (opaque && _this._serialize0$_tryIntegerRgb$1(rgb)) + return; + t3 = rgb.channel0OrNull; + red = _this._serialize0$_writeNumberToString$1(t3 == null ? 0 : t3); + t3 = rgb.channel1OrNull; + green = _this._serialize0$_writeNumberToString$1(t3 == null ? 0 : t3); + t3 = rgb.channel2OrNull; + blue = _this._serialize0$_writeNumberToString$1(t3 == null ? 0 : t3); + hsl = color.toSpace$1(B.HslColorSpace_JQ20); + t3 = hsl.channel0OrNull; + hue = _this._serialize0$_writeNumberToString$1(t3 == null ? 0 : t3); + t3 = hsl.channel1OrNull; + saturation = _this._serialize0$_writeNumberToString$1(t3 == null ? 0 : t3); + t3 = hsl.channel2OrNull; + lightness = _this._serialize0$_writeNumberToString$1(t3 == null ? 0 : t3); + t3 = _this._serialize0$_buffer; + if (red.length + green.length + blue.length <= hue.length + saturation.length + lightness.length + 2) { + t3.write$1(0, opaque ? "rgb(" : "rgba("); + t3.write$1(0, red); + t3.writeCharCode$1(44); + t3.write$1(0, green); + t3.writeCharCode$1(44); + t3.write$1(0, blue); + } else { + t3.write$1(0, opaque ? "hsl(" : "hsla("); + t3.write$1(0, hue); + t3.writeCharCode$1(44); + t3.write$1(0, saturation); + t3.write$1(0, "%,"); + t3.write$1(0, lightness); + t3.writeCharCode$1(37); + } + if (!opaque) { + t3.writeCharCode$1(44); + _this._serialize0$_writeNumber$1(t2 ? 0 : t1); + } + t3.writeCharCode$1(41); + return; + } + t3 = color._color0$_space; + if (t3 === B.HslColorSpace_JQ20) { + _this._serialize0$_writeHsl$1(color); + return; + } else if (_this._serialize0$_inspect && t3 === B.HwbColorSpace_guQ0) { + t3 = _this._serialize0$_buffer; + t3.write$1(0, "hwb("); + hwb = color.toSpace$1(B.HwbColorSpace_guQ0); + _this._serialize0$_writeNumber$1(hwb.channel$1(0, "hue")); + t3.writeCharCode$1(32); + _this._serialize0$_writeNumber$1(hwb.channel$1(0, "whiteness")); + t3.writeCharCode$1(37); + t3.writeCharCode$1(32); + _this._serialize0$_writeNumber$1(hwb.channel$1(0, "blackness")); + t3.writeCharCode$1(37); + if (!A.fuzzyEquals0(t2 ? 0 : t1, 1)) { + t3.write$1(0, " / "); + _this._serialize0$_writeNumber$1(t2 ? 0 : t1); + } + t3.writeCharCode$1(41); + return; + } + _0_0 = color.format; + if (B.C__ColorFormatEnum0 === _0_0) { + _this._serialize0$_writeRgb$1(color); + return; + } + t1 = _0_0 instanceof A.SpanColorFormat0; + format = t1 ? _0_0 : null; + if (t1) { + _this._serialize0$_buffer.write$1(0, format._color0$_span.get$text()); + return; + } + if (opaque) { + rgb = color.toSpace$1(B.RgbColorSpace_i0P0); + _1_0 = $.$get$namesByColor0().$index(0, rgb); + if (_1_0 != null) { + _this._serialize0$_buffer.write$1(0, _1_0); + return; + } + if (_this._serialize0$_canUseHex$1(rgb)) { + _this._serialize0$_buffer.writeCharCode$1(35); + t1 = rgb.channel0OrNull; + _this._serialize0$_writeHexComponent$1(B.JSNumber_methods.round$0(t1 == null ? 0 : t1)); + t1 = rgb.channel1OrNull; + _this._serialize0$_writeHexComponent$1(B.JSNumber_methods.round$0(t1 == null ? 0 : t1)); + t1 = rgb.channel2OrNull; + _this._serialize0$_writeHexComponent$1(B.JSNumber_methods.round$0(t1 == null ? 0 : t1)); + return; + } + } + if (t3 === B.HwbColorSpace_guQ0) + _this._serialize0$_writeHsl$1(color); + else + _this._serialize0$_writeRgb$1(color); + }, + _serialize0$_tryIntegerRgb$1(rgb) { + var t1, redInt, greenInt, blueInt, shortHex, _0_0, t2, t3, $name, _this = this; + if (!_this._serialize0$_canUseHex$1(rgb)) + return false; + t1 = rgb.channel0OrNull; + redInt = B.JSNumber_methods.round$0(t1 == null ? 0 : t1); + t1 = rgb.channel1OrNull; + greenInt = B.JSNumber_methods.round$0(t1 == null ? 0 : t1); + t1 = rgb.channel2OrNull; + blueInt = B.JSNumber_methods.round$0(t1 == null ? 0 : t1); + t1 = redInt & 15; + shortHex = t1 === B.JSInt_methods._shrOtherPositive$1(redInt, 4) && (greenInt & 15) === B.JSInt_methods._shrOtherPositive$1(greenInt, 4) && (blueInt & 15) === B.JSInt_methods._shrOtherPositive$1(blueInt, 4); + _0_0 = $.$get$namesByColor0().$index(0, rgb); + t2 = false; + if (_0_0 != null) { + t3 = _0_0.length; + t2 = t3 <= (shortHex ? 4 : 7); + $name = _0_0; + } else + $name = null; + if (t2) + _this._serialize0$_buffer.write$1(0, $name); + else { + t2 = _this._serialize0$_buffer; + if (shortHex) { + t2.writeCharCode$1(35); + t2.writeCharCode$1(A.hexCharFor0(t1)); + t2.writeCharCode$1(A.hexCharFor0(greenInt & 15)); + t2.writeCharCode$1(A.hexCharFor0(blueInt & 15)); + } else { + t2.writeCharCode$1(35); + _this._serialize0$_writeHexComponent$1(redInt); + _this._serialize0$_writeHexComponent$1(greenInt); + _this._serialize0$_writeHexComponent$1(blueInt); + } + } + return true; + }, + _serialize0$_canUseHex$1(rgb) { + var t2, + t1 = rgb.channel0OrNull; + if (t1 == null) + t1 = 0; + if (A.fuzzyIsInt0(t1)) + t1 = (t1 > 0 || A.fuzzyEquals0(t1, 0)) && t1 < 256 && !A.fuzzyEquals0(t1, 256); + else + t1 = false; + t2 = false; + if (t1) { + t1 = rgb.channel1OrNull; + if (t1 == null) + t1 = 0; + if (A.fuzzyIsInt0(t1)) + t1 = (t1 > 0 || A.fuzzyEquals0(t1, 0)) && t1 < 256 && !A.fuzzyEquals0(t1, 256); + else + t1 = false; + if (t1) { + t1 = rgb.channel2OrNull; + if (t1 == null) + t1 = 0; + if (A.fuzzyIsInt0(t1)) + t1 = (t1 > 0 || A.fuzzyEquals0(t1, 0)) && t1 < 256 && !A.fuzzyEquals0(t1, 256); + else + t1 = t2; + } else + t1 = t2; + } else + t1 = t2; + return t1; + }, + _serialize0$_writeRgb$1(color) { + var t4, _this = this, + t1 = color.alphaOrNull, + t2 = t1 == null, + opaque = A.fuzzyEquals0(t2 ? 0 : t1, 1), + rgb = color.toSpace$1(B.RgbColorSpace_i0P0), + t3 = _this._serialize0$_buffer; + t3.write$1(0, opaque ? "rgb(" : "rgba("); + _this._serialize0$_writeNumber$1(rgb.channel$1(0, "red")); + t4 = _this._serialize0$_style === B.OutputStyle_10; + t3.write$1(0, t4 ? "," : ", "); + _this._serialize0$_writeNumber$1(rgb.channel$1(0, "green")); + t3.write$1(0, t4 ? "," : ", "); + _this._serialize0$_writeNumber$1(rgb.channel$1(0, "blue")); + if (!opaque) { + t3.write$1(0, t4 ? "," : ", "); + _this._serialize0$_writeNumber$1(t2 ? 0 : t1); + } + t3.writeCharCode$1(41); + }, + _serialize0$_writeHsl$1(color) { + var t4, _this = this, + t1 = color.alphaOrNull, + t2 = t1 == null, + opaque = A.fuzzyEquals0(t2 ? 0 : t1, 1), + hsl = color.toSpace$1(B.HslColorSpace_JQ20), + t3 = _this._serialize0$_buffer; + t3.write$1(0, opaque ? "hsl(" : "hsla("); + _this._serialize0$_writeChannel$1(hsl.channel$1(0, "hue")); + t4 = _this._serialize0$_style === B.OutputStyle_10; + t3.write$1(0, t4 ? "," : ", "); + _this._serialize0$_writeChannel$2(hsl.channel$1(0, "saturation"), "%"); + t3.write$1(0, t4 ? "," : ", "); + _this._serialize0$_writeChannel$2(hsl.channel$1(0, "lightness"), "%"); + if (!opaque) { + t3.write$1(0, t4 ? "," : ", "); + _this._serialize0$_writeNumber$1(t2 ? 0 : t1); + } + t3.writeCharCode$1(41); + }, + _serialize0$_writeColorFunction$1(color) { + var _this = this, + t1 = _this._serialize0$_buffer; + t1.write$1(0, "color("); + t1.write$1(0, color._color0$_space); + t1.writeCharCode$1(32); + _this._serialize0$_writeBetween$3(color.get$channelsOrNull(), " ", _this.get$_serialize0$_writeChannel()); + _this._serialize0$_maybeWriteSlashAlpha$1(color); + t1.writeCharCode$1(41); + }, + _serialize0$_writeHexComponent$1(color) { + var t1 = this._serialize0$_buffer; + t1.writeCharCode$1(A.hexCharFor0(B.JSInt_methods._shrOtherPositive$1(color, 4))); + t1.writeCharCode$1(A.hexCharFor0(color & 15)); + }, + _serialize0$_maybeWriteSlashAlpha$1(color) { + var t2, t3, _this = this, + t1 = color.alphaOrNull; + if (A.fuzzyEquals0(t1 == null ? 0 : t1, 1)) + return; + t2 = _this._serialize0$_style !== B.OutputStyle_10; + if (t2) + _this._serialize0$_buffer.writeCharCode$1(32); + t3 = _this._serialize0$_buffer; + t3.writeCharCode$1(47); + if (t2) + t3.writeCharCode$1(32); + _this._serialize0$_writeChannel$1(t1); + }, + visitList$1(value) { + var t2, singleton, t3, t4, t5, _this = this, + t1 = value._list1$_hasBrackets; + if (t1) + _this._serialize0$_buffer.writeCharCode$1(91); + else if (value._list1$_contents.length === 0) { + if (!_this._serialize0$_inspect) + throw A.wrapException(A.SassScriptException$0("() isn't a valid CSS value.", null)); + _this._serialize0$_buffer.write$1(0, "()"); + return; + } + t2 = _this._serialize0$_inspect; + singleton = false; + if (t2) + if (value._list1$_contents.length === 1) { + t3 = value._list1$_separator; + t3 = t3 === B.ListSeparator_qVN0 || t3 === B.ListSeparator_bRz0; + singleton = t3; + } + if (singleton && !t1) + _this._serialize0$_buffer.writeCharCode$1(40); + t3 = value._list1$_contents; + t3 = t2 ? t3 : new A.WhereIterable(t3, new A._SerializeVisitor_visitList_closure2(), A._arrayInstanceType(t3)._eval$1("WhereIterable<1>")); + t4 = value._list1$_separator; + t5 = _this._serialize0$_separatorString$1(t4); + _this._serialize0$_writeBetween$3(t3, t5, t2 ? new A._SerializeVisitor_visitList_closure3(_this, value) : new A._SerializeVisitor_visitList_closure4(_this)); + if (singleton) { + t2 = _this._serialize0$_buffer; + t2.write$1(0, t4.separator); + if (!t1) + t2.writeCharCode$1(41); + } + if (t1) + _this._serialize0$_buffer.writeCharCode$1(93); + }, + _serialize0$_separatorString$1(separator) { + var t1; + $label0$0: { + if (B.ListSeparator_qVN0 === separator) { + t1 = this._serialize0$_style === B.OutputStyle_10 ? "," : ", "; + break $label0$0; + } + if (B.ListSeparator_bRz0 === separator) { + t1 = this._serialize0$_style === B.OutputStyle_10 ? "/" : " / "; + break $label0$0; + } + if (B.ListSeparator_qSL0 === separator) { + t1 = " "; + break $label0$0; + } + t1 = ""; + break $label0$0; + } + return t1; + }, + _serialize0$_elementNeedsParens$2(separator, value) { + var t1; + $label1$1: { + if (value instanceof A.SassList0 && value._list1$_contents.length > 1 && !value._list1$_hasBrackets) { + $label0$0: { + if (B.ListSeparator_qVN0 === separator) { + t1 = value._list1$_separator === B.ListSeparator_qVN0; + break $label0$0; + } + if (B.ListSeparator_bRz0 === separator) { + t1 = value._list1$_separator; + t1 = t1 === B.ListSeparator_qVN0 || t1 === B.ListSeparator_bRz0; + break $label0$0; + } + t1 = value._list1$_separator !== B.ListSeparator_undecided_null_undecided0; + break $label0$0; + } + break $label1$1; + } + t1 = false; + break $label1$1; + } + return t1; + }, + visitMap$1(map) { + var t1, t2, _this = this; + if (!_this._serialize0$_inspect) + throw A.wrapException(A.SassScriptException$0(map.toString$0(0) + " isn't a valid CSS value.", null)); + t1 = _this._serialize0$_buffer; + t1.writeCharCode$1(40); + t2 = map._map0$_contents; + _this._serialize0$_writeBetween$3(t2.get$entries(t2), ", ", new A._SerializeVisitor_visitMap_closure0(_this)); + t1.writeCharCode$1(41); + }, + _serialize0$_writeMapElement$1(value) { + var needsParens = value instanceof A.SassList0 && value._list1$_separator === B.ListSeparator_qVN0 && !value._list1$_hasBrackets; + if (needsParens) + this._serialize0$_buffer.writeCharCode$1(40); + value.accept$1(this); + if (needsParens) + this._serialize0$_buffer.writeCharCode$1(41); + }, + visitNumber$1(value) { + var before, after, t1, _1_0, _this = this, + _0_0 = value.asSlash; + if (type$.Record_2_nullable_Object_and_nullable_Object._is(_0_0)) { + before = _0_0._0; + after = _0_0._1; + _this.visitNumber$1(before); + _this._serialize0$_buffer.writeCharCode$1(47); + _this.visitNumber$1(after); + return; + } + t1 = value._number1$_value; + if (!isFinite(t1)) { + _this.visitCalculation$1(new A.SassCalculation0("calc", A.List_List$unmodifiable(A._setArrayType([value], type$.JSArray_Object), type$.Object))); + return; + } + if (value.get$hasComplexUnits()) { + if (!_this._serialize0$_inspect) + throw A.wrapException(A.SassScriptException$0(value.toString$0(0) + " isn't a valid CSS value.", null)); + _this.visitCalculation$1(new A.SassCalculation0("calc", A.List_List$unmodifiable(A._setArrayType([value], type$.JSArray_Object), type$.Object))); + } else { + _this._serialize0$_writeNumber$1(t1); + _1_0 = value.get$numeratorUnits(value); + if (_1_0.length === 1) + _this._serialize0$_buffer.write$1(0, _1_0[0]); + } + }, + _serialize0$_writeNumberToString$1(number) { + var t1 = new A.StringBuffer(""); + this._serialize0$_writeNumber$2(number, new A.NoSourceMapBuffer0(t1)); + t1 = t1._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _serialize0$_writeNumber$2(number, buffer) { + var _0_0, text, _this = this; + if (buffer == null) + buffer = _this._serialize0$_buffer; + _0_0 = A.fuzzyAsInt0(number); + if (_0_0 != null) { + buffer.write$1(0, _this._serialize0$_removeExponent$1(B.JSInt_methods.toString$0(_0_0))); + return; + } + text = _this._serialize0$_removeExponent$1(B.JSNumber_methods.toString$0(number)); + if (text.length < 12) { + buffer.write$1(0, _this._serialize0$_style === B.OutputStyle_10 && text.charCodeAt(0) === 48 ? B.JSString_methods.substring$1(text, 1) : text); + return; + } + _this._serialize0$_writeRounded$2(text, buffer); + }, + _serialize0$_writeNumber$1(number) { + return this._serialize0$_writeNumber$2(number, null); + }, + _serialize0$_removeExponent$1(text) { + var buffer, t2, t3, additionalZeroes, + negative = text.charCodeAt(0) === 45, + exponent = A._Cell$(), + t1 = text.length, + i = 0; + while (true) { + if (!(i < t1)) { + buffer = null; + break; + } + c$0: { + if (text.charCodeAt(i) !== 101) + break c$0; + buffer = new A.StringBuffer(""); + t2 = buffer._contents = "" + A.Primitives_stringFromCharCode(text.charCodeAt(0)); + if (negative) { + t2 += A.Primitives_stringFromCharCode(text.charCodeAt(1)); + buffer._contents = t2; + if (i > 3) + buffer._contents = t2 + B.JSString_methods.substring$2(text, 3, i); + } else if (i > 2) + buffer._contents = t2 + B.JSString_methods.substring$2(text, 2, i); + exponent.__late_helper$_value = A.int_parse(B.JSString_methods.substring$2(text, i + 1, t1), null); + break; + } + ++i; + } + if (buffer == null) + return text; + if (exponent._readLocal$0() > 0) { + t1 = exponent._readLocal$0(); + t2 = buffer._contents; + t3 = negative ? 1 : 0; + additionalZeroes = t1 - (t2.length - 1 - t3); + for (t1 = t2, i = 0; i < additionalZeroes; ++i) { + t1 = A.Primitives_stringFromCharCode(48); + t1 = buffer._contents += t1; + } + return t1.charCodeAt(0) == 0 ? t1 : t1; + } else { + negative = text.charCodeAt(0) === 45; + t1 = (negative ? "" + A.Primitives_stringFromCharCode(45) : "") + "0."; + i = -1; + while (true) { + t2 = exponent.__late_helper$_value; + if (t2 === exponent) + A.throwExpression(A.LateError$localNI("")); + if (!(i > t2)) + break; + t1 += A.Primitives_stringFromCharCode(48); + --i; + } + if (negative) { + t2 = buffer._contents; + t2 = B.JSString_methods.substring$1(t2.charCodeAt(0) == 0 ? t2 : t2, 1); + } else + t2 = buffer; + t2 = t1 + A.S(t2); + return t2.charCodeAt(0) == 0 ? t2 : t2; + } + }, + _serialize0$_writeRounded$2(text, buffer) { + var t1, digits, negative, textIndex, digitsIndex, textIndex0, codeUnit, digitsIndex0, indexAfterPrecision, digitsIndex1, newDigit, writtenIndex; + if (B.JSString_methods.endsWith$1(text, ".0")) { + buffer.write$1(0, B.JSString_methods.substring$2(text, 0, text.length - 2)); + return; + } + t1 = text.length; + digits = new Uint8Array(t1 + 1); + negative = text.charCodeAt(0) === 45; + textIndex = negative ? 1 : 0; + for (digitsIndex = 1; true; textIndex = textIndex0, digitsIndex = digitsIndex0) { + if (textIndex === t1) { + buffer.write$1(0, text); + return; + } + textIndex0 = textIndex + 1; + codeUnit = text.charCodeAt(textIndex); + if (codeUnit === 46) { + textIndex = textIndex0; + break; + } + digitsIndex0 = digitsIndex + 1; + digits[digitsIndex] = codeUnit - 48; + } + indexAfterPrecision = textIndex + 10; + if (indexAfterPrecision >= t1) { + buffer.write$1(0, text); + return; + } + for (digitsIndex0 = digitsIndex; textIndex < indexAfterPrecision; textIndex = textIndex0, digitsIndex0 = digitsIndex1) { + digitsIndex1 = digitsIndex0 + 1; + textIndex0 = textIndex + 1; + digits[digitsIndex0] = text.charCodeAt(textIndex) - 48; + } + if (text.charCodeAt(textIndex) - 48 >= 5) + for (; true; digitsIndex0 = digitsIndex1) { + digitsIndex1 = digitsIndex0 - 1; + newDigit = digits[digitsIndex1] + 1; + digits[digitsIndex1] = newDigit; + if (newDigit !== 10) + break; + } + for (; digitsIndex0 < digitsIndex; ++digitsIndex0) + digits[digitsIndex0] = 0; + while (true) { + t1 = digitsIndex0 > digitsIndex; + if (!(t1 && digits[digitsIndex0 - 1] === 0)) + break; + --digitsIndex0; + } + if (digitsIndex0 === 2 && digits[0] === 0 && digits[1] === 0) { + buffer.writeCharCode$1(48); + return; + } + if (negative) + buffer.writeCharCode$1(45); + if (digits[0] === 0) + writtenIndex = this._serialize0$_style === B.OutputStyle_10 && digits[1] === 0 ? 2 : 1; + else + writtenIndex = 0; + for (; writtenIndex < digitsIndex; ++writtenIndex) + buffer.writeCharCode$1(48 + digits[writtenIndex]); + if (t1) { + buffer.writeCharCode$1(46); + for (; writtenIndex < digitsIndex0; ++writtenIndex) + buffer.writeCharCode$1(48 + digits[writtenIndex]); + } + }, + _serialize0$_visitQuotedString$2$forceDoubleQuote(string, forceDoubleQuote) { + var t1, includesSingleQuote, includesDoubleQuote, i, char, _1_2, _1_4, _0_0, quote, _this = this, + buffer = forceDoubleQuote ? _this._serialize0$_buffer : new A.StringBuffer(""); + if (forceDoubleQuote) + buffer.writeCharCode$1(34); + for (t1 = string.length, includesSingleQuote = false, includesDoubleQuote = false, i = 0; i < t1; ++i) { + char = string.charCodeAt(i); + _1_2 = 39 === char; + if (_1_2 && forceDoubleQuote) { + buffer.writeCharCode$1(39); + continue; + } + if (_1_2 && includesDoubleQuote) { + _this._serialize0$_visitQuotedString$2$forceDoubleQuote(string, true); + return; + } + if (_1_2) { + buffer.writeCharCode$1(39); + includesSingleQuote = true; + continue; + } + _1_4 = 34 === char; + if (_1_4 && forceDoubleQuote) { + buffer.writeCharCode$1(92); + buffer.writeCharCode$1(34); + continue; + } + if (_1_4 && includesSingleQuote) { + _this._serialize0$_visitQuotedString$2$forceDoubleQuote(string, true); + return; + } + if (_1_4) { + buffer.writeCharCode$1(34); + includesDoubleQuote = true; + continue; + } + if (0 === char || 1 === char || 2 === char || 3 === char || 4 === char || 5 === char || 6 === char || 7 === char || 8 === char || 10 === char || 11 === char || 12 === char || 13 === char || 14 === char || 15 === char || 16 === char || 17 === char || 18 === char || 19 === char || 20 === char || 21 === char || 22 === char || 23 === char || 24 === char || 25 === char || 26 === char || 27 === char || 28 === char || 29 === char || 30 === char || 31 === char || 127 === char) { + _this._serialize0$_writeEscape$4(buffer, char, string, i); + continue; + } + if (92 === char) { + buffer.writeCharCode$1(92); + buffer.writeCharCode$1(92); + continue; + } + _0_0 = _this._serialize0$_tryPrivateUseCharacter$4(buffer, char, string, i); + if (_0_0 != null) + i = _0_0; + else + buffer.writeCharCode$1(char); + } + if (forceDoubleQuote) + buffer.writeCharCode$1(34); + else { + quote = includesDoubleQuote ? 39 : 34; + t1 = _this._serialize0$_buffer; + t1.writeCharCode$1(quote); + t1.write$1(0, buffer); + t1.writeCharCode$1(quote); + } + }, + _serialize0$_visitQuotedString$1(string) { + return this._serialize0$_visitQuotedString$2$forceDoubleQuote(string, false); + }, + _serialize0$_visitUnquotedString$1(string) { + var t1, t2, afterNewline, i, _1_0, _0_0; + for (t1 = string.length, t2 = this._serialize0$_buffer, afterNewline = false, i = 0; i < t1; ++i) { + _1_0 = string.charCodeAt(i); + if (10 === _1_0) { + t2.writeCharCode$1(32); + afterNewline = true; + continue; + } + if (32 === _1_0) { + if (!afterNewline) + t2.writeCharCode$1(32); + continue; + } + _0_0 = this._serialize0$_tryPrivateUseCharacter$4(t2, _1_0, string, i); + if (_0_0 != null) + i = _0_0; + else + t2.writeCharCode$1(_1_0); + afterNewline = false; + } + }, + _serialize0$_tryPrivateUseCharacter$4(buffer, codeUnit, string, i) { + var t1; + if (this._serialize0$_style === B.OutputStyle_10) + return null; + if (codeUnit >= 57344 && codeUnit <= 63743) { + this._serialize0$_writeEscape$4(buffer, codeUnit, string, i); + return i; + } + if (codeUnit >>> 7 === 439 && string.length > i + 1) { + t1 = i + 1; + this._serialize0$_writeEscape$4(buffer, A.combineSurrogates(codeUnit, string.charCodeAt(t1)), string, t1); + return t1; + } + return null; + }, + _serialize0$_writeEscape$4(buffer, character, string, i) { + var t1, next; + buffer.writeCharCode$1(92); + buffer.write$1(0, B.JSInt_methods.toRadixString$1(character, 16)); + t1 = i + 1; + if (string.length === t1) + return; + next = string.charCodeAt(t1); + if (A.CharacterExtension_get_isHex0(next) || 32 === next || 9 === next) + buffer.writeCharCode$1(32); + }, + visitAttributeSelector$1(attribute) { + var _0_0, t2, + t1 = this._serialize0$_buffer; + t1.writeCharCode$1(91); + t1.write$1(0, attribute.name); + _0_0 = attribute.value; + if (_0_0 != null) { + t1.write$1(0, attribute.op); + if (A.Parser_isIdentifier0(_0_0) && !B.JSString_methods.startsWith$1(_0_0, "--")) { + t1.write$1(0, _0_0); + t2 = attribute.modifier; + if (t2 != null) + t1.writeCharCode$1(32); + } else { + this._serialize0$_visitQuotedString$1(_0_0); + t2 = attribute.modifier; + if (t2 != null) + if (this._serialize0$_style !== B.OutputStyle_10) + t1.writeCharCode$1(32); + } + A.NullableExtension_andThen0(t2, t1.get$write(t1)); + } + t1.writeCharCode$1(93); + }, + visitClassSelector$1(klass) { + var t1 = this._serialize0$_buffer; + t1.writeCharCode$1(46); + t1.write$1(0, klass.name); + }, + visitComplexSelector$1(complex) { + var t2, t3, t4, t5, t6, i, component, t7, t8, t9, _this = this, + t1 = complex.leadingCombinators; + _this._serialize0$_writeCombinators$1(t1); + if (t1.length >= 1 && complex.components.length >= 1) + if (_this._serialize0$_style !== B.OutputStyle_10) + _this._serialize0$_buffer.writeCharCode$1(32); + for (t1 = complex.components, t2 = t1.length, t3 = t2 - 1, t4 = _this._serialize0$_buffer, t5 = _this._serialize0$_style === B.OutputStyle_10, t6 = !t5, i = 0; i < t2; ++i) { + component = t1[i]; + _this.visitCompoundSelector$1(component.selector); + t7 = component.combinators; + t8 = t7.length === 0; + if (!t8) + if (t6) + t4.writeCharCode$1(32); + t9 = t5 ? "" : " "; + _this._serialize0$_writeBetween$3(t7, t9, t4.get$write(t4)); + if (i !== t3) + t7 = !t5 || t8; + else + t7 = false; + if (t7) + t4.writeCharCode$1(32); + } + }, + _serialize0$_writeCombinators$1(combinators) { + var t1 = this._serialize0$_style === B.OutputStyle_10 ? "" : " ", + t2 = this._serialize0$_buffer; + return this._serialize0$_writeBetween$3(combinators, t1, t2.get$write(t2)); + }, + visitCompoundSelector$1(compound) { + var t2, t3, _i, + t1 = this._serialize0$_buffer, + start = t1.get$length(t1); + for (t2 = compound.components, t3 = t2.length, _i = 0; _i < t3; ++_i) + t2[_i].accept$1(this); + if (t1.get$length(t1) === start) + t1.writeCharCode$1(42); + }, + visitIDSelector$1(id) { + var t1 = this._serialize0$_buffer; + t1.writeCharCode$1(35); + t1.write$1(0, id.name); + }, + visitSelectorList$1(list) { + var t1, t2, t3, t4, first, t5, _this = this, + complexes = list.components; + for (t1 = J.get$iterator$ax(_this._serialize0$_inspect ? complexes : new A.WhereIterable(complexes, new A._SerializeVisitor_visitSelectorList_closure0(), A._arrayInstanceType(complexes)._eval$1("WhereIterable<1>"))), t2 = _this._serialize0$_style !== B.OutputStyle_10, t3 = _this._serialize0$_buffer, t4 = _this._lineFeed.text, first = true; t1.moveNext$0();) { + t5 = t1.get$current(t1); + if (first) + first = false; + else { + t3.writeCharCode$1(44); + if (t5.lineBreak) { + if (t2) + t3.write$1(0, t4); + _this._serialize0$_writeIndentation$0(); + } else if (t2) + t3.writeCharCode$1(32); + } + _this.visitComplexSelector$1(t5); + } + }, + visitParentSelector$1($parent) { + var t1 = this._serialize0$_buffer; + t1.writeCharCode$1(38); + A.NullableExtension_andThen0($parent.suffix, t1.get$write(t1)); + }, + visitPlaceholderSelector$1(placeholder) { + var t1 = this._serialize0$_buffer; + t1.writeCharCode$1(37); + t1.write$1(0, placeholder.name); + }, + visitPseudoSelector$1(pseudo) { + var _0_4, t3, + t1 = pseudo.name, + t2 = false; + if ("not" === t1) { + _0_4 = pseudo.selector; + if (_0_4 instanceof A.SelectorList0) + t2 = (_0_4 == null ? type$.SelectorList_2._as(_0_4) : _0_4).accept$1(B._IsInvisibleVisitor_true0); + } + if (t2) + return; + t2 = this._serialize0$_buffer; + t2.writeCharCode$1(58); + if (!pseudo.isSyntacticClass) + t2.writeCharCode$1(58); + t2.write$1(0, t1); + t1 = pseudo.argument; + t3 = t1 == null; + if (t3 && pseudo.selector == null) + return; + t2.writeCharCode$1(40); + if (!t3) { + t2.write$1(0, t1); + if (pseudo.selector != null) + t2.writeCharCode$1(32); + } + A.NullableExtension_andThen0(pseudo.selector, this.get$visitSelectorList()); + t2.writeCharCode$1(41); + }, + visitTypeSelector$1(type) { + this._serialize0$_buffer.write$1(0, type.name); + }, + visitUniversalSelector$1(universal) { + var t2, + t1 = universal.namespace; + if (t1 != null) { + t2 = this._serialize0$_buffer; + t2.write$1(0, t1); + t2.writeCharCode$1(124); + } + this._serialize0$_buffer.writeCharCode$1(42); + }, + _serialize0$_write$1(value) { + return this._serialize0$_buffer.forSpan$2(value.span, new A._SerializeVisitor__write_closure0(this, value)); + }, + _serialize0$_visitChildren$1($parent) { + var t2, t3, t4, t5, t6, t7, t8, prePrevious, previous, t9, previous0, t10, savedIndentation, _this = this, + t1 = _this._serialize0$_buffer; + t1.writeCharCode$1(123); + for (t2 = $parent.children, t3 = t2.$ti, t2 = new A.ListIterator(t2, t2.get$length(0), t3._eval$1("ListIterator")), t4 = _this._serialize0$_style === B.OutputStyle_10, t5 = !t4, t6 = _this.get$_serialize0$_requiresSemicolon(), t7 = !_this._serialize0$_inspect, t3 = t3._eval$1("ListBase.E"), t8 = _this._lineFeed.text, prePrevious = null, previous = null; t2.moveNext$0();) { + t9 = t2.__internal$_current; + previous0 = t9 == null ? t3._as(t9) : t9; + if (t7) + t9 = t4 ? previous0.accept$1(B._IsInvisibleVisitor_true_true0) : previous0.accept$1(B._IsInvisibleVisitor_true_false0); + else + t9 = false; + if (t9) + continue; + t9 = previous == null; + t10 = t9 ? null : t6.call$1(previous); + if (t10 == null ? false : t10) + t1.writeCharCode$1(59); + if (_this._serialize0$_isTrailingComment$2(previous0, t9 ? $parent : previous)) { + if (t5) + t1.writeCharCode$1(32); + savedIndentation = _this._serialize0$_indentation; + _this._serialize0$_indentation = 0; + new A._SerializeVisitor__visitChildren_closure1(_this, previous0).call$0(); + _this._serialize0$_indentation = savedIndentation; + } else { + if (t5) + t1.write$1(0, t8); + ++_this._serialize0$_indentation; + new A._SerializeVisitor__visitChildren_closure2(_this, previous0).call$0(); + --_this._serialize0$_indentation; + } + prePrevious = previous; + previous = previous0; + } + if (previous != null) { + if ((type$.CssParentNode_2._is(previous) ? previous.get$isChildless() : !(previous instanceof A.ModifiableCssComment0)) && t5) + t1.writeCharCode$1(59); + if (prePrevious == null && _this._serialize0$_isTrailingComment$2(previous, $parent)) { + if (t5) + t1.writeCharCode$1(32); + } else { + _this._serialize0$_writeLineFeed$0(); + _this._serialize0$_writeIndentation$0(); + } + } + t1.writeCharCode$1(125); + }, + _serialize0$_requiresSemicolon$1(node) { + return type$.CssParentNode_2._is(node) ? node.get$isChildless() : !(node instanceof A.ModifiableCssComment0); + }, + _serialize0$_isTrailingComment$2(node, previous) { + var t1, t2, t3, searchFrom, endOffset, t4, span; + if (this._serialize0$_style === B.OutputStyle_10) + return false; + if (!(node instanceof A.ModifiableCssComment0)) + return false; + t1 = node.span; + t2 = t1.get$sourceUrl(t1); + t3 = previous.get$span(previous); + if (!J.$eq$(t2, t3.get$sourceUrl(t3))) + return false; + t2 = previous.get$span(previous); + if (!(J.$eq$(t2.get$file(t2).url, t1.get$file(t1).url) && t2.get$start(t2).offset <= t1.get$start(t1).offset && t2.get$end(t2).offset >= t1.get$end(t1).offset)) { + t1 = t1.get$start(t1); + t1 = t1.file.getLine$1(t1.offset); + t2 = previous.get$span(previous); + t2 = t2.get$end(t2); + return t1 === t2.file.getLine$1(t2.offset); + } + t2 = t1.get$start(t1); + t3 = previous.get$span(previous); + searchFrom = t2.offset - t3.get$start(t3).offset - 1; + if (searchFrom < 0) + return false; + endOffset = Math.max(0, B.JSString_methods.lastIndexOf$2(previous.get$span(previous).get$text(), "{", searchFrom)); + t2 = previous.get$span(previous); + t2 = t2.get$file(t2); + t3 = previous.get$span(previous); + t3 = t3.get$start(t3); + t4 = previous.get$span(previous); + span = t2.span$2(0, t3.offset, t4.get$start(t4).offset + endOffset); + t1 = t1.get$start(t1); + t1 = t1.file.getLine$1(t1.offset); + t4 = A.FileLocation$_(span.file, span._end); + return t1 === t4.file.getLine$1(t4.offset); + }, + _serialize0$_writeLineFeed$0() { + if (this._serialize0$_style !== B.OutputStyle_10) + this._serialize0$_buffer.write$1(0, this._lineFeed.text); + }, + _serialize0$_writeIndentation$0() { + var _this = this; + if (_this._serialize0$_style === B.OutputStyle_10) + return; + _this._serialize0$_writeTimes$2(_this._serialize0$_indentCharacter, _this._serialize0$_indentation * _this._serialize0$_indentWidth); + }, + _serialize0$_writeTimes$2(char, times) { + var t1, i; + for (t1 = this._serialize0$_buffer, i = 0; i < times; ++i) + t1.writeCharCode$1(char); + }, + _serialize0$_writeBetween$1$3(iterable, text, callback) { + var t1, t2, first, value; + for (t1 = J.get$iterator$ax(iterable), t2 = this._serialize0$_buffer, first = true; t1.moveNext$0();) { + value = t1.get$current(t1); + if (first) + first = false; + else + t2.write$1(0, text); + callback.call$1(value); + } + }, + _serialize0$_writeBetween$3(iterable, text, callback) { + return this._serialize0$_writeBetween$1$3(iterable, text, callback, type$.dynamic); + } + }; + A._SerializeVisitor_visitCssComment_closure0.prototype = { + call$0() { + var t2, t3, _0_0, minimumIndentation, + t1 = this.$this; + if (t1._serialize0$_style === B.OutputStyle_10 && this.node.text.charCodeAt(2) !== 33) + return; + t2 = this.node; + t3 = t2.text; + if (B.JSString_methods.startsWith$1(t3, A.RegExp_RegExp("/\\*# source(Mapping)?URL=", false))) + return; + _0_0 = t1._serialize0$_minimumIndentation$1(t3); + if (_0_0 != null) { + t2 = t2.span; + t2 = t2.get$start(t2); + minimumIndentation = Math.min(_0_0, t2.file.getColumn$1(t2.offset)); + t1._serialize0$_writeIndentation$0(); + t1._serialize0$_writeWithIndent$2(t3, minimumIndentation); + } else { + t1._serialize0$_writeIndentation$0(); + t1._serialize0$_buffer.write$1(0, t3); + } + }, + $signature: 1 + }; + A._SerializeVisitor_visitCssAtRule_closure0.prototype = { + call$0() { + var t3, _0_0, + t1 = this.$this, + t2 = t1._serialize0$_buffer; + t2.writeCharCode$1(64); + t3 = this.node; + t1._serialize0$_write$1(t3.name); + _0_0 = t3.value; + if (_0_0 != null) { + t2.writeCharCode$1(32); + t1._serialize0$_write$1(_0_0); + } + }, + $signature: 1 + }; + A._SerializeVisitor_visitCssMediaRule_closure0.prototype = { + call$0() { + var t3, firstQuery, t4, t5, + t1 = this.$this, + t2 = t1._serialize0$_buffer; + t2.write$1(0, "@media"); + t3 = this.node.queries; + firstQuery = B.JSArray_methods.get$first(t3); + t4 = t1._serialize0$_style === B.OutputStyle_10; + t5 = true; + if (t4) + if (firstQuery.modifier == null) + if (firstQuery.type == null) { + t5 = firstQuery.conditions; + t5 = t5.length === 1 && J.startsWith$1$s(B.JSArray_methods.get$first(t5), "(not "); + } + if (t5) + t2.writeCharCode$1(32); + t2 = t4 ? "," : ", "; + t1._serialize0$_writeBetween$3(t3, t2, t1.get$_serialize0$_visitMediaQuery()); + }, + $signature: 1 + }; + A._SerializeVisitor_visitCssImport_closure0.prototype = { + call$0() { + var t3, t4, _0_0, + t1 = this.$this, + t2 = t1._serialize0$_buffer; + t2.write$1(0, "@import"); + t3 = t1._serialize0$_style !== B.OutputStyle_10; + if (t3) + t2.writeCharCode$1(32); + t4 = this.node; + t2.forSpan$2(t4.url.span, new A._SerializeVisitor_visitCssImport__closure0(t1, t4)); + _0_0 = t4.modifiers; + if (_0_0 != null) { + if (t3) + t2.writeCharCode$1(32); + t2.write$1(0, _0_0); + } + }, + $signature: 1 + }; + A._SerializeVisitor_visitCssImport__closure0.prototype = { + call$0() { + return this.$this._serialize0$_writeImportUrl$1(this.node.url.value); + }, + $signature: 0 + }; + A._SerializeVisitor_visitCssKeyframeBlock_closure0.prototype = { + call$0() { + var t1 = this.$this, + t2 = t1._serialize0$_style === B.OutputStyle_10 ? "," : ", ", + t3 = t1._serialize0$_buffer; + return t1._serialize0$_writeBetween$3(this.node.selector.value, t2, t3.get$write(t3)); + }, + $signature: 0 + }; + A._SerializeVisitor_visitCssStyleRule_closure0.prototype = { + call$0() { + return this.$this.visitSelectorList$1(this.node._style_rule0$_selector._box0$_inner.value); + }, + $signature: 0 + }; + A._SerializeVisitor_visitCssSupportsRule_closure0.prototype = { + call$0() { + var t1 = this.$this, + t2 = t1._serialize0$_buffer; + t2.write$1(0, "@supports"); + if (!(t1._serialize0$_style === B.OutputStyle_10 && J.codeUnitAt$1$s(this.node.condition.value, 0) === 40)) + t2.writeCharCode$1(32); + t1._serialize0$_write$1(this.node.condition); + }, + $signature: 1 + }; + A._SerializeVisitor_visitCssDeclaration_closure1.prototype = { + call$0() { + var t1 = this.$this, + t2 = this.node; + if (t1._serialize0$_style === B.OutputStyle_10) + t1._serialize0$_writeFoldedValue$1(t2); + else + t1._serialize0$_writeReindentedValue$1(t2); + }, + $signature: 1 + }; + A._SerializeVisitor_visitCssDeclaration_closure2.prototype = { + call$0() { + return this.node.value.value.accept$1(this.$this); + }, + $signature: 0 + }; + A._SerializeVisitor_visitList_closure2.prototype = { + call$1(element) { + return !element.get$isBlank(); + }, + $signature: 54 + }; + A._SerializeVisitor_visitList_closure3.prototype = { + call$1(element) { + var t1 = this.$this, + needsParens = t1._serialize0$_elementNeedsParens$2(this.value._list1$_separator, element); + if (needsParens) + t1._serialize0$_buffer.writeCharCode$1(40); + element.accept$1(t1); + if (needsParens) + t1._serialize0$_buffer.writeCharCode$1(41); + }, + $signature: 66 + }; + A._SerializeVisitor_visitList_closure4.prototype = { + call$1(element) { + element.accept$1(this.$this); + }, + $signature: 66 + }; + A._SerializeVisitor_visitMap_closure0.prototype = { + call$1(entry) { + var t1 = this.$this; + t1._serialize0$_writeMapElement$1(entry.key); + t1._serialize0$_buffer.write$1(0, ": "); + t1._serialize0$_writeMapElement$1(entry.value); + }, + $signature: 577 + }; + A._SerializeVisitor_visitSelectorList_closure0.prototype = { + call$1(complex) { + return !complex.accept$1(B._IsInvisibleVisitor_true0); + }, + $signature: 21 + }; + A._SerializeVisitor__write_closure0.prototype = { + call$0() { + return this.$this._serialize0$_buffer.write$1(0, this.value.value); + }, + $signature: 0 + }; + A._SerializeVisitor__visitChildren_closure1.prototype = { + call$0() { + return this.child.accept$1(this.$this); + }, + $signature: 0 + }; + A._SerializeVisitor__visitChildren_closure2.prototype = { + call$0() { + this.child.accept$1(this.$this); + }, + $signature: 0 + }; + A.OutputStyle0.prototype = { + _enumToString$0() { + return "OutputStyle." + this._name; + } + }; + A.LineFeed0.prototype = { + _enumToString$0() { + return "LineFeed." + this._name; + }, + toString$0(_) { + return this.name; + } + }; + A.JSSet.prototype = {}; + A.ShadowedModuleView0.prototype = { + get$url(_) { + var t1 = this._shadowed_view0$_inner; + return t1.get$url(t1); + }, + get$upstream() { + return this._shadowed_view0$_inner.get$upstream(); + }, + get$extensionStore() { + return this._shadowed_view0$_inner.get$extensionStore(); + }, + get$css(_) { + var t1 = this._shadowed_view0$_inner; + return t1.get$css(t1); + }, + get$preModuleComments() { + return this._shadowed_view0$_inner.get$preModuleComments(); + }, + get$transitivelyContainsCss() { + return this._shadowed_view0$_inner.get$transitivelyContainsCss(); + }, + get$transitivelyContainsExtensions() { + return this._shadowed_view0$_inner.get$transitivelyContainsExtensions(); + }, + setVariable$3($name, value, nodeWithSpan) { + if (!this.variables.containsKey$1($name)) + throw A.wrapException(A.SassScriptException$0("Undefined variable.", null)); + else + this._shadowed_view0$_inner.setVariable$3($name, value, nodeWithSpan); + }, + variableIdentity$1($name) { + return this._shadowed_view0$_inner.variableIdentity$1($name); + }, + $eq(_, other) { + var t1, t2, t3, _this = this; + if (other == null) + return false; + t1 = false; + if (other instanceof A.ShadowedModuleView0) + if (_this._shadowed_view0$_inner.$eq(0, other._shadowed_view0$_inner)) { + t2 = _this.variables; + t2 = t2.get$keys(t2); + t3 = other.variables; + if (B.C_IterableEquality.equals$2(0, t2, t3.get$keys(t3))) { + t2 = _this.functions; + t2 = t2.get$keys(t2); + t3 = other.functions; + if (B.C_IterableEquality.equals$2(0, t2, t3.get$keys(t3))) { + t1 = _this.mixins; + t1 = t1.get$keys(t1); + t2 = other.mixins; + t2 = B.C_IterableEquality.equals$2(0, t1, t2.get$keys(t2)); + t1 = t2; + } + } + } + return t1; + }, + get$hashCode(_) { + var t1 = this._shadowed_view0$_inner; + return t1.get$hashCode(t1); + }, + cloneCss$0() { + var _this = this; + return new A.ShadowedModuleView0(_this._shadowed_view0$_inner.cloneCss$0(), _this.variables, _this.variableNodes, _this.functions, _this.mixins, _this.$ti); + }, + toString$0(_) { + return "shadowed " + this._shadowed_view0$_inner.toString$0(0); + }, + $isModule1: 1, + get$variables() { + return this.variables; + }, + get$variableNodes() { + return this.variableNodes; + }, + get$functions(receiver) { + return this.functions; + }, + get$mixins() { + return this.mixins; + } + }; + A.SilentComment0.prototype = { + accept$1$1(visitor) { + return visitor.visitSilentComment$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return this.text; + }, + get$span(receiver) { + return this.span; + } + }; + A.SimpleSelector0.prototype = { + get$specificity() { + return 1000; + }, + get$hasComplicatedSuperselectorSemantics() { + return false; + }, + addSuffix$1(suffix) { + return A.throwExpression(A.MultiSpanSassException$0('Selector "' + this.toString$0(0) + "\" can't have a suffix", this.span, "outer selector", A.LinkedHashMap_LinkedHashMap$_empty(type$.FileSpan, type$.String), null)); + }, + unify$1(compound) { + var other, result, addedThis, _i, simple, _this = this, + t1 = false; + if (compound.length === 1) { + other = compound[0]; + if (!(other instanceof A.UniversalSelector0)) { + if (other instanceof A.PseudoSelector0) + t1 = other.isClass && other.name === "host" || other.get$isHostContext(); + } else + t1 = true; + } else + other = null; + if (t1) + return other.unify$1(A._setArrayType([_this], type$.JSArray_SimpleSelector_2)); + if (B.JSArray_methods.contains$1(compound, _this)) + return compound; + result = A._setArrayType([], type$.JSArray_SimpleSelector_2); + for (t1 = compound.length, addedThis = false, _i = 0; _i < compound.length; compound.length === t1 || (0, A.throwConcurrentModificationError)(compound), ++_i) { + simple = compound[_i]; + if (!addedThis && simple instanceof A.PseudoSelector0) { + result.push(_this); + addedThis = true; + } + result.push(simple); + } + if (!addedThis) + result.push(_this); + return result; + }, + isSuperselector$1(other) { + var list; + if (this.$eq(0, other)) + return true; + if (other instanceof A.PseudoSelector0 && other.isClass) { + list = other.selector; + if (list != null && $._subselectorPseudos0.contains$1(0, other.normalizedName)) + return B.JSArray_methods.every$1(list.components, new A.SimpleSelector_isSuperselector_closure0(this)); + } + return false; + } + }; + A.SimpleSelector_isSuperselector_closure0.prototype = { + call$1(complex) { + var t1 = complex.components; + return t1.length !== 0 && B.JSArray_methods.any$1(B.JSArray_methods.get$last(t1).selector.components, new A.SimpleSelector_isSuperselector__closure0(this.$this)); + }, + $signature: 21 + }; + A.SimpleSelector_isSuperselector__closure0.prototype = { + call$1(simple) { + return this.$this.isSuperselector$1(simple); + }, + $signature: 14 + }; + A.SingleUnitSassNumber0.prototype = { + get$numeratorUnits(_) { + return A.List_List$unmodifiable([this._single_unit$_unit], type$.String); + }, + get$denominatorUnits(_) { + return B.List_empty; + }, + get$hasUnits() { + return true; + }, + get$hasComplexUnits() { + return false; + }, + withValue$1(value) { + return new A.SingleUnitSassNumber0(this._single_unit$_unit, value, null); + }, + withSlash$2(numerator, denominator) { + return new A.SingleUnitSassNumber0(this._single_unit$_unit, this._number1$_value, new A._Record_2(numerator, denominator)); + }, + hasUnit$1(unit) { + return unit === this._single_unit$_unit; + }, + hasCompatibleUnits$1(other) { + return other instanceof A.SingleUnitSassNumber0 && A.conversionFactor0(this._single_unit$_unit, other._single_unit$_unit) != null; + }, + hasPossiblyCompatibleUnits$1(other) { + var t1, knownCompatibilities, otherUnit; + if (!(other instanceof A.SingleUnitSassNumber0)) + return false; + t1 = $.$get$_knownCompatibilitiesByUnit0(); + knownCompatibilities = t1.$index(0, this._single_unit$_unit.toLowerCase()); + if (knownCompatibilities == null) + return true; + otherUnit = other._single_unit$_unit.toLowerCase(); + return knownCompatibilities.contains$1(0, otherUnit) || !t1.containsKey$1(otherUnit); + }, + compatibleWithUnit$1(unit) { + return A.conversionFactor0(this._single_unit$_unit, unit) != null; + }, + coerceToMatch$3(other, $name, otherName) { + var t1 = other instanceof A.SingleUnitSassNumber0 ? this._single_unit$_coerceToUnit$1(other._single_unit$_unit) : null; + return t1 == null ? this.super$SassNumber$coerceToMatch0(other, $name, otherName) : t1; + }, + coerceToMatch$1(other) { + return this.coerceToMatch$3(other, null, null); + }, + coerceValueToMatch$3(other, $name, otherName) { + var t1 = other instanceof A.SingleUnitSassNumber0 ? this._single_unit$_coerceValueToUnit$1(other._single_unit$_unit) : null; + return t1 == null ? this.super$SassNumber$coerceValueToMatch0(other, $name, otherName) : t1; + }, + coerceValueToMatch$1(other) { + return this.coerceValueToMatch$3(other, null, null); + }, + convertToMatch$3(other, $name, otherName) { + var t1 = other instanceof A.SingleUnitSassNumber0 ? this._single_unit$_coerceToUnit$1(other._single_unit$_unit) : null; + return t1 == null ? this.super$SassNumber$convertToMatch(other, $name, otherName) : t1; + }, + convertValueToMatch$3(other, $name, otherName) { + var t1 = other instanceof A.SingleUnitSassNumber0 ? this._single_unit$_coerceValueToUnit$1(other._single_unit$_unit) : null; + return t1 == null ? this.super$SassNumber$convertValueToMatch0(other, $name, otherName) : t1; + }, + convertValueToMatch$1(other) { + return this.convertValueToMatch$3(other, null, null); + }, + coerce$3(newNumerators, newDenominators, $name) { + var t1 = J.getInterceptor$asx(newNumerators); + t1 = t1.get$length(newNumerators) === 1 && J.get$isEmpty$asx(newDenominators) ? this._single_unit$_coerceToUnit$1(t1.$index(newNumerators, 0)) : null; + return t1 == null ? this.super$SassNumber$coerce0(newNumerators, newDenominators, $name) : t1; + }, + coerce$2(newNumerators, newDenominators) { + return this.coerce$3(newNumerators, newDenominators, null); + }, + coerceValue$3(newNumerators, newDenominators, $name) { + var t1 = J.getInterceptor$asx(newNumerators); + t1 = t1.get$length(newNumerators) === 1 && J.get$isEmpty$asx(newDenominators) ? this._single_unit$_coerceValueToUnit$1(t1.$index(newNumerators, 0)) : null; + return t1 == null ? this.super$SassNumber$coerceValue0(newNumerators, newDenominators, $name) : t1; + }, + coerceValueToUnit$2(unit, $name) { + var t1 = this._single_unit$_coerceValueToUnit$1(unit); + return t1 == null ? this.super$SassNumber$coerceValueToUnit0(unit, $name) : t1; + }, + coerceValueToUnit$1(unit) { + return this.coerceValueToUnit$2(unit, null); + }, + _single_unit$_coerceToUnit$1(unit) { + var t1 = this._single_unit$_unit; + if (t1 === unit) + return this; + return A.NullableExtension_andThen0(A.conversionFactor0(unit, t1), new A.SingleUnitSassNumber__coerceToUnit_closure0(this, unit)); + }, + _single_unit$_coerceValueToUnit$1(unit) { + return A.NullableExtension_andThen0(A.conversionFactor0(unit, this._single_unit$_unit), new A.SingleUnitSassNumber__coerceValueToUnit_closure0(this)); + }, + multiplyUnits$3(value, otherNumerators, otherDenominators) { + var mutableOtherDenominators, t1 = {}; + t1.value = value; + t1.newNumerators = otherNumerators; + mutableOtherDenominators = A._setArrayType(otherDenominators.slice(0), A._arrayInstanceType(otherDenominators)); + A.removeFirstWhere0(mutableOtherDenominators, new A.SingleUnitSassNumber_multiplyUnits_closure1(t1, this), new A.SingleUnitSassNumber_multiplyUnits_closure2(t1, this)); + return A.SassNumber_SassNumber$withUnits0(t1.value, mutableOtherDenominators, t1.newNumerators); + }, + unaryMinus$0() { + return new A.SingleUnitSassNumber0(this._single_unit$_unit, -this._number1$_value, null); + }, + $eq(_, other) { + var factor; + if (other == null) + return false; + if (other instanceof A.SingleUnitSassNumber0) { + factor = A.conversionFactor0(other._single_unit$_unit, this._single_unit$_unit); + return factor != null && A.fuzzyEquals0(this._number1$_value * factor, other._number1$_value); + } else + return false; + }, + get$hashCode(_) { + var _this = this, + t1 = _this.hashCache; + return t1 == null ? _this.hashCache = A.fuzzyHashCode0(_this._number1$_value * _this.canonicalMultiplierForUnit$1(_this._single_unit$_unit)) : t1; + } + }; + A.SingleUnitSassNumber__coerceToUnit_closure0.prototype = { + call$1(factor) { + return new A.SingleUnitSassNumber0(this.unit, this.$this._number1$_value * factor, null); + }, + $signature: 578 + }; + A.SingleUnitSassNumber__coerceValueToUnit_closure0.prototype = { + call$1(factor) { + return this.$this._number1$_value * factor; + }, + $signature: 16 + }; + A.SingleUnitSassNumber_multiplyUnits_closure1.prototype = { + call$1(denominator) { + var factor = A.conversionFactor0(denominator, this.$this._single_unit$_unit); + if (factor == null) + return false; + this._box_0.value *= factor; + return true; + }, + $signature: 5 + }; + A.SingleUnitSassNumber_multiplyUnits_closure2.prototype = { + call$0() { + var t1 = A._setArrayType([this.$this._single_unit$_unit], type$.JSArray_String), + t2 = this._box_0; + B.JSArray_methods.addAll$1(t1, t2.newNumerators); + t2.newNumerators = t1; + }, + $signature: 0 + }; + A.SourceInterpolationVisitor.prototype = { + visitBinaryOperationExpression$1(_, node) { + return this.buffer = null; + }, + visitBooleanExpression$1(_, node) { + return this.buffer = null; + }, + visitColorExpression$1(_, node) { + var t2, + t1 = this.buffer; + if (t1 != null) { + t2 = node.span.get$text(); + t1 = t1._interpolation_buffer0$_text; + t1._contents += t2; + } + return null; + }, + visitFunctionExpression$1(_, node) { + return this.buffer = null; + }, + visitInterpolatedFunctionExpression$1(_, node) { + var t1 = this.buffer; + if (t1 != null) + t1.addInterpolation$1(node.name); + this._visitArguments$1(node.$arguments); + }, + _visitArguments$1($arguments) { + var t2, t3, _this = this, + t1 = $arguments.named; + if (t1.get$isNotEmpty(t1) || $arguments.rest != null) + return; + t1 = $arguments.positional; + if (t1.length === 0) { + t1 = _this.buffer; + if (t1 != null) { + t2 = $arguments.span.get$text(); + t1 = t1._interpolation_buffer0$_text; + t1._contents += t2; + } + return; + } + t2 = _this.buffer; + if (t2 != null) { + t3 = A.SpanExtensions_before($arguments.span, J.get$span$z(B.JSArray_methods.get$first(t1))); + t3 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t3.file._decodedChars, t3._file$_start, t3._end), 0, null); + t2 = t2._interpolation_buffer0$_text; + t2._contents += t3; + } + _this._writeListAndBetween$2(t1, null); + t2 = _this.buffer; + if (t2 != null) { + t1 = A.SpanExtensions_after($arguments.span, J.get$span$z(B.JSArray_methods.get$last(t1))); + t1 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1.file._decodedChars, t1._file$_start, t1._end), 0, null); + t2 = t2._interpolation_buffer0$_text; + t2._contents += t1; + } + }, + visitIfExpression$1(_, node) { + return this.buffer = null; + }, + visitListExpression$1(_, node) { + var t3, t4, _this = this, + t1 = node.contents, + t2 = t1.length; + if (t2 <= 1 && !node.hasBrackets) { + _this.buffer = null; + return; + } + t3 = node.hasBrackets; + if (t3 && t2 === 0) { + t1 = _this.buffer; + if (t1 != null) { + t2 = node.span.get$text(); + t1 = t1._interpolation_buffer0$_text; + t1._contents += t2; + } + return; + } + if (t3) { + t2 = _this.buffer; + if (t2 != null) { + t4 = A.SpanExtensions_before(node.span, J.get$span$z(B.JSArray_methods.get$first(t1))); + t4 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t4.file._decodedChars, t4._file$_start, t4._end), 0, null); + t2 = t2._interpolation_buffer0$_text; + t2._contents += t4; + } + } + _this._writeListAndBetween$1(t1); + if (t3) { + t2 = _this.buffer; + if (t2 != null) { + t1 = A.SpanExtensions_after(node.span, J.get$span$z(B.JSArray_methods.get$last(t1))); + t1 = A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1.file._decodedChars, t1._file$_start, t1._end), 0, null); + t2 = t2._interpolation_buffer0$_text; + t2._contents += t1; + } + } + }, + visitMapExpression$1(_, node) { + return this.buffer = null; + }, + visitNullExpression$1(_, node) { + return this.buffer = null; + }, + visitNumberExpression$1(_, node) { + var t2, + t1 = this.buffer; + if (t1 != null) { + t2 = node.span.get$text(); + t1 = t1._interpolation_buffer0$_text; + t1._contents += t2; + } + return null; + }, + visitParenthesizedExpression$1(_, node) { + return this.buffer = null; + }, + visitSelectorExpression$1(_, node) { + return this.buffer = null; + }, + visitStringExpression$1(_, node) { + var t2, t3, t4, t5, i, span, _0_0, t6, expression, t7, t8, t9, _this = this, + t1 = node.text; + if (t1.get$asPlain() != null) { + t2 = _this.buffer; + if (t2 != null) { + t1 = t1.span.get$text(); + t2 = t2._interpolation_buffer0$_text; + t2._contents += t1; + } + return; + } + for (t2 = t1.contents, t3 = t2.length, t4 = t3 - 1, t5 = t1.span, i = 0; i < t3; ++i) { + span = t1.spanForElement$1(i); + _0_0 = t2[i]; + t6 = _0_0 instanceof A.Expression0; + expression = t6 ? _0_0 : null; + if (t6) { + if (i === 0) { + t6 = _this.buffer; + if (t6 != null) { + t7 = A.SpanExtensions_before(t5, span); + t8 = t7._file$_start; + t9 = t7.file._decodedChars; + t9 = A.String_String$fromCharCodes(new Uint32Array(t9.subarray(t8, A._checkValidRange(t8, t7._end, t9.length))), 0, null); + t6 = t6._interpolation_buffer0$_text; + t6._contents += t9; + } + } + t6 = _this.buffer; + if (t6 != null) { + t6._interpolation_buffer0$_flushText$0(); + t6._interpolation_buffer0$_contents.push(expression); + t6._interpolation_buffer0$_spans.push(span); + } + if (i === t4) { + t6 = _this.buffer; + if (t6 != null) { + t7 = A.SpanExtensions_after(t5, span); + t8 = t7._file$_start; + t9 = t7.file._decodedChars; + t9 = A.String_String$fromCharCodes(new Uint32Array(t9.subarray(t8, A._checkValidRange(t8, t7._end, t9.length))), 0, null); + t6 = t6._interpolation_buffer0$_text; + t6._contents += t9; + } + } + continue; + } + t6 = _this.buffer; + if (t6 != null) { + t6 = t6._interpolation_buffer0$_text; + t7 = span.toString$0(0); + t6._contents += t7; + } + } + }, + visitSupportsExpression$1(_, node) { + return this.buffer = null; + }, + visitUnaryOperationExpression$1(_, node) { + return this.buffer = null; + }, + visitValueExpression$1(_, node) { + return this.buffer = null; + }, + visitVariableExpression$1(_, node) { + return this.buffer = null; + }, + _writeListAndBetween$2(expressions, visitor) { + var t1, lastExpression, _i, expression, t2, t3, t4, t5; + for (t1 = expressions.length, lastExpression = null, _i = 0; _i < t1; ++_i, lastExpression = expression) { + expression = expressions[_i]; + if (lastExpression != null) { + t2 = this.buffer; + if (t2 != null) { + t3 = A.SpanExtensions_between(lastExpression.get$span(lastExpression), expression.get$span(expression)); + t4 = t3._file$_start; + t5 = t3.file._decodedChars; + t5 = A.String_String$fromCharCodes(new Uint32Array(t5.subarray(t4, A._checkValidRange(t4, t3._end, t5.length))), 0, null); + t2 = t2._interpolation_buffer0$_text; + t2._contents += t5; + } + } + expression.accept$1(this); + if (this.buffer == null) + return; + } + }, + _writeListAndBetween$1(expressions) { + return this._writeListAndBetween$2(expressions, null); + }, + $isExpressionVisitor: 1 + }; + A.SourceMapBuffer0.prototype = { + get$_source_map_buffer0$_targetLocation() { + var t1 = this._source_map_buffer0$_buffer._contents, + t2 = this._source_map_buffer0$_line; + return A.SourceLocation$(t1.length, this._source_map_buffer0$_column, t2, null); + }, + get$length(_) { + return this._source_map_buffer0$_buffer._contents.length; + }, + forSpan$1$2(span, callback) { + var t1, _this = this, + wasInSpan = _this._source_map_buffer0$_inSpan; + _this._source_map_buffer0$_inSpan = true; + _this._source_map_buffer0$_addEntry$2(span.get$start(span), _this.get$_source_map_buffer0$_targetLocation()); + try { + t1 = callback.call$0(); + return t1; + } finally { + _this._source_map_buffer0$_inSpan = wasInSpan; + } + }, + forSpan$2(span, callback) { + return this.forSpan$1$2(span, callback, type$.dynamic); + }, + _source_map_buffer0$_addEntry$2(source, target) { + var entry, t2, + t1 = this._source_map_buffer0$_entries; + if (t1.length !== 0) { + entry = B.JSArray_methods.get$last(t1); + t2 = entry.source; + if (t2.file.getLine$1(t2.offset) === source.file.getLine$1(source.offset) && entry.target.line === target.line) + return; + if (entry.target.offset === target.offset) + return; + } + t1.push(new A.Entry(source, target, null)); + }, + write$1(_, object) { + var t1, i, + string = J.toString$0$(object); + this._source_map_buffer0$_buffer._contents += string; + for (t1 = string.length, i = 0; i < t1; ++i) + if (string.charCodeAt(i) === 10) + this._source_map_buffer0$_writeLine$0(); + else + ++this._source_map_buffer0$_column; + }, + writeCharCode$1(charCode) { + var t1 = this._source_map_buffer0$_buffer, + t2 = A.Primitives_stringFromCharCode(charCode); + t1._contents += t2; + if (charCode === 10) + this._source_map_buffer0$_writeLine$0(); + else + ++this._source_map_buffer0$_column; + }, + _source_map_buffer0$_writeLine$0() { + var _this = this, + t1 = _this._source_map_buffer0$_entries; + if (B.JSArray_methods.get$last(t1).target.line === _this._source_map_buffer0$_line && B.JSArray_methods.get$last(t1).target.column === _this._source_map_buffer0$_column) + t1.pop(); + ++_this._source_map_buffer0$_line; + _this._source_map_buffer0$_column = 0; + if (_this._source_map_buffer0$_inSpan) + t1.push(new A.Entry(B.JSArray_methods.get$last(t1).source, _this.get$_source_map_buffer0$_targetLocation(), null)); + }, + toString$0(_) { + var t1 = this._source_map_buffer0$_buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + buildSourceMap$1$prefix(prefix) { + var i, t2, prefixColumn, _box_0 = {}, + t1 = prefix.length; + if (t1 === 0) + return A.SingleMapping_SingleMapping$fromEntries(this._source_map_buffer0$_entries); + _box_0.prefixColumn = _box_0.prefixLines = 0; + for (i = 0, t2 = 0; i < t1; ++i) + if (prefix.charCodeAt(i) === 10) { + ++_box_0.prefixLines; + _box_0.prefixColumn = 0; + t2 = 0; + } else { + prefixColumn = t2 + 1; + _box_0.prefixColumn = prefixColumn; + t2 = prefixColumn; + } + t2 = this._source_map_buffer0$_entries; + return A.SingleMapping_SingleMapping$fromEntries(new A.MappedListIterable(t2, new A.SourceMapBuffer_buildSourceMap_closure0(_box_0, t1), A._arrayInstanceType(t2)._eval$1("MappedListIterable<1,Entry>"))); + } + }; + A.SourceMapBuffer_buildSourceMap_closure0.prototype = { + call$1(entry) { + var t1 = entry.target, + t2 = t1.line, + t3 = this._box_0, + t4 = t3.prefixLines; + t3 = t2 === 0 ? t3.prefixColumn : 0; + return new A.Entry(entry.source, A.SourceLocation$(t1.offset + this.prefixLength, t1.column + t3, t2 + t4, null), entry.identifierName); + }, + $signature: 164 + }; + A.updateSourceSpanPrototype_closure.prototype = { + call$0() { + return this.span; + }, + $signature: 29 + }; + A.updateSourceSpanPrototype_closure0.prototype = { + call$1(span) { + return span.get$start(span); + }, + $signature: 263 + }; + A.updateSourceSpanPrototype_closure1.prototype = { + call$1(span) { + return span.get$end(span); + }, + $signature: 263 + }; + A.updateSourceSpanPrototype_closure2.prototype = { + call$1(span) { + return A.NullableExtension_andThen0(span.get$sourceUrl(span), new A.updateSourceSpanPrototype__closure()); + }, + $signature: 580 + }; + A.updateSourceSpanPrototype__closure.prototype = { + call$1(url) { + var t1, _null = null; + if (url.get$scheme() === "") { + t1 = $.$get$context(); + t1 = t1.toUri$1(A.absolute(t1.style.pathFromUri$1(A._parseUri(url)), _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null)); + } else + t1 = url; + return new self.URL(t1.toString$0(0)); + }, + $signature: 264 + }; + A.updateSourceSpanPrototype_closure3.prototype = { + call$1(span) { + return span.get$text(); + }, + $signature: 265 + }; + A.updateSourceSpanPrototype_closure4.prototype = { + call$1(span) { + return span.get$context(span); + }, + $signature: 265 + }; + A.updateSourceSpanPrototype_closure5.prototype = { + call$1($location) { + return $location.get$line(); + }, + $signature: 266 + }; + A.updateSourceSpanPrototype_closure6.prototype = { + call$1($location) { + return $location.get$column(); + }, + $signature: 266 + }; + A.ColorSpace0.prototype = { + get$isLegacyInternal() { + return false; + }, + get$isPolarInternal() { + return false; + }, + convert$5(dest, channel0, channel1, channel2, alpha) { + return this.convertLinear$5(dest, channel0, channel1, channel2, alpha); + }, + convertLinear$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, red, green, blue, alpha, missingA, missingB, missingChroma, missingHue, missingLightness) { + var t1, t2, transformedBlue, transformedGreen, transformedRed, linearRed, linearGreen, linearBlue, matrix, _this = this; + $label0$0: { + t1 = B.HslColorSpace_JQ20 !== dest; + if (!t1 || B.HwbColorSpace_guQ0 === dest) { + t2 = B.SrgbColorSpace_thf0; + break $label0$0; + } + if (B.LabColorSpace_2nT0 === dest || B.LchColorSpace_Bpv0 === dest) { + t2 = B.XyzD50ColorSpace_2OB0; + break $label0$0; + } + if (B.OklabColorSpace_5400 === dest || B.OklchColorSpace_9Gj0 === dest) { + t2 = B.LmsColorSpace_Os30; + break $label0$0; + } + t2 = dest; + break $label0$0; + } + if (t2 === _this) { + transformedBlue = blue; + transformedGreen = green; + transformedRed = red; + } else { + linearRed = _this.toLinear$1(red == null ? 0 : red); + linearGreen = _this.toLinear$1(green == null ? 0 : green); + linearBlue = _this.toLinear$1(blue == null ? 0 : blue); + matrix = _this.transformationMatrix$1(t2); + transformedRed = t2.fromLinear$1(matrix[0] * linearRed + matrix[1] * linearGreen + matrix[2] * linearBlue); + transformedGreen = t2.fromLinear$1(matrix[3] * linearRed + matrix[4] * linearGreen + matrix[5] * linearBlue); + transformedBlue = t2.fromLinear$1(matrix[6] * linearRed + matrix[7] * linearGreen + matrix[8] * linearBlue); + } + $label1$1: { + if (!t1 || B.HwbColorSpace_guQ0 === dest) { + t1 = B.SrgbColorSpace_thf0.convert$8$missingChroma$missingHue$missingLightness(dest, transformedRed, transformedGreen, transformedBlue, alpha, missingChroma, missingHue, missingLightness); + break $label1$1; + } + if (B.LabColorSpace_2nT0 === dest || B.LchColorSpace_Bpv0 === dest) { + t1 = B.XyzD50ColorSpace_2OB0.convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, transformedRed, transformedGreen, transformedBlue, alpha, missingA, missingB, missingChroma, missingHue, missingLightness); + break $label1$1; + } + if (B.OklabColorSpace_5400 === dest || B.OklchColorSpace_9Gj0 === dest) { + t1 = B.LmsColorSpace_Os30.convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, transformedRed, transformedGreen, transformedBlue, alpha, missingA, missingB, missingChroma, missingHue, missingLightness); + break $label1$1; + } + t1 = red == null ? null : transformedRed; + t2 = green == null ? null : transformedGreen; + t1 = A.SassColor_SassColor$forSpaceInternal0(dest, t1, t2, blue == null ? null : transformedBlue, alpha); + break $label1$1; + } + return t1; + }, + convertLinear$5(dest, red, green, blue, alpha) { + return this.convertLinear$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, red, green, blue, alpha, false, false, false, false, false); + }, + toLinear$1(channel) { + return A.throwExpression(A.UnimplementedError$("[BUG] Color space " + this.toString$0(0) + " doesn't support linear conversions.")); + }, + fromLinear$1(channel) { + return A.throwExpression(A.UnimplementedError$("[BUG] Color space " + this.toString$0(0) + " doesn't support linear conversions.")); + }, + transformationMatrix$1(dest) { + return A.throwExpression(A.UnimplementedError$("[BUG] Color space conversion from " + this.toString$0(0) + " to " + dest.toString$0(0) + " not implemented.")); + }, + toString$0(_) { + return this.name; + } + }; + A.SrgbColorSpace0.prototype = { + get$isBoundedInternal() { + return true; + }, + convert$8$missingChroma$missingHue$missingLightness(dest, red, green, blue, alpha, missingChroma, missingHue, missingLightness) { + var max, min, delta, hue, lightness, saturation, t1, t2, whiteness, blackness, _null = null; + if (B.HslColorSpace_JQ20 === dest || B.HwbColorSpace_guQ0 === dest) { + if (red == null) + red = 0; + if (green == null) + green = 0; + if (blue == null) + blue = 0; + max = Math.max(Math.max(red, green), blue); + min = Math.min(Math.min(red, green), blue); + delta = max - min; + if (max === min) + hue = 0; + else if (max === red) + hue = 60 * (green - blue) / delta + 360; + else + hue = max === green ? 60 * (blue - red) / delta + 120 : 60 * (red - green) / delta + 240; + if (dest === B.HslColorSpace_JQ20) { + lightness = (min + max) / 2; + saturation = lightness === 0 || lightness === 1 ? 0 : 100 * (max - lightness) / Math.min(lightness, 1 - lightness); + if (saturation < 0) { + hue += 180; + saturation = Math.abs(saturation); + } + t1 = missingHue || A.fuzzyEquals0(saturation, 0) ? _null : B.JSNumber_methods.$mod(hue, 360); + t2 = missingChroma ? _null : saturation; + return A.SassColor_SassColor$forSpaceInternal0(dest, t1, t2, missingLightness ? _null : lightness * 100, alpha); + } else { + whiteness = min * 100; + blackness = 100 - max * 100; + if (!missingHue) { + t1 = whiteness + blackness; + t1 = t1 > 100 || A.fuzzyEquals0(t1, 100); + } else + t1 = true; + return A.SassColor_SassColor$forSpaceInternal0(dest, t1 ? _null : B.JSNumber_methods.$mod(hue, 360), whiteness, blackness, alpha); + } + } + if (B.RgbColorSpace_i0P0 === dest) { + t1 = red == null ? _null : red * 255; + t2 = green == null ? _null : green * 255; + return A.SassColor_SassColor$rgbInternal0(t1, t2, blue == null ? _null : blue * 255, alpha, _null); + } + if (B.SrgbLinearColorSpace_kUj0 === dest) { + t1 = this.get$toLinear(); + return A.SassColor_SassColor$forSpaceInternal0(dest, A.NullableExtension_andThen0(red, t1), A.NullableExtension_andThen0(green, t1), A.NullableExtension_andThen0(blue, t1), alpha); + } + return this.super$ColorSpace$convertLinear0(dest, red, green, blue, alpha, false, false, missingChroma, missingHue, missingLightness); + }, + convert$5(dest, red, green, blue, alpha) { + return this.convert$8$missingChroma$missingHue$missingLightness(dest, red, green, blue, alpha, false, false, false); + }, + convert$6$missingHue(dest, red, green, blue, alpha, missingHue) { + return this.convert$8$missingChroma$missingHue$missingLightness(dest, red, green, blue, alpha, false, missingHue, false); + }, + toLinear$1(channel) { + return A.srgbAndDisplayP3ToLinear0(channel); + }, + fromLinear$1(channel) { + return A.srgbAndDisplayP3FromLinear0(channel); + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.DisplayP3ColorSpace_MmT0 === dest) { + t1 = $.$get$linearSrgbToLinearDisplayP30(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf20 === dest) { + t1 = $.$get$linearSrgbToLinearA98Rgb0(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz0 === dest) { + t1 = $.$get$linearSrgbToLinearProphotoRgb0(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo0 === dest) { + t1 = $.$get$linearSrgbToLinearRec20200(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ0 === dest) { + t1 = $.$get$linearSrgbToXyzD650(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB0 === dest) { + t1 = $.$get$linearSrgbToXyzD500(); + break $label0$0; + } + if (B.LmsColorSpace_Os30 === dest) { + t1 = $.$get$linearSrgbToLms0(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix0(dest); + break $label0$0; + } + return t1; + } + }; + A.SrgbLinearColorSpace0.prototype = { + get$isBoundedInternal() { + return true; + }, + convert$5(dest, red, green, blue, alpha) { + var t1; + $label0$0: { + if (B.RgbColorSpace_i0P0 === dest || B.HslColorSpace_JQ20 === dest || B.HwbColorSpace_guQ0 === dest || B.SrgbColorSpace_thf0 === dest) { + t1 = B.SrgbColorSpace_thf0.convert$5(dest, A.NullableExtension_andThen0(red, A.utils2__srgbAndDisplayP3FromLinear$closure()), A.NullableExtension_andThen0(green, A.utils2__srgbAndDisplayP3FromLinear$closure()), A.NullableExtension_andThen0(blue, A.utils2__srgbAndDisplayP3FromLinear$closure()), alpha); + break $label0$0; + } + t1 = this.super$ColorSpace$convert0(dest, red, green, blue, alpha); + break $label0$0; + } + return t1; + }, + toLinear$1(channel) { + return channel; + }, + fromLinear$1(channel) { + return channel; + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.DisplayP3ColorSpace_MmT0 === dest) { + t1 = $.$get$linearSrgbToLinearDisplayP30(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf20 === dest) { + t1 = $.$get$linearSrgbToLinearA98Rgb0(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz0 === dest) { + t1 = $.$get$linearSrgbToLinearProphotoRgb0(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo0 === dest) { + t1 = $.$get$linearSrgbToLinearRec20200(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ0 === dest) { + t1 = $.$get$linearSrgbToXyzD650(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB0 === dest) { + t1 = $.$get$linearSrgbToXyzD500(); + break $label0$0; + } + if (B.LmsColorSpace_Os30 === dest) { + t1 = $.$get$linearSrgbToLms0(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix0(dest); + break $label0$0; + } + return t1; + } + }; + A.Statement0.prototype = {$isAstNode0: 1, $isSassNode: 1}; + A.JSStatementVisitor.prototype = { + visitAtRootRule$1(_, node) { + return J.visitAtRootRule$1$x(this._statement$_inner, node); + }, + visitAtRule$1(_, node) { + return J.visitAtRule$1$x(this._statement$_inner, node); + }, + visitContentBlock$1(_, node) { + return J.visitContentBlock$1$x(this._statement$_inner, node); + }, + visitContentRule$1(_, node) { + return J.visitContentRule$1$x(this._statement$_inner, node); + }, + visitDebugRule$1(_, node) { + return J.visitDebugRule$1$x(this._statement$_inner, node); + }, + visitDeclaration$1(_, node) { + return J.visitDeclaration$1$x(this._statement$_inner, node); + }, + visitEachRule$1(_, node) { + return J.visitEachRule$1$x(this._statement$_inner, node); + }, + visitErrorRule$1(_, node) { + return J.visitErrorRule$1$x(this._statement$_inner, node); + }, + visitExtendRule$1(_, node) { + return J.visitExtendRule$1$x(this._statement$_inner, node); + }, + visitForRule$1(_, node) { + return J.visitForRule$1$x(this._statement$_inner, node); + }, + visitForwardRule$1(_, node) { + return J.visitForwardRule$1$x(this._statement$_inner, node); + }, + visitFunctionRule$1(_, node) { + return J.visitFunctionRule$1$x(this._statement$_inner, node); + }, + visitIfRule$1(_, node) { + return J.visitIfRule$1$x(this._statement$_inner, node); + }, + visitImportRule$1(_, node) { + return J.visitImportRule$1$x(this._statement$_inner, node); + }, + visitIncludeRule$1(_, node) { + return J.visitIncludeRule$1$x(this._statement$_inner, node); + }, + visitLoudComment$1(_, node) { + return J.visitLoudComment$1$x(this._statement$_inner, node); + }, + visitMediaRule$1(_, node) { + return J.visitMediaRule$1$x(this._statement$_inner, node); + }, + visitMixinRule$1(_, node) { + return J.visitMixinRule$1$x(this._statement$_inner, node); + }, + visitReturnRule$1(_, node) { + return J.visitReturnRule$1$x(this._statement$_inner, node); + }, + visitSilentComment$1(_, node) { + return J.visitSilentComment$1$x(this._statement$_inner, node); + }, + visitStyleRule$1(_, node) { + return J.visitStyleRule$1$x(this._statement$_inner, node); + }, + visitStylesheet$1(_, node) { + return J.visitStylesheet$1$x(this._statement$_inner, node); + }, + visitSupportsRule$1(_, node) { + return J.visitSupportsRule$1$x(this._statement$_inner, node); + }, + visitUseRule$1(_, node) { + return J.visitUseRule$1$x(this._statement$_inner, node); + }, + visitVariableDeclaration$1(_, node) { + return J.visitVariableDeclaration$1$x(this._statement$_inner, node); + }, + visitWarnRule$1(_, node) { + return J.visitWarnRule$1$x(this._statement$_inner, node); + }, + visitWhileRule$1(_, node) { + return J.visitWhileRule$1$x(this._statement$_inner, node); + }, + $isStatementVisitor: 1 + }; + A.JSStatementVisitorObject.prototype = {}; + A.StatementSearchVisitor0.prototype = { + visitAtRootRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitAtRule$1(_, node) { + return A.NullableExtension_andThen0(node.children, this.get$visitChildren()); + }, + visitContentBlock$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitContentRule$1(_, node) { + return null; + }, + visitDebugRule$1(_, node) { + return null; + }, + visitDeclaration$1(_, node) { + return A.NullableExtension_andThen0(node.children, this.get$visitChildren()); + }, + visitEachRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitErrorRule$1(_, node) { + return null; + }, + visitExtendRule$1(_, node) { + return null; + }, + visitForRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitForwardRule$1(_, node) { + return null; + }, + visitFunctionRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitIfRule$1(_, node) { + var t1 = A.IterableExtension_search0(node.clauses, new A.StatementSearchVisitor_visitIfRule_closure1(this)); + return t1 == null ? A.NullableExtension_andThen0(node.lastClause, new A.StatementSearchVisitor_visitIfRule_closure2(this)) : t1; + }, + visitImportRule$1(_, node) { + return null; + }, + visitIncludeRule$1(_, node) { + return A.NullableExtension_andThen0(node.content, this.get$visitContentBlock(this)); + }, + visitLoudComment$1(_, node) { + return null; + }, + visitMediaRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitMixinRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitReturnRule$1(_, node) { + return null; + }, + visitSilentComment$1(_, node) { + return null; + }, + visitStyleRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitStylesheet$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitSupportsRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitUseRule$1(_, node) { + return null; + }, + visitVariableDeclaration$1(_, node) { + return null; + }, + visitWarnRule$1(_, node) { + return null; + }, + visitWhileRule$1(_, node) { + return this.visitChildren$1(node.children); + }, + visitChildren$1(children) { + return A.IterableExtension_search0(children, new A.StatementSearchVisitor_visitChildren_closure0(this)); + } + }; + A.StatementSearchVisitor_visitIfRule_closure1.prototype = { + call$1(clause) { + return A.IterableExtension_search0(clause.children, new A.StatementSearchVisitor_visitIfRule__closure2(this.$this)); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("StatementSearchVisitor0.T?(IfClause0)"); + } + }; + A.StatementSearchVisitor_visitIfRule__closure2.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("StatementSearchVisitor0.T?(Statement0)"); + } + }; + A.StatementSearchVisitor_visitIfRule_closure2.prototype = { + call$1(lastClause) { + return A.IterableExtension_search0(lastClause.children, new A.StatementSearchVisitor_visitIfRule__closure1(this.$this)); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("StatementSearchVisitor0.T?(ElseClause0)"); + } + }; + A.StatementSearchVisitor_visitIfRule__closure1.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("StatementSearchVisitor0.T?(Statement0)"); + } + }; + A.StatementSearchVisitor_visitChildren_closure0.prototype = { + call$1(child) { + return child.accept$1(this.$this); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("StatementSearchVisitor0.T?(Statement0)"); + } + }; + A.StaticImport0.prototype = { + toString$0(_) { + var t1 = this.url.toString$0(0), + t2 = this.modifiers; + return t1 + (t2 == null ? "" : " " + t2.toString$0(0)); + }, + $isImport0: 1, + $isAstNode0: 1, + $isSassNode: 1, + get$span(receiver) { + return this.span; + } + }; + A.StderrLogger0.prototype = { + internalWarn$4$deprecation$span$trace(message, deprecation, span, trace) { + var t3, + result = new A.StringBuffer(""), + t1 = deprecation != null, + showDeprecation = t1 && deprecation !== B.Deprecation_ZVM, + t2 = this.color; + if (t2) { + t3 = result._contents = "" + "\x1b[33m\x1b[1m"; + t3 = result._contents = (t1 ? result._contents = t3 + "Deprecation " : t3) + "Warning\x1b[0m"; + if (showDeprecation) { + t1 = t3 + (" [\x1b[34m" + A.S(deprecation) + "\x1b[0m]"); + result._contents = t1; + } else + t1 = t3; + } else { + t3 = result._contents = (t1 ? result._contents = "" + "DEPRECATION " : "") + "WARNING"; + if (showDeprecation) { + t1 = t3 + (" [" + A.S(deprecation) + "]"); + result._contents = t1; + } else + t1 = t3; + } + if (span == null) + t1 = result._contents = t1 + (": " + message + "\n"); + else if (trace != null) { + t1 += ": " + message + "\n\n" + span.highlight$1$color(t2) + "\n"; + result._contents = t1; + } else { + t1 += " on " + span.message$2$color(0, "\n" + message, t2) + "\n"; + result._contents = t1; + } + if (trace != null) + result._contents = t1 + (A.indent0(B.JSString_methods.trimRight$0(trace.toString$0(0)), 4) + "\n"); + A.printError0(result); + }, + debug$2(_, message, span) { + var url, t3, t4, + t1 = span.file, + t2 = span._file$_start; + if (A.FileLocation$_(t1, t2).file.url == null) + url = "-"; + else { + t3 = A.FileLocation$_(t1, t2).file.url; + t4 = $.$get$context(); + t3.toString; + url = t4.prettyUri$1(t3); + } + t1 = A.FileLocation$_(t1, t2); + t1 = t1.file.getLine$1(t1.offset); + t2 = this.color ? "\x1b[1mDebug\x1b[0m" : "DEBUG"; + t2 = "" + (url + ":" + (t1 + 1) + " ") + t2 + (": " + message); + A.printError0(t2.charCodeAt(0) == 0 ? t2 : t2); + } + }; + A.StringExpression0.prototype = { + get$span(_) { + return this.text.span; + }, + accept$1$1(visitor) { + return visitor.visitStringExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + asInterpolation$1$static($static) { + var t1, t2, quote, t3, t4, t5, buffer, t6, i, value, t7; + if (!this.hasQuotes) + return this.text; + t1 = this.text; + t2 = t1.contents; + quote = A.StringExpression__bestQuote0(new A.WhereTypeIterable(t2, type$.WhereTypeIterable_String)); + t3 = new A.StringBuffer(""); + t4 = A._setArrayType([], type$.JSArray_Object); + t5 = A._setArrayType([], type$.JSArray_nullable_FileSpan); + buffer = new A.InterpolationBuffer0(t3, t4, t5); + t6 = A.Primitives_stringFromCharCode(quote); + t3._contents += t6; + for (t6 = t2.length, i = 0; i < t6; ++i) { + value = t2[i]; + if (value instanceof A.Expression0) { + t7 = t1.spanForElement$1(i); + buffer._interpolation_buffer0$_flushText$0(); + t4.push(value); + t5.push(t7); + continue; + } + if (typeof value == "string") + A.StringExpression__quoteInnerText0(value, quote, buffer, $static); + } + t2 = A.Primitives_stringFromCharCode(quote); + t3._contents += t2; + return buffer.interpolation$1(t1.span); + }, + asInterpolation$0() { + return this.asInterpolation$1$static(false); + }, + toString$0(_) { + return this.asInterpolation$0().toString$0(0); + } + }; + A.module_closure25.prototype = { + call$1($arguments) { + var limit, t2, chunks, i, lastEnd, match, t3, + t1 = J.getInterceptor$asx($arguments), + string = t1.$index($arguments, 0).assertString$1("string"), + separator = t1.$index($arguments, 1).assertString$1("separator"); + t1 = t1.$index($arguments, 2).get$realNull(); + limit = t1 == null ? null : t1.assertNumber$1("limit").assertInt$1("limit"); + if (limit != null && limit < 1) + throw A.wrapException(A.SassScriptException$0("$limit: Must be 1 or greater, was " + A.S(limit) + ".", null)); + t1 = string._string0$_text; + if (t1.length === 0) + return B.SassList_qAD0; + else { + t2 = separator._string0$_text; + if (t2.length === 0) + return A.SassList$0(A.MappedIterable_MappedIterable(new A.Runes(t1), new A.module__closure3(string), type$.Runes._eval$1("Iterable.E"), type$.Value_2), B.ListSeparator_qVN0, true); + } + chunks = A._setArrayType([], type$.JSArray_String); + for (t2 = B.JSString_methods.allMatches$1(t2, t1), t2 = new A._StringAllMatchesIterator(t2._input, t2._pattern, t2.__js_helper$_index), i = 0, lastEnd = 0; t2.moveNext$0();) { + match = t2.__js_helper$_current; + t3 = match.start; + chunks.push(B.JSString_methods.substring$2(t1, lastEnd, t3)); + lastEnd = t3 + match.pattern.length; + ++i; + if (i === limit) + break; + } + chunks.push(B.JSString_methods.substring$1(t1, lastEnd)); + return A.SassList$0(new A.MappedListIterable(chunks, new A.module__closure4(string), type$.MappedListIterable_String_Value_2), B.ListSeparator_qVN0, true); + }, + $signature: 28 + }; + A.module__closure3.prototype = { + call$1(rune) { + return new A.SassString0(A.Primitives_stringFromCharCode(rune), this.string._string0$_hasQuotes); + }, + $signature: 584 + }; + A.module__closure4.prototype = { + call$1(chunk) { + return new A.SassString0(chunk, this.string._string0$_hasQuotes); + }, + $signature: 585 + }; + A._unquote_closure0.prototype = { + call$1($arguments) { + var string = J.$index$asx($arguments, 0).assertString$1("string"); + if (!string._string0$_hasQuotes) + return string; + return new A.SassString0(string._string0$_text, false); + }, + $signature: 18 + }; + A._quote_closure0.prototype = { + call$1($arguments) { + var string = J.$index$asx($arguments, 0).assertString$1("string"); + if (string._string0$_hasQuotes) + return string; + return new A.SassString0(string._string0$_text, true); + }, + $signature: 18 + }; + A._length_closure1.prototype = { + call$1($arguments) { + return A.SassNumber_SassNumber0(J.$index$asx($arguments, 0).assertString$1("string").get$_string0$_sassLength(), null); + }, + $signature: 22 + }; + A._insert_closure0.prototype = { + call$1($arguments) { + var indexInt, codeUnitIndex, _s5_ = "index", + t1 = J.getInterceptor$asx($arguments), + string = t1.$index($arguments, 0).assertString$1("string"), + insert = t1.$index($arguments, 1).assertString$1("insert"), + index = t1.$index($arguments, 2).assertNumber$1(_s5_); + index.assertNoUnits$1(_s5_); + indexInt = index.assertInt$1(_s5_); + if (indexInt < 0) + indexInt = Math.max(string.get$_string0$_sassLength() + indexInt + 2, 0); + t1 = string._string0$_text; + codeUnitIndex = A.codepointIndexToCodeUnitIndex0(t1, A._codepointForIndex0(indexInt, string.get$_string0$_sassLength(), false)); + return new A.SassString0(B.JSString_methods.replaceRange$3(t1, codeUnitIndex, codeUnitIndex, insert._string0$_text), string._string0$_hasQuotes); + }, + $signature: 18 + }; + A._index_closure1.prototype = { + call$1($arguments) { + var t1 = J.getInterceptor$asx($arguments), + t2 = t1.$index($arguments, 0).assertString$1("string")._string0$_text, + codeUnitIndex = B.JSString_methods.indexOf$1(t2, t1.$index($arguments, 1).assertString$1("substring")._string0$_text); + if (codeUnitIndex === -1) + return B.C__SassNull0; + return A.SassNumber_SassNumber0(A.codeUnitIndexToCodepointIndex0(t2, codeUnitIndex) + 1, null); + }, + $signature: 3 + }; + A._slice_closure0.prototype = { + call$1($arguments) { + var lengthInCodepoints, endInt, startCodepoint, endCodepoint, + _s8_ = "start-at", + t1 = J.getInterceptor$asx($arguments), + string = t1.$index($arguments, 0).assertString$1("string"), + start = t1.$index($arguments, 1).assertNumber$1(_s8_), + end = t1.$index($arguments, 2).assertNumber$1("end-at"); + start.assertNoUnits$1(_s8_); + end.assertNoUnits$1("end-at"); + lengthInCodepoints = string.get$_string0$_sassLength(); + endInt = end.assertInt$0(); + if (endInt === 0) + return string._string0$_hasQuotes ? $.$get$_emptyQuoted0() : $.$get$_emptyUnquoted0(); + startCodepoint = A._codepointForIndex0(start.assertInt$0(), lengthInCodepoints, false); + endCodepoint = A._codepointForIndex0(endInt, lengthInCodepoints, true); + if (endCodepoint === lengthInCodepoints) + --endCodepoint; + if (endCodepoint < startCodepoint) + return string._string0$_hasQuotes ? $.$get$_emptyQuoted0() : $.$get$_emptyUnquoted0(); + t1 = string._string0$_text; + return new A.SassString0(B.JSString_methods.substring$2(t1, A.codepointIndexToCodeUnitIndex0(t1, startCodepoint), A.codepointIndexToCodeUnitIndex0(t1, endCodepoint + 1)), string._string0$_hasQuotes); + }, + $signature: 18 + }; + A._toUpperCase_closure0.prototype = { + call$1($arguments) { + var t1, t2, i, t3, t4, + string = J.$index$asx($arguments, 0).assertString$1("string"); + for (t1 = string._string0$_text, t2 = t1.length, i = 0, t3 = ""; i < t2; ++i) { + t4 = t1.charCodeAt(i); + t3 += A.Primitives_stringFromCharCode(t4 >= 97 && t4 <= 122 ? t4 & 4294967263 : t4); + } + return new A.SassString0(t3.charCodeAt(0) == 0 ? t3 : t3, string._string0$_hasQuotes); + }, + $signature: 18 + }; + A._toLowerCase_closure0.prototype = { + call$1($arguments) { + var t1, t2, i, t3, t4, + string = J.$index$asx($arguments, 0).assertString$1("string"); + for (t1 = string._string0$_text, t2 = t1.length, i = 0, t3 = ""; i < t2; ++i) { + t4 = t1.charCodeAt(i); + t3 += A.Primitives_stringFromCharCode(t4 >= 65 && t4 <= 90 ? t4 | 32 : t4); + } + return new A.SassString0(t3.charCodeAt(0) == 0 ? t3 : t3, string._string0$_hasQuotes); + }, + $signature: 18 + }; + A._uniqueId_closure0.prototype = { + call$1($arguments) { + var t1 = $.$get$_previousUniqueId0() + ($.$get$_random1().nextInt$1(36) + 1); + $._previousUniqueId0 = t1; + if (t1 > Math.pow(36, 6)) + $._previousUniqueId0 = B.JSInt_methods.$mod($.$get$_previousUniqueId0(), A._asInt(Math.pow(36, 6))); + return new A.SassString0("u" + B.JSString_methods.padLeft$2(B.JSInt_methods.toRadixString$1($.$get$_previousUniqueId0(), 36), 6, "0"), false); + }, + $signature: 18 + }; + A.StringExtension_toCssIdentifier_writeEscape.prototype = { + call$1(character) { + var _0_0, + t1 = this.buffer, + t2 = A.Primitives_stringFromCharCode(92); + t1._contents += t2; + t2 = B.JSInt_methods.toRadixString$1(character, 16); + t1._contents += t2; + _0_0 = this.scanner.peekChar$0(); + if (A._isInt(_0_0) && A.CharacterExtension_get_isHex0(_0_0)) { + t2 = A.Primitives_stringFromCharCode(32); + t1._contents += t2; + } + }, + $signature: 174 + }; + A.StringExtension_toCssIdentifier_consumeSurrogatePair.prototype = { + call$1(character) { + var t2, t3, + t1 = this.scanner, + _1_0 = t1.peekChar$1(1); + if (_1_0 == null || _1_0 >>> 10 !== 55) + t1.error$2$length(0, "An individual surrogates can't be represented as a CSS identifier.", 1); + else if (character >>> 7 === 439) + this.writeEscape.call$1(A.combineSurrogates(t1.readChar$0(), t1.readChar$0())); + else { + t2 = this.buffer; + t3 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t3; + t1 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t1; + } + }, + $signature: 174 + }; + A.stringClass_closure.prototype = { + call$0() { + var t2, + t1 = type$.JSClass, + jsClass = t1._as(A.allowInteropCaptureThisNamed("sass.SassString", new A.stringClass__closure())); + A.LinkedHashMap_LinkedHashMap$_literal(["text", new A.stringClass__closure0(), "hasQuotes", new A.stringClass__closure1(), "sassLength", new A.stringClass__closure2()], type$.String, type$.Function).forEach$1(0, A.JSClassExtension_get_defineGetter(jsClass)); + J.get$$prototype$x(jsClass).sassIndexToStringIndex = A.allowInteropCaptureThisNamed("sassIndexToStringIndex", new A.stringClass__closure3()); + t2 = $.$get$_emptyQuoted0(); + A.JSClassExtension_injectSuperclass(t1._as(t2.constructor), jsClass); + return jsClass; + }, + $signature: 15 + }; + A.stringClass__closure.prototype = { + call$3($self, textOrOptions, options) { + var t1; + if (typeof textOrOptions == "string") { + t1 = options == null ? null : J.get$quotes$x(options); + t1 = new A.SassString0(textOrOptions, t1 == null ? true : t1); + } else { + type$.nullable__ConstructorOptions_3._as(textOrOptions); + t1 = textOrOptions == null ? null : J.get$quotes$x(textOrOptions); + t1 = (t1 == null ? true : t1) ? $.$get$_emptyQuoted0() : $.$get$_emptyUnquoted0(); + } + return t1; + }, + call$1($self) { + return this.call$3($self, null, null); + }, + call$2($self, textOrOptions) { + return this.call$3($self, textOrOptions, null); + }, + "call*": "call$3", + $requiredArgCount: 1, + $defaultValues() { + return [null, null]; + }, + $signature: 587 + }; + A.stringClass__closure0.prototype = { + call$1($self) { + return $self._string0$_text; + }, + $signature: 588 + }; + A.stringClass__closure1.prototype = { + call$1($self) { + return $self._string0$_hasQuotes; + }, + $signature: 589 + }; + A.stringClass__closure2.prototype = { + call$1($self) { + return $self.get$_string0$_sassLength(); + }, + $signature: 590 + }; + A.stringClass__closure3.prototype = { + call$3($self, sassIndex, $name) { + var t1, + index = sassIndex.assertNumber$1($name).assertInt$1($name); + if (index === 0) + A.throwExpression(A.SassScriptException$0("String index may not be 0.", $name)); + else if (Math.abs(index) > $self.get$_string0$_sassLength()) + A.throwExpression(A.SassScriptException$0("Invalid index " + sassIndex.toString$0(0) + " for a string with " + $self.get$_string0$_sassLength() + " characters.", $name)); + t1 = index < 0 ? $self.get$_string0$_sassLength() + index : index - 1; + return A.codepointIndexToCodeUnitIndex0($self._string0$_text, t1); + }, + call$2($self, sassIndex) { + return this.call$3($self, sassIndex, null); + }, + "call*": "call$3", + $requiredArgCount: 2, + $defaultValues() { + return [null]; + }, + $signature: 591 + }; + A._ConstructorOptions1.prototype = {}; + A._NodeSassString.prototype = {}; + A.legacyStringClass_closure.prototype = { + call$3(thisArg, value, dartValue) { + var t1; + if (dartValue == null) { + value.toString; + t1 = new A.SassString0(value, false); + } else + t1 = dartValue; + J.set$dartValue$x(thisArg, t1); + }, + call$2(thisArg, value) { + return this.call$3(thisArg, value, null); + }, + "call*": "call$3", + $requiredArgCount: 2, + $defaultValues() { + return [null]; + }, + $signature: 592 + }; + A.legacyStringClass_closure0.prototype = { + call$1(thisArg) { + return J.get$dartValue$x(thisArg)._string0$_text; + }, + $signature: 593 + }; + A.legacyStringClass_closure1.prototype = { + call$2(thisArg, value) { + J.set$dartValue$x(thisArg, new A.SassString0(value, false)); + }, + $signature: 594 + }; + A.SassString0.prototype = { + get$_string0$_sassLength() { + var result, _this = this, + value = _this._string0$__SassString__sassLength_FI; + if (value === $) { + result = new A.Runes(_this._string0$_text).get$length(0); + _this._string0$__SassString__sassLength_FI !== $ && A.throwUnnamedLateFieldADI(); + _this._string0$__SassString__sassLength_FI = result; + value = result; + } + return value; + }, + get$isSpecialNumber() { + var t1, _2_0, t2, _0_0, _1_0; + if (this._string0$_hasQuotes) + return false; + t1 = this._string0$_text; + if (t1.length < 6) + return false; + _2_0 = t1.charCodeAt(0); + $label0$0: { + t2 = false; + if (97 === _2_0 || 65 === _2_0) { + t1 = (t1.charCodeAt(1) | 32) === 116 && (t1.charCodeAt(2) | 32) === 116 && (t1.charCodeAt(3) | 32) === 114 && t1.charCodeAt(4) === 40; + break $label0$0; + } + if (99 === _2_0 || 67 === _2_0) { + _0_0 = t1.charCodeAt(1); + $label1$1: { + if (108 === _0_0 || 76 === _0_0) { + t1 = (t1.charCodeAt(2) | 32) === 97 && (t1.charCodeAt(3) | 32) === 109 && (t1.charCodeAt(4) | 32) === 112 && t1.charCodeAt(5) === 40; + break $label1$1; + } + if (97 === _0_0 || 65 === _0_0) { + t1 = (t1.charCodeAt(2) | 32) === 108 && (t1.charCodeAt(3) | 32) === 99 && t1.charCodeAt(4) === 40; + break $label1$1; + } + t1 = t2; + break $label1$1; + } + break $label0$0; + } + if (118 === _2_0 || 86 === _2_0) { + t1 = (t1.charCodeAt(1) | 32) === 97 && (t1.charCodeAt(2) | 32) === 114 && t1.charCodeAt(3) === 40; + break $label0$0; + } + if (101 === _2_0 || 69 === _2_0) { + t1 = (t1.charCodeAt(1) | 32) === 110 && (t1.charCodeAt(2) | 32) === 118 && t1.charCodeAt(3) === 40; + break $label0$0; + } + if (109 === _2_0 || 77 === _2_0) { + _1_0 = t1.charCodeAt(1); + $label2$2: { + if (97 === _1_0 || 65 === _1_0) { + t1 = (t1.charCodeAt(2) | 32) === 120 && t1.charCodeAt(3) === 40; + break $label2$2; + } + if (105 === _1_0 || 73 === _1_0) { + t1 = (t1.charCodeAt(2) | 32) === 110 && t1.charCodeAt(3) === 40; + break $label2$2; + } + t1 = t2; + break $label2$2; + } + break $label0$0; + } + t1 = t2; + break $label0$0; + } + return t1; + }, + get$isVar() { + if (this._string0$_hasQuotes) + return false; + var t1 = this._string0$_text; + if (t1.length < 8) + return false; + return (t1.charCodeAt(0) | 32) === 118 && (t1.charCodeAt(1) | 32) === 97 && (t1.charCodeAt(2) | 32) === 114 && t1.charCodeAt(3) === 40; + }, + get$isBlank() { + return !this._string0$_hasQuotes && this._string0$_text.length === 0; + }, + assertQuoted$1($name) { + if (this._string0$_hasQuotes) + return; + throw A.wrapException(A.SassScriptException$0("Expected " + this.toString$0(0) + " to be a quoted string.", $name)); + }, + assertUnquoted$1($name) { + if (!this._string0$_hasQuotes) + return; + throw A.wrapException(A.SassScriptException$0("Expected " + this.toString$0(0) + " to be an unquoted string.", $name)); + }, + assertUnquoted$0() { + return this.assertUnquoted$1(null); + }, + accept$1$1(visitor) { + var t1 = visitor._serialize0$_quote && this._string0$_hasQuotes, + t2 = this._string0$_text; + if (t1) + visitor._serialize0$_visitQuotedString$1(t2); + else + visitor._serialize0$_visitUnquotedString$1(t2); + return null; + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + assertString$1($name) { + return this; + }, + plus$1(other) { + var t1 = this._string0$_text, + t2 = this._string0$_hasQuotes; + return other instanceof A.SassString0 ? new A.SassString0(t1 + other._string0$_text, t2) : new A.SassString0(t1 + A.serializeValue0(other, false, true), t2); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.SassString0 && this._string0$_text === other._string0$_text; + }, + get$hashCode(_) { + var t1 = this._string0$_hashCache; + return t1 == null ? this._string0$_hashCache = B.JSString_methods.get$hashCode(this._string0$_text) : t1; + } + }; + A.ModifiableCssStyleRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitCssStyleRule$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + equalsIgnoringChildren$1(other) { + var t1; + if (other instanceof A.ModifiableCssStyleRule0) + t1 = B.C_ListEquality.equals$2(0, other._style_rule0$_selector._box0$_inner.value.components, this._style_rule0$_selector._box0$_inner.value.components); + else + t1 = false; + return t1; + }, + copyWithoutChildren$0() { + return A.ModifiableCssStyleRule$0(this._style_rule0$_selector, this.span, false, this.originalSelector); + }, + $isCssStyleRule0: 1, + get$span(receiver) { + return this.span; + } + }; + A.StyleRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitStyleRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.children; + return this.selector.toString$0(0) + " {" + (t1 && B.JSArray_methods).join$1(t1, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.CssStylesheet0.prototype = { + get$parent(_) { + return null; + }, + get$isGroupEnd() { + return false; + }, + get$isChildless() { + return false; + }, + accept$1$1(visitor) { + return visitor.visitCssStylesheet$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + get$children(receiver) { + return this.children; + }, + get$span(receiver) { + return this.span; + } + }; + A.ModifiableCssStylesheet0.prototype = { + accept$1$1(visitor) { + return visitor.visitCssStylesheet$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + equalsIgnoringChildren$1(other) { + return other instanceof A.ModifiableCssStylesheet0; + }, + copyWithoutChildren$0() { + return A.ModifiableCssStylesheet$0(this.span); + }, + $isCssStylesheet0: 1, + get$span(receiver) { + return this.span; + } + }; + A.StylesheetParser0.prototype = { + parse$0(_) { + return this.wrapSpanFormatException$1(new A.StylesheetParser_parse_closure0(this)); + }, + parseParameterList$0() { + return this._stylesheet0$_parseSingleProduction$1$1(new A.StylesheetParser_parseParameterList_closure0(this), type$.ParameterList_2); + }, + _stylesheet0$_parseSingleProduction$1$1(production, $T) { + return this.wrapSpanFormatException$1(new A.StylesheetParser__parseSingleProduction_closure0(this, production, $T)); + }, + parseSignature$1$requireParens(requireParens) { + return this.wrapSpanFormatException$1(new A.StylesheetParser_parseSignature_closure(this, requireParens)); + }, + _stylesheet0$_statement$1$root(root) { + var t2, _this = this, + t1 = _this.scanner, + _0_0 = t1.peekChar$0(); + if (64 === _0_0) + return _this.atRule$2$root(new A.StylesheetParser__statement_closure0(_this), root); + if (43 === _0_0) { + if (!_this.get$indented() || !_this.lookingAtIdentifier$1(1)) + return _this._stylesheet0$_styleRule$0(); + _this._stylesheet0$_isUseAllowed = false; + t2 = t1._string_scanner$_position; + t1.readChar$0(); + return _this._stylesheet0$_includeRule$1(new A._SpanScannerState(t1, t2)); + } + if (61 === _0_0) { + if (!_this.get$indented()) + return _this._stylesheet0$_styleRule$0(); + _this._stylesheet0$_isUseAllowed = false; + t2 = t1._string_scanner$_position; + t1.readChar$0(); + _this.whitespace$1$consumeNewlines(true); + return _this._stylesheet0$_mixinRule$1(new A._SpanScannerState(t1, t2)); + } + if (125 === _0_0) + t1.error$2$length(0, 'unmatched "}".', 1); + return _this._stylesheet0$_inStyleRule || _this._stylesheet0$_inUnknownAtRule || _this._stylesheet0$_inMixin || _this._stylesheet0$_inContentBlock ? _this._stylesheet0$_declarationOrStyleRule$0() : _this._stylesheet0$_variableDeclarationOrStyleRule$0(); + }, + _stylesheet0$_statement$0() { + return this._stylesheet0$_statement$1$root(false); + }, + variableDeclarationWithoutNamespace$2(namespace, start_) { + var t1, start, $name, t2, value, flagStart, t3, guarded, global, _0_0, endPosition, t4, t5, t6, declaration, _this = this, + precedingComment = _this.lastSilentComment; + _this.lastSilentComment = null; + if (start_ == null) { + t1 = _this.scanner; + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + } else + start = start_; + $name = _this.variableName$0(); + t1 = namespace != null; + if (t1) + _this._stylesheet0$_assertPublic$2($name, new A.StylesheetParser_variableDeclarationWithoutNamespace_closure1(_this, start)); + if (_this.get$plainCss()) + _this.error$2(0, string$.Sassx20v, _this.scanner.spanFrom$1(start)); + _this.whitespace$1$consumeNewlines(true); + t2 = _this.scanner; + t2.expectChar$1(58); + _this.whitespace$1$consumeNewlines(true); + value = _this._stylesheet0$_expression$0(); + flagStart = new A._SpanScannerState(t2, t2._string_scanner$_position); + for (t3 = _this.warnings, guarded = false, global = false; t2.scanChar$1(33);) { + $label0$0: { + _0_0 = _this.identifier$0(); + if ("default" === _0_0) { + if (guarded) { + endPosition = t2._string_scanner$_position; + t4 = t2._sourceFile; + t5 = flagStart.position; + t6 = new A._FileSpan(t4, t5, endPosition); + t6._FileSpan$3(t4, t5, endPosition); + t3.push(new A._Record_3_deprecation_message_span(B.Deprecation_BzI, string$.x21defau, t6)); + } + guarded = true; + break $label0$0; + } + if ("global" === _0_0) { + if (t1) { + endPosition = t2._string_scanner$_position; + t4 = t2._sourceFile; + t5 = flagStart.position; + t6 = new A._FileSpan(t4, t5, endPosition); + t6._FileSpan$3(t4, t5, endPosition); + _this.error$2(0, string$.x21globai, t6); + } else if (global) { + endPosition = t2._string_scanner$_position; + t4 = t2._sourceFile; + t5 = flagStart.position; + t6 = new A._FileSpan(t4, t5, endPosition); + t6._FileSpan$3(t4, t5, endPosition); + t3.push(new A._Record_3_deprecation_message_span(B.Deprecation_BzI, string$.x21globas, t6)); + } + global = true; + break $label0$0; + } + endPosition = t2._string_scanner$_position; + t4 = t2._sourceFile; + t5 = flagStart.position; + t6 = new A._FileSpan(t4, t5, endPosition); + t6._FileSpan$3(t4, t5, endPosition); + _this.error$2(0, "Invalid flag name.", t6); + } + _this.whitespace$1$consumeNewlines(false); + flagStart = new A._SpanScannerState(t2, t2._string_scanner$_position); + } + _this.expectStatementSeparator$1("variable declaration"); + declaration = A.VariableDeclaration$0($name, value, t2.spanFrom$1(start), precedingComment, global, guarded, namespace); + if (global) + _this._stylesheet0$_globalVariables.putIfAbsent$2($name, new A.StylesheetParser_variableDeclarationWithoutNamespace_closure2(declaration)); + return declaration; + }, + variableDeclarationWithoutNamespace$0() { + return this.variableDeclarationWithoutNamespace$2(null, null); + }, + _stylesheet0$_variableDeclarationOrStyleRule$0() { + var t1, t2, variableOrInterpolation, t3, _this = this; + if (_this.get$plainCss()) + return _this._stylesheet0$_styleRule$0(); + if (_this.get$indented() && _this.scanner.scanChar$1(92)) + return _this._stylesheet0$_styleRule$0(); + if (!_this.lookingAtIdentifier$0()) + return _this._stylesheet0$_styleRule$0(); + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + variableOrInterpolation = _this._stylesheet0$_variableDeclarationOrInterpolation$0(); + if (variableOrInterpolation instanceof A.VariableDeclaration0) + t1 = variableOrInterpolation; + else { + t3 = new A.InterpolationBuffer0(new A.StringBuffer(""), A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t3.addInterpolation$1(type$.Interpolation_2._as(variableOrInterpolation)); + t2 = _this._stylesheet0$_styleRule$2(t3, new A._SpanScannerState(t1, t2)); + t1 = t2; + } + return t1; + }, + _stylesheet0$_declarationOrStyleRule$0() { + var t1, t2, declarationOrBuffer, _this = this; + if (_this.get$indented() && _this.scanner.scanChar$1(92)) + return _this._stylesheet0$_styleRule$0(); + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + declarationOrBuffer = _this._stylesheet0$_declarationOrBuffer$0(); + return declarationOrBuffer instanceof A.Statement0 ? declarationOrBuffer : _this._stylesheet0$_styleRule$2(type$.InterpolationBuffer_2._as(declarationOrBuffer), new A._SpanScannerState(t1, t2)); + }, + _stylesheet0$_declarationOrBuffer$0() { + var midBuffer, couldBeSelector, beforeDeclaration, value, additional, t2, t3, variableOrInterpolation, t4, $name, postColonWhitespace, _0_0, exception, _1_0, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + nameBuffer = new A.InterpolationBuffer0(new A.StringBuffer(""), A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)), + startsWithPunctuation = _this._stylesheet0$_lookingAtPotentialPropertyHack$0(); + if (startsWithPunctuation) { + t2 = t1.readChar$0(); + t3 = nameBuffer._interpolation_buffer0$_text; + t2 = A.Primitives_stringFromCharCode(t2); + t3._contents += t2; + t2 = _this.rawText$1(new A.StylesheetParser__declarationOrBuffer_closure2(_this)); + t3 = nameBuffer._interpolation_buffer0$_text; + t3._contents += t2; + } + if (!_this._stylesheet0$_lookingAtInterpolatedIdentifier$0()) + return nameBuffer; + variableOrInterpolation = startsWithPunctuation ? _this.interpolatedIdentifier$0() : _this._stylesheet0$_variableDeclarationOrInterpolation$0(); + if (variableOrInterpolation instanceof A.VariableDeclaration0) + return variableOrInterpolation; + else + nameBuffer.addInterpolation$1(type$.Interpolation_2._as(variableOrInterpolation)); + _this._stylesheet0$_isUseAllowed = false; + if (t1.matches$1("/*")) { + t2 = _this.rawText$1(_this.get$loudComment()); + t3 = nameBuffer._interpolation_buffer0$_text; + t3._contents += t2; + } + midBuffer = new A.StringBuffer(""); + t2 = midBuffer; + t3 = _this.rawText$1(new A.StylesheetParser__declarationOrBuffer_closure3(_this)); + t2._contents += t3; + t3 = t1._string_scanner$_position; + if (!t1.scanChar$1(58)) { + if (midBuffer._contents.length !== 0) { + t1 = nameBuffer._interpolation_buffer0$_text; + t2 = A.Primitives_stringFromCharCode(32); + t1._contents += t2; + } + return nameBuffer; + } + t2 = midBuffer; + t4 = A.Primitives_stringFromCharCode(58); + t2._contents += t4; + $name = nameBuffer.interpolation$1(t1.spanFrom$2(start, new A._SpanScannerState(t1, t3))); + if (B.JSString_methods.startsWith$1($name.get$initialPlain(), "--")) { + t2 = _this._stylesheet0$_interpolatedDeclarationValue$1$silentComments(false); + _this.expectStatementSeparator$1("custom property"); + return A.Declaration$0($name, new A.StringExpression0(t2, false), t1.spanFrom$1(start)); + } + if (t1.scanChar$1(58)) { + t1 = nameBuffer; + t2 = t1._interpolation_buffer0$_text; + t3 = A.S(midBuffer); + t2._contents += t3; + t3 = A.Primitives_stringFromCharCode(58); + t2._contents += t3; + return t1; + } else if (_this.get$indented() && _this._stylesheet0$_lookingAtInterpolatedIdentifier$0()) { + t1 = nameBuffer; + t2 = t1._interpolation_buffer0$_text; + t3 = A.S(midBuffer); + t2._contents += t3; + return t1; + } + postColonWhitespace = _this.rawText$1(new A.StylesheetParser__declarationOrBuffer_closure4(_this)); + _0_0 = _this._stylesheet0$_tryDeclarationChildren$2($name, start); + if (_0_0 != null) + return _0_0; + midBuffer._contents += postColonWhitespace; + couldBeSelector = postColonWhitespace.length === 0 && _this._stylesheet0$_lookingAtInterpolatedIdentifier$0(); + beforeDeclaration = new A._SpanScannerState(t1, t1._string_scanner$_position); + value = null; + try { + value = _this._stylesheet0$_expression$0(); + if (_this.lookingAtChildren$0()) { + if (couldBeSelector) + _this.expectStatementSeparator$0(); + } else if (!_this.atEndOfStatement$0()) + _this.expectStatementSeparator$0(); + } catch (exception) { + if (type$.FormatException._is(A.unwrapException(exception))) { + if (!couldBeSelector) + throw exception; + t1.set$state(beforeDeclaration); + additional = _this.almostAnyValue$0(); + if (!_this.get$indented() && t1.peekChar$0() === 59) + throw exception; + t1 = nameBuffer._interpolation_buffer0$_text; + t2 = A.S(midBuffer); + t1._contents += t2; + nameBuffer.addInterpolation$1(additional); + return nameBuffer; + } else + throw exception; + } + _1_0 = _this._stylesheet0$_tryDeclarationChildren$3$value($name, start, value); + if (_1_0 != null) + return _1_0; + else { + _this.expectStatementSeparator$0(); + return A.Declaration$0($name, value, t1.spanFrom$1(start)); + } + }, + _stylesheet0$_variableDeclarationOrInterpolation$0() { + var t1, start, identifier, t2, buffer, _this = this; + if (!_this.lookingAtIdentifier$0()) + return _this.interpolatedIdentifier$0(); + t1 = _this.scanner; + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + identifier = _this.identifier$0(); + if (t1.matches$1(".$")) { + t1.readChar$0(); + return _this.variableDeclarationWithoutNamespace$2(identifier, start); + } else { + t2 = new A.StringBuffer(""); + buffer = new A.InterpolationBuffer0(t2, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t2._contents = "" + identifier; + if (_this._stylesheet0$_lookingAtInterpolatedIdentifierBody$0()) + buffer.addInterpolation$1(_this.interpolatedIdentifier$0()); + return buffer.interpolation$1(t1.spanFrom$1(start)); + } + }, + _stylesheet0$_styleRule$2(buffer, start_) { + var t2, start, interpolation, wasInStyleRule, _this = this, t1 = {}; + _this._stylesheet0$_isUseAllowed = false; + if (start_ == null) { + t2 = _this.scanner; + start = new A._SpanScannerState(t2, t2._string_scanner$_position); + } else + start = start_; + interpolation = t1.interpolation = _this.styleRuleSelector$0(); + if (buffer != null) { + buffer.addInterpolation$1(interpolation); + t2 = t1.interpolation = buffer.interpolation$1(_this.scanner.spanFrom$1(start)); + } else + t2 = interpolation; + if (t2.contents.length === 0) + _this.scanner.error$1(0, 'expected "}".'); + wasInStyleRule = _this._stylesheet0$_inStyleRule; + _this._stylesheet0$_inStyleRule = true; + return _this._stylesheet0$_withChildren$3(_this.get$_stylesheet0$_statement(), start, new A.StylesheetParser__styleRule_closure0(t1, _this, wasInStyleRule, start)); + }, + _stylesheet0$_styleRule$0() { + return this._stylesheet0$_styleRule$2(null, null); + }, + _stylesheet0$_propertyOrVariableDeclaration$1$parseCustomProperties(parseCustomProperties) { + var t2, nameBuffer, t3, $name, variableOrInterpolation, _0_0, value, _1_0, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + if (_this._stylesheet0$_lookingAtPotentialPropertyHack$0()) { + t2 = new A.StringBuffer(""); + nameBuffer = new A.InterpolationBuffer0(t2, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t3 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t3; + t3 = _this.rawText$1(new A.StylesheetParser__propertyOrVariableDeclaration_closure0(_this)); + t2._contents += t3; + nameBuffer.addInterpolation$1(_this.interpolatedIdentifier$0()); + $name = nameBuffer.interpolation$1(t1.spanFrom$1(start)); + } else if (!_this.get$plainCss()) { + variableOrInterpolation = _this._stylesheet0$_variableDeclarationOrInterpolation$0(); + if (variableOrInterpolation instanceof A.VariableDeclaration0) + return variableOrInterpolation; + else + type$.Interpolation_2._as(variableOrInterpolation); + $name = variableOrInterpolation; + } else + $name = _this.interpolatedIdentifier$0(); + _this.whitespace$1$consumeNewlines(false); + t1.expectChar$1(58); + _this.whitespace$1$consumeNewlines(false); + _0_0 = _this._stylesheet0$_tryDeclarationChildren$2($name, start); + if (_0_0 != null) + return _0_0; + value = _this._stylesheet0$_expression$0(); + _1_0 = _this._stylesheet0$_tryDeclarationChildren$3$value($name, start, value); + if (_1_0 != null) + return _1_0; + else { + _this.expectStatementSeparator$0(); + return A.Declaration$0($name, value, t1.spanFrom$1(start)); + } + }, + _stylesheet0$_tryDeclarationChildren$3$value($name, start, value) { + var _this = this; + if (!_this.lookingAtChildren$0()) + return null; + if (_this.get$plainCss()) + _this.scanner.error$1(0, string$.Nested); + return _this._stylesheet0$_withChildren$3(_this.get$_stylesheet0$_declarationChild(), start, new A.StylesheetParser__tryDeclarationChildren_closure0($name, value)); + }, + _stylesheet0$_tryDeclarationChildren$2($name, start) { + return this._stylesheet0$_tryDeclarationChildren$3$value($name, start, null); + }, + _stylesheet0$_declarationChild$0() { + return this.scanner.peekChar$0() === 64 ? this._stylesheet0$_declarationAtRule$0() : this._stylesheet0$_propertyOrVariableDeclaration$1$parseCustomProperties(false); + }, + atRule$2$root(child, root) { + var $name, wasUseAllowed, value, optional, url, namespace, configuration, span, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expectChar$2$name(64, "@-rule"); + $name = _this.interpolatedIdentifier$0(); + wasUseAllowed = _this._stylesheet0$_isUseAllowed; + _this._stylesheet0$_isUseAllowed = false; + switch ($name.get$asPlain()) { + case "at-root": + return _this._stylesheet0$_atRootRule$1(start); + case "content": + return _this._stylesheet0$_contentRule$1(start); + case "debug": + return _this._stylesheet0$_debugRule$1(start); + case "each": + return _this._stylesheet0$_eachRule$2(start, child); + case "else": + return _this._stylesheet0$_disallowedAtRule$1(start); + case "error": + return _this._stylesheet0$_errorRule$1(start); + case "extend": + _this.whitespace$1$consumeNewlines(true); + if (!_this._stylesheet0$_inStyleRule && !_this._stylesheet0$_inMixin && !_this._stylesheet0$_inContentBlock) + _this.error$2(0, string$.x40exten, t1.spanFrom$1(start)); + value = _this.almostAnyValue$0(); + optional = t1.scanChar$1(33); + if (optional) { + _this.expectIdentifier$1("optional"); + _this.whitespace$1$consumeNewlines(false); + } + _this.expectStatementSeparator$1("@extend rule"); + return new A.ExtendRule0(value, optional, t1.spanFrom$1(start)); + case "for": + return _this._stylesheet0$_forRule$2(start, child); + case "forward": + _this._stylesheet0$_isUseAllowed = wasUseAllowed; + if (!root) + _this._stylesheet0$_disallowedAtRule$1(start); + return _this._stylesheet0$_forwardRule$1(start); + case "function": + return _this._stylesheet0$_functionRule$1(start); + case "if": + return _this._stylesheet0$_ifRule$2(start, child); + case "import": + return _this._stylesheet0$_importRule$1(start); + case "include": + return _this._stylesheet0$_includeRule$1(start); + case "media": + return _this.mediaRule$1(start); + case "mixin": + return _this._stylesheet0$_mixinRule$1(start); + case "-moz-document": + return _this.mozDocumentRule$2(start, $name); + case "return": + return _this._stylesheet0$_disallowedAtRule$1(start); + case "supports": + return _this.supportsRule$1(start); + case "use": + _this._stylesheet0$_isUseAllowed = wasUseAllowed; + if (!root) + _this._stylesheet0$_disallowedAtRule$1(start); + _this.whitespace$1$consumeNewlines(true); + url = _this._stylesheet0$_urlString$0(); + _this.whitespace$1$consumeNewlines(false); + namespace = _this._stylesheet0$_useNamespace$2(url, start); + _this.whitespace$1$consumeNewlines(false); + configuration = _this._stylesheet0$_configuration$0(); + _this.whitespace$1$consumeNewlines(false); + span = t1.spanFrom$1(start); + if (!_this._stylesheet0$_isUseAllowed) + _this.error$2(0, string$.x40use_r, span); + _this.expectStatementSeparator$1("@use rule"); + t1 = new A.UseRule0(url, namespace, configuration == null ? B.List_empty22 : A.List_List$unmodifiable(configuration, type$.ConfiguredVariable_2), span); + t1.UseRule$4$configuration0(url, namespace, span, configuration); + return t1; + case "warn": + return _this._stylesheet0$_warnRule$1(start); + case "while": + return _this._stylesheet0$_whileRule$2(start, child); + default: + return _this.unknownAtRule$2(start, $name); + } + }, + _stylesheet0$_declarationAtRule$0() { + var _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + _0_0 = _this._stylesheet0$_plainAtRuleName$0(); + $label0$0: { + if ("content" === _0_0) { + t1 = _this._stylesheet0$_contentRule$1(start); + break $label0$0; + } + if ("debug" === _0_0) { + t1 = _this._stylesheet0$_debugRule$1(start); + break $label0$0; + } + if ("each" === _0_0) { + t1 = _this._stylesheet0$_eachRule$2(start, _this.get$_stylesheet0$_declarationChild()); + break $label0$0; + } + if ("else" === _0_0) + _this._stylesheet0$_disallowedAtRule$1(start); + if ("error" === _0_0) { + t1 = _this._stylesheet0$_errorRule$1(start); + break $label0$0; + } + if ("for" === _0_0) { + t1 = _this._stylesheet0$_forRule$2(start, _this.get$_stylesheet0$_declarationChild()); + break $label0$0; + } + if ("if" === _0_0) { + t1 = _this._stylesheet0$_ifRule$2(start, _this.get$_stylesheet0$_declarationChild()); + break $label0$0; + } + if ("include" === _0_0) { + t1 = _this._stylesheet0$_includeRule$1(start); + break $label0$0; + } + if ("warn" === _0_0) { + t1 = _this._stylesheet0$_warnRule$1(start); + break $label0$0; + } + if ("while" === _0_0) { + t1 = _this._stylesheet0$_whileRule$2(start, _this.get$_stylesheet0$_declarationChild()); + break $label0$0; + } + t1 = _this._stylesheet0$_disallowedAtRule$1(start); + } + return t1; + }, + _stylesheet0$_functionChild$0() { + var state, variableDeclarationError, stackTrace, statement, t2, namespace, exception, t3, start, _0_0, value, _this = this, + t1 = _this.scanner; + if (t1.peekChar$0() !== 64) { + t2 = t1._string_scanner$_position; + state = new A._SpanScannerState(t1, t2); + try { + namespace = _this.identifier$0(); + t1.expectChar$1(46); + t2 = _this.variableDeclarationWithoutNamespace$2(namespace, new A._SpanScannerState(t1, t2)); + return t2; + } catch (exception) { + t2 = A.unwrapException(exception); + t3 = type$.SourceSpanFormatException; + if (t3._is(t2)) { + variableDeclarationError = t2; + stackTrace = A.getTraceFromException(exception); + t1.set$state(state); + statement = null; + try { + statement = _this._stylesheet0$_declarationOrStyleRule$0(); + } catch (exception) { + if (t3._is(A.unwrapException(exception))) + throw A.wrapException(variableDeclarationError); + else + throw exception; + } + t2 = statement instanceof A.StyleRule0 ? "style rules" : "declarations"; + _this.error$3(0, "@function rules may not contain " + t2 + ".", J.get$span$z(statement), stackTrace); + } else + throw exception; + } + } + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + _0_0 = _this._stylesheet0$_plainAtRuleName$0(); + $label0$0: { + if ("debug" === _0_0) { + t1 = _this._stylesheet0$_debugRule$1(start); + break $label0$0; + } + if ("each" === _0_0) { + t1 = _this._stylesheet0$_eachRule$2(start, _this.get$_stylesheet0$_functionChild()); + break $label0$0; + } + if ("else" === _0_0) + _this._stylesheet0$_disallowedAtRule$1(start); + if ("error" === _0_0) { + t1 = _this._stylesheet0$_errorRule$1(start); + break $label0$0; + } + if ("for" === _0_0) { + t1 = _this._stylesheet0$_forRule$2(start, _this.get$_stylesheet0$_functionChild()); + break $label0$0; + } + if ("if" === _0_0) { + t1 = _this._stylesheet0$_ifRule$2(start, _this.get$_stylesheet0$_functionChild()); + break $label0$0; + } + if ("return" === _0_0) { + _this.whitespace$1$consumeNewlines(true); + value = _this._stylesheet0$_expression$0(); + _this.expectStatementSeparator$1("@return rule"); + t1 = new A.ReturnRule0(value, t1.spanFrom$1(start)); + break $label0$0; + } + if ("warn" === _0_0) { + t1 = _this._stylesheet0$_warnRule$1(start); + break $label0$0; + } + if ("while" === _0_0) { + t1 = _this._stylesheet0$_whileRule$2(start, _this.get$_stylesheet0$_functionChild()); + break $label0$0; + } + t1 = _this._stylesheet0$_disallowedAtRule$1(start); + } + return t1; + }, + _stylesheet0$_plainAtRuleName$0() { + this.scanner.expectChar$2$name(64, "@-rule"); + return this.identifier$0(); + }, + _stylesheet0$_atRootRule$1(start) { + var t1, t2, t3, buffer, t4, _this = this; + _this.whitespace$1$consumeNewlines(false); + t1 = _this.scanner; + if (t1.peekChar$0() === 40) { + t2 = t1._string_scanner$_position; + t3 = new A.StringBuffer(""); + buffer = new A.InterpolationBuffer0(t3, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t1.expectChar$1(40); + t4 = A.Primitives_stringFromCharCode(40); + t3._contents += t4; + _this.whitespace$1$consumeNewlines(true); + _this._stylesheet0$_addOrInject$2(buffer, _this._stylesheet0$_expression$1$consumeNewlines(true)); + if (t1.scanChar$1(58)) { + _this.whitespace$1$consumeNewlines(true); + t4 = A.Primitives_stringFromCharCode(58); + t3._contents += t4; + t4 = A.Primitives_stringFromCharCode(32); + t3._contents += t4; + _this._stylesheet0$_addOrInject$2(buffer, _this._stylesheet0$_expression$1$consumeNewlines(true)); + } + t1.expectChar$1(41); + _this.whitespace$1$consumeNewlines(false); + t4 = A.Primitives_stringFromCharCode(41); + t3._contents += t4; + return _this._stylesheet0$_withChildren$3(_this.get$_stylesheet0$_statement(), start, new A.StylesheetParser__atRootRule_closure1(buffer.interpolation$1(t1.spanFrom$1(new A._SpanScannerState(t1, t2))))); + } else { + if (!_this.lookingAtChildren$0()) + t2 = _this.get$indented() && _this.atEndOfStatement$0(); + else + t2 = true; + if (t2) + return _this._stylesheet0$_withChildren$3(_this.get$_stylesheet0$_statement(), start, new A.StylesheetParser__atRootRule_closure2()); + else + return A.AtRootRule$0(A._setArrayType([_this._stylesheet0$_styleRule$0()], type$.JSArray_Statement_2), t1.spanFrom$1(start), null); + } + }, + _stylesheet0$_contentRule$1(start) { + var t1, beforeWhitespace, $arguments, t2, _this = this; + if (!_this._stylesheet0$_inMixin) + _this.error$2(0, string$.x40conte, _this.scanner.spanFrom$1(start)); + t1 = _this.scanner; + beforeWhitespace = A.FileLocation$_(t1._sourceFile, t1._string_scanner$_position); + _this.whitespace$1$consumeNewlines(false); + if (t1.peekChar$0() === 40) { + $arguments = _this._stylesheet0$_argumentInvocation$1$mixin(true); + _this.whitespace$1$consumeNewlines(false); + } else { + t2 = beforeWhitespace.offset; + $arguments = A.ArgumentList$empty0(A._FileSpan$(beforeWhitespace.file, t2, t2)); + } + _this.expectStatementSeparator$1("@content rule"); + return new A.ContentRule0($arguments, t1.spanFrom$1(start)); + }, + _stylesheet0$_debugRule$1(start) { + var value, t1, t2, _this = this; + _this.whitespace$1$consumeNewlines(true); + value = _this._stylesheet0$_expression$0(); + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + _this.expectStatementSeparator$1("@debug rule"); + return new A.DebugRule0(value, t1.spanFrom$2(start, new A._SpanScannerState(t1, t2))); + }, + _stylesheet0$_eachRule$2(start, child) { + var wasInControlDirective, variables, t1, _this = this; + _this.whitespace$1$consumeNewlines(true); + wasInControlDirective = _this._stylesheet0$_inControlDirective; + _this._stylesheet0$_inControlDirective = true; + variables = A._setArrayType([_this.variableName$0()], type$.JSArray_String); + _this.whitespace$1$consumeNewlines(true); + for (t1 = _this.scanner; t1.scanChar$1(44);) { + _this.whitespace$1$consumeNewlines(true); + t1.expectChar$1(36); + variables.push(_this.identifier$1$normalize(true)); + _this.whitespace$1$consumeNewlines(true); + } + _this.whitespace$1$consumeNewlines(true); + _this.expectIdentifier$1("in"); + _this.whitespace$1$consumeNewlines(true); + return _this._stylesheet0$_withChildren$3(child, start, new A.StylesheetParser__eachRule_closure0(_this, wasInControlDirective, variables, _this._stylesheet0$_expression$0())); + }, + _stylesheet0$_errorRule$1(start) { + var value, t1, t2, _this = this; + _this.whitespace$1$consumeNewlines(true); + value = _this._stylesheet0$_expression$0(); + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + _this.expectStatementSeparator$1("@error rule"); + return new A.ErrorRule0(value, t1.spanFrom$2(start, new A._SpanScannerState(t1, t2))); + }, + _stylesheet0$_functionRule$1(start) { + var precedingComment, t1, beforeName, $name, parameters, _0_0, _this = this; + _this.whitespace$1$consumeNewlines(true); + precedingComment = _this.lastSilentComment; + _this.lastSilentComment = null; + t1 = _this.scanner; + beforeName = new A._SpanScannerState(t1, t1._string_scanner$_position); + $name = _this.identifier$0(); + if (B.JSString_methods.startsWith$1($name, "--")) + _this.warnings.push(new A._Record_3_deprecation_message_span(B.Deprecation_d4j, string$.Sassx20_f_, t1.spanFrom$1(beforeName))); + else if (A.equalsIgnoreCase0($name, "type")) + _this.warnings.push(new A._Record_3_deprecation_message_span(B.Deprecation_vQt, string$.Sassx20_fs, t1.spanFrom$1(beforeName))); + _this.whitespace$1$consumeNewlines(true); + parameters = _this._stylesheet0$_parameterList$0(); + if (_this._stylesheet0$_inMixin || _this._stylesheet0$_inContentBlock) + _this.error$2(0, string$.Mixinscf, t1.spanFrom$1(start)); + else if (_this._stylesheet0$_inControlDirective) + _this.error$2(0, string$.Functi, t1.spanFrom$1(start)); + _0_0 = A.unvendor0($name); + if ("calc" === _0_0 || "element" === _0_0 || "expression" === _0_0 || "url" === _0_0 || "and" === _0_0 || "or" === _0_0 || "not" === _0_0 || "clamp" === _0_0) + _this.error$2(0, "Invalid function name.", t1.spanFrom$1(start)); + _this.whitespace$1$consumeNewlines(false); + return _this._stylesheet0$_withChildren$3(_this.get$_stylesheet0$_functionChild(), start, new A.StylesheetParser__functionRule_closure0($name, parameters, precedingComment)); + }, + _stylesheet0$_forRule$2(start, child) { + var wasInControlDirective, variable, from, _this = this, t1 = {}; + _this.whitespace$1$consumeNewlines(true); + wasInControlDirective = _this._stylesheet0$_inControlDirective; + _this._stylesheet0$_inControlDirective = true; + variable = _this.variableName$0(); + _this.whitespace$1$consumeNewlines(true); + _this.expectIdentifier$1("from"); + _this.whitespace$1$consumeNewlines(true); + t1.exclusive = null; + from = _this._stylesheet0$_expression$2$consumeNewlines$until(true, new A.StylesheetParser__forRule_closure1(t1, _this)); + if (t1.exclusive == null) + _this.scanner.error$1(0, 'Expected "to" or "through".'); + _this.whitespace$1$consumeNewlines(true); + return _this._stylesheet0$_withChildren$3(child, start, new A.StylesheetParser__forRule_closure2(t1, _this, wasInControlDirective, variable, from, _this._stylesheet0$_expression$0())); + }, + _stylesheet0$_forwardRule$1(start) { + var url, prefix, hiddenMixinsAndFunctions, hiddenVariables, _0_0, shownMixinsAndFunctions, shownVariables, _1_0, configuration, span, t1, t2, t3, t4, _this = this, _null = null; + _this.whitespace$1$consumeNewlines(true); + url = _this._stylesheet0$_urlString$0(); + _this.whitespace$1$consumeNewlines(false); + if (_this.scanIdentifier$1("as")) { + _this.whitespace$1$consumeNewlines(true); + prefix = _this.identifier$1$normalize(true); + _this.scanner.expectChar$1(42); + _this.whitespace$1$consumeNewlines(false); + } else + prefix = _null; + hiddenMixinsAndFunctions = _null; + hiddenVariables = _null; + if (_this.scanIdentifier$1("show")) { + _this.whitespace$1$consumeNewlines(true); + _0_0 = _this._stylesheet0$_memberList$0(); + shownMixinsAndFunctions = _0_0._0; + shownVariables = _0_0._1; + } else { + if (_this.scanIdentifier$1("hide")) { + _this.whitespace$1$consumeNewlines(true); + _1_0 = _this._stylesheet0$_memberList$0(); + hiddenMixinsAndFunctions = _1_0._0; + hiddenVariables = _1_0._1; + } + shownVariables = _null; + shownMixinsAndFunctions = shownVariables; + } + configuration = _this._stylesheet0$_configuration$1$allowGuarded(true); + _this.whitespace$1$consumeNewlines(false); + _this.expectStatementSeparator$1("@forward rule"); + span = _this.scanner.spanFrom$1(start); + if (!_this._stylesheet0$_isUseAllowed) + _this.error$2(0, string$.x40forwa, span); + if (shownMixinsAndFunctions != null) { + shownVariables.toString; + t1 = type$.String; + t2 = A.LinkedHashSet_LinkedHashSet$of(shownMixinsAndFunctions, t1); + t3 = type$.UnmodifiableSetView_String; + t1 = A.LinkedHashSet_LinkedHashSet$of(shownVariables, t1); + t4 = configuration == null ? B.List_empty22 : A.List_List$unmodifiable(configuration, type$.ConfiguredVariable_2); + return new A.ForwardRule0(url, new A.UnmodifiableSetView0(t2, t3), new A.UnmodifiableSetView0(t1, t3), _null, _null, prefix, t4, span); + } else if (hiddenMixinsAndFunctions != null) { + hiddenVariables.toString; + t1 = type$.String; + t2 = A.LinkedHashSet_LinkedHashSet$of(hiddenMixinsAndFunctions, t1); + t3 = type$.UnmodifiableSetView_String; + t1 = A.LinkedHashSet_LinkedHashSet$of(hiddenVariables, t1); + t4 = configuration == null ? B.List_empty22 : A.List_List$unmodifiable(configuration, type$.ConfiguredVariable_2); + return new A.ForwardRule0(url, _null, _null, new A.UnmodifiableSetView0(t2, t3), new A.UnmodifiableSetView0(t1, t3), prefix, t4, span); + } else + return new A.ForwardRule0(url, _null, _null, _null, _null, prefix, configuration == null ? B.List_empty22 : A.List_List$unmodifiable(configuration, type$.ConfiguredVariable_2), span); + }, + _stylesheet0$_memberList$0() { + var _this = this, + t1 = type$.String, + identifiers = A.LinkedHashSet_LinkedHashSet$_empty(t1), + variables = A.LinkedHashSet_LinkedHashSet$_empty(t1); + t1 = _this.scanner; + do { + _this.whitespace$1$consumeNewlines(true); + _this.withErrorMessage$2(string$.Expectv, new A.StylesheetParser__memberList_closure0(_this, variables, identifiers)); + _this.whitespace$1$consumeNewlines(false); + } while (t1.scanChar$1(44)); + return new A._Record_2(identifiers, variables); + }, + _stylesheet0$_ifRule$2(start, child) { + var ifIndentation, wasInControlDirective, condition, children, clauses, lastClause, span, _this = this; + _this.whitespace$1$consumeNewlines(true); + ifIndentation = _this.get$currentIndentation(); + wasInControlDirective = _this._stylesheet0$_inControlDirective; + _this._stylesheet0$_inControlDirective = true; + condition = _this._stylesheet0$_expression$0(); + children = _this.children$1(0, child); + _this.whitespaceWithoutComments$1$consumeNewlines(false); + clauses = A._setArrayType([A.IfClause$0(condition, children)], type$.JSArray_IfClause_2); + while (true) { + if (!_this.scanElse$1(ifIndentation)) { + lastClause = null; + break; + } + _this.whitespace$1$consumeNewlines(false); + if (_this.scanIdentifier$1("if")) { + _this.whitespace$1$consumeNewlines(true); + clauses.push(A.IfClause$0(_this._stylesheet0$_expression$0(), _this.children$1(0, child))); + } else { + lastClause = A.ElseClause$0(_this.children$1(0, child)); + break; + } + } + _this._stylesheet0$_inControlDirective = wasInControlDirective; + span = _this.scanner.spanFrom$1(start); + _this.whitespaceWithoutComments$1$consumeNewlines(false); + return new A.IfRule0(A.List_List$unmodifiable(clauses, type$.IfClause_2), lastClause, span); + }, + _stylesheet0$_importRule$1(start) { + var argument, t3, _this = this, + imports = A._setArrayType([], type$.JSArray_Import_2), + t1 = _this.scanner, + t2 = _this.warnings; + do { + _this.whitespace$1$consumeNewlines(false); + argument = _this.importArgument$0(); + t3 = argument instanceof A.DynamicImport0; + if (t3) + t2.push(new A._Record_3_deprecation_message_span(B.Deprecation_OHJ, string$.Sassx20_i, argument.span)); + if ((_this._stylesheet0$_inControlDirective || _this._stylesheet0$_inMixin) && t3) + _this._stylesheet0$_disallowedAtRule$1(start); + imports.push(argument); + _this.whitespace$1$consumeNewlines(false); + } while (t1.scanChar$1(44)); + _this.expectStatementSeparator$1("@import rule"); + t1 = t1.spanFrom$1(start); + return new A.ImportRule0(A.List_List$unmodifiable(imports, type$.Import_2), t1); + }, + importArgument$0() { + var url, urlSpan, innerError, stackTrace, modifiers, t2, exception, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + _0_0 = t1.peekChar$0(); + if (117 === _0_0 || 85 === _0_0) { + url = _this.dynamicUrl$0(); + _this.whitespace$1$consumeNewlines(false); + modifiers = _this.tryImportModifiers$0(); + t2 = url instanceof A.StringExpression0 ? url.text : A.Interpolation$0(A._setArrayType([url], type$.JSArray_Object), A._setArrayType([url.get$span(url)], type$.JSArray_nullable_FileSpan), url.get$span(url)); + return new A.StaticImport0(t2, modifiers, t1.spanFrom$1(start)); + } + url = _this.string$0(); + urlSpan = t1.spanFrom$1(start); + _this.whitespace$1$consumeNewlines(false); + modifiers = _this.tryImportModifiers$0(); + if (_this.isPlainImportUrl$1(url) || modifiers != null) { + t2 = urlSpan; + return new A.StaticImport0(new A.Interpolation0(A.List_List$unmodifiable([A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t2.file._decodedChars, t2._file$_start, t2._end), 0, null)], type$.Object), B.List_null, urlSpan), modifiers, t1.spanFrom$1(start)); + } else + try { + t1 = _this.parseImportUrl$1(url); + return new A.DynamicImport0(t1, urlSpan); + } catch (exception) { + t1 = A.unwrapException(exception); + if (type$.FormatException._is(t1)) { + innerError = t1; + stackTrace = A.getTraceFromException(exception); + _this.error$3(0, "Invalid URL: " + J.get$message$x(innerError), urlSpan, stackTrace); + } else + throw exception; + } + }, + parseImportUrl$1(url) { + var t1 = $.$get$windows(); + if (t1.style.rootLength$1(url) > 0 && !$.$get$url().style.isRootRelative$1(url)) + return t1.toUri$1(url).toString$0(0); + A.Uri_parse(url); + return url; + }, + isPlainImportUrl$1(url) { + var _0_0, t1; + if (url.length < 5) + return false; + if (B.JSString_methods.endsWith$1(url, ".css")) + return true; + _0_0 = url.charCodeAt(0); + $label0$0: { + if (47 === _0_0) { + t1 = url.charCodeAt(1) === 47; + break $label0$0; + } + if (104 === _0_0) { + t1 = B.JSString_methods.startsWith$1(url, "http://") || B.JSString_methods.startsWith$1(url, "https://"); + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + tryImportModifiers$0() { + var t1, start, t2, t3, t4, buffer, t5, identifier, $name, query, t6, endPosition, _this = this; + if (!_this._stylesheet0$_lookingAtInterpolatedIdentifier$0() && _this.scanner.peekChar$0() !== 40) + return null; + t1 = _this.scanner; + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t2 = new A.StringBuffer(""); + t3 = A._setArrayType([], type$.JSArray_Object); + t4 = A._setArrayType([], type$.JSArray_nullable_FileSpan); + buffer = new A.InterpolationBuffer0(t2, t3, t4); + for (; true;) + if (_this._stylesheet0$_lookingAtInterpolatedIdentifier$0()) { + if (!(t3.length === 0 && t2._contents.length === 0)) { + t5 = A.Primitives_stringFromCharCode(32); + t2._contents += t5; + } + identifier = _this.interpolatedIdentifier$0(); + buffer.addInterpolation$1(identifier); + t5 = identifier.get$asPlain(); + $name = t5 == null ? null : t5.toLowerCase(); + if ($name !== "and" && t1.scanChar$1(40)) { + if ($name === "supports") { + query = _this._stylesheet0$_importSupportsQuery$0(); + t5 = !(query instanceof A.SupportsDeclaration0); + if (t5) { + t6 = A.Primitives_stringFromCharCode(40); + t2._contents += t6; + } + t6 = query.get$span(query); + buffer._interpolation_buffer0$_flushText$0(); + t3.push(new A.SupportsExpression0(query)); + t4.push(t6); + if (t5) { + t5 = A.Primitives_stringFromCharCode(41); + t2._contents += t5; + } + } else { + t5 = A.Primitives_stringFromCharCode(40); + t2._contents += t5; + buffer.addInterpolation$1(_this._stylesheet0$_interpolatedDeclarationValue$3$allowEmpty$allowSemicolon$consumeNewlines(true, true, true)); + t5 = A.Primitives_stringFromCharCode(41); + t2._contents += t5; + } + t1.expectChar$1(41); + _this.whitespace$1$consumeNewlines(false); + } else { + _this.whitespace$1$consumeNewlines(false); + if (t1.scanChar$1(44)) { + t2._contents += ", "; + buffer.addInterpolation$1(_this._stylesheet0$_mediaQueryList$0()); + endPosition = t1._string_scanner$_position; + t2 = t1._sourceFile; + t3 = start.position; + t1 = new A._FileSpan(t2, t3, endPosition); + t1._FileSpan$3(t2, t3, endPosition); + return buffer.interpolation$1(t1); + } + } + } else if (t1.peekChar$0() === 40) { + if (!(t3.length === 0 && t2._contents.length === 0)) { + t3 = A.Primitives_stringFromCharCode(32); + t2._contents += t3; + } + buffer.addInterpolation$1(_this._stylesheet0$_mediaQueryList$0()); + endPosition = t1._string_scanner$_position; + t1 = t1._sourceFile; + t2 = start.position; + t3 = new A._FileSpan(t1, t2, endPosition); + t3._FileSpan$3(t1, t2, endPosition); + return buffer.interpolation$1(t3); + } else { + endPosition = t1._string_scanner$_position; + t1 = t1._sourceFile; + t2 = start.position; + t3 = new A._FileSpan(t1, t2, endPosition); + t3._FileSpan$3(t1, t2, endPosition); + return buffer.interpolation$1(t3); + } + }, + _stylesheet0$_importSupportsQuery$0() { + var t1, t2, _0_0, $name, _this = this; + _this.whitespace$1$consumeNewlines(true); + if (_this.scanIdentifier$1("not")) { + _this.whitespace$1$consumeNewlines(true); + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + return new A.SupportsNegation0(_this._stylesheet0$_supportsConditionInParens$0(), t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + } else { + t1 = _this.scanner; + if (t1.peekChar$0() === 40) + return _this._stylesheet0$_supportsCondition$1$inParentheses(true); + else { + _0_0 = _this._stylesheet0$_tryImportSupportsFunction$0(); + if (_0_0 != null) + return _0_0; + t2 = t1._string_scanner$_position; + $name = _this._stylesheet0$_expression$1$consumeNewlines(true); + t1.expectChar$1(58); + return new A.SupportsDeclaration0($name, _this._stylesheet0$_supportsDeclarationValue$1($name), t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + } + } + }, + _stylesheet0$_tryImportSupportsFunction$0() { + var t1, start, $name, value, _this = this; + if (!_this._stylesheet0$_lookingAtInterpolatedIdentifier$0()) + return null; + t1 = _this.scanner; + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + $name = _this.interpolatedIdentifier$0(); + if (!t1.scanChar$1(40)) { + t1.set$state(start); + return null; + } + value = _this._stylesheet0$_interpolatedDeclarationValue$3$allowEmpty$allowSemicolon$consumeNewlines(true, true, true); + t1.expectChar$1(41); + return new A.SupportsFunction0($name, value, t1.spanFrom$1(start)); + }, + _stylesheet0$_includeRule$1(start) { + var $name, t1, name0, namespace, $arguments, t2, t3, contentParameters, contentParameters_, wasInContentBlock, $content, span, _this = this, _null = null; + _this.whitespace$1$consumeNewlines(true); + $name = _this.identifier$0(); + t1 = _this.scanner; + if (t1.scanChar$1(46)) { + name0 = _this._stylesheet0$_publicIdentifier$0(); + namespace = $name; + $name = name0; + } else + namespace = _null; + _this.whitespace$1$consumeNewlines(false); + if (t1.peekChar$0() === 40) + $arguments = _this._stylesheet0$_argumentInvocation$1$mixin(true); + else { + t2 = A.FileLocation$_(t1._sourceFile, t1._string_scanner$_position); + t3 = t2.offset; + $arguments = A.ArgumentList$empty0(A._FileSpan$(t2.file, t3, t3)); + } + _this.whitespace$1$consumeNewlines(false); + if (_this.scanIdentifier$1("using")) { + _this.whitespace$1$consumeNewlines(true); + contentParameters = _this._stylesheet0$_parameterList$0(); + _this.whitespace$1$consumeNewlines(false); + } else + contentParameters = _null; + t2 = contentParameters == null; + if (!t2 || _this.lookingAtChildren$0()) { + if (t2) { + t2 = A.FileLocation$_(t1._sourceFile, t1._string_scanner$_position); + t3 = t2.offset; + contentParameters_ = new A.ParameterList0(B.List_empty24, _null, A._FileSpan$(t2.file, t3, t3)); + } else + contentParameters_ = contentParameters; + wasInContentBlock = _this._stylesheet0$_inContentBlock; + _this._stylesheet0$_inContentBlock = true; + $content = _this._stylesheet0$_withChildren$3(_this.get$_stylesheet0$_statement(), start, new A.StylesheetParser__includeRule_closure0(contentParameters_)); + _this._stylesheet0$_inContentBlock = wasInContentBlock; + } else { + _this.expectStatementSeparator$0(); + $content = _null; + } + t1 = t1.spanFrom$2(start, start); + t2 = $content == null ? $arguments : $content; + span = t1.expand$1(0, t2.get$span(t2)); + return new A.IncludeRule0(namespace, A.stringReplaceAllUnchecked($name, "_", "-"), $name, $arguments, $content, span); + }, + mediaRule$1(start) { + var _this = this; + _this.whitespace$1$consumeNewlines(false); + return _this._stylesheet0$_withChildren$3(_this.get$_stylesheet0$_statement(), start, new A.StylesheetParser_mediaRule_closure0(_this._stylesheet0$_mediaQueryList$0())); + }, + _stylesheet0$_mixinRule$1(start) { + var precedingComment, t1, t2, $name, parameters, t3, _this = this; + _this.whitespace$1$consumeNewlines(true); + precedingComment = _this.lastSilentComment; + _this.lastSilentComment = null; + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + $name = _this.identifier$0(); + if (B.JSString_methods.startsWith$1($name, "--")) + _this.warnings.push(new A._Record_3_deprecation_message_span(B.Deprecation_d4j, string$.Sassx20_m, t1.spanFrom$1(new A._SpanScannerState(t1, t2)))); + _this.whitespace$1$consumeNewlines(false); + if (t1.peekChar$0() === 40) + parameters = _this._stylesheet0$_parameterList$0(); + else { + t2 = A.FileLocation$_(t1._sourceFile, t1._string_scanner$_position); + t3 = t2.offset; + parameters = new A.ParameterList0(B.List_empty24, null, A._FileSpan$(t2.file, t3, t3)); + } + if (_this._stylesheet0$_inMixin || _this._stylesheet0$_inContentBlock) + _this.error$2(0, string$.Mixinscm, t1.spanFrom$1(start)); + else if (_this._stylesheet0$_inControlDirective) + _this.error$2(0, string$.Mixinsb, t1.spanFrom$1(start)); + _this.whitespace$1$consumeNewlines(false); + _this._stylesheet0$_inMixin = true; + return _this._stylesheet0$_withChildren$3(_this.get$_stylesheet0$_statement(), start, new A.StylesheetParser__mixinRule_closure0(_this, $name, parameters, precedingComment)); + }, + mozDocumentRule$2(start, $name) { + var t1, t2, t3, t4, t5, buffer, _0_0, t6, identifier, _1_0, argument, trailing, endPosition, t7, t8, start0, end, _this = this, _box_0 = {}; + _this.whitespace$1$consumeNewlines(false); + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + t3 = new A.StringBuffer(""); + t4 = A._setArrayType([], type$.JSArray_Object); + t5 = A._setArrayType([], type$.JSArray_nullable_FileSpan); + buffer = new A.InterpolationBuffer0(t3, t4, t5); + _box_0.needsDeprecationWarning = false; + for (; true;) { + if (t1.peekChar$0() === 35) { + _0_0 = _this.singleInterpolation$0(); + buffer._interpolation_buffer0$_flushText$0(); + t4.push(_0_0._0); + t5.push(_0_0._1); + _box_0.needsDeprecationWarning = true; + } else { + t6 = t1._string_scanner$_position; + identifier = _this.identifier$0(); + $label0$0: { + if ("url" === identifier || "url-prefix" === identifier || "domain" === identifier) { + _1_0 = _this._stylesheet0$_tryUrlContents$2$name(new A._SpanScannerState(t1, t6), identifier); + if (_1_0 != null) + buffer.addInterpolation$1(_1_0); + else { + t1.expectChar$1(40); + _this.whitespace$1$consumeNewlines(false); + argument = _this.interpolatedString$0(); + t1.expectChar$1(41); + t3._contents += identifier; + t6 = A.Primitives_stringFromCharCode(40); + t3._contents += t6; + buffer.addInterpolation$1(argument.asInterpolation$0()); + t6 = A.Primitives_stringFromCharCode(41); + t3._contents += t6; + } + t6 = t3._contents; + trailing = t6.charCodeAt(0) == 0 ? t6 : t6; + if (!B.JSString_methods.endsWith$1(trailing, "url-prefix()") && !B.JSString_methods.endsWith$1(trailing, "url-prefix('')") && !B.JSString_methods.endsWith$1(trailing, 'url-prefix("")')) + _box_0.needsDeprecationWarning = true; + break $label0$0; + } + if ("regexp" === identifier) { + t3._contents += "regexp("; + t1.expectChar$1(40); + buffer.addInterpolation$1(_this.interpolatedString$0().asInterpolation$0()); + t1.expectChar$1(41); + t6 = A.Primitives_stringFromCharCode(41); + t3._contents += t6; + _box_0.needsDeprecationWarning = true; + break $label0$0; + } + endPosition = t1._string_scanner$_position; + t7 = t1._sourceFile; + t8 = new A._FileSpan(t7, t6, endPosition); + t8._FileSpan$3(t7, t6, endPosition); + _this.error$2(0, "Invalid function name.", t8); + } + } + _this.whitespace$1$consumeNewlines(false); + if (!t1.scanChar$1(44)) + break; + t6 = A.Primitives_stringFromCharCode(44); + t3._contents += t6; + start0 = t1._string_scanner$_position; + new A.StylesheetParser_mozDocumentRule_closure1(_this).call$0(); + end = t1._string_scanner$_position; + t3._contents += B.JSString_methods.substring$2(t1.string, start0, end); + } + return _this._stylesheet0$_withChildren$3(_this.get$_stylesheet0$_statement(), start, new A.StylesheetParser_mozDocumentRule_closure2(_box_0, _this, $name, buffer.interpolation$1(t1.spanFrom$1(new A._SpanScannerState(t1, t2))))); + }, + supportsRule$1(start) { + var condition, _this = this; + _this.whitespace$1$consumeNewlines(false); + condition = _this._stylesheet0$_supportsCondition$0(); + _this.whitespace$1$consumeNewlines(false); + return _this._stylesheet0$_withChildren$3(_this.get$_stylesheet0$_statement(), start, new A.StylesheetParser_supportsRule_closure0(condition)); + }, + _stylesheet0$_useNamespace$2(url, start) { + var namespace, basename, dot, t1, exception, _this = this; + if (_this.scanIdentifier$1("as")) { + _this.whitespace$1$consumeNewlines(true); + return _this.scanner.scanChar$1(42) ? null : _this.identifier$0(); + } + basename = url.get$pathSegments().length === 0 ? "" : B.JSArray_methods.get$last(url.get$pathSegments()); + dot = B.JSString_methods.indexOf$1(basename, "."); + t1 = B.JSString_methods.startsWith$1(basename, "_") ? 1 : 0; + namespace = B.JSString_methods.substring$2(basename, t1, dot === -1 ? basename.length : dot); + try { + t1 = new A.Parser1(A.SpanScanner$(namespace, null), null)._parser1$_parseIdentifier$0(); + return t1; + } catch (exception) { + if (type$.SassFormatException_2._is(A.unwrapException(exception))) + _this.error$2(0, 'The default namespace "' + A.S(namespace) + string$.x22x20is_n, _this.scanner.spanFrom$1(start)); + else + throw exception; + } + }, + _stylesheet0$_configuration$1$allowGuarded(allowGuarded) { + var variableNames, configuration, t1, t2, $name, expression, t3, guarded, endPosition, t4, t5, span, _this = this; + if (!_this.scanIdentifier$1("with")) + return null; + variableNames = A.LinkedHashSet_LinkedHashSet$_empty(type$.String); + configuration = A._setArrayType([], type$.JSArray_ConfiguredVariable_2); + _this.whitespace$1$consumeNewlines(true); + t1 = _this.scanner; + t1.expectChar$1(40); + for (; true;) { + _this.whitespace$1$consumeNewlines(true); + t2 = t1._string_scanner$_position; + t1.expectChar$1(36); + $name = _this.identifier$1$normalize(true); + _this.whitespace$1$consumeNewlines(true); + t1.expectChar$1(58); + _this.whitespace$1$consumeNewlines(true); + expression = _this.expressionUntilComma$0(); + t3 = t1._string_scanner$_position; + if (allowGuarded && t1.scanChar$1(33)) { + guarded = _this.identifier$0() === "default"; + if (guarded) + _this.whitespace$1$consumeNewlines(true); + else { + endPosition = t1._string_scanner$_position; + t4 = t1._sourceFile; + t5 = new A._FileSpan(t4, t3, endPosition); + t5._FileSpan$3(t4, t3, endPosition); + _this.error$2(0, "Invalid flag name.", t5); + } + } else + guarded = false; + endPosition = t1._string_scanner$_position; + t3 = t1._sourceFile; + span = new A._FileSpan(t3, t2, endPosition); + span._FileSpan$3(t3, t2, endPosition); + if (variableNames.contains$1(0, $name)) + _this.error$2(0, string$.The_sa, span); + variableNames.add$1(0, $name); + configuration.push(new A.ConfiguredVariable0($name, expression, guarded, span)); + if (!t1.scanChar$1(44)) + break; + _this.whitespace$1$consumeNewlines(true); + if (!_this._stylesheet0$_lookingAtExpression$0()) + break; + } + t1.expectChar$1(41); + return configuration; + }, + _stylesheet0$_configuration$0() { + return this._stylesheet0$_configuration$1$allowGuarded(false); + }, + _stylesheet0$_warnRule$1(start) { + var value, t1, t2, _this = this; + _this.whitespace$1$consumeNewlines(true); + value = _this._stylesheet0$_expression$0(); + t1 = _this.scanner; + t2 = t1._string_scanner$_position; + _this.expectStatementSeparator$1("@warn rule"); + return new A.WarnRule0(value, t1.spanFrom$2(start, new A._SpanScannerState(t1, t2))); + }, + _stylesheet0$_whileRule$2(start, child) { + var wasInControlDirective, _this = this; + _this.whitespace$1$consumeNewlines(true); + wasInControlDirective = _this._stylesheet0$_inControlDirective; + _this._stylesheet0$_inControlDirective = true; + return _this._stylesheet0$_withChildren$3(child, start, new A.StylesheetParser__whileRule_closure0(_this, wasInControlDirective, _this._stylesheet0$_expression$0())); + }, + unknownAtRule$2(start, $name) { + var t2, t3, rule, _this = this, t1 = {}, + wasInUnknownAtRule = _this._stylesheet0$_inUnknownAtRule; + _this._stylesheet0$_inUnknownAtRule = true; + _this.whitespace$1$consumeNewlines(false); + t1.value = null; + t2 = _this.scanner; + t3 = t2.peekChar$0() !== 33 && !_this.atEndOfStatement$0() ? t1.value = _this._stylesheet0$_interpolatedDeclarationValue$1$allowOpenBrace(false) : null; + if (_this.lookingAtChildren$0()) + rule = _this._stylesheet0$_withChildren$3(_this.get$_stylesheet0$_statement(), start, new A.StylesheetParser_unknownAtRule_closure0(t1, $name)); + else { + _this.expectStatementSeparator$0(); + rule = A.AtRule$0($name, t2.spanFrom$1(start), null, t3); + } + _this._stylesheet0$_inUnknownAtRule = wasInUnknownAtRule; + return rule; + }, + _stylesheet0$_disallowedAtRule$1(start) { + var _this = this; + _this.whitespace$1$consumeNewlines(false); + _this._stylesheet0$_interpolatedDeclarationValue$2$allowEmpty$allowOpenBrace(true, false); + _this.error$2(0, "This at-rule is not allowed here.", _this.scanner.spanFrom$1(start)); + }, + _stylesheet0$_parameterList$0() { + var parameters, named, restParameter, t3, $name, defaultValue, endPosition, t4, t5, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position; + t1.expectChar$1(40); + _this.whitespace$1$consumeNewlines(true); + parameters = A._setArrayType([], type$.JSArray_Parameter_2); + named = A.LinkedHashSet_LinkedHashSet$_empty(type$.String); + for (; restParameter = null, t1.peekChar$0() === 36;) { + t3 = t1._string_scanner$_position; + t1.expectChar$1(36); + $name = _this.identifier$1$normalize(true); + _this.whitespace$1$consumeNewlines(true); + if (t1.scanChar$1(58)) { + _this.whitespace$1$consumeNewlines(true); + defaultValue = _this.expressionUntilComma$0(); + } else { + if (t1.scanChar$1(46)) { + t1.expectChar$1(46); + t1.expectChar$1(46); + _this.whitespace$1$consumeNewlines(true); + if (t1.scanChar$1(44)) + _this.whitespace$1$consumeNewlines(true); + restParameter = $name; + break; + } + defaultValue = null; + } + endPosition = t1._string_scanner$_position; + t4 = t1._sourceFile; + t5 = new A._FileSpan(t4, t3, endPosition); + t5._FileSpan$3(t4, t3, endPosition); + parameters.push(new A.Parameter0($name, defaultValue, t5)); + if (!named.add$1(0, $name)) + _this.error$2(0, "Duplicate parameter.", B.JSArray_methods.get$last(parameters).span); + if (!t1.scanChar$1(44)) + break; + _this.whitespace$1$consumeNewlines(true); + } + t1.expectChar$1(41); + t1 = t1.spanFrom$1(new A._SpanScannerState(t1, t2)); + return new A.ParameterList0(A.List_List$unmodifiable(parameters, type$.Parameter_2), restParameter, t1); + }, + _stylesheet0$_argumentInvocation$2$allowEmptySecondArg$mixin(allowEmptySecondArg, mixin) { + var positional, t3, t4, named, t5, rest, keywordRest, expression, t6, t7, result, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position; + t1.expectChar$1(40); + _this.whitespace$1$consumeNewlines(true); + positional = A._setArrayType([], type$.JSArray_Expression_2); + t3 = type$.String; + t4 = type$.Expression_2; + named = A.LinkedHashMap_LinkedHashMap$_empty(t3, t4); + for (t5 = !mixin, rest = null; keywordRest = null, _this._stylesheet0$_lookingAtExpression$0();) { + expression = _this.expressionUntilComma$1$singleEquals(t5); + _this.whitespace$1$consumeNewlines(true); + if (expression instanceof A.VariableExpression0 && t1.scanChar$1(58)) { + _this.whitespace$1$consumeNewlines(true); + t6 = expression.name; + if (named.containsKey$1(t6)) + _this.error$2(0, "Duplicate argument.", expression.span); + named.$indexSet(0, t6, _this.expressionUntilComma$1$singleEquals(t5)); + } else if (t1.scanChar$1(46)) { + t1.expectChar$1(46); + t1.expectChar$1(46); + if (rest != null) { + _this.whitespace$1$consumeNewlines(true); + if (t1.scanChar$1(44)) + _this.whitespace$1$consumeNewlines(true); + keywordRest = expression; + break; + } + rest = expression; + } else if (named.__js_helper$_length !== 0) + _this.error$2(0, string$.Positi, expression.get$span(expression)); + else + positional.push(expression); + _this.whitespace$1$consumeNewlines(true); + if (!t1.scanChar$1(44)) + break; + _this.whitespace$1$consumeNewlines(true); + if (allowEmptySecondArg && positional.length === 1 && named.__js_helper$_length === 0 && rest == null && t1.peekChar$0() === 41) { + t5 = t1._sourceFile; + t6 = t1._string_scanner$_position; + new A.FileLocation(t5, t6).FileLocation$_$2(t5, t6); + t7 = new A._FileSpan(t5, t6, t6); + t7._FileSpan$3(t5, t6, t6); + result = A.List_List$from([""], false, type$.Object); + result.$flags = 3; + positional.push(new A.StringExpression0(new A.Interpolation0(result, B.List_null, t7), false)); + break; + } + } + t1.expectChar$1(41); + t1 = t1.spanFrom$1(new A._SpanScannerState(t1, t2)); + return new A.ArgumentList0(A.List_List$unmodifiable(positional, t4), A.ConstantMap_ConstantMap$from(named, t3, t4), rest, keywordRest, t1); + }, + _stylesheet0$_argumentInvocation$0() { + return this._stylesheet0$_argumentInvocation$2$allowEmptySecondArg$mixin(false, false); + }, + _stylesheet0$_argumentInvocation$1$allowEmptySecondArg(allowEmptySecondArg) { + return this._stylesheet0$_argumentInvocation$2$allowEmptySecondArg$mixin(allowEmptySecondArg, false); + }, + _stylesheet0$_argumentInvocation$1$mixin(mixin) { + return this._stylesheet0$_argumentInvocation$2$allowEmptySecondArg$mixin(false, mixin); + }, + _stylesheet0$_expression$4$bracketList$consumeNewlines$singleEquals$until(bracketList, consumeNewlines, singleEquals, until) { + var t2, beforeBracket, start, wasInExpression, wasInParentheses, resetState, resolveOneOperation, resolveOperations, addSingleExpression, addOperator, resolveSpaceExpressions, t3, t4, _3_0, _1_0, t5, _3_28, _2_0, _3_32, _3_40, commaExpressions, spaceExpressions, singleExpression, _this = this, + _s20_ = "Expected expression.", + _box_0 = {}, + t1 = until != null; + if (t1 && until.call$0()) + _this.scanner.error$1(0, _s20_); + if (bracketList) { + t2 = _this.scanner; + beforeBracket = new A._SpanScannerState(t2, t2._string_scanner$_position); + t2.expectChar$1(91); + _this.whitespace$1$consumeNewlines(true); + if (t2.scanChar$1(93)) { + t1 = A._setArrayType([], type$.JSArray_Expression_2); + t2 = t2.spanFrom$1(beforeBracket); + return new A.ListExpression0(A.List_List$unmodifiable(t1, type$.Expression_2), B.ListSeparator_undecided_null_undecided0, true, t2); + } + } else + beforeBracket = null; + t2 = _this.scanner; + start = new A._SpanScannerState(t2, t2._string_scanner$_position); + wasInExpression = _this._stylesheet0$_inExpression; + wasInParentheses = _this._stylesheet0$_inParentheses; + _this._stylesheet0$_inExpression = true; + _box_0.operands_ = _box_0.operators_ = _box_0.spaceExpressions_ = _box_0.commaExpressions_ = null; + _box_0.allowSlash = true; + _box_0.singleExpression_ = _this._stylesheet0$_singleExpression$0(); + resetState = new A.StylesheetParser__expression_resetState0(_box_0, _this, start); + resolveOneOperation = new A.StylesheetParser__expression_resolveOneOperation0(_box_0, _this); + resolveOperations = new A.StylesheetParser__expression_resolveOperations0(_box_0, resolveOneOperation); + addSingleExpression = new A.StylesheetParser__expression_addSingleExpression0(_box_0, _this, resetState, resolveOperations); + addOperator = new A.StylesheetParser__expression_addOperator0(_box_0, _this, resolveOneOperation, addSingleExpression); + resolveSpaceExpressions = new A.StylesheetParser__expression_resolveSpaceExpressions0(_box_0, _this, resolveOperations); + for (t3 = !consumeNewlines, t4 = type$.JSArray_Expression_2; true;) { + _this.whitespace$1$consumeNewlines(!t3 || bracketList); + if (t1 && until.call$0()) + break; + _3_0 = t2.peekChar$0(); + if (_3_0 == null) + break; + if (40 === _3_0) { + addSingleExpression.call$1(_this.parentheses$0()); + continue; + } + if (91 === _3_0) { + addSingleExpression.call$1(_this._stylesheet0$_expression$1$bracketList(true)); + continue; + } + if (36 === _3_0) { + addSingleExpression.call$1(_this._stylesheet0$_variable$0()); + continue; + } + if (38 === _3_0) { + addSingleExpression.call$1(_this._stylesheet0$_selector$0()); + continue; + } + if (39 === _3_0 || 34 === _3_0) { + addSingleExpression.call$1(_this.interpolatedString$0()); + continue; + } + if (35 === _3_0) { + addSingleExpression.call$1(_this._stylesheet0$_hashExpression$0()); + continue; + } + if (61 === _3_0) { + t2.readChar$0(); + if (singleEquals && t2.peekChar$0() !== 61) + addOperator.call$1(B.BinaryOperator_Kyq0); + else { + t2.expectChar$1(61); + addOperator.call$1(B.BinaryOperator_r840); + } + continue; + } + if (33 === _3_0) { + $label0$1: { + _1_0 = t2.peekChar$1(1); + if (61 === _1_0) { + t2.readChar$0(); + t2.readChar$0(); + addOperator.call$1(B.BinaryOperator_qGq0); + break $label0$1; + } + t5 = true; + if (_1_0 != null) + if (105 !== _1_0) + if (73 !== _1_0) + t5 = _1_0 === 32 || _1_0 === 9 || _1_0 === 10 || _1_0 === 13 || _1_0 === 12; + if (t5) { + addSingleExpression.call$1(_this._stylesheet0$_importantExpression$0()); + break $label0$1; + } + break; + } + continue; + } + if (60 === _3_0) { + t2.readChar$0(); + addOperator.call$1(t2.scanChar$1(61) ? B.BinaryOperator_FPG0 : B.BinaryOperator_qHy0); + continue; + } + if (62 === _3_0) { + t2.readChar$0(); + addOperator.call$1(t2.scanChar$1(61) ? B.BinaryOperator_JiR0 : B.BinaryOperator_o8O0); + continue; + } + if (42 === _3_0) { + t2.readChar$0(); + addOperator.call$1(B.BinaryOperator_tht0); + continue; + } + _3_28 = 43 === _3_0; + if (_3_28 && _box_0.singleExpression_ == null) { + addSingleExpression.call$1(_this._stylesheet0$_unaryOperation$0()); + continue; + } + if (_3_28) { + t2.readChar$0(); + addOperator.call$1(B.BinaryOperator_Swh0); + continue; + } + if (45 === _3_0) { + _2_0 = t2.peekChar$1(1); + if (A._isInt(_2_0) && _2_0 >= 48 && _2_0 <= 57 || 46 === _2_0) + if (_box_0.singleExpression_ != null) { + t5 = t2.peekChar$1(-1); + t5 = t5 === 32 || t5 === 9 || t5 === 10 || t5 === 13 || t5 === 12; + } else + t5 = true; + else + t5 = false; + if (t5) + addSingleExpression.call$1(_this._stylesheet0$_number$0()); + else if (_this._stylesheet0$_lookingAtInterpolatedIdentifier$0()) + addSingleExpression.call$1(_this.identifierLike$0()); + else if (_box_0.singleExpression_ == null) + addSingleExpression.call$1(_this._stylesheet0$_unaryOperation$0()); + else { + t2.readChar$0(); + addOperator.call$1(B.BinaryOperator_QG10); + } + continue; + } + _3_32 = 47 === _3_0; + if (_3_32 && _box_0.singleExpression_ == null) { + addSingleExpression.call$1(_this._stylesheet0$_unaryOperation$0()); + continue; + } + if (_3_32) { + t2.readChar$0(); + addOperator.call$1(B.BinaryOperator_Mh50); + continue; + } + if (37 === _3_0) { + t2.readChar$0(); + addOperator.call$1(B.BinaryOperator_s7T0); + continue; + } + if (_3_0 >= 48 && _3_0 <= 57) { + addSingleExpression.call$1(_this._stylesheet0$_number$0()); + continue; + } + _3_40 = 46 === _3_0; + if (_3_40 && t2.peekChar$1(1) === 46) + break; + if (_3_40) { + addSingleExpression.call$1(_this._stylesheet0$_number$0()); + continue; + } + if (97 === _3_0 && !_this.get$plainCss() && _this.scanIdentifier$1("and")) { + addOperator.call$1(B.BinaryOperator_uke0); + continue; + } + if (111 === _3_0 && !_this.get$plainCss() && _this.scanIdentifier$1("or")) { + addOperator.call$1(B.BinaryOperator_tKu0); + continue; + } + if ((117 === _3_0 || 85 === _3_0) && t2.peekChar$1(1) === 43) { + addSingleExpression.call$1(_this._stylesheet0$_unicodeRange$0()); + continue; + } + if (!(_3_0 >= 97 && _3_0 <= 122)) + t5 = _3_0 >= 65 && _3_0 <= 90 || 95 === _3_0 || 92 === _3_0 || _3_0 >= 128; + else + t5 = true; + if (t5) { + addSingleExpression.call$1(_this.identifierLike$0()); + continue; + } + if (44 === _3_0) { + if (_this._stylesheet0$_inParentheses) { + _this._stylesheet0$_inParentheses = false; + if (_box_0.allowSlash) { + resetState.call$0(); + continue; + } + } + commaExpressions = _box_0.commaExpressions_; + if (commaExpressions == null) + commaExpressions = _box_0.commaExpressions_ = A._setArrayType([], t4); + if (_box_0.singleExpression_ == null) + t2.error$1(0, _s20_); + resolveSpaceExpressions.call$0(); + t5 = _box_0.singleExpression_; + t5.toString; + commaExpressions.push(t5); + t2.readChar$0(); + _box_0.allowSlash = true; + _box_0.singleExpression_ = null; + continue; + } + break; + } + if (bracketList) + t2.expectChar$1(93); + commaExpressions = _box_0.commaExpressions_; + spaceExpressions = _box_0.spaceExpressions_; + if (commaExpressions != null) { + resolveSpaceExpressions.call$0(); + _this._stylesheet0$_inParentheses = wasInParentheses; + singleExpression = _box_0.singleExpression_; + if (singleExpression != null) + commaExpressions.push(singleExpression); + _this._stylesheet0$_inExpression = wasInExpression; + t1 = t2.spanFrom$1(beforeBracket == null ? start : beforeBracket); + return new A.ListExpression0(A.List_List$unmodifiable(commaExpressions, type$.Expression_2), B.ListSeparator_qVN0, bracketList, t1); + } else if (bracketList && spaceExpressions != null) { + resolveOperations.call$0(); + _this._stylesheet0$_inExpression = wasInExpression; + t1 = _box_0.singleExpression_; + t1.toString; + spaceExpressions.push(t1); + beforeBracket.toString; + t2 = t2.spanFrom$1(beforeBracket); + return new A.ListExpression0(A.List_List$unmodifiable(spaceExpressions, type$.Expression_2), B.ListSeparator_qSL0, true, t2); + } else { + resolveSpaceExpressions.call$0(); + if (bracketList) { + t1 = _box_0.singleExpression_; + t1.toString; + t4 = A._setArrayType([t1], t4); + beforeBracket.toString; + t2 = t2.spanFrom$1(beforeBracket); + _box_0.singleExpression_ = new A.ListExpression0(A.List_List$unmodifiable(t4, type$.Expression_2), B.ListSeparator_undecided_null_undecided0, true, t2); + } + _this._stylesheet0$_inExpression = wasInExpression; + t1 = _box_0.singleExpression_; + t1.toString; + return t1; + } + }, + _stylesheet0$_expression$3$consumeNewlines$singleEquals$until(consumeNewlines, singleEquals, until) { + return this._stylesheet0$_expression$4$bracketList$consumeNewlines$singleEquals$until(false, consumeNewlines, singleEquals, until); + }, + _stylesheet0$_expression$1$bracketList(bracketList) { + return this._stylesheet0$_expression$4$bracketList$consumeNewlines$singleEquals$until(bracketList, false, false, null); + }, + _stylesheet0$_expression$1$consumeNewlines(consumeNewlines) { + return this._stylesheet0$_expression$4$bracketList$consumeNewlines$singleEquals$until(false, consumeNewlines, false, null); + }, + _stylesheet0$_expression$0() { + return this._stylesheet0$_expression$4$bracketList$consumeNewlines$singleEquals$until(false, false, false, null); + }, + _stylesheet0$_expression$2$consumeNewlines$until(consumeNewlines, until) { + return this._stylesheet0$_expression$4$bracketList$consumeNewlines$singleEquals$until(false, consumeNewlines, false, until); + }, + expressionUntilComma$1$singleEquals(singleEquals) { + return this._stylesheet0$_expression$3$consumeNewlines$singleEquals$until(true, singleEquals, new A.StylesheetParser_expressionUntilComma_closure0(this)); + }, + expressionUntilComma$0() { + return this.expressionUntilComma$1$singleEquals(false); + }, + _stylesheet0$_isSlashOperand$1(expression) { + var t1 = true; + if (!(expression instanceof A.NumberExpression0)) + if (!(expression instanceof A.FunctionExpression0)) + t1 = expression instanceof A.BinaryOperationExpression0 && expression.allowsSlash; + return t1; + }, + _stylesheet0$_singleExpression$0() { + var next, t2, _this = this, + _s20_ = "Expected expression.", + t1 = _this.scanner, + _0_0 = t1.peekChar$0(); + $label0$0: { + if (_0_0 == null) + t1.error$1(0, _s20_); + if (40 === _0_0) { + t1 = _this.parentheses$0(); + break $label0$0; + } + if (47 === _0_0) { + t1 = _this._stylesheet0$_unaryOperation$0(); + break $label0$0; + } + if (46 === _0_0) { + t1 = _this._stylesheet0$_number$0(); + break $label0$0; + } + if (91 === _0_0) { + t1 = _this._stylesheet0$_expression$1$bracketList(true); + break $label0$0; + } + if (36 === _0_0) { + t1 = _this._stylesheet0$_variable$0(); + break $label0$0; + } + if (38 === _0_0) { + t1 = _this._stylesheet0$_selector$0(); + break $label0$0; + } + if (39 === _0_0 || 34 === _0_0) { + t1 = _this.interpolatedString$0(); + break $label0$0; + } + if (35 === _0_0) { + t1 = _this._stylesheet0$_hashExpression$0(); + break $label0$0; + } + if (43 === _0_0) { + next = t1.peekChar$1(1); + t1 = next != null && next >= 48 && next <= 57 || next === 46 ? _this._stylesheet0$_number$0() : _this._stylesheet0$_unaryOperation$0(); + break $label0$0; + } + if (45 === _0_0) { + t1 = _this._stylesheet0$_minusExpression$0(); + break $label0$0; + } + if (33 === _0_0) { + t1 = _this._stylesheet0$_importantExpression$0(); + break $label0$0; + } + if (37 === _0_0) { + t2 = t1._string_scanner$_position; + t1.readChar$0(); + t2 = t1.spanFrom$1(new A._SpanScannerState(t1, t2)); + t2 = new A.StringExpression0(new A.Interpolation0(A.List_List$unmodifiable(["%"], type$.Object), B.List_null, t2), false); + t1 = t2; + break $label0$0; + } + if ((117 === _0_0 || 85 === _0_0) && t1.peekChar$1(1) === 43) { + t1 = _this._stylesheet0$_unicodeRange$0(); + break $label0$0; + } + if (_0_0 >= 48 && _0_0 <= 57) { + t1 = _this._stylesheet0$_number$0(); + break $label0$0; + } + if (!(_0_0 >= 97 && _0_0 <= 122)) + t2 = _0_0 >= 65 && _0_0 <= 90 || 95 === _0_0 || 92 === _0_0 || _0_0 >= 128; + else + t2 = true; + if (t2) { + t1 = _this.identifierLike$0(); + break $label0$0; + } + t1 = t1.error$1(0, _s20_); + } + return t1; + }, + parentheses$0() { + var start, first, expressions, t1, t2, _this = this, + wasInParentheses = _this._stylesheet0$_inParentheses; + _this._stylesheet0$_inParentheses = true; + try { + t1 = _this.scanner; + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expectChar$1(40); + _this.whitespace$1$consumeNewlines(true); + if (!_this._stylesheet0$_lookingAtExpression$0()) { + t1.expectChar$1(41); + t2 = A._setArrayType([], type$.JSArray_Expression_2); + t1 = t1.spanFrom$1(start); + t2 = A.List_List$unmodifiable(t2, type$.Expression_2); + return new A.ListExpression0(t2, B.ListSeparator_undecided_null_undecided0, false, t1); + } + first = _this.expressionUntilComma$0(); + if (t1.scanChar$1(58)) { + _this.whitespace$1$consumeNewlines(true); + t1 = _this._stylesheet0$_map$2(first, start); + return t1; + } + if (!t1.scanChar$1(44)) { + t1.expectChar$1(41); + t1 = t1.spanFrom$1(start); + return new A.ParenthesizedExpression0(first, t1); + } + _this.whitespace$1$consumeNewlines(true); + expressions = A._setArrayType([first], type$.JSArray_Expression_2); + for (; true;) { + if (!_this._stylesheet0$_lookingAtExpression$0()) + break; + J.add$1$ax(expressions, _this.expressionUntilComma$0()); + if (!t1.scanChar$1(44)) + break; + _this.whitespace$1$consumeNewlines(true); + } + t1.expectChar$1(41); + t1 = t1.spanFrom$1(start); + t2 = A.List_List$unmodifiable(expressions, type$.Expression_2); + return new A.ListExpression0(t2, B.ListSeparator_qVN0, false, t1); + } finally { + _this._stylesheet0$_inParentheses = wasInParentheses; + } + }, + _stylesheet0$_map$2(first, start) { + var t1, key, _this = this, + pairs = A._setArrayType([new A._Record_2(first, _this.expressionUntilComma$0())], type$.JSArray_Record_2_Expression_and_Expression_2); + for (t1 = _this.scanner; t1.scanChar$1(44);) { + _this.whitespace$1$consumeNewlines(true); + if (!_this._stylesheet0$_lookingAtExpression$0()) + break; + key = _this.expressionUntilComma$0(); + t1.expectChar$1(58); + _this.whitespace$1$consumeNewlines(true); + pairs.push(new A._Record_2(key, _this.expressionUntilComma$0())); + } + t1.expectChar$1(41); + t1 = t1.spanFrom$1(start); + return new A.MapExpression0(A.List_List$unmodifiable(pairs, type$.Record_2_Expression_and_Expression_2), t1); + }, + _stylesheet0$_hashExpression$0() { + var start, t2, identifier, buffer, t3, _this = this, + t1 = _this.scanner; + if (t1.peekChar$1(1) === 123) + return _this.identifierLike$0(); + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expectChar$1(35); + t2 = t1.peekChar$0(); + if (t2 == null) + t2 = null; + else + t2 = t2 >= 48 && t2 <= 57; + if (t2 === true) + return new A.ColorExpression0(_this._stylesheet0$_hexColorContents$1(start), t1.spanFrom$1(start)); + t2 = t1._string_scanner$_position; + identifier = _this.interpolatedIdentifier$0(); + if (_this._stylesheet0$_isHexColor$1(identifier)) { + t1.set$state(new A._SpanScannerState(t1, t2)); + return new A.ColorExpression0(_this._stylesheet0$_hexColorContents$1(start), t1.spanFrom$1(start)); + } + t2 = new A.StringBuffer(""); + buffer = new A.InterpolationBuffer0(t2, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t3 = A.Primitives_stringFromCharCode(35); + t2._contents += t3; + buffer.addInterpolation$1(identifier); + return new A.StringExpression0(buffer.interpolation$1(t1.spanFrom$1(start)), false); + }, + _stylesheet0$_hexColorContents$1(start) { + var red, green, blue, alpha, digit4, t2, t3, t4, _this = this, + digit1 = _this._stylesheet0$_hexDigit$0(), + digit2 = _this._stylesheet0$_hexDigit$0(), + digit3 = _this._stylesheet0$_hexDigit$0(), + t1 = _this.scanner, + $self = t1.peekChar$0(); + if (!($self != null && A.CharacterExtension_get_isHex0($self))) { + red = (digit1 << 4 >>> 0) + digit1; + green = (digit2 << 4 >>> 0) + digit2; + blue = (digit3 << 4 >>> 0) + digit3; + alpha = null; + } else { + digit4 = _this._stylesheet0$_hexDigit$0(); + $self = t1.peekChar$0(); + t2 = $self != null && A.CharacterExtension_get_isHex0($self); + t3 = digit1 << 4 >>> 0; + t4 = digit3 << 4 >>> 0; + if (!t2) { + red = t3 + digit1; + green = (digit2 << 4 >>> 0) + digit2; + blue = t4 + digit3; + alpha = ((digit4 << 4 >>> 0) + digit4) / 255; + } else { + red = t3 + digit2; + green = t4 + digit4; + blue = (_this._stylesheet0$_hexDigit$0() << 4 >>> 0) + _this._stylesheet0$_hexDigit$0(); + $self = t1.peekChar$0(); + alpha = $self != null && A.CharacterExtension_get_isHex0($self) ? ((_this._stylesheet0$_hexDigit$0() << 4 >>> 0) + _this._stylesheet0$_hexDigit$0()) / 255 : null; + } + } + t2 = alpha == null; + t3 = t2 ? 1 : alpha; + return A.SassColor_SassColor$rgbInternal0(red, green, blue, t3, t2 ? new A.SpanColorFormat0(t1.spanFrom$1(start)) : null); + }, + _stylesheet0$_isHexColor$1(interpolation) { + var _0_2, t1, + plain = interpolation.get$asPlain(); + if (typeof plain == "string") { + _0_2 = plain.length; + t1 = true; + if (3 !== _0_2) + if (4 !== _0_2) + if (6 !== _0_2) + t1 = 8 === _0_2; + } else + t1 = false; + if (t1) { + t1 = new A.CodeUnits(plain); + return t1.every$1(t1, new A.StylesheetParser__isHexColor_closure0()); + } else + return false; + }, + _stylesheet0$_hexDigit$0() { + var t1 = this.scanner, + t2 = t1.peekChar$0(); + t2 = t2 == null ? null : A.CharacterExtension_get_isHex0(t2); + return t2 === true ? A.asHex0(t1.readChar$0()) : t1.error$1(0, "Expected hex digit."); + }, + _stylesheet0$_minusExpression$0() { + var _this = this, + _0_0 = _this.scanner.peekChar$1(1); + if (A._isInt(_0_0) && _0_0 >= 48 && _0_0 <= 57 || 46 === _0_0) + return _this._stylesheet0$_number$0(); + if (_this._stylesheet0$_lookingAtInterpolatedIdentifier$0()) + return _this.identifierLike$0(); + return _this._stylesheet0$_unaryOperation$0(); + }, + _stylesheet0$_importantExpression$0() { + var t1 = this.scanner, + t2 = t1._string_scanner$_position; + t1.readChar$0(); + this.whitespace$1$consumeNewlines(true); + this.expectIdentifier$1("important"); + t2 = t1.spanFrom$1(new A._SpanScannerState(t1, t2)); + return new A.StringExpression0(new A.Interpolation0(A.List_List$unmodifiable(["!important"], type$.Object), B.List_null, t2), false); + }, + _stylesheet0$_unaryOperation$0() { + var _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + operator = _this._stylesheet0$_unaryOperatorFor$1(t1.readChar$0()); + if (operator == null) + t1.error$2$position(0, "Expected unary operator.", t1._string_scanner$_position - 1); + else if (_this.get$plainCss() && operator !== B.UnaryOperator_lZV0) + t1.error$3$length$position(0, "Operators aren't allowed in plain CSS.", 1, t1._string_scanner$_position - 1); + _this.whitespace$1$consumeNewlines(true); + return new A.UnaryOperationExpression0(operator, _this._stylesheet0$_singleExpression$0(), t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + _stylesheet0$_unaryOperatorFor$1(character) { + var t1; + $label0$0: { + if (43 === character) { + t1 = B.UnaryOperator_Rbl0; + break $label0$0; + } + if (45 === character) { + t1 = B.UnaryOperator_UCP0; + break $label0$0; + } + if (47 === character) { + t1 = B.UnaryOperator_lZV0; + break $label0$0; + } + t1 = null; + break $label0$0; + } + return t1; + }, + _stylesheet0$_number$0() { + var number, unit, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + first = t1.peekChar$0(), + t3 = first !== 43; + if (!t3 || first === 45) + t1.readChar$0(); + if (t1.peekChar$0() !== 46) + _this._stylesheet0$_consumeNaturalNumber$0(); + _this._stylesheet0$_tryDecimal$1$allowTrailingDot(t1._string_scanner$_position !== t2 && t3 && first !== 45); + _this._stylesheet0$_tryExponent$0(); + number = A.double_parse(t1.substring$1(0, t2)); + if (t1.scanChar$1(37)) + unit = "%"; + else { + if (_this.lookingAtIdentifier$0()) + t3 = t1.peekChar$0() !== 45 || t1.peekChar$1(1) !== 45; + else + t3 = false; + unit = t3 ? _this.identifier$1$unit(true) : null; + } + return new A.NumberExpression0(number, unit, t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + _stylesheet0$_consumeNaturalNumber$0() { + var $self, + t1 = this.scanner, + t2 = t1.readChar$0(); + if (!(t2 >= 48 && t2 <= 57)) + t1.error$2$position(0, "Expected digit.", t1._string_scanner$_position - 1); + while (true) { + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + break; + t1.readChar$0(); + } + }, + _stylesheet0$_tryDecimal$1$allowTrailingDot(allowTrailingDot) { + var $self, + t1 = this.scanner; + if (t1.peekChar$0() !== 46) + return; + $self = t1.peekChar$1(1); + if (!($self != null && $self >= 48 && $self <= 57)) { + if (allowTrailingDot) + return; + t1.error$2$position(0, "Expected digit.", t1._string_scanner$_position + 1); + } + t1.readChar$0(); + while (true) { + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + break; + t1.readChar$0(); + } + }, + _stylesheet0$_tryExponent$0() { + var next, $self, + t1 = this.scanner, + first = t1.peekChar$0(); + if (first !== 101 && first !== 69) + return; + next = t1.peekChar$1(1); + if (!(next != null && next >= 48 && next <= 57) && next !== 45 && next !== 43) + return; + t1.readChar$0(); + if (43 === next || 45 === next) + t1.readChar$0(); + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + t1.error$1(0, "Expected digit."); + while (true) { + $self = t1.peekChar$0(); + if (!($self != null && $self >= 48 && $self <= 57)) + break; + t1.readChar$0(); + } + }, + _stylesheet0$_unicodeRange$0() { + var firstRangeLength, hasQuestionMark, t2, secondRangeLength, _this = this, + _s26_ = "Expected at most 6 digits.", + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + _this.expectIdentChar$1(117); + t1.expectChar$1(43); + for (firstRangeLength = 0; _this.scanCharIf$1(new A.StylesheetParser__unicodeRange_closure1());) + ++firstRangeLength; + for (hasQuestionMark = false; t1.scanChar$1(63); hasQuestionMark = true) + ++firstRangeLength; + if (firstRangeLength === 0) + t1.error$1(0, 'Expected hex digit or "?".'); + else if (firstRangeLength > 6) + _this.error$2(0, _s26_, t1.spanFrom$1(start)); + else if (hasQuestionMark) { + t2 = t1.substring$1(0, start.position); + t1 = t1.spanFrom$1(start); + return new A.StringExpression0(new A.Interpolation0(A.List_List$unmodifiable([t2], type$.Object), B.List_null, t1), false); + } + if (t1.scanChar$1(45)) { + t2 = t1._string_scanner$_position; + for (secondRangeLength = 0; _this.scanCharIf$1(new A.StylesheetParser__unicodeRange_closure2());) + ++secondRangeLength; + if (secondRangeLength === 0) + t1.error$1(0, "Expected hex digit."); + else if (secondRangeLength > 6) + _this.error$2(0, _s26_, t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + } + if (_this._stylesheet0$_lookingAtInterpolatedIdentifierBody$0()) + t1.error$1(0, "Expected end of identifier."); + t2 = t1.substring$1(0, start.position); + t1 = t1.spanFrom$1(start); + return new A.StringExpression0(new A.Interpolation0(A.List_List$unmodifiable([t2], type$.Object), B.List_null, t1), false); + }, + _stylesheet0$_variable$0() { + var _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + $name = _this.variableName$0(); + if (_this.get$plainCss()) + _this.error$2(0, string$.Sassx20v, t1.spanFrom$1(start)); + return new A.VariableExpression0(null, $name, t1.spanFrom$1(start)); + }, + _stylesheet0$_selector$0() { + var t1, start, _this = this; + if (_this.get$plainCss()) + _this.scanner.error$2$length(0, string$.The_pa, 1); + t1 = _this.scanner; + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + t1.expectChar$1(38); + if (t1.scanChar$1(38)) { + _this.warnings.push(new A._Record_3_deprecation_message_span(null, string$.In_Sas, t1.spanFrom$1(start))); + t1.set$position(t1._string_scanner$_position - 1); + } + return new A.SelectorExpression0(t1.spanFrom$1(start)); + }, + interpolatedString$0() { + var t3, t4, t5, buffer, _1_0, second, t6, _0_0, + t1 = this.scanner, + t2 = t1._string_scanner$_position, + quote = t1.readChar$0(); + if (quote !== 39 && quote !== 34) + t1.error$2$position(0, "Expected string.", t2); + t3 = new A.StringBuffer(""); + t4 = A._setArrayType([], type$.JSArray_Object); + t5 = A._setArrayType([], type$.JSArray_nullable_FileSpan); + buffer = new A.InterpolationBuffer0(t3, t4, t5); + for (; true;) { + _1_0 = t1.peekChar$0(); + if (_1_0 === quote) { + t1.readChar$0(); + break; + } + if (_1_0 == null || _1_0 === 10 || _1_0 === 13 || _1_0 === 12) + t1.error$1(0, "Expected " + A.Primitives_stringFromCharCode(quote) + "."); + if (92 === _1_0) { + second = t1.peekChar$1(1); + if (second === 10 || second === 13 || second === 12) { + t1.readChar$0(); + t1.readChar$0(); + if (second === 13) + t1.scanChar$1(10); + } else { + t6 = A.Primitives_stringFromCharCode(A.consumeEscapedCharacter0(t1)); + t3._contents += t6; + } + continue; + } + if (35 === _1_0 && t1.peekChar$1(1) === 123) { + _0_0 = this.singleInterpolation$0(); + buffer._interpolation_buffer0$_flushText$0(); + t4.push(_0_0._0); + t5.push(_0_0._1); + continue; + } + t6 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t6; + } + return new A.StringExpression0(buffer.interpolation$1(t1.spanFrom$1(new A._SpanScannerState(t1, t2))), true); + }, + identifierLike$0() { + var invocation, expression, _0_0, t3, t4, t5, _1_0, _2_0, _2_2, _2_4, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + identifier = _this.interpolatedIdentifier$0(), + plain = identifier.get$asPlain(), + lower = A._Cell$(), + t2 = plain != null; + if (t2) { + if (plain === "if" && t1.peekChar$0() === 40) { + invocation = _this._stylesheet0$_argumentInvocation$0(); + return new A.IfExpression0(invocation, identifier.span.expand$1(0, invocation.span)); + } else if (plain === "not") { + _this.whitespace$1$consumeNewlines(true); + expression = _this._stylesheet0$_singleExpression$0(); + return new A.UnaryOperationExpression0(B.UnaryOperator_not_not_not0, expression, identifier.span.expand$1(0, expression.get$span(expression))); + } + lower.__late_helper$_value = plain.toLowerCase(); + if (t1.peekChar$0() !== 40) { + switch (plain) { + case "false": + return new A.BooleanExpression0(false, identifier.span); + case "null": + return new A.NullExpression0(identifier.span); + case "true": + return new A.BooleanExpression0(true, identifier.span); + } + _0_0 = $.$get$colorsByName0().$index(0, lower._readLocal$0()); + if (_0_0 != null) { + t1 = B.JSNumber_methods.round$0(_0_0._color0$_legacyChannel$2(B.RgbColorSpace_i0P0, "red")); + t2 = B.JSNumber_methods.round$0(_0_0._color0$_legacyChannel$2(B.RgbColorSpace_i0P0, "green")); + t3 = B.JSNumber_methods.round$0(_0_0._color0$_legacyChannel$2(B.RgbColorSpace_i0P0, "blue")); + t4 = _0_0.alphaOrNull; + if (t4 == null) + t4 = 0; + t5 = identifier.span; + return new A.ColorExpression0(A.SassColor_SassColor$rgbInternal0(t1, t2, t3, t4, new A.SpanColorFormat0(t5)), t5); + } + } + _1_0 = _this.trySpecialFunction$2(lower._readLocal$0(), start); + if (_1_0 != null) + return _1_0; + } + _2_0 = t1.peekChar$0(); + _2_2 = 46 === _2_0; + if (_2_2 && t1.peekChar$1(1) === 46) + return new A.StringExpression0(identifier, false); + if (_2_2) { + t1.readChar$0(); + if (t2) + return _this.namespacedExpression$2(plain, start); + _this.error$2(0, string$.Interpn, identifier.span); + } + _2_4 = 40 === _2_0; + if (_2_4 && t2) { + t2 = _this._stylesheet0$_argumentInvocation$1$allowEmptySecondArg(J.$eq$(lower._readLocal$0(), "var")); + t1 = t1.spanFrom$1(start); + return new A.FunctionExpression0(null, A.stringReplaceAllUnchecked(plain, "_", "-"), plain, t2, t1); + } + if (_2_4) + return new A.InterpolatedFunctionExpression0(identifier, _this._stylesheet0$_argumentInvocation$0(), t1.spanFrom$1(start)); + return new A.StringExpression0(identifier, false); + }, + namespacedExpression$2(namespace, start) { + var $name, t2, t3, _this = this, + t1 = _this.scanner; + if (t1.peekChar$0() === 36) { + $name = _this.variableName$0(); + _this._stylesheet0$_assertPublic$2($name, new A.StylesheetParser_namespacedExpression_closure0(_this, start)); + return new A.VariableExpression0(namespace, $name, t1.spanFrom$1(start)); + } + t2 = _this._stylesheet0$_publicIdentifier$0(); + t3 = _this._stylesheet0$_argumentInvocation$0(); + t1 = t1.spanFrom$1(start); + return new A.FunctionExpression0(namespace, A.stringReplaceAllUnchecked(t2, "_", "-"), t2, t3, t1); + }, + trySpecialFunction$2($name, start) { + var t1, buffer, t2, next, t3, _this = this, + normalized = A.unvendor0($name); + $label0$0: { + if (!("calc" === normalized && normalized !== $name && _this.scanner.scanChar$1(40))) + t1 = ("element" === normalized || "expression" === normalized) && _this.scanner.scanChar$1(40); + else + t1 = true; + if (t1) { + t1 = new A.StringBuffer(""); + buffer = new A.InterpolationBuffer0(t1, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t1._contents = "" + $name; + t2 = A.Primitives_stringFromCharCode(40); + t1._contents += t2; + break $label0$0; + } + if ("progid" === normalized && _this.scanner.scanChar$1(58)) { + t1 = new A.StringBuffer(""); + buffer = new A.InterpolationBuffer0(t1, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t1._contents = "" + $name; + t2 = A.Primitives_stringFromCharCode(58); + t1._contents += t2; + t2 = _this.scanner; + next = t2.peekChar$0(); + while (true) { + if (next != null) { + if (!(next >= 97 && next <= 122)) + t3 = next >= 65 && next <= 90; + else + t3 = true; + t3 = t3 || next === 46; + } else + t3 = false; + if (!t3) + break; + t3 = A.Primitives_stringFromCharCode(t2.readChar$0()); + t1._contents += t3; + next = t2.peekChar$0(); + } + t2.expectChar$1(40); + t2 = A.Primitives_stringFromCharCode(40); + t1._contents += t2; + break $label0$0; + } + if ("url" === normalized) + return A.NullableExtension_andThen0(_this._stylesheet0$_tryUrlContents$1(start), new A.StylesheetParser_trySpecialFunction_closure0()); + return null; + } + buffer.addInterpolation$1(_this._stylesheet0$_interpolatedDeclarationValue$1$allowEmpty(true)); + t1 = _this.scanner; + t1.expectChar$1(41); + t2 = buffer._interpolation_buffer0$_text; + t3 = A.Primitives_stringFromCharCode(41); + t2._contents += t3; + return new A.StringExpression0(buffer.interpolation$1(t1.spanFrom$1(start)), false); + }, + _stylesheet0$_tryUrlContents$2$name(start, $name) { + var t3, t4, t5, buffer, t6, _1_0, _1_6, _0_0, endPosition, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position; + if (!t1.scanChar$1(40)) + return null; + _this.whitespaceWithoutComments$1$consumeNewlines(true); + t3 = new A.StringBuffer(""); + t4 = A._setArrayType([], type$.JSArray_Object); + t5 = A._setArrayType([], type$.JSArray_nullable_FileSpan); + buffer = new A.InterpolationBuffer0(t3, t4, t5); + t3._contents = "" + ($name == null ? "url" : $name); + t6 = A.Primitives_stringFromCharCode(40); + t3._contents += t6; + for (; true;) { + _1_0 = t1.peekChar$0(); + if (_1_0 == null) + break; + if (92 === _1_0) { + t6 = _this.escape$0(); + t3._contents += t6; + continue; + } + _1_6 = 35 === _1_0; + if (_1_6 && t1.peekChar$1(1) === 123) { + _0_0 = _this.singleInterpolation$0(); + buffer._interpolation_buffer0$_flushText$0(); + t4.push(_0_0._0); + t5.push(_0_0._1); + continue; + } + t6 = true; + if (33 !== _1_0) + if (37 !== _1_0) + if (38 !== _1_0) + if (!_1_6) + t6 = _1_0 >= 42 && _1_0 <= 126 || _1_0 >= 128; + if (t6) { + t6 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t6; + continue; + } + if (_1_0 === 32 || _1_0 === 9 || _1_0 === 10 || _1_0 === 13 || _1_0 === 12) { + _this.whitespaceWithoutComments$1$consumeNewlines(true); + if (t1.peekChar$0() !== 41) + break; + continue; + } + if (41 === _1_0) { + t2 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t2; + endPosition = t1._string_scanner$_position; + t2 = t1._sourceFile; + t3 = start.position; + t1 = new A._FileSpan(t2, t3, endPosition); + t1._FileSpan$3(t2, t3, endPosition); + return buffer.interpolation$1(t1); + } + break; + } + t1.set$state(new A._SpanScannerState(t1, t2)); + return null; + }, + _stylesheet0$_tryUrlContents$1(start) { + return this._stylesheet0$_tryUrlContents$2$name(start, null); + }, + dynamicUrl$0() { + var _0_0, t2, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + _this.expectIdentifier$1("url"); + _0_0 = _this._stylesheet0$_tryUrlContents$1(start); + if (_0_0 != null) + return new A.StringExpression0(_0_0, false); + t2 = t1.spanFrom$1(start); + return new A.InterpolatedFunctionExpression0(new A.Interpolation0(A.List_List$unmodifiable(["url"], type$.Object), B.List_null, t2), _this._stylesheet0$_argumentInvocation$0(), t1.spanFrom$1(start)); + }, + almostAnyValue$1$omitComments(omitComments) { + var t4, t5, t6, t7, _2_0, t8, _0_0, _0_2, start, end, _0_4, identifier, _1_0, bracket, char, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + t3 = new A.StringBuffer(""), + buffer = new A.InterpolationBuffer0(t3, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)), + brackets = A._setArrayType([], type$.JSArray_int); + for (t4 = t1.string, t5 = t4.length, t6 = !omitComments, t7 = _this.get$loudComment(); true;) + $label0$0: { + _2_0 = t1.peekChar$0(); + if (92 === _2_0) { + t8 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t8; + t8 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t8; + break $label0$0; + } + if (34 === _2_0 || 39 === _2_0) { + buffer.addInterpolation$1(_this.interpolatedString$0().asInterpolation$0()); + break $label0$0; + } + if (47 === _2_0) { + $label1$1: { + _0_0 = t1.peekChar$1(1); + _0_2 = 42 === _0_0; + if (_0_2 && t6) { + start = t1._string_scanner$_position; + t7.call$0(); + end = t1._string_scanner$_position; + t3._contents += B.JSString_methods.substring$2(t4, start, end); + break $label1$1; + } + if (_0_2) { + _this.loudComment$0(); + break $label1$1; + } + _0_4 = 47 === _0_0; + if (_0_4 && t6) { + t8 = _this.get$silentComment(); + start = t1._string_scanner$_position; + t8.call$0(); + end = t1._string_scanner$_position; + t3._contents += B.JSString_methods.substring$2(t4, start, end); + break $label1$1; + } + if (_0_4) { + _this.silentComment$0(); + break $label1$1; + } + t8 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t8; + } + break $label0$0; + } + if (35 === _2_0 && t1.peekChar$1(1) === 123) { + buffer.addInterpolation$1(_this.interpolatedIdentifier$0()); + break $label0$0; + } + if (13 === _2_0 || 10 === _2_0 || 12 === _2_0) { + if (_this.get$indented() && brackets.length === 0) + break; + t8 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t8; + break $label0$0; + } + if (33 === _2_0 || 59 === _2_0 || 123 === _2_0 || 125 === _2_0) + break; + if (117 === _2_0 || 85 === _2_0) { + t8 = t1._string_scanner$_position; + identifier = _this.identifier$0(); + if (identifier !== "url" && identifier !== "url-prefix") { + t3._contents += identifier; + continue; + } + _1_0 = _this._stylesheet0$_tryUrlContents$2$name(new A._SpanScannerState(t1, t8), identifier); + if (_1_0 != null) + buffer.addInterpolation$1(_1_0); + else { + if ((t8 === 0 ? 1 / t8 < 0 : t8 < 0) || t8 > t5) + A.throwExpression(A.ArgumentError$("Invalid position " + t8, null)); + t1._string_scanner$_position = t8; + t1._lastMatch = null; + t8 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t8; + } + break $label0$0; + } + if (40 === _2_0 || 91 === _2_0) { + bracket = t1.readChar$0(); + t8 = A.Primitives_stringFromCharCode(bracket); + t3._contents += t8; + brackets.push(A.opposite0(bracket)); + break $label0$0; + } + if (41 === _2_0 || 93 === _2_0) { + t8 = _2_0 != null; + char = t8 ? _2_0 : null; + } else { + char = null; + t8 = false; + } + if (t8) { + if (brackets.length === 0) + t1.error$1(0, 'Unexpected "' + A.Primitives_stringFromCharCode(char) + '".'); + bracket = brackets.pop(); + t1.expectChar$1(bracket); + t8 = A.Primitives_stringFromCharCode(bracket); + t3._contents += t8; + break $label0$0; + } + if (_2_0 == null) + break; + t8 = _this.lookingAtIdentifier$0(); + if (t8) { + t8 = _this.identifier$0(); + t3._contents += t8; + break $label0$0; + } + t8 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t8; + } + return buffer.interpolation$1(t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + almostAnyValue$0() { + return this.almostAnyValue$1$omitComments(false); + }, + _stylesheet0$_interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(allowColon, allowEmpty, allowOpenBrace, allowSemicolon, consumeNewlines, silentComments) { + var t4, t5, t6, t7, t8, t9, t10, wroteNewline, _2_0, wroteNewline0, t11, _0_0, start, end, _2_14_isSet, _2_14, t12, _2_18_isSet, _2_20, _2_18, _2_20_isSet, _2_22, bracket, identifier, _1_0, _this = this, _null = null, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + t3 = new A.StringBuffer(""), + buffer = new A.InterpolationBuffer0(t3, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)), + brackets = A._setArrayType([], type$.JSArray_int); + for (t4 = !consumeNewlines, t5 = !allowOpenBrace, t6 = t1.string, t7 = t6.length, t8 = !allowColon, t9 = !allowSemicolon, t10 = _this.get$loudComment(), wroteNewline = false; true;) + $label0$0: { + _2_0 = t1.peekChar$0(); + wroteNewline0 = false; + if (92 === _2_0) { + t11 = _this.escape$1$identifierStart(true); + t3._contents += t11; + wroteNewline = wroteNewline0; + break $label0$0; + } + if (34 === _2_0 || 39 === _2_0) { + buffer.addInterpolation$1(_this.interpolatedString$0().asInterpolation$0()); + wroteNewline = wroteNewline0; + break $label0$0; + } + if (47 === _2_0) { + $label1$1: { + _0_0 = t1.peekChar$1(1); + if (42 === _0_0) { + start = t1._string_scanner$_position; + t10.call$0(); + end = t1._string_scanner$_position; + t3._contents += B.JSString_methods.substring$2(t6, start, end); + break $label1$1; + } + if (47 === _0_0 && silentComments) { + _this.silentComment$0(); + break $label1$1; + } + t11 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t11; + } + wroteNewline = wroteNewline0; + break $label0$0; + } + if (35 === _2_0 && t1.peekChar$1(1) === 123) { + buffer.addInterpolation$1(_this.interpolatedIdentifier$0()); + wroteNewline = wroteNewline0; + break $label0$0; + } + _2_14_isSet = 32 !== _2_0; + if (_2_14_isSet) { + _2_14 = 9 === _2_0; + t11 = _2_14; + } else { + _2_14 = _null; + t11 = true; + } + t12 = false; + if (t11) + if (!wroteNewline) { + t11 = t1.peekChar$1(1); + t11 = t11 === 32 || t11 === 9 || t11 === 10 || t11 === 13 || t11 === 12; + } else + t11 = t12; + else + t11 = t12; + if (t11) { + t1.readChar$0(); + break $label0$0; + } + if (_2_14_isSet) + t11 = _2_14; + else + t11 = true; + if (t11) { + t11 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t11; + break $label0$0; + } + _2_18_isSet = 10 !== _2_0; + _2_20 = _null; + t11 = true; + if (_2_18_isSet) { + _2_18 = 13 === _2_0; + _2_20_isSet = !_2_18; + if (_2_20_isSet) { + _2_20 = 12 === _2_0; + t11 = _2_20; + } + } else { + _2_18 = _null; + _2_20_isSet = false; + } + if (t11 && _this.get$indented() && t4 && brackets.length === 0) + break; + t11 = true; + if (_2_18_isSet) + if (!_2_18) + t11 = _2_20_isSet ? _2_20 : 12 === _2_0; + if (t11) { + t11 = t1.peekChar$1(-1); + if (!(t11 === 10 || t11 === 13 || t11 === 12)) + t3._contents += "\n"; + t1.readChar$0(); + wroteNewline = true; + break $label0$0; + } + _2_22 = 123 === _2_0; + if (_2_22 && t5) + break; + if (40 !== _2_0) + t11 = _2_22 || 91 === _2_0; + else + t11 = true; + if (t11) { + bracket = t1.readChar$0(); + t11 = A.Primitives_stringFromCharCode(bracket); + t3._contents += t11; + brackets.push(A.opposite0(bracket)); + wroteNewline = wroteNewline0; + break $label0$0; + } + if (41 === _2_0 || 125 === _2_0 || 93 === _2_0) { + if (brackets.length === 0) + break; + bracket = brackets.pop(); + t1.expectChar$1(bracket); + t11 = A.Primitives_stringFromCharCode(bracket); + t3._contents += t11; + wroteNewline = wroteNewline0; + break $label0$0; + } + if (59 === _2_0) { + if (t9 && brackets.length === 0) + break; + t11 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t11; + wroteNewline = wroteNewline0; + break $label0$0; + } + if (58 === _2_0) { + if (t8 && brackets.length === 0) + break; + t11 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t11; + wroteNewline = wroteNewline0; + break $label0$0; + } + if (117 === _2_0 || 85 === _2_0) { + t11 = t1._string_scanner$_position; + identifier = _this.identifier$0(); + if (identifier !== "url" && identifier !== "url-prefix") { + t3._contents += identifier; + wroteNewline = wroteNewline0; + continue; + } + _1_0 = _this._stylesheet0$_tryUrlContents$2$name(new A._SpanScannerState(t1, t11), identifier); + if (_1_0 != null) + buffer.addInterpolation$1(_1_0); + else { + if ((t11 === 0 ? 1 / t11 < 0 : t11 < 0) || t11 > t7) + A.throwExpression(A.ArgumentError$("Invalid position " + t11, _null)); + t1._string_scanner$_position = t11; + t1._lastMatch = null; + t11 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t11; + } + wroteNewline = wroteNewline0; + break $label0$0; + } + if (_2_0 == null) + break; + t11 = _this.lookingAtIdentifier$0(); + if (t11) { + t11 = _this.identifier$0(); + t3._contents += t11; + wroteNewline = wroteNewline0; + break $label0$0; + } + t11 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t3._contents += t11; + wroteNewline = wroteNewline0; + } + if (brackets.length !== 0) + t1.expectChar$1(B.JSArray_methods.get$last(brackets)); + if (!allowEmpty && buffer._interpolation_buffer0$_contents.length === 0 && t3._contents.length === 0) + t1.error$1(0, "Expected token."); + return buffer.interpolation$1(t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + _stylesheet0$_interpolatedDeclarationValue$1$allowEmpty(allowEmpty) { + return this._stylesheet0$_interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(true, allowEmpty, true, false, false, true); + }, + _stylesheet0$_interpolatedDeclarationValue$1$allowOpenBrace(allowOpenBrace) { + return this._stylesheet0$_interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(true, false, allowOpenBrace, false, false, true); + }, + _stylesheet0$_interpolatedDeclarationValue$3$allowEmpty$allowSemicolon$consumeNewlines(allowEmpty, allowSemicolon, consumeNewlines) { + return this._stylesheet0$_interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(true, allowEmpty, true, allowSemicolon, consumeNewlines, true); + }, + _stylesheet0$_interpolatedDeclarationValue$4$allowColon$allowEmpty$allowSemicolon$consumeNewlines(allowColon, allowEmpty, allowSemicolon, consumeNewlines) { + return this._stylesheet0$_interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(allowColon, allowEmpty, true, allowSemicolon, consumeNewlines, true); + }, + _stylesheet0$_interpolatedDeclarationValue$0() { + return this._stylesheet0$_interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(true, false, true, false, false, true); + }, + _stylesheet0$_interpolatedDeclarationValue$2$allowEmpty$allowOpenBrace(allowEmpty, allowOpenBrace) { + return this._stylesheet0$_interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(true, allowEmpty, allowOpenBrace, false, false, true); + }, + _stylesheet0$_interpolatedDeclarationValue$1$silentComments(silentComments) { + return this._stylesheet0$_interpolatedDeclarationValue$6$allowColon$allowEmpty$allowOpenBrace$allowSemicolon$consumeNewlines$silentComments(true, false, true, false, false, silentComments); + }, + interpolatedIdentifier$0() { + var t3, _1_0, _0_0, _this = this, + _s20_ = "Expected identifier.", + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + t2 = new A.StringBuffer(""), + buffer = new A.InterpolationBuffer0(t2, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + if (t1.scanChar$1(45)) { + t3 = A.Primitives_stringFromCharCode(45); + t2._contents += t3; + if (t1.scanChar$1(45)) { + t3 = A.Primitives_stringFromCharCode(45); + t2._contents += t3; + _this._stylesheet0$_interpolatedIdentifierBody$1(buffer); + return buffer.interpolation$1(t1.spanFrom$1(start)); + } + } + $label0$0: { + _1_0 = t1.peekChar$0(); + if (_1_0 == null) + t1.error$1(0, _s20_); + if (_1_0 === 95 || A.CharacterExtension_get_isAlphabetic0(_1_0) || _1_0 >= 128) { + t3 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t3; + break $label0$0; + } + if (92 === _1_0) { + t3 = _this.escape$1$identifierStart(true); + t2._contents += t3; + break $label0$0; + } + if (35 === _1_0 && t1.peekChar$1(1) === 123) { + _0_0 = _this.singleInterpolation$0(); + buffer.add$2(0, _0_0._0, _0_0._1); + break $label0$0; + } + t1.error$1(0, _s20_); + } + _this._stylesheet0$_interpolatedIdentifierBody$1(buffer); + return buffer.interpolation$1(t1.spanFrom$1(start)); + }, + _stylesheet0$_interpolatedIdentifierBody$1(buffer) { + var t1, t2, t3, t4, _1_0, t5, _0_0; + for (t1 = buffer._interpolation_buffer0$_contents, t2 = buffer._interpolation_buffer0$_spans, t3 = this.scanner, t4 = buffer._interpolation_buffer0$_text; true;) { + _1_0 = t3.peekChar$0(); + if (_1_0 == null) + break; + t5 = true; + if (95 !== _1_0) + if (45 !== _1_0) { + if (!(_1_0 >= 97 && _1_0 <= 122)) + t5 = _1_0 >= 65 && _1_0 <= 90; + else + t5 = true; + if (!t5) + t5 = _1_0 >= 48 && _1_0 <= 57; + else + t5 = true; + t5 = t5 || _1_0 >= 128; + } + if (t5) { + t5 = A.Primitives_stringFromCharCode(t3.readChar$0()); + t4._contents += t5; + continue; + } + if (92 === _1_0) { + t5 = this.escape$0(); + t4._contents += t5; + continue; + } + if (35 === _1_0 && t3.peekChar$1(1) === 123) { + _0_0 = this.singleInterpolation$0(); + buffer._interpolation_buffer0$_flushText$0(); + t1.push(_0_0._0); + t2.push(_0_0._1); + continue; + } + break; + } + }, + singleInterpolation$0() { + var contents, span, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position; + t1.expect$1("#{"); + _this.whitespace$1$consumeNewlines(true); + contents = _this._stylesheet0$_expression$1$consumeNewlines(true); + t1.expectChar$1(125); + span = t1.spanFrom$1(new A._SpanScannerState(t1, t2)); + if (_this.get$plainCss()) + _this.error$2(0, string$.Interpp, span); + return new A._Record_2(contents, span); + }, + _stylesheet0$_mediaQueryList$0() { + var t4, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + t3 = new A.StringBuffer(""), + buffer = new A.InterpolationBuffer0(t3, A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + for (; true;) { + _this.whitespace$1$consumeNewlines(false); + _this._stylesheet0$_mediaQuery$1(buffer); + _this.whitespace$1$consumeNewlines(false); + if (!t1.scanChar$1(44)) + break; + t4 = A.Primitives_stringFromCharCode(44); + t3._contents += t4; + t4 = A.Primitives_stringFromCharCode(32); + t3._contents += t4; + } + return buffer.interpolation$1(t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + }, + _stylesheet0$_mediaQuery$1(buffer) { + var identifier1, t1, t2, identifier2, _this = this, _s3_ = "and"; + if (_this.scanner.peekChar$0() === 40) { + _this._stylesheet0$_mediaInParens$1(buffer); + _this.whitespace$1$consumeNewlines(false); + if (_this.scanIdentifier$1(_s3_)) { + buffer._interpolation_buffer0$_text._contents += " and "; + _this.expectWhitespace$0(); + _this._stylesheet0$_mediaLogicSequence$2(buffer, _s3_); + } else if (_this.scanIdentifier$1("or")) { + buffer._interpolation_buffer0$_text._contents += " or "; + _this.expectWhitespace$0(); + _this._stylesheet0$_mediaLogicSequence$2(buffer, "or"); + } + return; + } + identifier1 = _this.interpolatedIdentifier$0(); + if (A.equalsIgnoreCase0(identifier1.get$asPlain(), "not")) { + _this.expectWhitespace$0(); + if (!_this._stylesheet0$_lookingAtInterpolatedIdentifier$0()) { + buffer._interpolation_buffer0$_text._contents += "not "; + _this._stylesheet0$_mediaOrInterp$1(buffer); + return; + } + } + _this.whitespace$1$consumeNewlines(false); + buffer.addInterpolation$1(identifier1); + if (!_this._stylesheet0$_lookingAtInterpolatedIdentifier$0()) + return; + t1 = buffer._interpolation_buffer0$_text; + t2 = A.Primitives_stringFromCharCode(32); + t1._contents += t2; + identifier2 = _this.interpolatedIdentifier$0(); + if (A.equalsIgnoreCase0(identifier2.get$asPlain(), _s3_)) { + _this.expectWhitespace$0(); + t1._contents += " and "; + } else { + _this.whitespace$1$consumeNewlines(false); + buffer.addInterpolation$1(identifier2); + if (_this.scanIdentifier$1(_s3_)) { + _this.expectWhitespace$0(); + t1._contents += " and "; + } else + return; + } + if (_this.scanIdentifier$1("not")) { + _this.expectWhitespace$0(); + t1._contents += "not "; + _this._stylesheet0$_mediaOrInterp$1(buffer); + return; + } + _this._stylesheet0$_mediaLogicSequence$2(buffer, _s3_); + return; + }, + _stylesheet0$_mediaLogicSequence$2(buffer, operator) { + var t1, t2, _this = this; + for (t1 = buffer._interpolation_buffer0$_text; true;) { + _this._stylesheet0$_mediaOrInterp$1(buffer); + _this.whitespace$1$consumeNewlines(false); + if (!_this.scanIdentifier$1(operator)) + return; + _this.expectWhitespace$1$consumeNewlines(false); + t2 = A.Primitives_stringFromCharCode(32); + t2 = t1._contents += t2; + t1._contents = t2 + operator; + t2 = A.Primitives_stringFromCharCode(32); + t1._contents += t2; + } + }, + _stylesheet0$_mediaOrInterp$1(buffer) { + var _0_0; + if (this.scanner.peekChar$0() === 35) { + _0_0 = this.singleInterpolation$0(); + buffer.add$2(0, _0_0._0, _0_0._1); + } else + this._stylesheet0$_mediaInParens$1(buffer); + }, + _stylesheet0$_mediaInParens$1(buffer) { + var t2, t3, expressionBefore, expressionAfter, next, t4, expressionMiddle, _this = this, + t1 = _this.scanner; + t1.expectChar$2$name(40, "media condition in parentheses"); + t2 = buffer._interpolation_buffer0$_text; + t3 = A.Primitives_stringFromCharCode(40); + t2._contents += t3; + _this.whitespace$1$consumeNewlines(true); + if (t1.peekChar$0() === 40) { + _this._stylesheet0$_mediaInParens$1(buffer); + _this.whitespace$1$consumeNewlines(true); + if (_this.scanIdentifier$1("and")) { + t2._contents += " and "; + _this.expectWhitespace$1$consumeNewlines(true); + _this._stylesheet0$_mediaLogicSequence$2(buffer, "and"); + } else if (_this.scanIdentifier$1("or")) { + t2._contents += " or "; + _this.expectWhitespace$1$consumeNewlines(true); + _this._stylesheet0$_mediaLogicSequence$2(buffer, "or"); + } + } else if (_this.scanIdentifier$1("not")) { + t2._contents += "not "; + _this.expectWhitespace$1$consumeNewlines(true); + _this._stylesheet0$_mediaOrInterp$1(buffer); + } else { + expressionBefore = _this._stylesheet0$_expressionUntilComparison$0(); + buffer.add$2(0, expressionBefore, expressionBefore.get$span(expressionBefore)); + if (t1.scanChar$1(58)) { + _this.whitespace$1$consumeNewlines(true); + t3 = A.Primitives_stringFromCharCode(58); + t2._contents += t3; + t3 = A.Primitives_stringFromCharCode(32); + t2._contents += t3; + expressionAfter = _this._stylesheet0$_expression$1$consumeNewlines(true); + buffer.add$2(0, expressionAfter, expressionAfter.get$span(expressionAfter)); + } else { + next = t1.peekChar$0(); + t3 = 60 !== next; + if (!t3 || 62 === next || 61 === next) { + t4 = A.Primitives_stringFromCharCode(32); + t2._contents += t4; + t4 = A.Primitives_stringFromCharCode(t1.readChar$0()); + t2._contents += t4; + if ((!t3 || 62 === next) && t1.scanChar$1(61)) { + t4 = A.Primitives_stringFromCharCode(61); + t2._contents += t4; + } + t4 = A.Primitives_stringFromCharCode(32); + t2._contents += t4; + _this.whitespace$1$consumeNewlines(true); + expressionMiddle = _this._stylesheet0$_expressionUntilComparison$0(); + buffer.add$2(0, expressionMiddle, expressionMiddle.get$span(expressionMiddle)); + if (!t3 || 62 === next) { + next.toString; + t3 = t1.scanChar$1(next); + } else + t3 = false; + if (t3) { + t3 = A.Primitives_stringFromCharCode(32); + t2._contents += t3; + t3 = A.Primitives_stringFromCharCode(next); + t2._contents += t3; + if (t1.scanChar$1(61)) { + t3 = A.Primitives_stringFromCharCode(61); + t2._contents += t3; + } + t3 = A.Primitives_stringFromCharCode(32); + t2._contents += t3; + _this.whitespace$1$consumeNewlines(true); + expressionAfter = _this._stylesheet0$_expressionUntilComparison$0(); + buffer.add$2(0, expressionAfter, expressionAfter.get$span(expressionAfter)); + } + } + } + } + t1.expectChar$1(41); + _this.whitespace$1$consumeNewlines(false); + t1 = A.Primitives_stringFromCharCode(41); + t2._contents += t1; + }, + _stylesheet0$_expressionUntilComparison$0() { + return this._stylesheet0$_expression$2$consumeNewlines$until(true, new A.StylesheetParser__expressionUntilComparison_closure0(this)); + }, + _stylesheet0$_supportsCondition$1$inParentheses(inParentheses) { + var condition, operator, right, endPosition, t3, t4, lowerOperator, _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position; + if (_this.scanIdentifier$1("not")) { + _this.whitespace$1$consumeNewlines(inParentheses); + return new A.SupportsNegation0(_this._stylesheet0$_supportsConditionInParens$0(), t1.spanFrom$1(new A._SpanScannerState(t1, t2))); + } + condition = _this._stylesheet0$_supportsConditionInParens$0(); + _this.whitespace$1$consumeNewlines(inParentheses); + for (operator = null; _this.lookingAtIdentifier$0();) { + if (operator != null) + _this.expectIdentifier$1(operator); + else if (_this.scanIdentifier$1("or")) + operator = "or"; + else { + _this.expectIdentifier$1("and"); + operator = "and"; + } + _this.whitespace$1$consumeNewlines(inParentheses); + right = _this._stylesheet0$_supportsConditionInParens$0(); + endPosition = t1._string_scanner$_position; + t3 = t1._sourceFile; + t4 = new A._FileSpan(t3, t2, endPosition); + t4._FileSpan$3(t3, t2, endPosition); + condition = new A.SupportsOperation0(condition, right, operator, t4); + lowerOperator = operator.toLowerCase(); + if (lowerOperator !== "and" && lowerOperator !== "or") + A.throwExpression(A.ArgumentError$value(operator, "operator", 'may only be "and" or "or".')); + _this.whitespace$1$consumeNewlines(inParentheses); + } + return condition; + }, + _stylesheet0$_supportsCondition$0() { + return this._stylesheet0$_supportsCondition$1$inParentheses(false); + }, + _stylesheet0$_supportsConditionInParens$0() { + var $name, nameStart, wasInParentheses, identifier, _1_0, operation, contents, identifier0, t2, $arguments, _0_0, _0_4_isSet, _0_4, _0_40, condition, exception, value, _this = this, + t1 = _this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position); + if (_this._stylesheet0$_lookingAtInterpolatedIdentifier$0()) { + identifier0 = _this.interpolatedIdentifier$0(); + t2 = identifier0.get$asPlain(); + if ((t2 == null ? null : t2.toLowerCase()) === "not") + _this.error$2(0, '"not" is not a valid identifier here.', identifier0.span); + if (t1.scanChar$1(40)) { + $arguments = _this._stylesheet0$_interpolatedDeclarationValue$3$allowEmpty$allowSemicolon$consumeNewlines(true, true, true); + t1.expectChar$1(41); + return new A.SupportsFunction0(identifier0, $arguments, t1.spanFrom$1(start)); + } else { + _0_0 = identifier0.contents; + _0_4_isSet = _0_0.length === 1; + if (_0_4_isSet) { + _0_4 = _0_0[0]; + _0_40 = _0_4; + t2 = _0_4 instanceof A.Expression0; + _0_4 = _0_40; + } else { + _0_4 = null; + t2 = false; + } + if (t2) { + t2 = _0_4_isSet ? _0_4 : _0_0[0]; + return new A.SupportsInterpolation0(type$.Expression_2._as(t2), t1.spanFrom$1(start)); + } else + _this.error$2(0, "Expected @supports condition.", identifier0.span); + } + } + t1.expectChar$1(40); + _this.whitespace$1$consumeNewlines(true); + if (_this.scanIdentifier$1("not")) { + _this.whitespace$1$consumeNewlines(true); + condition = _this._stylesheet0$_supportsConditionInParens$0(); + t1.expectChar$1(41); + return new A.SupportsNegation0(condition, t1.spanFrom$1(start)); + } else if (t1.peekChar$0() === 40) { + condition = _this._stylesheet0$_supportsCondition$1$inParentheses(true); + t1.expectChar$1(41); + return condition.withSpan$1(t1.spanFrom$1(start)); + } + $name = null; + nameStart = new A._SpanScannerState(t1, t1._string_scanner$_position); + wasInParentheses = _this._stylesheet0$_inParentheses; + try { + $name = _this._stylesheet0$_expression$1$consumeNewlines(true); + t1.expectChar$1(58); + } catch (exception) { + if (type$.FormatException._is(A.unwrapException(exception))) { + t1.set$state(nameStart); + _this._stylesheet0$_inParentheses = wasInParentheses; + identifier = _this.interpolatedIdentifier$0(); + _1_0 = _this._stylesheet0$_trySupportsOperation$2(identifier, nameStart); + operation = null; + if (_1_0 != null) { + operation = _1_0; + t1.expectChar$1(41); + t2 = operation; + t1 = t1.spanFrom$1(start); + return A.SupportsOperation$0(t2.left, t2.right, t2.operator, t1); + } + t2 = new A.InterpolationBuffer0(new A.StringBuffer(""), A._setArrayType([], type$.JSArray_Object), A._setArrayType([], type$.JSArray_nullable_FileSpan)); + t2.addInterpolation$1(identifier); + t2.addInterpolation$1(_this._stylesheet0$_interpolatedDeclarationValue$4$allowColon$allowEmpty$allowSemicolon$consumeNewlines(false, true, true, true)); + contents = t2.interpolation$1(t1.spanFrom$1(nameStart)); + if (t1.peekChar$0() === 58) + throw exception; + t1.expectChar$1(41); + return new A.SupportsAnything0(contents, t1.spanFrom$1(start)); + } else + throw exception; + } + value = _this._stylesheet0$_supportsDeclarationValue$1($name); + t1.expectChar$1(41); + return new A.SupportsDeclaration0($name, value, t1.spanFrom$1(start)); + }, + _stylesheet0$_supportsDeclarationValue$1($name) { + var t1 = false; + if ($name instanceof A.StringExpression0) + if (!$name.hasQuotes) + t1 = B.JSString_methods.startsWith$1($name.text.get$initialPlain(), "--"); + if (t1) + return new A.StringExpression0(this._stylesheet0$_interpolatedDeclarationValue$0(), false); + else { + this.whitespace$1$consumeNewlines(true); + return this._stylesheet0$_expression$1$consumeNewlines(true); + } + }, + _stylesheet0$_trySupportsOperation$2(interpolation, start) { + var expression, beforeWhitespace, t2, t3, operator, operation, right, t4, endPosition, t5, t6, lowerOperator, _this = this, _null = null, + t1 = interpolation.contents; + if (t1.length !== 1) + return _null; + expression = B.JSArray_methods.get$first(t1); + if (!(expression instanceof A.Expression0)) + return _null; + t1 = _this.scanner; + beforeWhitespace = new A._SpanScannerState(t1, t1._string_scanner$_position); + _this.whitespace$1$consumeNewlines(true); + for (t2 = start.position, t3 = interpolation.span, operator = _null, operation = operator; _this.lookingAtIdentifier$0();) { + if (operator != null) + _this.expectIdentifier$1(operator); + else if (_this.scanIdentifier$1("and")) + operator = "and"; + else { + if (!_this.scanIdentifier$1("or")) { + if (beforeWhitespace._scanner !== t1) + A.throwExpression(A.ArgumentError$(string$.The_gi, _null)); + t2 = beforeWhitespace.position; + if ((t2 === 0 ? 1 / t2 < 0 : t2 < 0) || t2 > t1.string.length) + A.throwExpression(A.ArgumentError$("Invalid position " + t2, _null)); + t1._string_scanner$_position = t2; + return t1._lastMatch = null; + } + operator = "or"; + } + _this.whitespace$1$consumeNewlines(true); + right = _this._stylesheet0$_supportsConditionInParens$0(); + t4 = operation == null ? new A.SupportsInterpolation0(expression, t3) : operation; + endPosition = t1._string_scanner$_position; + t5 = t1._sourceFile; + t6 = new A._FileSpan(t5, t2, endPosition); + t6._FileSpan$3(t5, t2, endPosition); + operation = new A.SupportsOperation0(t4, right, operator, t6); + lowerOperator = operator.toLowerCase(); + if (lowerOperator !== "and" && lowerOperator !== "or") + A.throwExpression(A.ArgumentError$value(operator, "operator", 'may only be "and" or "or".')); + _this.whitespace$1$consumeNewlines(true); + } + return operation; + }, + _stylesheet0$_lookingAtInterpolatedIdentifier$0() { + var t2, _0_0, + t1 = this.scanner, + _1_0 = t1.peekChar$0(); + $label0$0: { + t2 = false; + if (_1_0 == null) { + t1 = t2; + break $label0$0; + } + if (_1_0 === 95 || A.CharacterExtension_get_isAlphabetic0(_1_0) || _1_0 >= 128 || 92 === _1_0) { + t1 = true; + break $label0$0; + } + if (35 === _1_0) { + t1 = t1.peekChar$1(1) === 123; + break $label0$0; + } + if (45 === _1_0) { + _0_0 = t1.peekChar$1(1); + $label1$1: { + if (_0_0 == null) { + t1 = t2; + break $label1$1; + } + if (35 === _0_0) { + t1 = t1.peekChar$1(2) === 123; + break $label1$1; + } + if (_0_0 === 95 || A.CharacterExtension_get_isAlphabetic0(_0_0) || _0_0 >= 128 || 92 === _0_0 || 45 === _0_0) { + t1 = true; + break $label1$1; + } + t1 = t2; + break $label1$1; + } + break $label0$0; + } + t1 = t2; + break $label0$0; + } + return t1; + }, + _stylesheet0$_lookingAtPotentialPropertyHack$0() { + var t1 = this.scanner, + _0_0 = t1.peekChar$0(); + $label0$0: { + if (58 === _0_0 || 42 === _0_0 || 46 === _0_0) { + t1 = true; + break $label0$0; + } + if (35 === _0_0) { + t1 = t1.peekChar$1(1) !== 123; + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + _stylesheet0$_lookingAtInterpolatedIdentifierBody$0() { + var t2, t3, + t1 = this.scanner, + _0_0 = t1.peekChar$0(); + $label0$0: { + t2 = false; + if (_0_0 == null) { + t1 = t2; + break $label0$0; + } + if (!(_0_0 === 95 || A.CharacterExtension_get_isAlphabetic0(_0_0) || _0_0 >= 128)) + t3 = _0_0 >= 48 && _0_0 <= 57 || _0_0 === 45; + else + t3 = true; + if (t3 || 92 === _0_0) { + t1 = true; + break $label0$0; + } + if (35 === _0_0) { + t1 = t1.peekChar$1(1) === 123; + break $label0$0; + } + t1 = t2; + break $label0$0; + } + return t1; + }, + _stylesheet0$_lookingAtExpression$0() { + var t2, _0_0, + t1 = this.scanner, + _1_0 = t1.peekChar$0(); + $label0$0: { + t2 = true; + if (_1_0 == null) { + t1 = false; + break $label0$0; + } + if (46 === _1_0) { + t1 = t1.peekChar$1(1) !== 46; + break $label0$0; + } + if (33 === _1_0) { + _0_0 = t1.peekChar$1(1); + $label1$1: { + if (_0_0 != null) + if (105 !== _0_0) + if (73 !== _0_0) + t1 = _0_0 === 32 || _0_0 === 9 || _0_0 === 10 || _0_0 === 13 || _0_0 === 12; + else + t1 = t2; + else + t1 = t2; + else + t1 = t2; + if (t1) + break $label1$1; + break $label1$1; + } + break $label0$0; + } + t1 = true; + if (40 !== _1_0) + if (47 !== _1_0) + if (91 !== _1_0) + if (39 !== _1_0) + if (34 !== _1_0) + if (35 !== _1_0) + if (43 !== _1_0) + if (45 !== _1_0) + if (92 !== _1_0) + if (36 !== _1_0) + if (38 !== _1_0) + if (37 !== _1_0) + if (!(_1_0 === 95 || A.CharacterExtension_get_isAlphabetic0(_1_0) || _1_0 >= 128)) + t1 = _1_0 >= 48 && _1_0 <= 57; + if (t1) { + t1 = t2; + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + _stylesheet0$_withChildren$1$3(child, start, create) { + var result = create.call$2(this.children$1(0, child), this.scanner.spanFrom$1(start)); + this.whitespaceWithoutComments$1$consumeNewlines(false); + return result; + }, + _stylesheet0$_withChildren$3(child, start, create) { + return this._stylesheet0$_withChildren$1$3(child, start, create, type$.dynamic); + }, + _stylesheet0$_urlString$0() { + var innerError, stackTrace, t2, exception, + t1 = this.scanner, + start = new A._SpanScannerState(t1, t1._string_scanner$_position), + url = this.string$0(); + try { + t2 = A.Uri_parse(url); + return t2; + } catch (exception) { + t2 = A.unwrapException(exception); + if (type$.FormatException._is(t2)) { + innerError = t2; + stackTrace = A.getTraceFromException(exception); + this.error$3(0, "Invalid URL: " + J.get$message$x(innerError), t1.spanFrom$1(start), stackTrace); + } else + throw exception; + } + }, + _stylesheet0$_publicIdentifier$0() { + var _this = this, + t1 = _this.scanner, + t2 = t1._string_scanner$_position, + result = _this.identifier$0(); + _this._stylesheet0$_assertPublic$2(result, new A.StylesheetParser__publicIdentifier_closure0(_this, new A._SpanScannerState(t1, t2))); + return result; + }, + _stylesheet0$_assertPublic$2(identifier, span) { + var first = identifier.charCodeAt(0); + if (!(first === 45 || first === 95)) + return; + this.error$2(0, string$.Privat, span.call$0()); + }, + _stylesheet0$_addOrInject$2(buffer, expression) { + if (expression instanceof A.StringExpression0 && !expression.hasQuotes) + buffer.addInterpolation$1(expression.text); + else + buffer.add$2(0, expression, expression.get$span(expression)); + }, + get$plainCss() { + return false; + } + }; + A.StylesheetParser_parse_closure0.prototype = { + call$0() { + var statements, + t1 = this.$this, + t2 = t1.scanner, + t3 = t2._string_scanner$_position; + t2.scanChar$1(65279); + statements = t1.statements$1(new A.StylesheetParser_parse__closure0(t1)); + t2.expectDone$0(); + return A.Stylesheet$internal0(statements, t2.spanFrom$1(new A._SpanScannerState(t2, t3)), t1.warnings, t1._stylesheet0$_globalVariables, t1.get$plainCss()); + }, + $signature: 598 + }; + A.StylesheetParser_parse__closure0.prototype = { + call$0() { + var t1 = this.$this; + if (t1.scanner.scan$1("@charset")) { + t1.whitespace$1$consumeNewlines(false); + t1.string$0(); + return null; + } + return t1._stylesheet0$_statement$1$root(true); + }, + $signature: 599 + }; + A.StylesheetParser_parseParameterList_closure0.prototype = { + call$0() { + var parameters, + t1 = this.$this, + t2 = t1.scanner; + t2.expectChar$2$name(64, "@-rule"); + t1.identifier$0(); + t1.whitespace$1$consumeNewlines(true); + t1.identifier$0(); + parameters = t1._stylesheet0$_parameterList$0(); + t1.whitespace$1$consumeNewlines(true); + t2.expectChar$1(123); + return parameters; + }, + $signature: 600 + }; + A.StylesheetParser__parseSingleProduction_closure0.prototype = { + call$0() { + var result = this.production.call$0(); + this.$this.scanner.expectDone$0(); + return result; + }, + $signature() { + return this.T._eval$1("0()"); + } + }; + A.StylesheetParser_parseSignature_closure.prototype = { + call$0() { + var parameters, t2, t3, + t1 = this.$this, + $name = t1.identifier$0(); + if (this.requireParens || t1.scanner.peekChar$0() === 40) + parameters = t1._stylesheet0$_parameterList$0(); + else { + t2 = t1.scanner; + t2 = A.FileLocation$_(t2._sourceFile, t2._string_scanner$_position); + t3 = t2.offset; + parameters = new A.ParameterList0(B.List_empty24, null, A._FileSpan$(t2.file, t3, t3)); + } + t1.scanner.expectDone$0(); + return new A._Record_2($name, parameters); + }, + $signature: 601 + }; + A.StylesheetParser__statement_closure0.prototype = { + call$0() { + return this.$this._stylesheet0$_statement$0(); + }, + $signature: 136 + }; + A.StylesheetParser_variableDeclarationWithoutNamespace_closure1.prototype = { + call$0() { + return this.$this.scanner.spanFrom$1(this.start); + }, + $signature: 29 + }; + A.StylesheetParser_variableDeclarationWithoutNamespace_closure2.prototype = { + call$0() { + return this.declaration.span; + }, + $signature: 29 + }; + A.StylesheetParser__declarationOrBuffer_closure2.prototype = { + call$0() { + return this.$this.whitespace$1$consumeNewlines(false); + }, + $signature: 0 + }; + A.StylesheetParser__declarationOrBuffer_closure3.prototype = { + call$0() { + return this.$this.whitespace$1$consumeNewlines(false); + }, + $signature: 0 + }; + A.StylesheetParser__declarationOrBuffer_closure4.prototype = { + call$0() { + return this.$this.whitespace$1$consumeNewlines(false); + }, + $signature: 0 + }; + A.StylesheetParser__styleRule_closure0.prototype = { + call$2(children, span) { + var _this = this, + t1 = _this.$this; + if (t1.get$indented() && children.length === 0) + t1.warnings.push(new A._Record_3_deprecation_message_span(null, string$.This_s, _this._box_0.interpolation.span)); + t1._stylesheet0$_inStyleRule = _this.wasInStyleRule; + return A.StyleRule$0(_this._box_0.interpolation, children, t1.scanner.spanFrom$1(_this.start)); + }, + $signature: 602 + }; + A.StylesheetParser__propertyOrVariableDeclaration_closure0.prototype = { + call$0() { + return this.$this.whitespace$1$consumeNewlines(false); + }, + $signature: 0 + }; + A.StylesheetParser__tryDeclarationChildren_closure0.prototype = { + call$2(children, span) { + return A.Declaration$nested0(this.name, children, span, this.value); + }, + $signature: 603 + }; + A.StylesheetParser__atRootRule_closure1.prototype = { + call$2(children, span) { + return A.AtRootRule$0(children, span, this.query); + }, + $signature: 267 + }; + A.StylesheetParser__atRootRule_closure2.prototype = { + call$2(children, span) { + return A.AtRootRule$0(children, span, null); + }, + $signature: 267 + }; + A.StylesheetParser__eachRule_closure0.prototype = { + call$2(children, span) { + var _this = this; + _this.$this._stylesheet0$_inControlDirective = _this.wasInControlDirective; + return A.EachRule$0(_this.variables, _this.list, children, span); + }, + $signature: 605 + }; + A.StylesheetParser__functionRule_closure0.prototype = { + call$2(children, span) { + return A.FunctionRule$0(this.name, this.parameters, children, span, this.precedingComment); + }, + $signature: 606 + }; + A.StylesheetParser__forRule_closure1.prototype = { + call$0() { + var t1 = this.$this; + if (!t1.lookingAtIdentifier$0()) + return false; + if (t1.scanIdentifier$1("to")) + return this._box_0.exclusive = true; + else if (t1.scanIdentifier$1("through")) { + this._box_0.exclusive = false; + return true; + } else + return false; + }, + $signature: 19 + }; + A.StylesheetParser__forRule_closure2.prototype = { + call$2(children, span) { + var t1, _this = this; + _this.$this._stylesheet0$_inControlDirective = _this.wasInControlDirective; + t1 = _this._box_0.exclusive; + t1.toString; + return A.ForRule$0(_this.variable, _this.from, _this.to, children, span, t1); + }, + $signature: 607 + }; + A.StylesheetParser__memberList_closure0.prototype = { + call$0() { + var t1 = this.$this; + if (t1.scanner.peekChar$0() === 36) + this.variables.add$1(0, t1.variableName$0()); + else + this.identifiers.add$1(0, t1.identifier$1$normalize(true)); + }, + $signature: 1 + }; + A.StylesheetParser__includeRule_closure0.prototype = { + call$2(children, span) { + return A.ContentBlock$0(this.contentParameters_, children, span); + }, + $signature: 608 + }; + A.StylesheetParser_mediaRule_closure0.prototype = { + call$2(children, span) { + return A.MediaRule$0(this.query, children, span); + }, + $signature: 609 + }; + A.StylesheetParser__mixinRule_closure0.prototype = { + call$2(children, span) { + var _this = this; + _this.$this._stylesheet0$_inMixin = false; + return A.MixinRule$0(_this.name, _this.parameters, children, span, _this.precedingComment); + }, + $signature: 610 + }; + A.StylesheetParser_mozDocumentRule_closure1.prototype = { + call$0() { + return this.$this.whitespace$1$consumeNewlines(false); + }, + $signature: 0 + }; + A.StylesheetParser_mozDocumentRule_closure2.prototype = { + call$2(children, span) { + var _this = this; + if (_this._box_0.needsDeprecationWarning) + _this.$this.warnings.push(new A._Record_3_deprecation_message_span(B.Deprecation_L0R, string$.x40_moz_, span)); + return A.AtRule$0(_this.name, span, children, _this.value); + }, + $signature: 268 + }; + A.StylesheetParser_supportsRule_closure0.prototype = { + call$2(children, span) { + return A.SupportsRule$0(this.condition, children, span); + }, + $signature: 612 + }; + A.StylesheetParser__whileRule_closure0.prototype = { + call$2(children, span) { + this.$this._stylesheet0$_inControlDirective = this.wasInControlDirective; + return A.WhileRule$0(this.condition, children, span); + }, + $signature: 613 + }; + A.StylesheetParser_unknownAtRule_closure0.prototype = { + call$2(children, span) { + return A.AtRule$0(this.name, span, children, this._box_0.value); + }, + $signature: 268 + }; + A.StylesheetParser__expression_resetState0.prototype = { + call$0() { + var t2, + t1 = this._box_0; + t1.operands_ = t1.operators_ = t1.spaceExpressions_ = t1.commaExpressions_ = null; + t2 = this.$this; + t2.scanner.set$state(this.start); + t1.allowSlash = true; + t1.singleExpression_ = t2._stylesheet0$_singleExpression$0(); + }, + $signature: 0 + }; + A.StylesheetParser__expression_resolveOneOperation0.prototype = { + call$0() { + var t2, t3, t4, t5, t6, t7, _this = this, + t1 = _this._box_0, + operator = t1.operators_.pop(), + left = t1.operands_.pop(), + right = t1.singleExpression_; + if (right == null) { + t2 = _this.$this.scanner; + t3 = operator.operator.length; + t2.error$3$length$position(0, "Expected expression.", t3, t2._string_scanner$_position - t3); + } + if (t1.allowSlash) { + t2 = _this.$this; + t2 = !t2._stylesheet0$_inParentheses && operator === B.BinaryOperator_Mh50 && t2._stylesheet0$_isSlashOperand$1(left) && t2._stylesheet0$_isSlashOperand$1(right); + } else + t2 = false; + if (t2) + t1.singleExpression_ = new A.BinaryOperationExpression0(B.BinaryOperator_Mh50, left, right, true); + else { + t1.singleExpression_ = new A.BinaryOperationExpression0(operator, left, right, false); + t2 = t1.allowSlash = false; + if (B.BinaryOperator_Swh0 === operator || B.BinaryOperator_QG10 === operator) { + t3 = _this.$this; + t4 = t3.scanner.string; + t5 = right.get$span(right); + t5 = t5.get$start(t5); + t6 = right.get$span(right); + t7 = operator.operator; + if (B.JSString_methods.substring$2(t4, t5.offset - 1, t6.get$start(t6).offset) === t7) { + t2 = left.get$span(left); + t2 = t4.charCodeAt(t2.get$end(t2).offset); + t2 = t2 === 32 || t2 === 9 || t2 === 10 || t2 === 13 || t2 === 12; + } + if (t2) { + t2 = left.toString$0(0); + t4 = right.toString$0(0); + t5 = left.toString$0(0); + t6 = right.toString$0(0); + t1 = t1.singleExpression_; + t3.warnings.push(new A._Record_3_deprecation_message_span(B.Deprecation_CRw, "This operation is parsed as:\n\n " + t2 + " " + t7 + " " + t4 + string$.x0a_but_ + t5 + " (" + t7 + t6 + ")\n\nAdd a space after " + t7 + string$.x20to_cl, t1.get$span(t1))); + } + } + } + }, + $signature: 0 + }; + A.StylesheetParser__expression_resolveOperations0.prototype = { + call$0() { + var t1, + operators = this._box_0.operators_; + if (operators == null) + return; + for (t1 = this.resolveOneOperation; operators.length !== 0;) + t1.call$0(); + }, + $signature: 0 + }; + A.StylesheetParser__expression_addSingleExpression0.prototype = { + call$1(expression) { + var t2, spaceExpressions, _this = this, + t1 = _this._box_0; + if (t1.singleExpression_ != null) { + t2 = _this.$this; + if (t2._stylesheet0$_inParentheses) { + t2._stylesheet0$_inParentheses = false; + if (t1.allowSlash) { + _this.resetState.call$0(); + return; + } + } + spaceExpressions = t1.spaceExpressions_; + if (spaceExpressions == null) + spaceExpressions = t1.spaceExpressions_ = A._setArrayType([], type$.JSArray_Expression_2); + _this.resolveOperations.call$0(); + t2 = t1.singleExpression_; + t2.toString; + spaceExpressions.push(t2); + t1.allowSlash = true; + } + t1.singleExpression_ = expression; + }, + $signature: 614 + }; + A.StylesheetParser__expression_addOperator0.prototype = { + call$1(operator) { + var t2, t3, operators, operands, t4, singleExpression, _this = this, + t1 = _this.$this; + if (t1.get$plainCss() && operator !== B.BinaryOperator_Kyq0 && operator !== B.BinaryOperator_Swh0 && operator !== B.BinaryOperator_QG10 && operator !== B.BinaryOperator_tht0 && operator !== B.BinaryOperator_Mh50) { + t2 = t1.scanner; + t3 = operator.operator.length; + t2.error$3$length$position(0, "Operators aren't allowed in plain CSS.", t3, t2._string_scanner$_position - t3); + } + t2 = _this._box_0; + t2.allowSlash = t2.allowSlash && operator === B.BinaryOperator_Mh50; + operators = t2.operators_; + if (operators == null) + operators = t2.operators_ = A._setArrayType([], type$.JSArray_BinaryOperator_2); + operands = t2.operands_; + if (operands == null) + operands = t2.operands_ = A._setArrayType([], type$.JSArray_Expression_2); + t3 = _this.resolveOneOperation; + t4 = operator.precedence; + while (true) { + if (!(operators.length !== 0 && B.JSArray_methods.get$last(operators).precedence >= t4)) + break; + t3.call$0(); + } + singleExpression = t2.singleExpression_; + if (singleExpression == null) { + t3 = t1.scanner; + t4 = operator.operator.length; + t3.error$3$length$position(0, "Expected expression.", t4, t3._string_scanner$_position - t4); + } + t1.whitespace$1$consumeNewlines(true); + if (operator === B.BinaryOperator_s7T0 && !t1._stylesheet0$_lookingAtExpression$0()) { + t1 = t1.scanner; + t1 = t1.spanFromPosition$1(t1._string_scanner$_position - 1); + _this.addSingleExpression.call$1(new A.StringExpression0(new A.Interpolation0(A.List_List$unmodifiable(["%"], type$.Object), B.List_null, t1), false)); + } else { + operators.push(operator); + operands.push(singleExpression); + t2.singleExpression_ = t1._stylesheet0$_singleExpression$0(); + } + }, + $signature: 615 + }; + A.StylesheetParser__expression_resolveSpaceExpressions0.prototype = { + call$0() { + var t1, spaceExpressions, singleExpression, t2; + this.resolveOperations.call$0(); + t1 = this._box_0; + spaceExpressions = t1.spaceExpressions_; + if (spaceExpressions == null) + return; + singleExpression = t1.singleExpression_; + if (singleExpression == null) + this.$this.scanner.error$1(0, "Expected expression."); + spaceExpressions.push(singleExpression); + t2 = B.JSArray_methods.get$first(spaceExpressions); + t2 = t2.get$span(t2).expand$1(0, singleExpression.get$span(singleExpression)); + t1.singleExpression_ = new A.ListExpression0(A.List_List$unmodifiable(spaceExpressions, type$.Expression_2), B.ListSeparator_qSL0, false, t2); + t1.spaceExpressions_ = null; + }, + $signature: 0 + }; + A.StylesheetParser_expressionUntilComma_closure0.prototype = { + call$0() { + return this.$this.scanner.peekChar$0() === 44; + }, + $signature: 19 + }; + A.StylesheetParser__isHexColor_closure0.prototype = { + call$1(char) { + return A.CharacterExtension_get_isHex0(char); + }, + $signature: 48 + }; + A.StylesheetParser__unicodeRange_closure1.prototype = { + call$1(char) { + return char != null && A.CharacterExtension_get_isHex0(char); + }, + $signature: 30 + }; + A.StylesheetParser__unicodeRange_closure2.prototype = { + call$1(char) { + return char != null && A.CharacterExtension_get_isHex0(char); + }, + $signature: 30 + }; + A.StylesheetParser_namespacedExpression_closure0.prototype = { + call$0() { + return this.$this.scanner.spanFrom$1(this.start); + }, + $signature: 29 + }; + A.StylesheetParser_trySpecialFunction_closure0.prototype = { + call$1(contents) { + return new A.StringExpression0(contents, false); + }, + $signature: 616 + }; + A.StylesheetParser__expressionUntilComparison_closure0.prototype = { + call$0() { + var t1 = this.$this.scanner, + _0_0 = t1.peekChar$0(); + $label0$0: { + if (61 === _0_0) { + t1 = t1.peekChar$1(1) !== 61; + break $label0$0; + } + if (60 === _0_0 || 62 === _0_0) { + t1 = true; + break $label0$0; + } + t1 = false; + break $label0$0; + } + return t1; + }, + $signature: 19 + }; + A.StylesheetParser__publicIdentifier_closure0.prototype = { + call$0() { + return this.$this.scanner.spanFrom$1(this.start); + }, + $signature: 29 + }; + A.Stylesheet0.prototype = { + Stylesheet$internal$5$globalVariables$plainCss0(children, span, parseTimeWarnings, globalVariables, plainCss) { + var t1, t2, t3, t4, _i, child; + for (t1 = this.children, t2 = t1.length, t3 = this._stylesheet1$_forwards, t4 = this._stylesheet1$_uses, _i = 0; _i < t2; ++_i) { + child = t1[_i]; + if (child instanceof A.UseRule0) { + t4.push(child); + continue; + } + if (child instanceof A.ForwardRule0) { + t3.push(child); + continue; + } + if (child instanceof A.SilentComment0 || child instanceof A.LoudComment0 || child instanceof A.VariableDeclaration0) + continue; + break; + } + }, + accept$1$1(visitor) { + return visitor.visitStylesheet$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.children; + return (t1 && B.JSArray_methods).join$1(t1, " "); + }, + get$span(receiver) { + return this.span; + } + }; + A.SupportsExpression0.prototype = { + get$span(_) { + var t1 = this.condition; + return t1.get$span(t1); + }, + accept$1$1(visitor) { + return visitor.visitSupportsExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return this.condition.toString$0(0); + } + }; + A.ModifiableCssSupportsRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitCssSupportsRule$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + equalsIgnoringChildren$1(other) { + var t1, t2; + if (other instanceof A.ModifiableCssSupportsRule0) { + t1 = this.condition; + t2 = other.condition; + t1 = t1.$ti._is(t2) && J.$eq$(t2.value, t1.value); + } else + t1 = false; + return t1; + }, + copyWithoutChildren$0() { + return A.ModifiableCssSupportsRule$0(this.condition, this.span); + }, + get$span(receiver) { + return this.span; + } + }; + A.SupportsRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitSupportsRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.children; + return "@supports " + this.condition.toString$0(0) + " {" + (t1 && B.JSArray_methods).join$1(t1, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.JSToDartImporter.prototype = { + canonicalize$1(_, url) { + var t1, + result = A.wrapJSExceptions(new A.JSToDartImporter_canonicalize_closure(this, url)); + if (result == null) + return null; + t1 = self.URL; + if (result instanceof t1) + return A.Uri_parse(J.toString$0$(type$.JSUrl._as(result))); + t1 = self.Promise; + if (result instanceof t1) + A.jsThrow(new self.Error("The canonicalize() function can't return a Promise for synchronous compile functions.")); + else + A.jsThrow(new self.Error(string$.The_ca)); + }, + load$1(_, url) { + var t1, contents, syntax, t2, + result = A.wrapJSExceptions(new A.JSToDartImporter_load_closure(this, url)); + if (result == null) + return null; + t1 = self.Promise; + if (result instanceof t1) + A.jsThrow(new self.Error("The load() function can't return a Promise for synchronous compile functions.")); + type$.JSImporterResult._as(result); + t1 = J.getInterceptor$x(result); + contents = t1.get$contents(result); + if (A._asString(new self.Function("value", "return typeof value").call$1(contents)) !== "string") + A.jsThrow(new A.ArgumentError(true, contents, "contents", "must be a string but was: " + A.jsType(contents))); + syntax = t1.get$syntax(result); + if (contents == null || syntax == null) + A.jsThrow(new self.Error(string$.The_lo)); + t2 = A.parseSyntax(syntax); + return A.ImporterResult$(contents, A.NullableExtension_andThen0(t1.get$sourceMapUrl(result), A.utils3__jsToDartUrl$closure()), t2); + }, + isNonCanonicalScheme$1(scheme) { + return this._sync$_nonCanonicalSchemes.contains$1(0, scheme); + } + }; + A.JSToDartImporter_canonicalize_closure.prototype = { + call$0() { + return this.$this._sync$_canonicalize.call$2(this.url.toString$0(0), A.canonicalizeContext0()); + }, + $signature: 36 + }; + A.JSToDartImporter_load_closure.prototype = { + call$0() { + return this.$this._sync$_load.call$1(new self.URL(this.url.toString$0(0))); + }, + $signature: 36 + }; + A.Syntax0.prototype = { + _enumToString$0() { + return "Syntax." + this._name; + }, + toString$0(_) { + return this._syntax0$_name; + } + }; + A.TypeSelector0.prototype = { + get$specificity() { + return 1; + }, + accept$1$1(visitor) { + return visitor.visitTypeSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + addSuffix$1(suffix) { + var t1 = this.name; + return new A.TypeSelector0(new A.QualifiedName0(t1.name + suffix, t1.namespace), this.span); + }, + unify$1(compound) { + var unified, t1, + _0_0 = A.IterableExtensions_get_firstOrNull(compound); + if (_0_0 instanceof A.UniversalSelector0 || _0_0 instanceof A.TypeSelector0) { + unified = A.unifyUniversalAndElement0(this, B.JSArray_methods.get$first(compound)); + if (unified == null) + return null; + t1 = A._setArrayType([unified], type$.JSArray_SimpleSelector_2); + B.JSArray_methods.addAll$1(t1, A.SubListIterable$(compound, 1, null, A._arrayInstanceType(compound)._precomputed1)); + return t1; + } else { + t1 = A._setArrayType([this], type$.JSArray_SimpleSelector_2); + B.JSArray_methods.addAll$1(t1, compound); + return t1; + } + }, + isSuperselector$1(other) { + var t1, t2, t3; + if (!this.super$SimpleSelector$isSuperselector0(other)) { + t1 = false; + if (other instanceof A.TypeSelector0) { + t2 = this.name; + t3 = other.name; + if (t2.name === t3.name) { + t1 = t2.namespace; + t1 = t1 === "*" || t1 == t3.namespace; + } + } + } else + t1 = true; + return t1; + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.TypeSelector0 && other.name.$eq(0, this.name); + }, + get$hashCode(_) { + var t1 = this.name; + return B.JSString_methods.get$hashCode(t1.name) ^ J.get$hashCode$(t1.namespace); + } + }; + A.Types.prototype = {}; + A.UnaryOperationExpression0.prototype = { + accept$1$1(visitor) { + return visitor.visitUnaryOperationExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var operand, + t1 = this.operator, + t2 = t1.operator; + t1 = t1 === B.UnaryOperator_not_not_not0 ? t2 + A.Primitives_stringFromCharCode(32) : t2; + operand = this.operand; + $label0$0: { + t2 = true; + if (!(operand instanceof A.BinaryOperationExpression0)) + if (!(operand instanceof A.UnaryOperationExpression0)) + t2 = operand instanceof A.ListExpression0 && !operand.hasBrackets && operand.contents.length >= 2; + if (t2) + break $label0$0; + break $label0$0; + } + if (t2) + t1 += "40"; + t1 += operand.toString$0(0); + if (t2) + t1 += "41"; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + get$span(receiver) { + return this.span; + } + }; + A.UnaryOperator0.prototype = { + _enumToString$0() { + return "UnaryOperator." + this._name; + }, + toString$0(_) { + return this.name; + } + }; + A.UnitlessSassNumber0.prototype = { + get$numeratorUnits(_) { + return B.List_empty; + }, + get$denominatorUnits(_) { + return B.List_empty; + }, + get$hasUnits() { + return false; + }, + get$hasComplexUnits() { + return false; + }, + withValue$1(value) { + return new A.UnitlessSassNumber0(value, null); + }, + withSlash$2(numerator, denominator) { + return new A.UnitlessSassNumber0(this._number1$_value, new A._Record_2(numerator, denominator)); + }, + hasUnit$1(unit) { + return false; + }, + hasCompatibleUnits$1(other) { + return other instanceof A.UnitlessSassNumber0; + }, + hasPossiblyCompatibleUnits$1(other) { + return other instanceof A.UnitlessSassNumber0; + }, + compatibleWithUnit$1(unit) { + return true; + }, + coerceToMatch$3(other, $name, otherName) { + return other.withValue$1(this._number1$_value); + }, + coerceToMatch$1(other) { + return this.coerceToMatch$3(other, null, null); + }, + coerceValueToMatch$3(other, $name, otherName) { + return this._number1$_value; + }, + coerceValueToMatch$1(other) { + return this.coerceValueToMatch$3(other, null, null); + }, + convertToMatch$3(other, $name, otherName) { + return other.get$hasUnits() ? this.super$SassNumber$convertToMatch(other, $name, otherName) : this; + }, + convertValueToMatch$3(other, $name, otherName) { + return other.get$hasUnits() ? this.super$SassNumber$convertValueToMatch0(other, $name, otherName) : this._number1$_value; + }, + convertValueToMatch$1(other) { + return this.convertValueToMatch$3(other, null, null); + }, + coerce$3(newNumerators, newDenominators, $name) { + return A.SassNumber_SassNumber$withUnits0(this._number1$_value, newDenominators, newNumerators); + }, + coerce$2(newNumerators, newDenominators) { + return this.coerce$3(newNumerators, newDenominators, null); + }, + coerceValue$3(newNumerators, newDenominators, $name) { + return this._number1$_value; + }, + coerceValueToUnit$2(unit, $name) { + return this._number1$_value; + }, + coerceValueToUnit$1(unit) { + return this.coerceValueToUnit$2(unit, null); + }, + greaterThan$1(other) { + var t1, t2; + if (other instanceof A.SassNumber0) { + t1 = this._number1$_value; + t2 = other._number1$_value; + return t1 > t2 && !A.fuzzyEquals0(t1, t2) ? B.SassBoolean_true0 : B.SassBoolean_false0; + } + return this.super$SassNumber$greaterThan0(other); + }, + greaterThanOrEquals$1(other) { + var t1, t2; + if (other instanceof A.SassNumber0) { + t1 = this._number1$_value; + t2 = other._number1$_value; + return t1 > t2 || A.fuzzyEquals0(t1, t2) ? B.SassBoolean_true0 : B.SassBoolean_false0; + } + return this.super$SassNumber$greaterThanOrEquals0(other); + }, + lessThan$1(other) { + var t1, t2; + if (other instanceof A.SassNumber0) { + t1 = this._number1$_value; + t2 = other._number1$_value; + return t1 < t2 && !A.fuzzyEquals0(t1, t2) ? B.SassBoolean_true0 : B.SassBoolean_false0; + } + return this.super$SassNumber$lessThan0(other); + }, + lessThanOrEquals$1(other) { + var t1, t2; + if (other instanceof A.SassNumber0) { + t1 = this._number1$_value; + t2 = other._number1$_value; + return t1 < t2 || A.fuzzyEquals0(t1, t2) ? B.SassBoolean_true0 : B.SassBoolean_false0; + } + return this.super$SassNumber$lessThanOrEquals0(other); + }, + modulo$1(other) { + if (other instanceof A.SassNumber0) + return other.withValue$1(A.moduloLikeSass0(this._number1$_value, other._number1$_value)); + return this.super$SassNumber$modulo0(other); + }, + plus$1(other) { + if (other instanceof A.SassNumber0) + return other.withValue$1(this._number1$_value + other._number1$_value); + return this.super$SassNumber$plus0(other); + }, + minus$1(other) { + if (other instanceof A.SassNumber0) + return other.withValue$1(this._number1$_value - other._number1$_value); + return this.super$SassNumber$minus0(other); + }, + times$1(other) { + if (other instanceof A.SassNumber0) + return other.withValue$1(this._number1$_value * other._number1$_value); + return this.super$SassNumber$times0(other); + }, + dividedBy$1(other) { + var t1, t2; + if (other instanceof A.SassNumber0) { + t1 = this._number1$_value / other._number1$_value; + if (other.get$hasUnits()) { + t2 = other.get$denominatorUnits(other); + t2 = A.SassNumber_SassNumber$withUnits0(t1, other.get$numeratorUnits(other), t2); + t1 = t2; + } else + t1 = new A.UnitlessSassNumber0(t1, null); + return t1; + } + return this.super$SassNumber$dividedBy0(other); + }, + unaryMinus$0() { + return new A.UnitlessSassNumber0(-this._number1$_value, null); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.UnitlessSassNumber0 && A.fuzzyEquals0(this._number1$_value, other._number1$_value); + }, + get$hashCode(_) { + var t1 = this.hashCache; + return t1 == null ? this.hashCache = A.fuzzyHashCode0(this._number1$_value) : t1; + } + }; + A.UniversalSelector0.prototype = { + get$specificity() { + return 0; + }, + accept$1$1(visitor) { + return visitor.visitUniversalSelector$1(this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + unify$1(compound) { + var _0_4, t1, rest, unified, t2, _this = this, _null = null, + _0_1 = compound.length, + _0_4_isSet = _0_1 >= 1; + if (_0_4_isSet) { + _0_4 = compound[0]; + if (!(_0_4 instanceof A.UniversalSelector0)) + t1 = _0_4 instanceof A.TypeSelector0; + else + t1 = true; + rest = t1 ? B.JSArray_methods.sublist$1(compound, 1) : _null; + } else { + rest = _null; + _0_4 = rest; + t1 = false; + } + if (t1) { + unified = A.unifyUniversalAndElement0(_this, B.JSArray_methods.get$first(compound)); + if (unified == null) + return _null; + t1 = A._setArrayType([unified], type$.JSArray_SimpleSelector_2); + B.JSArray_methods.addAll$1(t1, rest); + return t1; + } + t1 = false; + if (_0_1 === 1) { + if (_0_4_isSet) + t2 = _0_4; + else { + _0_4 = compound[0]; + t2 = _0_4; + _0_4_isSet = true; + } + if (t2 instanceof A.PseudoSelector0) { + t2 = _0_4_isSet ? _0_4 : compound[0]; + type$.PseudoSelector_2._as(t2); + t1 = t2.isClass && t2.name === "host" || t2.get$isHostContext(); + } + } + if (t1) + return _null; + if (_0_1 <= 0) + return A._setArrayType([_this], type$.JSArray_SimpleSelector_2); + t1 = _this.namespace; + if (t1 == null || t1 === "*") + t1 = compound; + else { + t1 = A._setArrayType([_this], type$.JSArray_SimpleSelector_2); + B.JSArray_methods.addAll$1(t1, compound); + } + return t1; + }, + isSuperselector$1(other) { + var t1 = this.namespace; + if (t1 === "*") + return true; + if (other instanceof A.TypeSelector0) + return t1 == other.name.namespace; + if (other instanceof A.UniversalSelector0) + return t1 == other.namespace; + return t1 == null || this.super$SimpleSelector$isSuperselector0(other); + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A.UniversalSelector0 && other.namespace == this.namespace; + }, + get$hashCode(_) { + return J.get$hashCode$(this.namespace); + } + }; + A.UnprefixedMapView0.prototype = { + get$keys(_) { + return new A._UnprefixedKeys0(this); + }, + $index(_, key) { + return typeof key == "string" ? this._unprefixed_map_view0$_map.$index(0, this._unprefixed_map_view0$_prefix + key) : null; + }, + containsKey$1(key) { + return typeof key == "string" && this._unprefixed_map_view0$_map.containsKey$1(this._unprefixed_map_view0$_prefix + key); + }, + remove$1(_, key) { + var t1 = this._unprefixed_map_view0$_map.remove$1(0, this._unprefixed_map_view0$_prefix + key); + return t1; + } + }; + A._UnprefixedKeys0.prototype = { + get$iterator(_) { + var t1 = this._unprefixed_map_view0$_view._unprefixed_map_view0$_map; + t1 = J.where$1$ax(t1.get$keys(t1), new A._UnprefixedKeys_iterator_closure1(this)).map$1$1(0, new A._UnprefixedKeys_iterator_closure2(this), type$.String); + return t1.get$iterator(t1); + }, + contains$1(_, key) { + return this._unprefixed_map_view0$_view.containsKey$1(key); + } + }; + A._UnprefixedKeys_iterator_closure1.prototype = { + call$1(key) { + return B.JSString_methods.startsWith$1(key, this.$this._unprefixed_map_view0$_view._unprefixed_map_view0$_prefix); + }, + $signature: 5 + }; + A._UnprefixedKeys_iterator_closure2.prototype = { + call$1(key) { + return B.JSString_methods.substring$1(key, this.$this._unprefixed_map_view0$_view._unprefixed_map_view0$_prefix.length); + }, + $signature: 6 + }; + A.JSUrl0.prototype = {}; + A.UseRule0.prototype = { + UseRule$4$configuration0(url, namespace, span, configuration) { + var t1, t2, _i, variable; + for (t1 = this.configuration, t2 = t1.length, _i = 0; _i < t2; ++_i) { + variable = t1[_i]; + if (variable.isGuarded) + throw A.wrapException(A.ArgumentError$value(variable, "configured variable", "can't be guarded in a @use rule.")); + } + }, + accept$1$1(visitor) { + return visitor.visitUseRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.url, + t2 = "@use " + A.StringExpression_quoteText0(t1.toString$0(0)), + basename = t1.get$pathSegments().length === 0 ? "" : B.JSArray_methods.get$last(t1.get$pathSegments()), + dot = B.JSString_methods.indexOf$1(basename, "."); + t1 = this.namespace; + if (t1 !== B.JSString_methods.substring$2(basename, 0, dot === -1 ? basename.length : dot)) + t1 = t2 + (" as " + (t1 == null ? "*" : t1)); + else + t1 = t2; + t2 = this.configuration; + t1 = (t2.length !== 0 ? t1 + (" with (" + B.JSArray_methods.join$1(t2, ", ") + ")") : t1) + ";"; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + get$span(receiver) { + return this.span; + } + }; + A.UserDefinedCallable0.prototype = { + get$name(_) { + return this.declaration.name; + }, + $isAsyncCallable0: 1, + $isCallable: 1 + }; + A.resolveImportPath_closure1.prototype = { + call$0() { + return A._exactlyOne0(A._tryPath0($.$get$context().withoutExtension$1(this.path) + ".import" + this.extension)); + }, + $signature: 47 + }; + A.resolveImportPath_closure2.prototype = { + call$0() { + return A._exactlyOne0(A._tryPathWithExtensions0(this.path + ".import")); + }, + $signature: 47 + }; + A._tryPathAsDirectory_closure0.prototype = { + call$0() { + return A._exactlyOne0(A._tryPathWithExtensions0(A.join(this.path, "index.import", null))); + }, + $signature: 47 + }; + A._exactlyOne_closure0.prototype = { + call$1(path) { + var t1 = $.$get$context(); + return " " + t1.prettyUri$1(t1.toUri$1(path)); + }, + $signature: 6 + }; + A._PropertyDescriptor0.prototype = {}; + A.futureToPromise_closure0.prototype = { + call$2(resolve, reject) { + this.future.then$1$2$onError(0, new A.futureToPromise__closure0(resolve), new A.futureToPromise__closure1(reject), type$.void); + }, + $signature: 617 + }; + A.futureToPromise__closure0.prototype = { + call$1(result) { + return this.resolve.call$1(result); + }, + $signature: 34 + }; + A.futureToPromise__closure1.prototype = { + call$2(error, stackTrace) { + A.attachTrace0(error, stackTrace); + this.reject.call$1(error); + }, + $signature: 46 + }; + A.objectToMap_closure.prototype = { + call$2(key, value) { + this.map.$indexSet(0, key, value); + return value; + }, + $signature: 126 + }; + A._RequireMain0.prototype = {}; + A.indent_closure0.prototype = { + call$1(line) { + return B.JSString_methods.$mul(" ", this.indentation) + line; + }, + $signature: 6 + }; + A.flattenVertically_closure1.prototype = { + call$1(inner) { + return A.QueueList_QueueList$from(inner, this.T); + }, + $signature() { + return this.T._eval$1("QueueList<0>(Iterable<0>)"); + } + }; + A.flattenVertically_closure2.prototype = { + call$1(queue) { + this.result.push(queue.removeFirst$0()); + return queue.get$length(0) === 0; + }, + $signature() { + return this.T._eval$1("bool(QueueList<0>)"); + } + }; + A.longestCommonSubsequence_backtrack0.prototype = { + call$2(i, j) { + var selection, t1, _this = this; + if (i === -1 || j === -1) + return A._setArrayType([], _this.T._eval$1("JSArray<0>")); + selection = _this.selections[i][j]; + if (selection != null) { + t1 = _this.call$2(i - 1, j - 1); + J.add$1$ax(t1, selection); + return t1; + } + t1 = _this.lengths; + return t1[i + 1][j] > t1[i][j + 1] ? _this.call$2(i, j - 1) : _this.call$2(i - 1, j); + }, + $signature() { + return this.T._eval$1("List<0>(int,int)"); + } + }; + A.mapAddAll2_closure0.prototype = { + call$2(key, inner) { + var t1 = this.destination, + _0_0 = t1.$index(0, key); + if (_0_0 != null) + _0_0.addAll$1(0, inner); + else + t1.$indexSet(0, key, inner); + }, + $signature() { + return this.K1._eval$1("@<0>")._bind$1(this.K2)._bind$1(this.V)._eval$1("~(1,Map<2,3>)"); + } + }; + A.CssValue0.prototype = { + $eq(_, other) { + if (other == null) + return false; + return this.$ti._is(other) && J.$eq$(other.value, this.value); + }, + get$hashCode(_) { + return J.get$hashCode$(this.value); + }, + toString$0(_) { + return J.toString$0$(this.value); + }, + $isAstNode0: 1, + get$span(receiver) { + return this.span; + } + }; + A.ValueExpression0.prototype = { + accept$1$1(visitor) { + return visitor.visitValueExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return this.value.toString$0(0); + }, + get$span(receiver) { + return this.span; + } + }; + A.valueClass_closure.prototype = { + call$0() { + var t2, + t1 = type$.JSClass, + jsClass = t1._as(self.Object.getPrototypeOf(J.get$$prototype$x(t1._as(B.C__SassNull0.constructor))).constructor); + A.JSClassExtension_setCustomInspect(jsClass, new A.valueClass__closure()); + t1 = type$.String; + t2 = type$.Function; + A.LinkedHashMap_LinkedHashMap$_literal(["asList", new A.valueClass__closure0(), "hasBrackets", new A.valueClass__closure1(), "isTruthy", new A.valueClass__closure2(), "realNull", new A.valueClass__closure3(), "separator", new A.valueClass__closure4()], t1, t2).forEach$1(0, A.JSClassExtension_get_defineGetter(jsClass)); + A.LinkedHashMap_LinkedHashMap$_literal(["sassIndexToListIndex", new A.valueClass__closure5(), "get", new A.valueClass__closure6(), "assertBoolean", new A.valueClass__closure7(), "assertCalculation", new A.valueClass__closure8(), "assertColor", new A.valueClass__closure9(), "assertFunction", new A.valueClass__closure10(), "assertMap", new A.valueClass__closure11(), "assertMixin", new A.valueClass__closure12(), "assertNumber", new A.valueClass__closure13(), "assertString", new A.valueClass__closure14(), "tryMap", new A.valueClass__closure15(), "equals", new A.valueClass__closure16(), "hashCode", new A.valueClass__closure17(), "toString", new A.valueClass__closure18()], t1, t2).forEach$1(0, A.JSClassExtension_get_defineMethod(jsClass)); + return jsClass; + }, + $signature: 15 + }; + A.valueClass__closure.prototype = { + call$1($self) { + return J.toString$0$($self); + }, + $signature: 132 + }; + A.valueClass__closure0.prototype = { + call$1($self) { + return new self.immutable.List($self.get$asList()); + }, + $signature: 618 + }; + A.valueClass__closure1.prototype = { + call$1($self) { + return $self.get$hasBrackets(); + }, + $signature: 54 + }; + A.valueClass__closure2.prototype = { + call$1($self) { + return $self.get$isTruthy(); + }, + $signature: 54 + }; + A.valueClass__closure3.prototype = { + call$1($self) { + return $self.get$realNull(); + }, + $signature: 240 + }; + A.valueClass__closure4.prototype = { + call$1($self) { + return $self.get$separator($self).separator; + }, + $signature: 619 + }; + A.valueClass__closure5.prototype = { + call$3($self, sassIndex, $name) { + return $self.sassIndexToListIndex$2(sassIndex, $name); + }, + call$2($self, sassIndex) { + return this.call$3($self, sassIndex, null); + }, + "call*": "call$3", + $requiredArgCount: 2, + $defaultValues() { + return [null]; + }, + $signature: 620 + }; + A.valueClass__closure6.prototype = { + call$2($self, index) { + return index < 1 && index >= -1 ? $self : self.undefined; + }, + $signature: 248 + }; + A.valueClass__closure7.prototype = { + call$2($self, $name) { + return $self.assertBoolean$1($name); + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 621 + }; + A.valueClass__closure8.prototype = { + call$2($self, $name) { + return $self.assertCalculation$1($name); + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 622 + }; + A.valueClass__closure9.prototype = { + call$2($self, $name) { + return $self.assertColor$1($name); + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 623 + }; + A.valueClass__closure10.prototype = { + call$2($self, $name) { + return $self.assertFunction$1($name); + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 624 + }; + A.valueClass__closure11.prototype = { + call$2($self, $name) { + return $self.assertMap$1($name); + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 625 + }; + A.valueClass__closure12.prototype = { + call$2($self, $name) { + return $self.assertMixin$1($name); + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 626 + }; + A.valueClass__closure13.prototype = { + call$2($self, $name) { + return $self.assertNumber$1($name); + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 627 + }; + A.valueClass__closure14.prototype = { + call$2($self, $name) { + return $self.assertString$1($name); + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 628 + }; + A.valueClass__closure15.prototype = { + call$1($self) { + return $self.tryMap$0(); + }, + $signature: 629 + }; + A.valueClass__closure16.prototype = { + call$2($self, other) { + return $self.$eq(0, other); + }, + $signature: 630 + }; + A.valueClass__closure17.prototype = { + call$2($self, _) { + return $self.get$hashCode($self); + }, + call$1($self) { + return this.call$2($self, null); + }, + "call*": "call$2", + $requiredArgCount: 1, + $defaultValues() { + return [null]; + }, + $signature: 631 + }; + A.valueClass__closure18.prototype = { + call$1($self) { + return $self.toString$0(0); + }, + $signature: 225 + }; + A.Value0.prototype = { + get$isTruthy() { + return true; + }, + get$separator(_) { + return B.ListSeparator_undecided_null_undecided0; + }, + get$hasBrackets() { + return false; + }, + get$asList() { + return A._setArrayType([this], type$.JSArray_Value_2); + }, + get$lengthAsList() { + return 1; + }, + get$isBlank() { + return false; + }, + get$isSpecialNumber() { + return false; + }, + get$isVar() { + return false; + }, + get$realNull() { + return this; + }, + sassIndexToListIndex$2(sassIndex, $name) { + var t1, index, + indexValue = sassIndex.assertNumber$1($name); + if (indexValue.get$hasUnits()) { + t1 = indexValue.get$unitString(); + A.warnForDeprecation0("$" + A.S($name) + ": Passing a number with unit " + t1 + string$.x20is_de + indexValue.unitSuggestion$1($name == null ? "index" : $name) + string$.x0a_Morex3af, B.Deprecation_vn5); + } + index = indexValue.assertInt$1($name); + if (index === 0) + throw A.wrapException(A.SassScriptException$0("List index may not be 0.", $name)); + if (Math.abs(index) > this.get$lengthAsList()) + throw A.wrapException(A.SassScriptException$0("Invalid index " + sassIndex.toString$0(0) + " for a list with " + this.get$lengthAsList() + " elements.", $name)); + return index < 0 ? this.get$lengthAsList() + index : index - 1; + }, + assertBoolean$1($name) { + return A.throwExpression(A.SassScriptException$0(this.toString$0(0) + " is not a boolean.", $name)); + }, + assertCalculation$1($name) { + return A.throwExpression(A.SassScriptException$0(this.toString$0(0) + " is not a calculation.", $name)); + }, + assertColor$1($name) { + return A.throwExpression(A.SassScriptException$0(this.toString$0(0) + " is not a color.", $name)); + }, + assertFunction$1($name) { + return A.throwExpression(A.SassScriptException$0(this.toString$0(0) + " is not a function reference.", $name)); + }, + assertMixin$1($name) { + return A.throwExpression(A.SassScriptException$0(this.toString$0(0) + " is not a mixin reference.", $name)); + }, + assertMap$1($name) { + return A.throwExpression(A.SassScriptException$0(this.toString$0(0) + " is not a map.", $name)); + }, + tryMap$0() { + return null; + }, + assertNumber$1($name) { + return A.throwExpression(A.SassScriptException$0(this.toString$0(0) + " is not a number.", $name)); + }, + assertNumber$0() { + return this.assertNumber$1(null); + }, + assertString$1($name) { + return A.throwExpression(A.SassScriptException$0(this.toString$0(0) + " is not a string.", $name)); + }, + assertCommonListStyle$2$allowSlash($name, allowSlash) { + var invalidSeparator, buffer, t1, _this = this, + _s8_ = "Expected"; + if (_this.get$separator(_this) !== B.ListSeparator_qVN0) + invalidSeparator = !allowSlash && _this.get$separator(_this) === B.ListSeparator_bRz0; + else + invalidSeparator = true; + if (!invalidSeparator && !_this.get$hasBrackets()) + return _this.get$asList(); + buffer = new A.StringBuffer(_s8_); + if (_this.get$hasBrackets()) { + t1 = "Expected" + " an unbracketed"; + buffer._contents = t1; + } else + t1 = _s8_; + if (invalidSeparator) { + t1 += _this.get$hasBrackets() ? "," : " a"; + buffer._contents = t1; + t1 = buffer._contents = t1 + " space-"; + t1 = buffer._contents = (allowSlash ? buffer._contents = t1 + " or slash-" : t1) + "separated"; + } + buffer._contents = t1 + (" list, was " + _this.toString$0(0)); + throw A.wrapException(A.SassScriptException$0(buffer.toString$0(0), $name)); + }, + _value$_selectorString$1($name) { + var _0_0 = this._value$_selectorStringOrNull$0(); + if (_0_0 != null) + return _0_0; + throw A.wrapException(A.SassScriptException$0(this.toString$0(0) + string$.x20is_noav, $name)); + }, + _value$_selectorStringOrNull$0() { + var t1, t2, result, _1_0, _i, complex, string, compound, _this = this, _null = null; + if (_this instanceof A.SassString0) + return _this._string0$_text; + if (!(_this instanceof A.SassList0)) + return _null; + t1 = _this._list1$_contents; + t2 = t1.length; + if (t2 === 0) + return _null; + result = A._setArrayType([], type$.JSArray_String); + $label0$1: { + _1_0 = _this._list1$_separator; + if (B.ListSeparator_qVN0 === _1_0) { + for (_i = 0; _i < t2; ++_i) { + complex = t1[_i]; + if (complex instanceof A.SassString0) { + result.push(complex._string0$_text); + continue; + } + if (complex instanceof A.SassList0 && B.ListSeparator_qSL0 === complex._list1$_separator) { + string = complex._value$_selectorStringOrNull$0(); + if (string == null) + return _null; + result.push(string); + continue; + } + return _null; + } + break $label0$1; + } + if (B.ListSeparator_bRz0 === _1_0) + return _null; + for (_i = 0; _i < t2; ++_i) { + compound = t1[_i]; + if (!(compound instanceof A.SassString0)) + return _null; + result.push(compound._string0$_text); + } + } + return B.JSArray_methods.join$1(result, _1_0 === B.ListSeparator_qVN0 ? ", " : " "); + }, + withListContents$2$separator(contents, separator) { + var t1 = separator == null ? this.get$separator(this) : separator, + t2 = this.get$hasBrackets(); + return A.SassList$0(contents, t1, t2); + }, + withListContents$1(contents) { + return this.withListContents$2$separator(contents, null); + }, + greaterThan$1(other) { + return A.throwExpression(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " > " + other.toString$0(0) + '".', null)); + }, + greaterThanOrEquals$1(other) { + return A.throwExpression(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " >= " + other.toString$0(0) + '".', null)); + }, + lessThan$1(other) { + return A.throwExpression(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " < " + other.toString$0(0) + '".', null)); + }, + lessThanOrEquals$1(other) { + return A.throwExpression(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " <= " + other.toString$0(0) + '".', null)); + }, + times$1(other) { + return A.throwExpression(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " * " + other.toString$0(0) + '".', null)); + }, + modulo$1(other) { + return A.throwExpression(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " % " + other.toString$0(0) + '".', null)); + }, + plus$1(other) { + var t1; + $label0$0: { + if (other instanceof A.SassString0) { + t1 = new A.SassString0(A.serializeValue0(this, false, true) + other._string0$_text, other._string0$_hasQuotes); + break $label0$0; + } + if (other instanceof A.SassCalculation0) + A.throwExpression(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " + " + other.toString$0(0) + '".', null)); + t1 = new A.SassString0(A.serializeValue0(this, false, true) + A.serializeValue0(other, false, true), false); + break $label0$0; + } + return t1; + }, + minus$1(other) { + return other instanceof A.SassCalculation0 ? A.throwExpression(A.SassScriptException$0('Undefined operation "' + this.toString$0(0) + " - " + other.toString$0(0) + '".', null)) : new A.SassString0(A.serializeValue0(this, false, true) + "-" + A.serializeValue0(other, false, true), false); + }, + dividedBy$1(other) { + return new A.SassString0(A.serializeValue0(this, false, true) + "/" + A.serializeValue0(other, false, true), false); + }, + unaryPlus$0() { + return new A.SassString0("+" + A.serializeValue0(this, false, true), false); + }, + unaryMinus$0() { + return new A.SassString0("-" + A.serializeValue0(this, false, true), false); + }, + unaryNot$0() { + return B.SassBoolean_false0; + }, + withoutSlash$0() { + return this; + }, + toString$0(_) { + return A.serializeValue0(this, true, true); + } + }; + A.VariableExpression0.prototype = { + accept$1$1(visitor) { + return visitor.visitVariableExpression$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.span; + return A.String_String$fromCharCodes(B.NativeUint32List_methods.sublist$2(t1.file._decodedChars, t1._file$_start, t1._end), 0, null); + }, + get$span(receiver) { + return this.span; + } + }; + A.VariableDeclaration0.prototype = { + accept$1$1(visitor) { + return visitor.visitVariableDeclaration$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.namespace; + t1 = t1 != null ? "" + (t1 + ".") : ""; + t1 += "$" + this.name + ": " + this.expression.toString$0(0) + ";"; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + get$span(receiver) { + return this.span; + } + }; + A.WarnRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitWarnRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + return "@warn " + this.expression.toString$0(0) + ";"; + }, + get$span(receiver) { + return this.span; + } + }; + A.WhileRule0.prototype = { + accept$1$1(visitor) { + return visitor.visitWhileRule$1(0, this); + }, + accept$1(visitor) { + return this.accept$1$1(visitor, type$.dynamic); + }, + toString$0(_) { + var t1 = this.children; + return "@while " + this.condition.toString$0(0) + " {" + (t1 && B.JSArray_methods).join$1(t1, " ") + "}"; + }, + get$span(receiver) { + return this.span; + } + }; + A.XyzD50ColorSpace0.prototype = { + get$isBoundedInternal() { + return false; + }, + convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, x, y, z, alpha, missingA, missingB, missingChroma, missingHue, missingLightness) { + var f0, f1, f2, lightness, a, b, t1, _this = this, _null = null; + if (B.LabColorSpace_2nT0 === dest || B.LchColorSpace_Bpv0 === dest) { + f0 = _this._xyz_d50$_convertComponentToLabF$1((x == null ? 0 : x) / 0.9642956764295677); + f1 = _this._xyz_d50$_convertComponentToLabF$1((y == null ? 0 : y) / 1); + f2 = _this._xyz_d50$_convertComponentToLabF$1((z == null ? 0 : z) / 0.8251046025104602); + lightness = missingLightness ? _null : 116 * f1 - 16; + a = 500 * (f0 - f1); + b = 200 * (f1 - f2); + if (dest === B.LabColorSpace_2nT0) { + t1 = missingA ? _null : a; + t1 = A.SassColor$_forSpace0(B.LabColorSpace_2nT0, lightness, t1, missingB ? _null : b, alpha, _null); + } else + t1 = A.labToLch0(B.LchColorSpace_Bpv0, lightness, a, b, alpha, missingChroma, missingHue); + return t1; + } + return _this.super$ColorSpace$convertLinear0(dest, x, y, z, alpha, missingA, missingB, missingChroma, missingHue, missingLightness); + }, + convert$5(dest, x, y, z, alpha) { + return this.convert$10$missingA$missingB$missingChroma$missingHue$missingLightness(dest, x, y, z, alpha, false, false, false, false, false); + }, + _xyz_d50$_convertComponentToLabF$1(component) { + return component > 0.008856451679035631 ? Math.pow(component, 0.3333333333333333) + 0 : (903.2962962962963 * component + 16) / 116; + }, + toLinear$1(channel) { + return channel; + }, + fromLinear$1(channel) { + return channel; + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.SrgbLinearColorSpace_kUj0 === dest || B.SrgbColorSpace_thf0 === dest || B.RgbColorSpace_i0P0 === dest) { + t1 = $.$get$xyzD50ToLinearSrgb0(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf20 === dest) { + t1 = $.$get$xyzD50ToLinearA98Rgb0(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz0 === dest) { + t1 = $.$get$xyzD50ToLinearProphotoRgb0(); + break $label0$0; + } + if (B.DisplayP3ColorSpace_MmT0 === dest) { + t1 = $.$get$xyzD50ToLinearDisplayP30(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo0 === dest) { + t1 = $.$get$xyzD50ToLinearRec20200(); + break $label0$0; + } + if (B.XyzD65ColorSpace_WiJ0 === dest) { + t1 = $.$get$xyzD50ToXyzD650(); + break $label0$0; + } + if (B.LmsColorSpace_Os30 === dest) { + t1 = $.$get$xyzD50ToLms0(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix0(dest); + break $label0$0; + } + return t1; + } + }; + A.XyzD65ColorSpace0.prototype = { + get$isBoundedInternal() { + return false; + }, + toLinear$1(channel) { + return channel; + }, + fromLinear$1(channel) { + return channel; + }, + transformationMatrix$1(dest) { + var t1; + $label0$0: { + if (B.SrgbLinearColorSpace_kUj0 === dest || B.SrgbColorSpace_thf0 === dest || B.RgbColorSpace_i0P0 === dest) { + t1 = $.$get$xyzD65ToLinearSrgb0(); + break $label0$0; + } + if (B.A98RgbColorSpace_lf20 === dest) { + t1 = $.$get$xyzD65ToLinearA98Rgb0(); + break $label0$0; + } + if (B.ProphotoRgbColorSpace_BDz0 === dest) { + t1 = $.$get$xyzD65ToLinearProphotoRgb0(); + break $label0$0; + } + if (B.DisplayP3ColorSpace_MmT0 === dest) { + t1 = $.$get$xyzD65ToLinearDisplayP30(); + break $label0$0; + } + if (B.Rec2020ColorSpace_6oo0 === dest) { + t1 = $.$get$xyzD65ToLinearRec20200(); + break $label0$0; + } + if (B.XyzD50ColorSpace_2OB0 === dest) { + t1 = $.$get$xyzD65ToXyzD500(); + break $label0$0; + } + if (B.LmsColorSpace_Os30 === dest) { + t1 = $.$get$xyzD65ToLms0(); + break $label0$0; + } + t1 = this.super$ColorSpace$transformationMatrix0(dest); + break $label0$0; + } + return t1; + } + }; + (function aliases() { + var _ = J.LegacyJavaScriptObject.prototype; + _.super$LegacyJavaScriptObject$toString = _.toString$0; + _ = A.JsLinkedHashMap.prototype; + _.super$JsLinkedHashMap$internalContainsKey = _.internalContainsKey$1; + _.super$JsLinkedHashMap$internalGet = _.internalGet$1; + _.super$JsLinkedHashMap$internalSet = _.internalSet$2; + _.super$JsLinkedHashMap$internalRemove = _.internalRemove$1; + _ = A._BufferingStreamSubscription.prototype; + _.super$_BufferingStreamSubscription$_add = _._async$_add$1; + _.super$_BufferingStreamSubscription$_addError = _._addError$2; + _ = A.ListBase.prototype; + _.super$ListBase$setRange = _.setRange$4; + _ = A.Iterable.prototype; + _.super$Iterable$where = _.where$1; + _.super$Iterable$skipWhile = _.skipWhile$1; + _ = A.ModifiableCssParentNode.prototype; + _.super$ModifiableCssParentNode$addChild = _.addChild$1; + _ = A.SimpleSelector.prototype; + _.super$SimpleSelector$addSuffix = _.addSuffix$1; + _.super$SimpleSelector$unify = _.unify$1; + _.super$SimpleSelector$isSuperselector = _.isSuperselector$1; + _ = A.Parser.prototype; + _.super$Parser$silentComment = _.silentComment$0; + _ = A.StylesheetParser.prototype; + _.super$StylesheetParser$importArgument = _.importArgument$0; + _.super$StylesheetParser$namespacedExpression = _.namespacedExpression$2; + _ = A.Value.prototype; + _.super$Value$assertMap = _.assertMap$1; + _.super$Value$plus = _.plus$1; + _.super$Value$minus = _.minus$1; + _.super$Value$dividedBy = _.dividedBy$1; + _.super$Value$toString = _.toString$0; + _ = A.ColorSpace.prototype; + _.super$ColorSpace$convert = _.convert$5; + _.super$ColorSpace$convertLinear = _.convertLinear$10$missingA$missingB$missingChroma$missingHue$missingLightness; + _.super$ColorSpace$transformationMatrix = _.transformationMatrix$1; + _ = A.SassNumber.prototype; + _.super$SassNumber$convertValueToMatch = _.convertValueToMatch$3; + _.super$SassNumber$coerce = _.coerce$3; + _.super$SassNumber$coerceValue = _.coerceValue$3; + _.super$SassNumber$coerceValueToUnit = _.coerceValueToUnit$2; + _.super$SassNumber$coerceToMatch = _.coerceToMatch$3; + _.super$SassNumber$coerceValueToMatch = _.coerceValueToMatch$3; + _.super$SassNumber$greaterThan = _.greaterThan$1; + _.super$SassNumber$greaterThanOrEquals = _.greaterThanOrEquals$1; + _.super$SassNumber$lessThan = _.lessThan$1; + _.super$SassNumber$lessThanOrEquals = _.lessThanOrEquals$1; + _.super$SassNumber$modulo = _.modulo$1; + _.super$SassNumber$plus = _.plus$1; + _.super$SassNumber$minus = _.minus$1; + _.super$SassNumber$times = _.times$1; + _.super$SassNumber$dividedBy = _.dividedBy$1; + _ = A.AnySelectorVisitor.prototype; + _.super$AnySelectorVisitor$visitComplexSelector = _.visitComplexSelector$1; + _ = A.EveryCssVisitor.prototype; + _.super$EveryCssVisitor$visitCssStyleRule = _.visitCssStyleRule$1; + _ = A.ReplaceExpressionVisitor.prototype; + _.super$ReplaceExpressionVisitor$visitBinaryOperationExpression = _.visitBinaryOperationExpression$1; + _.super$ReplaceExpressionVisitor$visitUnaryOperationExpression = _.visitUnaryOperationExpression$1; + _ = A.SourceSpanMixin.prototype; + _.super$SourceSpanMixin$compareTo = _.compareTo$1; + _.super$SourceSpanMixin$$eq = _.$eq; + _ = A.StringScanner.prototype; + _.super$StringScanner$readChar = _.readChar$0; + _.super$StringScanner$scanChar = _.scanChar$1; + _.super$StringScanner$scan = _.scan$1; + _.super$StringScanner$matches = _.matches$1; + _ = A.AnySelectorVisitor0.prototype; + _.super$AnySelectorVisitor$visitComplexSelector0 = _.visitComplexSelector$1; + _ = A.EveryCssVisitor0.prototype; + _.super$EveryCssVisitor$visitCssStyleRule0 = _.visitCssStyleRule$1; + _ = A.ModifiableCssParentNode0.prototype; + _.super$ModifiableCssParentNode$addChild0 = _.addChild$1; + _ = A.SassNumber0.prototype; + _.super$SassNumber$convertToMatch = _.convertToMatch$3; + _.super$SassNumber$convertValueToMatch0 = _.convertValueToMatch$3; + _.super$SassNumber$coerce0 = _.coerce$3; + _.super$SassNumber$coerceValue0 = _.coerceValue$3; + _.super$SassNumber$coerceValueToUnit0 = _.coerceValueToUnit$2; + _.super$SassNumber$coerceToMatch0 = _.coerceToMatch$3; + _.super$SassNumber$coerceValueToMatch0 = _.coerceValueToMatch$3; + _.super$SassNumber$greaterThan0 = _.greaterThan$1; + _.super$SassNumber$greaterThanOrEquals0 = _.greaterThanOrEquals$1; + _.super$SassNumber$lessThan0 = _.lessThan$1; + _.super$SassNumber$lessThanOrEquals0 = _.lessThanOrEquals$1; + _.super$SassNumber$modulo0 = _.modulo$1; + _.super$SassNumber$plus0 = _.plus$1; + _.super$SassNumber$minus0 = _.minus$1; + _.super$SassNumber$times0 = _.times$1; + _.super$SassNumber$dividedBy0 = _.dividedBy$1; + _ = A.Parser1.prototype; + _.super$Parser$silentComment0 = _.silentComment$0; + _ = A.ReplaceExpressionVisitor0.prototype; + _.super$ReplaceExpressionVisitor$visitBinaryOperationExpression0 = _.visitBinaryOperationExpression$1; + _.super$ReplaceExpressionVisitor$visitUnaryOperationExpression0 = _.visitUnaryOperationExpression$1; + _ = A.SimpleSelector0.prototype; + _.super$SimpleSelector$addSuffix0 = _.addSuffix$1; + _.super$SimpleSelector$unify0 = _.unify$1; + _.super$SimpleSelector$isSuperselector0 = _.isSuperselector$1; + _ = A.ColorSpace0.prototype; + _.super$ColorSpace$convert0 = _.convert$5; + _.super$ColorSpace$convertLinear0 = _.convertLinear$10$missingA$missingB$missingChroma$missingHue$missingLightness; + _.super$ColorSpace$transformationMatrix0 = _.transformationMatrix$1; + _ = A.StylesheetParser0.prototype; + _.super$StylesheetParser$importArgument0 = _.importArgument$0; + _.super$StylesheetParser$namespacedExpression0 = _.namespacedExpression$2; + _ = A.Value0.prototype; + _.super$Value$assertMap0 = _.assertMap$1; + _.super$Value$plus0 = _.plus$1; + _.super$Value$minus0 = _.minus$1; + _.super$Value$dividedBy0 = _.dividedBy$1; + _.super$Value$toString0 = _.toString$0; + })(); + (function installTearOffs() { + var _static_2 = hunkHelpers._static_2, + _instance_1_i = hunkHelpers._instance_1i, + _instance_1_u = hunkHelpers._instance_1u, + _static_1 = hunkHelpers._static_1, + _static_0 = hunkHelpers._static_0, + _static = hunkHelpers.installStaticTearOff, + _instance = hunkHelpers.installInstanceTearOff, + _instance_2_u = hunkHelpers._instance_2u, + _instance_0_i = hunkHelpers._instance_0i, + _instance_0_u = hunkHelpers._instance_0u; + _static_2(J, "_interceptors_JSArray__compareAny$closure", "JSArray__compareAny", 269); + _instance_1_i(J.JSArray.prototype, "get$contains", "contains$1", 9); + _instance_1_i(A._CastIterableBase.prototype, "get$contains", "contains$1", 9); + _instance_1_u(A.CastMap.prototype, "get$containsKey", "containsKey$1", 9); + _instance_1_u(A.ConstantStringMap.prototype, "get$containsKey", "containsKey$1", 9); + _instance_1_i(A.ConstantStringSet.prototype, "get$contains", "contains$1", 9); + _instance_1_i(A.GeneralConstantSet.prototype, "get$contains", "contains$1", 9); + _instance_1_u(A.JsLinkedHashMap.prototype, "get$containsKey", "containsKey$1", 9); + _static_1(A, "async__AsyncRun__scheduleImmediateJsOverride$closure", "_AsyncRun__scheduleImmediateJsOverride", 137); + _static_1(A, "async__AsyncRun__scheduleImmediateWithSetImmediate$closure", "_AsyncRun__scheduleImmediateWithSetImmediate", 137); + _static_1(A, "async__AsyncRun__scheduleImmediateWithTimer$closure", "_AsyncRun__scheduleImmediateWithTimer", 137); + _static_0(A, "async___startMicrotaskLoop$closure", "_startMicrotaskLoop", 0); + _static_1(A, "async___nullDataHandler$closure", "_nullDataHandler", 71); + _static_2(A, "async___nullErrorHandler$closure", "_nullErrorHandler", 75); + _static_0(A, "async___nullDoneHandler$closure", "_nullDoneHandler", 0); + _static(A, "async___rootHandleUncaughtError$closure", 5, null, ["call$5"], ["_rootHandleUncaughtError"], 634, 0); + _static(A, "async___rootRun$closure", 4, null, ["call$1$4", "call$4"], ["_rootRun", function($self, $parent, zone, f) { + return A._rootRun($self, $parent, zone, f, type$.dynamic); + }], 635, 1); + _static(A, "async___rootRunUnary$closure", 5, null, ["call$2$5", "call$5"], ["_rootRunUnary", function($self, $parent, zone, f, arg) { + var t1 = type$.dynamic; + return A._rootRunUnary($self, $parent, zone, f, arg, t1, t1); + }], 636, 1); + _static(A, "async___rootRunBinary$closure", 6, null, ["call$3$6", "call$6"], ["_rootRunBinary", function($self, $parent, zone, f, arg1, arg2) { + var t1 = type$.dynamic; + return A._rootRunBinary($self, $parent, zone, f, arg1, arg2, t1, t1, t1); + }], 637, 1); + _static(A, "async___rootRegisterCallback$closure", 4, null, ["call$1$4", "call$4"], ["_rootRegisterCallback", function($self, $parent, zone, f) { + return A._rootRegisterCallback($self, $parent, zone, f, type$.dynamic); + }], 638, 0); + _static(A, "async___rootRegisterUnaryCallback$closure", 4, null, ["call$2$4", "call$4"], ["_rootRegisterUnaryCallback", function($self, $parent, zone, f) { + var t1 = type$.dynamic; + return A._rootRegisterUnaryCallback($self, $parent, zone, f, t1, t1); + }], 639, 0); + _static(A, "async___rootRegisterBinaryCallback$closure", 4, null, ["call$3$4", "call$4"], ["_rootRegisterBinaryCallback", function($self, $parent, zone, f) { + var t1 = type$.dynamic; + return A._rootRegisterBinaryCallback($self, $parent, zone, f, t1, t1, t1); + }], 640, 0); + _static(A, "async___rootErrorCallback$closure", 5, null, ["call$5"], ["_rootErrorCallback"], 641, 0); + _static(A, "async___rootScheduleMicrotask$closure", 4, null, ["call$4"], ["_rootScheduleMicrotask"], 642, 0); + _static(A, "async___rootCreateTimer$closure", 5, null, ["call$5"], ["_rootCreateTimer"], 643, 0); + _static(A, "async___rootCreatePeriodicTimer$closure", 5, null, ["call$5"], ["_rootCreatePeriodicTimer"], 644, 0); + _static(A, "async___rootPrint$closure", 4, null, ["call$4"], ["_rootPrint"], 645, 0); + _static_1(A, "async___printToZone$closure", "_printToZone", 111); + _static(A, "async___rootFork$closure", 5, null, ["call$5"], ["_rootFork"], 646, 0); + _instance(A._AsyncCompleter.prototype, "get$complete", 0, 0, function() { + return [null]; + }, ["call$1", "call$0"], ["complete$1", "complete$0"], 217, 0, 0); + _instance_2_u(A._Future.prototype, "get$_completeError", "_completeError$2", 75); + var _; + _instance_1_i(_ = A._StreamController.prototype, "get$add", "add$1", 34); + _instance(_, "get$addError", 0, 1, function() { + return [null]; + }, ["call$2", "call$1"], ["addError$2", "addError$1"], 145, 0, 0); + _instance_0_i(_, "get$close", "close$0", 322); + _instance_1_u(_, "get$_async$_add", "_async$_add$1", 34); + _instance_2_u(_, "get$_addError", "_addError$2", 75); + _instance_0_u(_, "get$_close", "_close$0", 0); + _instance_0_u(_ = A._ControllerSubscription.prototype, "get$_async$_onPause", "_async$_onPause$0", 0); + _instance_0_u(_, "get$_async$_onResume", "_async$_onResume$0", 0); + _instance(_ = A._BufferingStreamSubscription.prototype, "get$pause", 1, 0, null, ["call$1", "call$0"], ["pause$1", "pause$0"], 304, 0, 0); + _instance_0_i(_, "get$resume", "resume$0", 0); + _instance_0_u(_, "get$_async$_onPause", "_async$_onPause$0", 0); + _instance_0_u(_, "get$_async$_onResume", "_async$_onResume$0", 0); + _instance_1_u(_ = A._StreamIterator.prototype, "get$_onData", "_onData$1", 34); + _instance_2_u(_, "get$_onError", "_onError$2", 75); + _instance_0_u(_, "get$_onDone", "_onDone$0", 0); + _instance_0_u(_ = A._ForwardingStreamSubscription.prototype, "get$_async$_onPause", "_async$_onPause$0", 0); + _instance_0_u(_, "get$_async$_onResume", "_async$_onResume$0", 0); + _instance_1_u(_, "get$_handleData", "_handleData$1", 34); + _instance_2_u(_, "get$_handleError", "_handleError$2", 345); + _instance_0_u(_, "get$_handleDone", "_handleDone$0", 0); + _static_2(A, "collection___defaultEquals$closure", "_defaultEquals", 270); + _static_1(A, "collection___defaultHashCode$closure", "_defaultHashCode", 227); + _static_2(A, "collection_ListBase__compareAny$closure", "ListBase__compareAny", 269); + _instance_1_u(A._HashMap.prototype, "get$containsKey", "containsKey$1", 9); + _instance_1_u(A._LinkedCustomHashMap.prototype, "get$containsKey", "containsKey$1", 9); + _instance(_ = A._LinkedHashSet.prototype, "get$_newSimilarSet", 0, 0, null, ["call$1$0", "call$0"], ["_newSimilarSet$1$0", "_newSimilarSet$0"], 159, 0, 0); + _instance_1_i(_, "get$contains", "contains$1", 9); + _instance_1_i(_, "get$add", "add$1", 9); + _instance(A._LinkedIdentityHashSet.prototype, "get$_newSimilarSet", 0, 0, null, ["call$1$0", "call$0"], ["_newSimilarSet$1$0", "_newSimilarSet$0"], 159, 0, 0); + _instance_1_u(A.MapBase.prototype, "get$containsKey", "containsKey$1", 9); + _instance_1_u(A.MapView.prototype, "get$containsKey", "containsKey$1", 9); + _instance_1_i(A.UnmodifiableSetView.prototype, "get$contains", "contains$1", 9); + _static_1(A, "convert___defaultToEncodable$closure", "_defaultToEncodable", 90); + _instance_1_u(A._JsonMap.prototype, "get$containsKey", "containsKey$1", 9); + _static_1(A, "core__identityHashCode$closure", "identityHashCode", 227); + _static_2(A, "core__identical$closure", "identical", 270); + _static_1(A, "core_Uri_decodeComponent$closure", "Uri_decodeComponent", 6); + _instance_1_i(A.Iterable.prototype, "get$contains", "contains$1", 9); + _instance_1_i(A.StringBuffer.prototype, "get$write", "write$1", 34); + _static(A, "math0__max$closure", 2, null, ["call$1$2", "call$2"], ["max", function(a, b) { + return A.max(a, b, type$.num); + }], 649, 1); + _instance_1_u(A.ArgResults.prototype, "get$wasParsed", "wasParsed$1", 5); + _instance_1_u(_ = A.StreamCompleter.prototype, "get$setSourceStream", "setSourceStream$1", 34); + _instance(_, "get$setError", 0, 1, function() { + return [null]; + }, ["call$2", "call$1"], ["setError$2", "setError$1"], 145, 0, 0); + _instance_0_u(_ = A.StreamGroup.prototype, "get$_onListen", "_onListen$0", 0); + _instance_0_u(_, "get$_onPause", "_onPause$0", 0); + _instance_0_u(_, "get$_onResume", "_onResume$0", 0); + _instance_0_u(_, "get$_onCancel", "_onCancel$0", 224); + _instance_0_i(A.ReplAdapter.prototype, "get$exit", "exit$0", 0); + _instance_1_i(A.EmptyUnmodifiableSet.prototype, "get$contains", "contains$1", 9); + _instance_1_i(A.UnionSet.prototype, "get$contains", "contains$1", 9); + _instance_1_i(A._DelegatingIterableBase.prototype, "get$contains", "contains$1", 9); + _instance_1_i(A.MapKeySet.prototype, "get$contains", "contains$1", 9); + _static_1(A, "version_Version___parse_tearOff$closure", "Version___parse_tearOff", 233); + _instance_1_u(A.VersionRange.prototype, "get$allows", "allows$1", 633); + _instance_1_u(A._IsInvisibleVisitor0.prototype, "get$visitComplexSelector", "visitComplexSelector$1", 20); + _instance_1_u(A._IsBogusVisitor.prototype, "get$visitComplexSelector", "visitComplexSelector$1", 20); + _instance_1_u(A._IsUselessVisitor.prototype, "get$visitComplexSelector", "visitComplexSelector$1", 20); + _instance_1_u(A.SelectorList.prototype, "get$isSuperselector", "isSuperselector$1", 73); + _instance_1_u(A.PseudoSelector.prototype, "get$isSuperselector", "isSuperselector$1", 13); + _instance_1_u(A.SimpleSelector.prototype, "get$isSuperselector", "isSuperselector$1", 13); + _instance_1_u(A.TypeSelector.prototype, "get$isSuperselector", "isSuperselector$1", 13); + _instance_1_u(A.UniversalSelector.prototype, "get$isSuperselector", "isSuperselector$1", 13); + _instance_1_u(A.EmptyExtensionStore.prototype, "get$addExtensions", "addExtensions$1", 208); + _instance_1_u(A.ExtensionStore.prototype, "get$addExtensions", "addExtensions$1", 208); + _static_1(A, "functions___isUnique$closure", "_isUnique", 13); + _instance_2_u(A.NodePackageImporter.prototype, "get$_compareExpansionKeys", "_compareExpansionKeys$2", 146); + _instance_0_u(A.CssParser.prototype, "get$silentComment", "silentComment$0", 19); + _instance_0_u(_ = A.Parser.prototype, "get$silentComment", "silentComment$0", 19); + _instance_0_u(_, "get$loudComment", "loudComment$0", 0); + _instance_0_u(_, "get$string", "string$0", 26); + _instance(_, "get$error", 1, 2, function() { + return [null]; + }, ["call$3", "call$2"], ["error$3", "error$2"], 158, 0, 0); + _instance(_ = A.StylesheetParser.prototype, "get$_statement", 0, 0, null, ["call$1$root", "call$0"], ["_statement$1$root", "_statement$0"], 459, 0, 0); + _instance_0_u(_, "get$_declarationChild", "_declarationChild$0", 121); + _instance_0_u(_, "get$_functionChild", "_functionChild$0", 121); + _instance(_, "get$_expression", 0, 0, null, ["call$4$bracketList$consumeNewlines$singleEquals$until", "call$0", "call$1$consumeNewlines", "call$3$consumeNewlines$singleEquals$until", "call$1$bracketList", "call$2$consumeNewlines$until"], ["_expression$4$bracketList$consumeNewlines$singleEquals$until", "_expression$0", "_expression$1$consumeNewlines", "_expression$3$consumeNewlines$singleEquals$until", "_expression$1$bracketList", "_expression$2$consumeNewlines$until"], 480, 0, 0); + _instance_0_u(_, "get$_number", "_number$0", 522); + _instance(A.LazyFileSpan.prototype, "get$message", 1, 1, function() { + return {color: null}; + }, ["call$2$color", "call$1"], ["message$2$color", "message$1"], 120, 0, 0); + _instance_1_u(A.LimitedMapView.prototype, "get$containsKey", "containsKey$1", 9); + _instance_1_u(A.MergedMapView.prototype, "get$containsKey", "containsKey$1", 9); + _instance(A.MultiSpan.prototype, "get$message", 1, 1, function() { + return {color: null}; + }, ["call$2$color", "call$1"], ["message$2$color", "message$1"], 163, 0, 0); + _instance_1_i(A.NoSourceMapBuffer.prototype, "get$write", "write$1", 34); + _instance_1_u(A.PrefixedMapView.prototype, "get$containsKey", "containsKey$1", 9); + _instance_1_u(A.PublicMemberMapView.prototype, "get$containsKey", "containsKey$1", 9); + _instance_1_i(A.SourceMapBuffer.prototype, "get$write", "write$1", 34); + _instance_1_u(A.UnprefixedMapView.prototype, "get$containsKey", "containsKey$1", 9); + _static_1(A, "utils__isPublic$closure", "isPublic", 5); + _static_1(A, "calculation_SassCalculation__simplify$closure", "SassCalculation__simplify", 79); + _instance_1_u(A.ColorChannel.prototype, "get$isAnalogous", "isAnalogous$1", 108); + _instance_1_u(A.SrgbColorSpace.prototype, "get$toLinear", "toLinear$1", 16); + _instance_1_u(A.AnySelectorVisitor.prototype, "get$visitComplexSelector", "visitComplexSelector$1", 20); + _instance(_ = A._EvaluateVisitor0.prototype, "get$_async_evaluate$_interpolationToValue", 0, 1, null, ["call$3$trim$warnForColor", "call$1", "call$2$warnForColor"], ["_async_evaluate$_interpolationToValue$3$trim$warnForColor", "_async_evaluate$_interpolationToValue$1", "_async_evaluate$_interpolationToValue$2$warnForColor"], 339, 0, 0); + _instance_1_u(_, "get$_async_evaluate$_expressionNode", "_async_evaluate$_expressionNode$1", 166); + _instance(_ = A._EvaluateVisitor.prototype, "get$_interpolationToValue", 0, 1, null, ["call$3$trim$warnForColor", "call$1", "call$2$warnForColor"], ["_interpolationToValue$3$trim$warnForColor", "_interpolationToValue$1", "_interpolationToValue$2$warnForColor"], 541, 0, 0); + _instance_1_u(_, "get$_expressionNode", "_expressionNode$1", 166); + _instance_1_i(_ = A.RecursiveStatementVisitor.prototype, "get$visitContentBlock", "visitContentBlock$1", 651); + _instance_1_u(_, "get$visitChildren", "visitChildren$1", 273); + _instance_1_u(_ = A.SelectorSearchVisitor.prototype, "get$visitComplexSelector", "visitComplexSelector$1", "SelectorSearchVisitor.T?(ComplexSelector)"); + _instance_1_u(_, "get$visitSelectorList", "visitSelectorList$1", "SelectorSearchVisitor.T?(SelectorList)"); + _instance_1_u(_ = A._SerializeVisitor.prototype, "get$_visitMediaQuery", "_visitMediaQuery$1", 276); + _instance_1_u(_, "get$_specificities", "_specificities$1", 277); + _instance_1_u(_, "get$_writeCalculationValue", "_writeCalculationValue$1", 95); + _instance(_, "get$_writeChannel", 0, 1, null, ["call$2", "call$1"], ["_writeChannel$2", "_writeChannel$1"], 191, 0, 0); + _instance_1_u(_, "get$visitSelectorList", "visitSelectorList$1", 279); + _instance_1_u(_, "get$_requiresSemicolon", "_requiresSemicolon$1", 8); + _instance_1_i(_ = A.StatementSearchVisitor.prototype, "get$visitContentBlock", "visitContentBlock$1", "StatementSearchVisitor.T?(ContentBlock)"); + _instance_1_u(_, "get$visitChildren", "visitChildren$1", "StatementSearchVisitor.T?(List)"); + _instance(A.SourceSpanMixin.prototype, "get$message", 1, 1, function() { + return {color: null}; + }, ["call$2$color", "call$1"], ["message$2$color", "message$1"], 120, 0, 0); + _static_1(A, "frame_Frame___parseVM_tearOff$closure", "Frame___parseVM_tearOff", 92); + _static_1(A, "frame_Frame___parseV8_tearOff$closure", "Frame___parseV8_tearOff", 92); + _static_1(A, "frame_Frame___parseFirefox_tearOff$closure", "Frame___parseFirefox_tearOff", 92); + _static_1(A, "frame_Frame___parseFriendly_tearOff$closure", "Frame___parseFriendly_tearOff", 92); + _static_1(A, "trace_Trace___parseVM_tearOff$closure", "Trace___parseVM_tearOff", 185); + _static_1(A, "trace_Trace___parseFriendly_tearOff$closure", "Trace___parseFriendly_tearOff", 185); + _static(A, "from_handlers__TransformByHandlers__defaultHandleError$closure", 3, null, ["call$1$3", "call$3"], ["TransformByHandlers__defaultHandleError", function(error, stackTrace, sink) { + return A.TransformByHandlers__defaultHandleError(error, stackTrace, sink, type$.dynamic); + }], 652, 0); + _static(A, "rate_limit___collect$closure", 2, null, ["call$1$2", "call$2"], ["_collect", function($event, soFar) { + return A._collect($event, soFar, type$.dynamic); + }], 653, 0); + _instance_1_u(A.AnySelectorVisitor0.prototype, "get$visitComplexSelector", "visitComplexSelector$1", 21); + _instance(_ = A._EvaluateVisitor2.prototype, "get$_async_evaluate0$_interpolationToValue", 0, 1, null, ["call$3$trim$warnForColor", "call$1", "call$2$warnForColor"], ["_async_evaluate0$_interpolationToValue$3$trim$warnForColor", "_async_evaluate0$_interpolationToValue$1", "_async_evaluate0$_interpolationToValue$2$warnForColor"], 318, 0, 0); + _instance_1_u(_, "get$_async_evaluate0$_expressionNode", "_async_evaluate0$_expressionNode$1", 203); + _static_1(A, "calculation1___assertCalculationValue$closure", "_assertCalculationValue", 95); + _static_1(A, "calculation1___isValidClampArg$closure", "_isValidClampArg", 9); + _static_1(A, "calculation0_SassCalculation__simplify$closure", "SassCalculation__simplify0", 79); + _instance_1_u(A.ColorChannel0.prototype, "get$isAnalogous", "isAnalogous$1", 70); + _static(A, "compile__compile$closure", 1, function() { + return [null]; + }, ["call$2", "call$1"], ["compile0", function(path) { + return A.compile0(path, null); + }], 654, 0); + _static(A, "compile__compileString$closure", 1, function() { + return [null]; + }, ["call$2", "call$1"], ["compileString0", function(text) { + return A.compileString0(text, null); + }], 655, 0); + _static(A, "compile__compileAsync$closure", 1, function() { + return [null]; + }, ["call$2", "call$1"], ["compileAsync1", function(path) { + return A.compileAsync1(path, null); + }], 656, 0); + _static(A, "compile__compileStringAsync$closure", 1, function() { + return [null]; + }, ["call$2", "call$1"], ["compileStringAsync1", function(text) { + return A.compileStringAsync1(text, null); + }], 657, 0); + _static_1(A, "compile___parseImporter$closure", "_parseImporter0", 658); + _static_1(A, "compile___simplifyCalcArg$closure", "_simplifyCalcArg", 79); + _static_0(A, "compiler__initCompiler$closure", "initCompiler", 659); + _static_0(A, "compiler__initAsyncCompiler$closure", "initAsyncCompiler", 660); + _instance_0_u(A.CssParser0.prototype, "get$silentComment", "silentComment$0", 19); + _instance_1_u(A.EmptyExtensionStore0.prototype, "get$addExtensions", "addExtensions$1", 234); + _instance(_ = A._EvaluateVisitor1.prototype, "get$_evaluate0$_interpolationToValue", 0, 1, null, ["call$3$trim$warnForColor", "call$1", "call$2$warnForColor"], ["_evaluate0$_interpolationToValue$3$trim$warnForColor", "_evaluate0$_interpolationToValue$1", "_evaluate0$_interpolationToValue$2$warnForColor"], 675, 0, 0); + _instance_1_u(_, "get$_evaluate0$_expressionNode", "_evaluate0$_expressionNode$1", 203); + _instance_1_u(A.ExtensionStore0.prototype, "get$addExtensions", "addExtensions$1", 234); + _static_1(A, "functions0___isUnique$closure", "_isUnique0", 14); + _static_1(A, "immutable__jsToDartList$closure", "jsToDartList", 661); + _instance(A.LazyFileSpan0.prototype, "get$message", 1, 1, function() { + return {color: null}; + }, ["call$2$color", "call$1"], ["message$2$color", "message$1"], 120, 0, 0); + _static_2(A, "legacy__render$closure", "render", 662); + _static_1(A, "legacy__renderSync$closure", "renderSync", 663); + _instance_1_u(A.LimitedMapView0.prototype, "get$containsKey", "containsKey$1", 9); + _instance_1_u(A.SelectorList0.prototype, "get$isSuperselector", "isSuperselector$1", 76); + _instance_1_u(A.MergedMapView0.prototype, "get$containsKey", "containsKey$1", 9); + _instance(A.MultiSpan0.prototype, "get$message", 1, 1, function() { + return {color: null}; + }, ["call$2$color", "call$1"], ["message$2$color", "message$1"], 163, 0, 0); + _instance_1_i(A.NoSourceMapBuffer0.prototype, "get$write", "write$1", 34); + _instance_2_u(A.NodePackageImporter0.prototype, "get$_node_package$_compareExpansionKeys", "_node_package$_compareExpansionKeys$2", 146); + _static_0(A, "parser0__loadParserExports$closure", "loadParserExports", 664); + _static(A, "parser0___parse$closure", 3, null, ["call$3"], ["_parse"], 665, 0); + _static_1(A, "parser0___parseIdentifier$closure", "_parseIdentifier", 666); + _static_1(A, "parser0___toCssIdentifier$closure", "_toCssIdentifier", 6); + _instance_0_u(_ = A.Parser1.prototype, "get$silentComment", "silentComment$0", 19); + _instance_0_u(_, "get$loudComment", "loudComment$0", 0); + _instance_0_u(_, "get$string", "string$0", 26); + _instance(_, "get$error", 1, 2, function() { + return [null]; + }, ["call$3", "call$2"], ["error$3", "error$2"], 158, 0, 0); + _instance_1_u(A.PrefixedMapView0.prototype, "get$containsKey", "containsKey$1", 9); + _instance_1_u(A.PseudoSelector0.prototype, "get$isSuperselector", "isSuperselector$1", 14); + _instance_1_u(A.PublicMemberMapView0.prototype, "get$containsKey", "containsKey$1", 9); + _instance_1_u(A._IsInvisibleVisitor2.prototype, "get$visitComplexSelector", "visitComplexSelector$1", 21); + _instance_1_u(A._IsBogusVisitor0.prototype, "get$visitComplexSelector", "visitComplexSelector$1", 21); + _instance_1_u(A._IsUselessVisitor0.prototype, "get$visitComplexSelector", "visitComplexSelector$1", 21); + _instance_1_u(_ = A.SelectorSearchVisitor0.prototype, "get$visitComplexSelector", "visitComplexSelector$1", "SelectorSearchVisitor0.T?(ComplexSelector0)"); + _instance_1_u(_, "get$visitSelectorList", "visitSelectorList$1", "SelectorSearchVisitor0.T?(SelectorList0)"); + _instance_1_u(_ = A._SerializeVisitor0.prototype, "get$_serialize0$_visitMediaQuery", "_serialize0$_visitMediaQuery$1", 574); + _instance_1_u(_, "get$_serialize0$_specificities", "_serialize0$_specificities$1", 575); + _instance_1_u(_, "get$_serialize0$_writeCalculationValue", "_serialize0$_writeCalculationValue$1", 95); + _instance(_, "get$_serialize0$_writeChannel", 0, 1, null, ["call$2", "call$1"], ["_serialize0$_writeChannel$2", "_serialize0$_writeChannel$1"], 191, 0, 0); + _instance_1_u(_, "get$visitSelectorList", "visitSelectorList$1", 576); + _instance_1_u(_, "get$_serialize0$_requiresSemicolon", "_serialize0$_requiresSemicolon$1", 7); + _instance_1_u(A.SimpleSelector0.prototype, "get$isSuperselector", "isSuperselector$1", 14); + _instance_1_i(A.SourceMapBuffer0.prototype, "get$write", "write$1", 34); + _instance_1_u(A.SrgbColorSpace0.prototype, "get$toLinear", "toLinear$1", 16); + _instance_1_i(_ = A.StatementSearchVisitor0.prototype, "get$visitContentBlock", "visitContentBlock$1", "StatementSearchVisitor0.T?(ContentBlock0)"); + _instance_1_u(_, "get$visitChildren", "visitChildren$1", "StatementSearchVisitor0.T?(List)"); + _instance(_ = A.StylesheetParser0.prototype, "get$_stylesheet0$_statement", 0, 0, null, ["call$1$root", "call$0"], ["_stylesheet0$_statement$1$root", "_stylesheet0$_statement$0"], 595, 0, 0); + _instance_0_u(_, "get$_stylesheet0$_declarationChild", "_stylesheet0$_declarationChild$0", 136); + _instance_0_u(_, "get$_stylesheet0$_functionChild", "_stylesheet0$_functionChild$0", 136); + _instance_0_u(_, "get$_stylesheet0$_number", "_stylesheet0$_number$0", 597); + _instance_1_u(A.TypeSelector0.prototype, "get$isSuperselector", "isSuperselector$1", 14); + _instance_1_u(A.UniversalSelector0.prototype, "get$isSuperselector", "isSuperselector$1", 14); + _instance_1_u(A.UnprefixedMapView0.prototype, "get$containsKey", "containsKey$1", 9); + _static_1(A, "utils3__jsToDartUrl$closure", "jsToDartUrl", 667); + _static_1(A, "utils3__dartToJSUrl$closure", "dartToJSUrl", 264); + _static_1(A, "utils3__mapToObject$closure", "mapToObject", 668); + _static_1(A, "utils1__isPublic$closure", "isPublic0", 5); + _static(A, "path__absolute$closure", 1, function() { + return [null, null, null, null, null, null, null, null, null, null, null, null, null, null]; + }, ["call$15", "call$1", "call$2", "call$3", "call$4", "call$5", "call$6"], ["absolute", function(part1) { + var _null = null; + return A.absolute(part1, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null); + }, function(part1, part2) { + var _null = null; + return A.absolute(part1, part2, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null); + }, function(part1, part2, part3) { + var _null = null; + return A.absolute(part1, part2, part3, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null); + }, function(part1, part2, part3, part4) { + var _null = null; + return A.absolute(part1, part2, part3, part4, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null); + }, function(part1, part2, part3, part4, part5) { + var _null = null; + return A.absolute(part1, part2, part3, part4, part5, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null); + }, function(part1, part2, part3, part4, part5, part6) { + var _null = null; + return A.absolute(part1, part2, part3, part4, part5, part6, _null, _null, _null, _null, _null, _null, _null, _null, _null); + }], 669, 0); + _static_1(A, "path__toUri$closure", "toUri", 122); + _static_1(A, "path__prettyUri$closure", "prettyUri", 670); + _static_2(A, "number0__fuzzyLessThan$closure", "fuzzyLessThan", 45); + _static_2(A, "number0__fuzzyLessThanOrEquals$closure", "fuzzyLessThanOrEquals", 45); + _static_2(A, "number0__fuzzyGreaterThan$closure", "fuzzyGreaterThan", 45); + _static_2(A, "number0__fuzzyGreaterThanOrEquals$closure", "fuzzyGreaterThanOrEquals", 45); + _static_2(A, "number0__moduloLikeSass$closure", "moduloLikeSass", 61); + _static_1(A, "number0__sqrt$closure", "sqrt", 52); + _static_1(A, "number0__sin$closure", "sin", 52); + _static_1(A, "number0__cos$closure", "cos", 52); + _static_1(A, "number0__tan$closure", "tan", 52); + _static_1(A, "number0__atan$closure", "atan", 52); + _static_1(A, "number0__asin$closure", "asin", 52); + _static_1(A, "number0__acos$closure", "acos", 52); + _static_1(A, "utils0__srgbAndDisplayP3FromLinear$closure", "srgbAndDisplayP3FromLinear", 16); + _static_2(A, "number2__fuzzyLessThan$closure", "fuzzyLessThan0", 45); + _static_2(A, "number2__fuzzyLessThanOrEquals$closure", "fuzzyLessThanOrEquals0", 45); + _static_2(A, "number2__fuzzyGreaterThan$closure", "fuzzyGreaterThan0", 45); + _static_2(A, "number2__fuzzyGreaterThanOrEquals$closure", "fuzzyGreaterThanOrEquals0", 45); + _static_2(A, "number2__moduloLikeSass$closure", "moduloLikeSass0", 61); + _static_1(A, "number2__sqrt$closure", "sqrt0", 56); + _static_1(A, "number2__sin$closure", "sin0", 56); + _static_1(A, "number2__cos$closure", "cos0", 56); + _static_1(A, "number2__tan$closure", "tan0", 56); + _static_1(A, "number2__atan$closure", "atan0", 56); + _static_1(A, "number2__asin$closure", "asin0", 56); + _static_1(A, "number2__acos$closure", "acos0", 56); + _static_1(A, "sass__main$closure", "main1", 496); + _static_1(A, "utils4__validateUrlScheme$closure", "validateUrlScheme", 111); + _static_1(A, "utils2__srgbAndDisplayP3FromLinear$closure", "srgbAndDisplayP3FromLinear0", 16); + _static_1(A, "value0__wrapValue$closure", "wrapValue", 449); + })(); + (function inheritance() { + var _mixin = hunkHelpers.mixin, + _inherit = hunkHelpers.inherit, + _inheritMany = hunkHelpers.inheritMany; + _inherit(A.Object, null); + _inheritMany(A.Object, [A.JS_CONST, J.Interceptor, J.ArrayIterator, A.Iterable, A.CastIterator, A.Closure, A.MapBase, A.Error, A.ListBase, A.SentinelValue, A.ListIterator, A.MappedIterator, A.WhereIterator, A.ExpandIterator, A.TakeIterator, A.SkipIterator, A.SkipWhileIterator, A.EmptyIterator, A.FollowedByIterator, A.WhereTypeIterator, A.NonNullsIterator, A.FixedLengthListMixin, A.UnmodifiableListMixin, A.Symbol, A._Record, A.MapView, A.ConstantMap, A._KeysOrValuesOrElementsIterator, A.SetBase, A.JSInvocationMirror, A.TypeErrorDecoder, A.NullThrownFromJavaScriptException, A.ExceptionAndStackTrace, A._StackTrace, A._Required, A.LinkedHashMapCell, A.LinkedHashMapKeyIterator, A.LinkedHashMapValueIterator, A.LinkedHashMapEntryIterator, A.JSSyntaxRegExp, A._MatchImplementation, A._AllMatchesIterator, A.StringMatch, A._StringAllMatchesIterator, A._Cell, A.Rti, A._FunctionParameters, A._Type, A._TimerImpl, A._AsyncAwaitCompleter, A._SyncStarIterator, A.AsyncError, A._Completer, A._FutureListener, A._Future, A._AsyncCallbackEntry, A.Stream, A._StreamController, A._SyncStreamControllerDispatch, A._AsyncStreamControllerDispatch, A._BufferingStreamSubscription, A._AddStreamState, A._DelayedEvent, A._DelayedDone, A._PendingEvents, A._StreamIterator, A._ZoneFunction, A._ZoneSpecification, A._ZoneDelegate, A._Zone, A._HashMapKeyIterator, A._LinkedHashSetCell, A._LinkedHashSetIterator, A._MapBaseValueIterator, A._UnmodifiableMapMixin, A._ListQueueIterator, A._UnmodifiableSetMixin, A.Codec, A.Converter, A._Base64Encoder, A.ByteConversionSink, A._JsonStringifier, A.StringConversionSink, A._Utf8Encoder, A._Utf8Decoder, A.DateTime, A.Duration, A._Enum, A.OutOfMemoryError, A.StackOverflowError, A._Exception, A.FormatException, A.MapEntry, A.Null, A._StringStackTrace, A.RuneIterator, A.StringBuffer, A._Uri, A.UriData, A._SimpleUri, A.Expando, A.NullRejectionException, A._JSRandom, A.ArgParser, A.ArgResults, A.Option, A.OptionType, A.Parser0, A._Usage, A.FutureGroup, A.ErrorResult, A.ValueResult, A.StreamCompleter, A.StreamGroup, A._StreamGroupState, A.StreamQueue, A._NextRequest, A.Repl, A.ReplAdapter, A.DefaultEquality, A.IterableEquality, A.ListEquality, A._MapEntry, A.MapEquality, A._QueueList_Object_ListMixin, A._DelegatingIterableBase, A.UnmodifiableSetMixin, A.Context, A._PathDirection, A._PathRelation, A.Style, A.ParsedPath, A.PathException, A.Version, A.VersionRange, A.CssMediaQuery, A.MediaQuerySuccessfulMergeResult, A.CssNode, A.__IsInvisibleVisitor_Object_EveryCssVisitor, A.CssValue, A._FakeAstNode, A.ArgumentList, A.AtRootQuery, A.ConfiguredVariable, A.Expression, A.DynamicImport, A.StaticImport, A.Interpolation, A.Parameter, A.ParameterList, A.Statement, A.IfRuleClause, A.__HasContentVisitor_Object_StatementSearchVisitor, A.SupportsAnything, A.SupportsDeclaration, A.SupportsFunction, A.SupportsInterpolation, A.SupportsNegation, A.SupportsOperation, A.Selector, A.__IsInvisibleVisitor_Object_AnySelectorVisitor, A.__IsBogusVisitor_Object_AnySelectorVisitor, A.__IsUselessVisitor_Object_AnySelectorVisitor, A.ComplexSelectorComponent, A.__ParentSelectorVisitor_Object_SelectorSearchVisitor, A.QualifiedName, A.AsyncEnvironment, A._EnvironmentModule0, A.AsyncImportCache, A.AsyncBuiltInCallable, A.BuiltInCallable, A.PlainCssCallable, A.UserDefinedCallable, A.CompileResult, A.Configuration, A.ConfiguredValue, A.Environment, A._EnvironmentModule, A.SourceSpanException, A.SassScriptException, A.ExecutableOptions, A.UsageException, A._Watcher, A.EmptyExtensionStore, A.Extension, A.Extender, A.ExtensionStore, A.ImportCache, A.AsyncImporter, A.CanonicalizeContext, A.ImporterResult, A.InterpolationBuffer, A.InterpolationMap, A.FileSystemException, A.LoggerWithDeprecationType, A._QuietLogger, A.TrackingLogger, A.BuiltInModule, A.ForwardedModuleView, A.ShadowedModuleView, A.Parser, A.StylesheetGraph, A.StylesheetNode, A.Box, A.ModifiableBox, A.LazyFileSpan, A.MultiDirWatcher, A.MultiSpan, A.NoSourceMapBuffer, A.SourceMapBuffer, A.Value, A.CalculationOperation, A._ColorFormatEnum, A.SpanColorFormat, A.ColorChannel, A.GamutMapMethod, A.InterpolationMethod, A.ColorSpace, A.AnySelectorVisitor, A._EvaluateVisitor0, A._ImportedCssVisitor0, A._EvaluationContext0, A._CloneCssVisitor, A.Evaluator, A._EvaluateVisitor, A._ImportedCssVisitor, A._EvaluationContext, A.EveryCssVisitor, A.__MakeExpressionCalculationSafe_Object_ReplaceExpressionVisitor, A.__FindDependenciesVisitor_Object_RecursiveStatementVisitor, A.DependencyReport, A.IsCalculationSafeVisitor, A.RecursiveStatementVisitor, A.ReplaceExpressionVisitor, A.SelectorSearchVisitor, A._SerializeVisitor, A.StatementSearchVisitor, A.Entry, A.Mapping, A.TargetLineEntry, A.TargetEntry, A.SourceFile, A.SourceLocationMixin, A.SourceSpanMixin, A.Highlighter, A._Highlight, A._Line, A.SourceLocation, A.Chain, A.Frame, A.LazyTrace, A.Trace, A.UnparsedFrame, A.StringScanner, A._SpanScannerState, A.AsciiGlyphSet, A.UnicodeGlyphSet, A.WatchEvent, A.ChangeType, A.ColorSpace0, A.AnySelectorVisitor0, A.SupportsAnything0, A.ArgumentList0, A.Value0, A.AsyncImporter0, A.AsyncBuiltInCallable0, A.AsyncEnvironment0, A._EnvironmentModule2, A._EvaluateVisitor2, A._ImportedCssVisitor2, A._EvaluationContext2, A.AsyncImportCache0, A.Parser1, A.AtRootQuery0, A.Statement0, A.CssNode0, A.Selector0, A.Expression0, A.Box0, A.ModifiableBox0, A.BuiltInCallable0, A.BuiltInModule0, A.CalculationOperation0, A.CalculationInterpolation, A.CanonicalizeContext0, A.ColorChannel0, A.GamutMapMethod0, A._CloneCssVisitor0, A._ColorFormatEnum0, A.SpanColorFormat0, A.CompileResult0, A.Compiler, A.ComplexSelectorComponent0, A.Configuration0, A.ConfiguredValue0, A.ConfiguredVariable0, A.SupportsDeclaration0, A.LoggerWithDeprecationType0, A.DynamicImport0, A.EmptyExtensionStore0, A.Environment0, A._EnvironmentModule1, A._EvaluateVisitor1, A._ImportedCssVisitor1, A._EvaluationContext1, A.EveryCssVisitor0, A.SassScriptException0, A.JSExpressionVisitor, A.__MakeExpressionCalculationSafe_Object_ReplaceExpressionVisitor0, A.Extension0, A.Extender0, A.ExtensionStore0, A.ForwardedModuleView0, A.SupportsFunction0, A.IfRuleClause0, A.NodeImporter, A.ImportCache0, A.Interpolation0, A.SupportsInterpolation0, A.InterpolationBuffer0, A.InterpolationMap0, A.InterpolationMethod0, A.IsCalculationSafeVisitor0, A.FileSystemException0, A.LazyFileSpan0, A.__ParentSelectorVisitor_Object_SelectorSearchVisitor0, A.CssMediaQuery0, A.MediaQuerySuccessfulMergeResult0, A.__HasContentVisitor_Object_StatementSearchVisitor0, A.MultiSpan0, A.SupportsNegation0, A.NoSourceMapBuffer0, A._FakeAstNode0, A.__IsInvisibleVisitor_Object_EveryCssVisitor0, A.SupportsOperation0, A.Parameter0, A.ParameterList0, A.PlainCssCallable0, A.QualifiedName0, A.ReplaceExpressionVisitor0, A.ImporterResult0, A.__IsInvisibleVisitor_Object_AnySelectorVisitor0, A.__IsBogusVisitor_Object_AnySelectorVisitor0, A.__IsUselessVisitor_Object_AnySelectorVisitor0, A.SelectorSearchVisitor0, A._SerializeVisitor0, A.ShadowedModuleView0, A.SourceInterpolationVisitor, A.SourceMapBuffer0, A.JSStatementVisitor, A.StatementSearchVisitor0, A.StaticImport0, A.UserDefinedCallable0, A.CssValue0]); + _inheritMany(J.Interceptor, [J.JSBool, J.JSNull, J.JavaScriptObject, J.JavaScriptBigInt, J.JavaScriptSymbol, J.JSNumber, J.JSString]); + _inheritMany(J.JavaScriptObject, [J.LegacyJavaScriptObject, J.JSArray, A.NativeByteBuffer, A.NativeTypedData]); + _inheritMany(J.LegacyJavaScriptObject, [J.PlainJavaScriptObject, J.UnknownJavaScriptObject, J.JavaScriptFunction, A.Stdin, A.Stdout, A.ReadlineModule, A.ReadlineOptions, A.ReadlineInterface, A.BufferModule, A.BufferConstants, A.Buffer, A.ConsoleModule, A.Console, A.EventEmitter, A.FS, A.FSConstants, A.Realpath, A.RealpathSync, A.FSWatcher, A.ReadStream, A.ReadStreamOptions, A.WriteStream, A.WriteStreamOptions, A.FileOptions, A.StatOptions, A.MkdirOptions, A.RmdirOptions, A.WatchOptions, A.WatchFileOptions, A.Stats, A.Promise, A.Date, A.JsError, A.Atomics, A.Modules, A.Module, A.Net, A.Socket, A.NetAddress, A.NetServer, A.NodeJsError, A.Process, A.CPUUsage, A.Release, A.StreamModule, A.Readable, A.Writable, A.Duplex, A.Transform, A.WritableOptions, A.ReadableOptions, A.Immediate, A.Timeout, A.TTY, A.Util, A.JSArray0, A.Chokidar, A.ChokidarOptions, A.ChokidarWatcher, A.JSFunction, A.ImmutableList, A.ImmutableMap, A.NodeImporterResult, A.RenderContext, A.RenderContextOptions, A.RenderContextResult, A.RenderContextResultStats, A.JSModule, A.JSModuleRequire, A.JSClass, A.JSUrl, A._PropertyDescriptor, A._RequireMain, A.JSArray1, A.Chokidar0, A.ChokidarOptions0, A.ChokidarWatcher0, A._Channels, A._ChannelOptions, A._ToGamutOptions, A._InterpolationOptions, A._NodeSassColor, A.CompileOptions, A.NodeCompileResult, A.Deprecation1, A.Exports, A.LoggerNamespace, A.JSExpressionVisitorObject, A.FiberClass, A.Fiber, A.JSFunction0, A.ImmutableList0, A.ImmutableMap0, A.JSImporter, A.JSImporterResult, A.NodeImporterResult0, A._ConstructorOptions, A._NodeSassList, A.JSLogger, A.WarnOptions, A.DebugOptions, A._NodeSassMap, A.JSModule0, A.JSModuleRequire0, A._ConstructorOptions0, A._NodeSassNumber, A.ParserExports, A.JSClass0, A.RenderContext0, A.RenderContextOptions0, A.RenderContextResult0, A.RenderContextResultStats0, A.RenderOptions, A.RenderResult, A.RenderResultStats, A._Exports, A.JSSet, A.JSStatementVisitorObject, A._ConstructorOptions1, A._NodeSassString, A.Types, A.JSUrl0, A._PropertyDescriptor0, A._RequireMain0]); + _inherit(J.JSUnmodifiableArray, J.JSArray); + _inheritMany(J.JSNumber, [J.JSInt, J.JSNumNotInt]); + _inheritMany(A.Iterable, [A._CastIterableBase, A.EfficientLengthIterable, A.MappedIterable, A.WhereIterable, A.ExpandIterable, A.TakeIterable, A.SkipIterable, A.SkipWhileIterable, A.FollowedByIterable, A.WhereTypeIterable, A.NonNullsIterable, A._KeysOrValues, A._AllMatchesIterable, A._StringAllMatchesIterable, A._SyncStarIterable, A.Runes, A._EmptyUnmodifiableSet_IterableBase_UnmodifiableSetMixin, A._PrefixedKeys, A._UnprefixedKeys, A._PrefixedKeys0, A._UnprefixedKeys0]); + _inheritMany(A._CastIterableBase, [A.CastIterable, A.__CastListBase__CastIterableBase_ListMixin, A.CastSet]); + _inherit(A._EfficientLengthCastIterable, A.CastIterable); + _inherit(A._CastListBase, A.__CastListBase__CastIterableBase_ListMixin); + _inheritMany(A.Closure, [A.Closure2Args, A.CastMap_entries_closure, A.Closure0Args, A.Instantiation, A.TearOffClosure, A.initHooks_closure, A.initHooks_closure1, A._AsyncRun__initializeScheduleImmediate_internalCallback, A._AsyncRun__initializeScheduleImmediate_closure, A._awaitOnObject_closure, A.Future_wait_closure, A._Future__chainForeignFuture_closure, A._Future__propagateToListeners_handleWhenCompleteCallback_closure, A.Stream_Stream$fromFuture_closure, A.Stream_length_closure, A._CustomZone_bindUnaryCallback_closure, A._RootZone_bindUnaryCallback_closure, A._HashMap_values_closure, A._LinkedCustomHashMap_closure, A.MapBase_entries_closure, A._JsonMap_values_closure, A._Uri__makePath_closure, A.jsify__convert, A.promiseToFuture_closure, A.promiseToFuture_closure0, A.ArgParser__addOption_closure, A._Usage__writeOption_closure, A._Usage__buildAllowedList_closure, A.FutureGroup_add_closure, A.StreamGroup__onListen_closure, A.StreamGroup__onCancel_closure, A.StreamQueue__ensureListening_closure, A.alwaysValid_closure, A.ReplAdapter_runAsync__closure, A.UnionSet__iterable_closure, A.UnionSet_contains_closure, A.MapKeySet_difference_closure, A.promiseToFuture_closure1, A.promiseToFuture_closure2, A.futureToPromise__closure, A.Context_joinAll_closure, A.Context_split_closure, A._validateArgList_closure, A.ParsedPath__splitExtension_closure, A.PathMap__create_closure0, A.PathMap__create_closure1, A.WindowsStyle_absolutePathToUri_closure, A.Version__splitParts_closure, A.ModifiableCssNode_hasFollowingSibling_closure, A.ListExpression_toString_closure, A.Interpolation_toString_closure, A.ParameterList_verify_closure, A.ParameterList_verify_closure0, A.EachRule_toString_closure, A.IfRuleClause$__closure, A.IfRuleClause$___closure, A.ParentStatement_closure, A.ParentStatement__closure, A._IsBogusVisitor_visitComplexSelector_closure, A._IsUselessVisitor_visitComplexSelector_closure, A.ComplexSelectorComponent_toString_closure, A.CompoundSelector_hasComplicatedSuperselectorSemantics_closure, A.IDSelector_unify_closure, A.SelectorList_asSassList_closure, A.SelectorList_nestWithin_closure, A.SelectorList_nestWithin__closure, A.SelectorList_nestWithin__closure0, A.SelectorList__nestWithinCompound_closure, A.SelectorList__nestWithinCompound_closure0, A.SelectorList__nestWithinCompound_closure1, A.SelectorList_withAdditionalCombinators_closure, A.PseudoSelector_specificity__closure, A.PseudoSelector_specificity__closure0, A.PseudoSelector_unify_closure, A.SimpleSelector_isSuperselector_closure, A.SimpleSelector_isSuperselector__closure, A._compileStylesheet_closure0, A.AsyncEnvironment__getVariableFromGlobalModule_closure, A.AsyncEnvironment_setVariable_closure0, A.AsyncEnvironment__getFunctionFromGlobalModule_closure, A.AsyncEnvironment__getMixinFromGlobalModule_closure, A.AsyncEnvironment_toModule_closure, A.AsyncEnvironment_toDummyModule_closure, A._EnvironmentModule__EnvironmentModule_closure5, A._EnvironmentModule__EnvironmentModule_closure6, A._EnvironmentModule__EnvironmentModule_closure7, A._EnvironmentModule__EnvironmentModule_closure8, A._EnvironmentModule__EnvironmentModule_closure9, A._EnvironmentModule__EnvironmentModule_closure10, A.AsyncImportCache_humanize_closure, A.AsyncImportCache_humanize_closure0, A.AsyncImportCache_humanize_closure1, A.AsyncImportCache_humanize_closure2, A.AsyncBuiltInCallable$mixin_closure, A.AsyncBuiltInCallable_withDeprecationWarning_closure, A.BuiltInCallable$mixin_closure, A.BuiltInCallable_withDeprecationWarning_closure, A._compileStylesheet_closure, A.Deprecation_fromId_closure, A.Environment__getVariableFromGlobalModule_closure, A.Environment_setVariable_closure0, A.Environment__getFunctionFromGlobalModule_closure, A.Environment__getMixinFromGlobalModule_closure, A.Environment_toModule_closure, A.Environment_toDummyModule_closure, A._EnvironmentModule__EnvironmentModule_closure, A._EnvironmentModule__EnvironmentModule_closure0, A._EnvironmentModule__EnvironmentModule_closure1, A._EnvironmentModule__EnvironmentModule_closure2, A._EnvironmentModule__EnvironmentModule_closure3, A._EnvironmentModule__EnvironmentModule_closure4, A._writeSourceMap_closure, A.ExecutableOptions_emitErrorCss_closure, A.repl_warn, A.watch_closure, A._Watcher__debounceEvents_closure, A.ExtensionStore_extensionsWhereTarget_closure, A.ExtensionStore__extendComplex_closure, A.ExtensionStore__extendComplex__closure, A.ExtensionStore__extendCompound_closure, A.ExtensionStore__extendCompound_closure0, A.ExtensionStore__extendCompound_closure1, A.ExtensionStore__extendSimple_withoutPseudo, A.ExtensionStore__extendSimple_closure, A.ExtensionStore__extendSimple_closure0, A.ExtensionStore__extendPseudo_closure, A.ExtensionStore__extendPseudo_closure0, A.ExtensionStore__extendPseudo_closure1, A.ExtensionStore__extendPseudo_closure2, A.ExtensionStore__extendPseudo_closure3, A.ExtensionStore__trim_closure, A.ExtensionStore__trim_closure0, A.unifyComplex_closure, A._weaveParents_closure0, A._weaveParents_closure1, A._weaveParents_closure2, A._mustUnify_closure, A._mustUnify__closure, A.paths__closure, A.paths___closure, A.listIsSuperselector_closure, A.listIsSuperselector__closure, A.complexIsSuperselector_closure, A.complexIsSuperselector_closure0, A._compatibleWithPreviousCombinator_closure, A.compoundIsSuperselector_closure, A._selectorPseudoIsSuperselector_closure, A._selectorPseudoIsSuperselector_closure0, A._selectorPseudoIsSuperselector_closure1, A._selectorPseudoIsSuperselector_closure2, A._selectorPseudoIsSuperselector_closure3, A._selectorPseudoIsSuperselector__closure, A._selectorPseudoIsSuperselector___closure, A._selectorPseudoIsSuperselector___closure0, A._selectorPseudoIsSuperselector_closure4, A._selectorPseudoIsSuperselector_closure5, A._selectorPseudoArgs_closure, A._selectorPseudoArgs_closure0, A.globalFunctions_closure, A.global_closure0, A.global_closure1, A.global_closure2, A.global_closure3, A.global_closure4, A.global_closure5, A.global_closure6, A.global_closure7, A.global_closure8, A.global_closure9, A.global_closure10, A.global_closure11, A.global_closure12, A.global_closure13, A.global_closure14, A.global_closure15, A.global_closure16, A.global_closure17, A.global_closure18, A.global_closure19, A.global_closure20, A.global_closure21, A.global_closure22, A.global_closure23, A.global_closure24, A.global_closure25, A.global_closure26, A.global_closure27, A.global_closure28, A.global_closure29, A.global_closure30, A.global_closure31, A.global_closure32, A.global_closure33, A.global_closure34, A.global_closure35, A.global__closure, A.global_closure36, A.global_closure37, A.global_closure38, A.global_closure39, A.global_closure40, A.global_closure41, A.global_closure42, A.module_closure1, A.module_closure2, A.module_closure3, A.module_closure4, A.module_closure5, A.module_closure6, A.module_closure7, A.module_closure8, A.module_closure9, A.module_closure10, A.module_closure11, A.module_closure12, A.module_closure13, A.module_closure14, A.module__closure2, A.module_closure15, A.module_closure16, A.module_closure17, A.module_closure18, A.module_closure19, A.module_closure20, A.module_closure21, A.module_closure22, A.module__closure1, A.module_closure23, A.module_closure_toXyzNoMissing, A.module_closure24, A._mix_closure, A._complement_closure, A._adjust_closure, A._scale_closure, A._change_closure, A._ieHexStr_closure, A._ieHexStr_closure_hexString, A._updateComponents_closure, A._updateComponents_closure0, A._adjustColor_closure, A._functionString_closure, A._removedColorFunction_closure, A._rgb_closure, A._hsl_closure, A._parseChannels_closure, A._parseChannels_closure0, A._colorFromChannels_closure, A._colorFromChannels_closure0, A._channelFromValue_closure, A._channelFunction_closure, A._suggestScaleAndAdjust_closure, A._length_closure0, A._nth_closure, A._setNth_closure, A._join_closure, A._append_closure0, A._zip_closure, A._zip__closure, A._zip__closure0, A._zip__closure1, A._index_closure0, A._separator_closure, A._isBracketed_closure, A._slash_closure, A._get_closure, A._set_closure, A._set__closure0, A._set_closure0, A._set__closure, A._merge_closure, A._merge_closure0, A._merge__closure, A._deepMerge_closure, A._deepRemove_closure, A._deepRemove__closure, A._remove_closure, A._remove_closure0, A._keys_closure, A._values_closure, A._hasKey_closure, A._modify_modifyNestedMap, A.global_closure, A.module_closure0, A._ceil_closure, A._clamp_closure, A._floor_closure, A._max_closure, A._min_closure, A._round_closure, A._hypot_closure, A._hypot__closure, A._log_closure, A._pow_closure, A._atan2_closure, A._compatible_closure, A._isUnitless_closure, A._unit_closure, A._percentage_closure, A._randomFunction_closure, A._div_closure, A._singleArgumentMathFunc_closure, A._numberFunction_closure, A._shared_closure, A._shared_closure0, A._shared_closure1, A._shared_closure2, A.moduleFunctions_closure, A.moduleFunctions_closure0, A.moduleFunctions__closure, A.moduleFunctions_closure1, A._nest_closure, A._nest__closure, A._append_closure, A._append__closure, A._append___closure, A._extend_closure, A._replace_closure, A._unify_closure, A._isSuperselector_closure, A._simpleSelectors_closure, A._simpleSelectors__closure, A._parse_closure, A.module_closure, A.module__closure, A.module__closure0, A._unquote_closure, A._quote_closure, A._length_closure, A._insert_closure, A._index_closure, A._slice_closure, A._toUpperCase_closure, A._toLowerCase_closure, A._uniqueId_closure, A.ImportCache_humanize_closure, A.ImportCache_humanize_closure0, A.ImportCache_humanize_closure1, A.ImportCache_humanize_closure2, A.FilesystemImporter_canonicalize_closure, A.NodePackageImporter__nodePackageExportsResolve_closure, A.NodePackageImporter__nodePackageExportsResolve_closure0, A.NodePackageImporter__nodePackageExportsResolve_closure1, A.NodePackageImporter__nodePackageExportsResolve_closure2, A.NodePackageImporter__nodePackageExportsResolve__closure, A.NodePackageImporter__nodePackageExportsResolve__closure0, A.NodePackageImporter__getMainExport_closure, A._exactlyOne_closure, A.InterpolationMap_mapException_closure, A._realCasePath_helper, A._realCasePath_helper__closure, A.readStdin_closure, A.readStdin_closure0, A.readStdin_closure1, A.readStdin_closure2, A.listDir__closure, A.listDir__closure0, A.listDir_closure_list, A.listDir__list_closure, A.watchDir_closure1, A.watchDir_closure2, A.watchDir_closure3, A.watchDir_closure4, A.DeprecationProcessingLogger_summarize_closure, A.DeprecationProcessingLogger_summarize_closure0, A._disallowedFunctionNames_closure, A.Parser_escape_closure, A.Parser_scanIdentChar_matches, A.SassParser_styleRuleSelector_closure, A.SassParser__peekIndentation_closure, A.SassParser__peekIndentation_closure0, A.SassParser__tryTrailingSemicolon_closure, A.StylesheetParser__expression_addSingleExpression, A.StylesheetParser__expression_addOperator, A.StylesheetParser__isHexColor_closure, A.StylesheetParser__unicodeRange_closure, A.StylesheetParser__unicodeRange_closure0, A.StylesheetParser_trySpecialFunction_closure, A.StylesheetGraph_modifiedSince_transitiveModificationTime, A.MapExtensions_get_pairs_closure, A._PrefixedKeys_iterator_closure, A.SourceMapBuffer_buildSourceMap_closure, A._UnprefixedKeys_iterator_closure, A._UnprefixedKeys_iterator_closure0, A.indent_closure, A.flattenVertically_closure, A.flattenVertically_closure0, A.SassCalculation__verifyLength_closure, A.SassColor$_forSpace_closure, A.HwbColorSpace_convert_toRgb, A.SassList_isBlank_closure, A.SassNumber__coerceOrConvertValue_closure, A.SassNumber__coerceOrConvertValue_closure1, A.SassNumber_multiplyUnits_closure, A.SassNumber_multiplyUnits_closure1, A.SassNumber__areAnyConvertible_closure, A.SassNumber__canonicalizeUnitList_closure, A.SassNumber_unitSuggestion_closure, A.SassNumber_unitSuggestion_closure0, A.SingleUnitSassNumber__coerceToUnit_closure, A.SingleUnitSassNumber__coerceValueToUnit_closure, A.SingleUnitSassNumber_multiplyUnits_closure, A.AnySelectorVisitor_visitComplexSelector_closure, A.AnySelectorVisitor_visitCompoundSelector_closure, A._EvaluateVisitor_closure12, A._EvaluateVisitor_closure13, A._EvaluateVisitor_closure14, A._EvaluateVisitor_closure15, A._EvaluateVisitor_closure16, A._EvaluateVisitor_closure17, A._EvaluateVisitor_closure18, A._EvaluateVisitor_closure19, A._EvaluateVisitor_closure20, A._EvaluateVisitor_closure21, A._EvaluateVisitor_closure22, A._EvaluateVisitor_closure23, A._EvaluateVisitor_closure24, A._EvaluateVisitor__loadModule__closure1, A._EvaluateVisitor__combineCss_closure1, A._EvaluateVisitor__combineCss_closure2, A._EvaluateVisitor__combineCss_visitModule0, A._EvaluateVisitor__extendModules_closure1, A._EvaluateVisitor__scopeForAtRoot_closure5, A._EvaluateVisitor__scopeForAtRoot_closure6, A._EvaluateVisitor__scopeForAtRoot_closure7, A._EvaluateVisitor__scopeForAtRoot_closure8, A._EvaluateVisitor__scopeForAtRoot_closure9, A._EvaluateVisitor__scopeForAtRoot_closure10, A._EvaluateVisitor_visitEachRule_closure2, A._EvaluateVisitor_visitEachRule_closure3, A._EvaluateVisitor_visitEachRule__closure0, A._EvaluateVisitor_visitEachRule___closure0, A._EvaluateVisitor_visitAtRule_closure2, A._EvaluateVisitor_visitAtRule_closure4, A._EvaluateVisitor_visitForRule__closure0, A._EvaluateVisitor_visitIfRule_closure0, A._EvaluateVisitor_visitIfRule___closure0, A._EvaluateVisitor__visitDynamicImport__closure3, A._EvaluateVisitor__visitDynamicImport__closure4, A._EvaluateVisitor__visitDynamicImport__closure5, A._EvaluateVisitor_visitIncludeRule_closure3, A._EvaluateVisitor_visitMediaRule_closure2, A._EvaluateVisitor_visitMediaRule_closure4, A._EvaluateVisitor_visitStyleRule_closure4, A._EvaluateVisitor_visitStyleRule_closure5, A._EvaluateVisitor__warnForBogusCombinators_closure0, A._EvaluateVisitor_visitSupportsRule_closure2, A._EvaluateVisitor_visitWhileRule__closure0, A._EvaluateVisitor__slash_recommendation0, A._EvaluateVisitor_visitListExpression_closure0, A._EvaluateVisitor_visitFunctionExpression_closure3, A._EvaluateVisitor__visitCalculation_closure0, A._EvaluateVisitor__checkCalculationArguments_check0, A._EvaluateVisitor__visitCalculationExpression__closure0, A._EvaluateVisitor__runUserDefinedCallable____closure0, A._EvaluateVisitor__runBuiltInCallable_closure4, A._EvaluateVisitor__evaluateArguments_closure3, A._EvaluateVisitor__evaluateArguments_closure4, A._EvaluateVisitor__evaluateArguments_closure6, A._EvaluateVisitor__evaluateMacroArguments_closure3, A._EvaluateVisitor__evaluateMacroArguments_closure4, A._EvaluateVisitor__evaluateMacroArguments_closure6, A._EvaluateVisitor_visitCssAtRule_closure2, A._EvaluateVisitor_visitCssKeyframeBlock_closure2, A._EvaluateVisitor_visitCssMediaRule_closure2, A._EvaluateVisitor_visitCssMediaRule_closure4, A._EvaluateVisitor_visitCssStyleRule_closure1, A._EvaluateVisitor_visitCssSupportsRule_closure2, A._EvaluateVisitor__performInterpolationHelper_closure0, A._EvaluateVisitor__withoutSlash_recommendation0, A._EvaluateVisitor__stackFrame_closure0, A._ImportedCssVisitor_visitCssAtRule_closure0, A._ImportedCssVisitor_visitCssMediaRule_closure0, A._ImportedCssVisitor_visitCssStyleRule_closure0, A._ImportedCssVisitor_visitCssSupportsRule_closure0, A._EvaluateVisitor_closure, A._EvaluateVisitor_closure0, A._EvaluateVisitor_closure1, A._EvaluateVisitor_closure2, A._EvaluateVisitor_closure3, A._EvaluateVisitor_closure4, A._EvaluateVisitor_closure5, A._EvaluateVisitor_closure6, A._EvaluateVisitor_closure7, A._EvaluateVisitor_closure8, A._EvaluateVisitor_closure9, A._EvaluateVisitor_closure10, A._EvaluateVisitor_closure11, A._EvaluateVisitor__loadModule__closure, A._EvaluateVisitor__combineCss_closure, A._EvaluateVisitor__combineCss_closure0, A._EvaluateVisitor__combineCss_visitModule, A._EvaluateVisitor__extendModules_closure, A._EvaluateVisitor__scopeForAtRoot_closure, A._EvaluateVisitor__scopeForAtRoot_closure0, A._EvaluateVisitor__scopeForAtRoot_closure1, A._EvaluateVisitor__scopeForAtRoot_closure2, A._EvaluateVisitor__scopeForAtRoot_closure3, A._EvaluateVisitor__scopeForAtRoot_closure4, A._EvaluateVisitor_visitEachRule_closure, A._EvaluateVisitor_visitEachRule_closure0, A._EvaluateVisitor_visitEachRule__closure, A._EvaluateVisitor_visitEachRule___closure, A._EvaluateVisitor_visitAtRule_closure, A._EvaluateVisitor_visitAtRule_closure1, A._EvaluateVisitor_visitForRule__closure, A._EvaluateVisitor_visitIfRule_closure, A._EvaluateVisitor_visitIfRule___closure, A._EvaluateVisitor__visitDynamicImport__closure, A._EvaluateVisitor__visitDynamicImport__closure0, A._EvaluateVisitor__visitDynamicImport__closure1, A._EvaluateVisitor_visitIncludeRule_closure0, A._EvaluateVisitor_visitMediaRule_closure, A._EvaluateVisitor_visitMediaRule_closure1, A._EvaluateVisitor_visitStyleRule_closure0, A._EvaluateVisitor_visitStyleRule_closure1, A._EvaluateVisitor__warnForBogusCombinators_closure, A._EvaluateVisitor_visitSupportsRule_closure0, A._EvaluateVisitor_visitWhileRule__closure, A._EvaluateVisitor__slash_recommendation, A._EvaluateVisitor_visitListExpression_closure, A._EvaluateVisitor_visitFunctionExpression_closure0, A._EvaluateVisitor__visitCalculation_closure, A._EvaluateVisitor__checkCalculationArguments_check, A._EvaluateVisitor__visitCalculationExpression__closure, A._EvaluateVisitor__runUserDefinedCallable____closure, A._EvaluateVisitor__runBuiltInCallable_closure1, A._EvaluateVisitor__evaluateArguments_closure, A._EvaluateVisitor__evaluateArguments_closure0, A._EvaluateVisitor__evaluateArguments_closure2, A._EvaluateVisitor__evaluateMacroArguments_closure, A._EvaluateVisitor__evaluateMacroArguments_closure0, A._EvaluateVisitor__evaluateMacroArguments_closure2, A._EvaluateVisitor_visitCssAtRule_closure0, A._EvaluateVisitor_visitCssKeyframeBlock_closure0, A._EvaluateVisitor_visitCssMediaRule_closure, A._EvaluateVisitor_visitCssMediaRule_closure1, A._EvaluateVisitor_visitCssStyleRule_closure, A._EvaluateVisitor_visitCssSupportsRule_closure0, A._EvaluateVisitor__performInterpolationHelper_closure, A._EvaluateVisitor__withoutSlash_recommendation, A._EvaluateVisitor__stackFrame_closure, A._ImportedCssVisitor_visitCssAtRule_closure, A._ImportedCssVisitor_visitCssMediaRule_closure, A._ImportedCssVisitor_visitCssStyleRule_closure, A._ImportedCssVisitor_visitCssSupportsRule_closure, A.EveryCssVisitor_visitCssAtRule_closure, A.EveryCssVisitor_visitCssKeyframeBlock_closure, A.EveryCssVisitor_visitCssMediaRule_closure, A.EveryCssVisitor_visitCssStyleRule_closure, A.EveryCssVisitor_visitCssStylesheet_closure, A.EveryCssVisitor_visitCssSupportsRule_closure, A.IsCalculationSafeVisitor_visitListExpression_closure, A.ReplaceExpressionVisitor_visitListExpression_closure, A.ReplaceExpressionVisitor_visitArgumentList_closure, A.ReplaceExpressionVisitor_visitInterpolation_closure, A.SelectorSearchVisitor_visitComplexSelector_closure, A.SelectorSearchVisitor_visitCompoundSelector_closure, A.serialize_closure, A._SerializeVisitor_visitList_closure, A._SerializeVisitor_visitList_closure0, A._SerializeVisitor_visitList_closure1, A._SerializeVisitor_visitMap_closure, A._SerializeVisitor_visitSelectorList_closure, A.StatementSearchVisitor_visitIfRule_closure, A.StatementSearchVisitor_visitIfRule__closure0, A.StatementSearchVisitor_visitIfRule_closure0, A.StatementSearchVisitor_visitIfRule__closure, A.StatementSearchVisitor_visitChildren_closure, A.SingleMapping_SingleMapping$fromEntries_closure1, A.SingleMapping_toJson_closure, A.Highlighter$__closure, A.Highlighter$___closure, A.Highlighter$__closure0, A.Highlighter__collateLines_closure, A.Highlighter__collateLines_closure1, A.Highlighter__collateLines__closure, A.Highlighter_highlight_closure, A.Chain_Chain$parse_closure, A.Chain_toTrace_closure, A.Chain_toString_closure0, A.Chain_toString__closure0, A.Chain_toString_closure, A.Chain_toString__closure, A.Trace__parseVM_closure, A.Trace$parseV8_closure, A.Trace$parseJSCore_closure, A.Trace$parseFirefox_closure, A.Trace$parseFriendly_closure, A.Trace_terse_closure, A.Trace_foldFrames_closure, A.Trace_foldFrames_closure0, A.Trace_toString_closure0, A.Trace_toString_closure, A.TransformByHandlers_transformByHandlers__closure, A.RateLimit__debounceAggregate_closure0, A.AnySelectorVisitor_visitComplexSelector_closure0, A.AnySelectorVisitor_visitCompoundSelector_closure0, A.argumentListClass__closure, A.argumentListClass__closure0, A.AsyncBuiltInCallable$mixin_closure0, A.AsyncBuiltInCallable_withDeprecationWarning_closure0, A._compileStylesheet_closure2, A.AsyncEnvironment__getVariableFromGlobalModule_closure0, A.AsyncEnvironment_setVariable_closure3, A.AsyncEnvironment__getFunctionFromGlobalModule_closure0, A.AsyncEnvironment__getMixinFromGlobalModule_closure0, A.AsyncEnvironment_toModule_closure0, A.AsyncEnvironment_toDummyModule_closure0, A._EnvironmentModule__EnvironmentModule_closure17, A._EnvironmentModule__EnvironmentModule_closure18, A._EnvironmentModule__EnvironmentModule_closure19, A._EnvironmentModule__EnvironmentModule_closure20, A._EnvironmentModule__EnvironmentModule_closure21, A._EnvironmentModule__EnvironmentModule_closure22, A._EvaluateVisitor_closure38, A._EvaluateVisitor_closure39, A._EvaluateVisitor_closure40, A._EvaluateVisitor_closure41, A._EvaluateVisitor_closure42, A._EvaluateVisitor_closure43, A._EvaluateVisitor_closure44, A._EvaluateVisitor_closure45, A._EvaluateVisitor_closure46, A._EvaluateVisitor_closure47, A._EvaluateVisitor_closure48, A._EvaluateVisitor_closure49, A._EvaluateVisitor_closure50, A._EvaluateVisitor__loadModule__closure5, A._EvaluateVisitor__combineCss_closure5, A._EvaluateVisitor__combineCss_closure6, A._EvaluateVisitor__combineCss_visitModule2, A._EvaluateVisitor__extendModules_closure5, A._EvaluateVisitor__scopeForAtRoot_closure17, A._EvaluateVisitor__scopeForAtRoot_closure18, A._EvaluateVisitor__scopeForAtRoot_closure19, A._EvaluateVisitor__scopeForAtRoot_closure20, A._EvaluateVisitor__scopeForAtRoot_closure21, A._EvaluateVisitor__scopeForAtRoot_closure22, A._EvaluateVisitor_visitEachRule_closure8, A._EvaluateVisitor_visitEachRule_closure9, A._EvaluateVisitor_visitEachRule__closure2, A._EvaluateVisitor_visitEachRule___closure2, A._EvaluateVisitor_visitAtRule_closure8, A._EvaluateVisitor_visitAtRule_closure10, A._EvaluateVisitor_visitForRule__closure2, A._EvaluateVisitor_visitIfRule_closure2, A._EvaluateVisitor_visitIfRule___closure2, A._EvaluateVisitor__visitDynamicImport__closure11, A._EvaluateVisitor__visitDynamicImport__closure12, A._EvaluateVisitor__visitDynamicImport__closure13, A._EvaluateVisitor_visitIncludeRule_closure9, A._EvaluateVisitor_visitMediaRule_closure8, A._EvaluateVisitor_visitMediaRule_closure10, A._EvaluateVisitor_visitStyleRule_closure12, A._EvaluateVisitor_visitStyleRule_closure13, A._EvaluateVisitor__warnForBogusCombinators_closure2, A._EvaluateVisitor_visitSupportsRule_closure6, A._EvaluateVisitor_visitWhileRule__closure2, A._EvaluateVisitor__slash_recommendation2, A._EvaluateVisitor_visitListExpression_closure2, A._EvaluateVisitor_visitFunctionExpression_closure9, A._EvaluateVisitor__visitCalculation_closure2, A._EvaluateVisitor__checkCalculationArguments_check2, A._EvaluateVisitor__visitCalculationExpression__closure2, A._EvaluateVisitor__runUserDefinedCallable____closure2, A._EvaluateVisitor__runBuiltInCallable_closure10, A._EvaluateVisitor__evaluateArguments_closure11, A._EvaluateVisitor__evaluateArguments_closure12, A._EvaluateVisitor__evaluateArguments_closure14, A._EvaluateVisitor__evaluateMacroArguments_closure11, A._EvaluateVisitor__evaluateMacroArguments_closure12, A._EvaluateVisitor__evaluateMacroArguments_closure14, A._EvaluateVisitor_visitCssAtRule_closure6, A._EvaluateVisitor_visitCssKeyframeBlock_closure6, A._EvaluateVisitor_visitCssMediaRule_closure8, A._EvaluateVisitor_visitCssMediaRule_closure10, A._EvaluateVisitor_visitCssStyleRule_closure5, A._EvaluateVisitor_visitCssSupportsRule_closure6, A._EvaluateVisitor__performInterpolationHelper_closure2, A._EvaluateVisitor__withoutSlash_recommendation2, A._EvaluateVisitor__stackFrame_closure2, A._ImportedCssVisitor_visitCssAtRule_closure2, A._ImportedCssVisitor_visitCssMediaRule_closure2, A._ImportedCssVisitor_visitCssStyleRule_closure2, A._ImportedCssVisitor_visitCssSupportsRule_closure2, A.AsyncImportCache_humanize_closure3, A.AsyncImportCache_humanize_closure4, A.AsyncImportCache_humanize_closure5, A.AsyncImportCache_humanize_closure6, A.booleanClass__closure, A.legacyBooleanClass__closure, A.legacyBooleanClass__closure0, A.BuiltInCallable$mixin_closure0, A.BuiltInCallable_withDeprecationWarning_closure0, A.calculationClass__closure, A.calculationClass__closure0, A.calculationClass__closure1, A.calculationClass__closure2, A.calculationClass__closure3, A.calculationClass__closure4, A.calculationClass__closure5, A.calculationOperationClass__closure, A.calculationOperationClass___closure, A.calculationOperationClass__closure1, A.calculationOperationClass__closure2, A.calculationOperationClass__closure3, A.calculationOperationClass__closure4, A.calculationInterpolationClass__closure1, A.calculationInterpolationClass__closure2, A.SassCalculation__verifyLength_closure0, A.updateCanonicalizeContextPrototype_closure, A.updateCanonicalizeContextPrototype_closure0, A.global_closure44, A.global_closure45, A.global_closure46, A.global_closure47, A.global_closure48, A.global_closure49, A.global_closure50, A.global_closure51, A.global_closure52, A.global_closure53, A.global_closure54, A.global_closure55, A.global_closure56, A.global_closure57, A.global_closure58, A.global_closure59, A.global_closure60, A.global_closure61, A.global_closure62, A.global_closure63, A.global_closure64, A.global_closure65, A.global_closure66, A.global_closure67, A.global_closure68, A.global_closure69, A.global_closure70, A.global_closure71, A.global_closure72, A.global_closure73, A.global_closure74, A.global_closure75, A.global_closure76, A.global_closure77, A.global_closure78, A.global_closure79, A.global__closure0, A.global_closure80, A.global_closure81, A.global_closure82, A.global_closure83, A.global_closure84, A.global_closure85, A.global_closure86, A.module_closure27, A.module_closure28, A.module_closure29, A.module_closure30, A.module_closure31, A.module_closure32, A.module_closure33, A.module_closure34, A.module_closure35, A.module_closure36, A.module_closure37, A.module_closure38, A.module_closure39, A.module_closure40, A.module__closure6, A.module_closure41, A.module_closure42, A.module_closure43, A.module_closure44, A.module_closure45, A.module_closure46, A.module_closure47, A.module_closure48, A.module__closure5, A.module_closure49, A.module_closure_toXyzNoMissing0, A.module_closure50, A._mix_closure0, A._complement_closure0, A._adjust_closure0, A._scale_closure0, A._change_closure0, A._ieHexStr_closure0, A._ieHexStr_closure_hexString0, A._updateComponents_closure1, A._updateComponents_closure2, A._adjustColor_closure0, A._functionString_closure0, A._removedColorFunction_closure0, A._rgb_closure0, A._hsl_closure0, A._parseChannels_closure1, A._parseChannels_closure2, A._colorFromChannels_closure1, A._colorFromChannels_closure2, A._channelFromValue_closure0, A._channelFunction_closure0, A._suggestScaleAndAdjust_closure0, A.colorClass__closure1, A.colorClass__closure3, A.colorClass__closure5, A.colorClass__closure7, A.colorClass___closure, A.colorClass__closure_changedValue, A.colorClass__closure9, A.colorClass__closure10, A.colorClass__closure11, A.colorClass__closure12, A.colorClass__closure13, A.colorClass__closure14, A.colorClass__closure15, A.colorClass__closure16, A.colorClass__closure17, A.colorClass__closure18, A.colorClass__closure19, A.colorClass__closure20, A.colorClass__closure21, A.colorClass__closure22, A.legacyColorClass_closure, A.legacyColorClass__closure, A.legacyColorClass_closure0, A.legacyColorClass_closure1, A.legacyColorClass_closure2, A.legacyColorClass_closure3, A.SassColor$_forSpace_closure0, A.compileAsync__closure, A.compileStringAsync__closure, A.compileStringAsync__closure0, A._wrapAsyncSassExceptions_closure, A._parseFunctions__closure2, A._parseFunctions__closure3, A.nodePackageImporterClass__closure, A._compileStylesheet_closure1, A.AsyncCompiler_addCompilation_closure, A.compilerClass__closure, A.compilerClass__closure0, A.compilerClass__closure1, A.compilerClass__closure2, A.asyncCompilerClass__closure, A.asyncCompilerClass__closure0, A.asyncCompilerClass__closure1, A.asyncCompilerClass__closure2, A.ComplexSelectorComponent_toString_closure0, A.CompoundSelector_hasComplicatedSuperselectorSemantics_closure0, A._disallowedFunctionNames_closure0, A.Deprecation_fromId_closure0, A.DeprecationProcessingLogger_summarize_closure1, A.DeprecationProcessingLogger_summarize_closure2, A.versionClass__closure, A.versionClass__closure0, A.EachRule_toString_closure0, A.Environment__getVariableFromGlobalModule_closure0, A.Environment_setVariable_closure3, A.Environment__getFunctionFromGlobalModule_closure0, A.Environment__getMixinFromGlobalModule_closure0, A.Environment_toModule_closure0, A.Environment_toDummyModule_closure0, A._EnvironmentModule__EnvironmentModule_closure11, A._EnvironmentModule__EnvironmentModule_closure12, A._EnvironmentModule__EnvironmentModule_closure13, A._EnvironmentModule__EnvironmentModule_closure14, A._EnvironmentModule__EnvironmentModule_closure15, A._EnvironmentModule__EnvironmentModule_closure16, A._EvaluateVisitor_closure25, A._EvaluateVisitor_closure26, A._EvaluateVisitor_closure27, A._EvaluateVisitor_closure28, A._EvaluateVisitor_closure29, A._EvaluateVisitor_closure30, A._EvaluateVisitor_closure31, A._EvaluateVisitor_closure32, A._EvaluateVisitor_closure33, A._EvaluateVisitor_closure34, A._EvaluateVisitor_closure35, A._EvaluateVisitor_closure36, A._EvaluateVisitor_closure37, A._EvaluateVisitor__loadModule__closure3, A._EvaluateVisitor__combineCss_closure3, A._EvaluateVisitor__combineCss_closure4, A._EvaluateVisitor__combineCss_visitModule1, A._EvaluateVisitor__extendModules_closure3, A._EvaluateVisitor__scopeForAtRoot_closure11, A._EvaluateVisitor__scopeForAtRoot_closure12, A._EvaluateVisitor__scopeForAtRoot_closure13, A._EvaluateVisitor__scopeForAtRoot_closure14, A._EvaluateVisitor__scopeForAtRoot_closure15, A._EvaluateVisitor__scopeForAtRoot_closure16, A._EvaluateVisitor_visitEachRule_closure5, A._EvaluateVisitor_visitEachRule_closure6, A._EvaluateVisitor_visitEachRule__closure1, A._EvaluateVisitor_visitEachRule___closure1, A._EvaluateVisitor_visitAtRule_closure5, A._EvaluateVisitor_visitAtRule_closure7, A._EvaluateVisitor_visitForRule__closure1, A._EvaluateVisitor_visitIfRule_closure1, A._EvaluateVisitor_visitIfRule___closure1, A._EvaluateVisitor__visitDynamicImport__closure7, A._EvaluateVisitor__visitDynamicImport__closure8, A._EvaluateVisitor__visitDynamicImport__closure9, A._EvaluateVisitor_visitIncludeRule_closure6, A._EvaluateVisitor_visitMediaRule_closure5, A._EvaluateVisitor_visitMediaRule_closure7, A._EvaluateVisitor_visitStyleRule_closure8, A._EvaluateVisitor_visitStyleRule_closure9, A._EvaluateVisitor__warnForBogusCombinators_closure1, A._EvaluateVisitor_visitSupportsRule_closure4, A._EvaluateVisitor_visitWhileRule__closure1, A._EvaluateVisitor__slash_recommendation1, A._EvaluateVisitor_visitListExpression_closure1, A._EvaluateVisitor_visitFunctionExpression_closure6, A._EvaluateVisitor__visitCalculation_closure1, A._EvaluateVisitor__checkCalculationArguments_check1, A._EvaluateVisitor__visitCalculationExpression__closure1, A._EvaluateVisitor__runUserDefinedCallable____closure1, A._EvaluateVisitor__runBuiltInCallable_closure7, A._EvaluateVisitor__evaluateArguments_closure7, A._EvaluateVisitor__evaluateArguments_closure8, A._EvaluateVisitor__evaluateArguments_closure10, A._EvaluateVisitor__evaluateMacroArguments_closure7, A._EvaluateVisitor__evaluateMacroArguments_closure8, A._EvaluateVisitor__evaluateMacroArguments_closure10, A._EvaluateVisitor_visitCssAtRule_closure4, A._EvaluateVisitor_visitCssKeyframeBlock_closure4, A._EvaluateVisitor_visitCssMediaRule_closure5, A._EvaluateVisitor_visitCssMediaRule_closure7, A._EvaluateVisitor_visitCssStyleRule_closure3, A._EvaluateVisitor_visitCssSupportsRule_closure4, A._EvaluateVisitor__performInterpolationHelper_closure1, A._EvaluateVisitor__withoutSlash_recommendation1, A._EvaluateVisitor__stackFrame_closure1, A._ImportedCssVisitor_visitCssAtRule_closure1, A._ImportedCssVisitor_visitCssMediaRule_closure1, A._ImportedCssVisitor_visitCssStyleRule_closure1, A._ImportedCssVisitor_visitCssSupportsRule_closure1, A.EveryCssVisitor_visitCssAtRule_closure0, A.EveryCssVisitor_visitCssKeyframeBlock_closure0, A.EveryCssVisitor_visitCssMediaRule_closure0, A.EveryCssVisitor_visitCssStyleRule_closure0, A.EveryCssVisitor_visitCssStylesheet_closure0, A.EveryCssVisitor_visitCssSupportsRule_closure0, A.exceptionClass__closure, A.exceptionClass__closure0, A.exceptionClass__closure1, A.ExtensionStore_extensionsWhereTarget_closure0, A.ExtensionStore__extendComplex_closure0, A.ExtensionStore__extendComplex__closure0, A.ExtensionStore__extendCompound_closure2, A.ExtensionStore__extendCompound_closure3, A.ExtensionStore__extendCompound_closure4, A.ExtensionStore__extendSimple_withoutPseudo0, A.ExtensionStore__extendSimple_closure1, A.ExtensionStore__extendSimple_closure2, A.ExtensionStore__extendPseudo_closure4, A.ExtensionStore__extendPseudo_closure5, A.ExtensionStore__extendPseudo_closure6, A.ExtensionStore__extendPseudo_closure7, A.ExtensionStore__extendPseudo_closure8, A.ExtensionStore__trim_closure1, A.ExtensionStore__trim_closure2, A.FilesystemImporter_canonicalize_closure0, A.functionClass__closure, A.functionClass__closure0, A.unifyComplex_closure0, A._weaveParents_closure4, A._weaveParents_closure5, A._weaveParents_closure6, A._mustUnify_closure0, A._mustUnify__closure0, A.paths__closure0, A.paths___closure0, A.listIsSuperselector_closure0, A.listIsSuperselector__closure0, A.complexIsSuperselector_closure1, A.complexIsSuperselector_closure2, A._compatibleWithPreviousCombinator_closure0, A.compoundIsSuperselector_closure0, A._selectorPseudoIsSuperselector_closure6, A._selectorPseudoIsSuperselector_closure7, A._selectorPseudoIsSuperselector_closure8, A._selectorPseudoIsSuperselector_closure9, A._selectorPseudoIsSuperselector_closure10, A._selectorPseudoIsSuperselector__closure0, A._selectorPseudoIsSuperselector___closure1, A._selectorPseudoIsSuperselector___closure2, A._selectorPseudoIsSuperselector_closure11, A._selectorPseudoIsSuperselector_closure12, A._selectorPseudoArgs_closure1, A._selectorPseudoArgs_closure2, A.globalFunctions_closure0, A.HwbColorSpace_convert_toRgb0, A.IDSelector_unify_closure0, A.IfRuleClause$__closure0, A.IfRuleClause$___closure0, A.immutableMapToDartMap_closure, A.NodeImporter__tryPath_closure0, A.ImportCache_humanize_closure3, A.ImportCache_humanize_closure4, A.ImportCache_humanize_closure5, A.ImportCache_humanize_closure6, A.Interpolation_toString_closure0, A.InterpolationMap_mapException_closure0, A._realCasePath_helper0, A._realCasePath_helper__closure0, A.IsCalculationSafeVisitor_visitListExpression_closure0, A.listDir__closure1, A.listDir__closure2, A.listDir_closure_list0, A.listDir__list_closure0, A.render_closure0, A._parseFunctions__closure, A._parseFunctions___closure2, A._parseFunctions__closure0, A._parseFunctions__closure1, A._parseFunctions___closure, A._parseImporter_closure, A._parseImporter__closure, A._parseImporter___closure, A.ListExpression_toString_closure0, A._length_closure2, A._nth_closure0, A._setNth_closure0, A._join_closure0, A._append_closure2, A._zip_closure0, A._zip__closure2, A._zip__closure3, A._zip__closure4, A._index_closure2, A._separator_closure0, A._isBracketed_closure0, A._slash_closure0, A.SelectorList_asSassList_closure0, A.SelectorList_nestWithin_closure0, A.SelectorList_nestWithin__closure1, A.SelectorList_nestWithin__closure2, A.SelectorList__nestWithinCompound_closure2, A.SelectorList__nestWithinCompound_closure3, A.SelectorList__nestWithinCompound_closure4, A.SelectorList_withAdditionalCombinators_closure0, A.listClass__closure, A.legacyListClass_closure, A.legacyListClass__closure, A.legacyListClass_closure1, A.legacyListClass_closure2, A.legacyListClass_closure4, A.SassList_isBlank_closure0, A._get_closure0, A._set_closure1, A._set__closure2, A._set_closure2, A._set__closure1, A._merge_closure1, A._merge_closure2, A._merge__closure0, A._deepMerge_closure0, A._deepRemove_closure0, A._deepRemove__closure0, A._remove_closure1, A._remove_closure2, A._keys_closure0, A._values_closure0, A._hasKey_closure0, A._modify_modifyNestedMap0, A.MapExtensions_get_pairs_closure0, A.mapClass__closure, A.mapClass__closure0, A.legacyMapClass_closure, A.legacyMapClass__closure, A.legacyMapClass__closure0, A.legacyMapClass_closure2, A.legacyMapClass_closure3, A.legacyMapClass_closure4, A.global_closure43, A.module_closure26, A._ceil_closure0, A._clamp_closure0, A._floor_closure0, A._max_closure0, A._min_closure0, A._round_closure0, A._hypot_closure0, A._hypot__closure0, A._log_closure0, A._pow_closure0, A._atan2_closure0, A._compatible_closure0, A._isUnitless_closure0, A._unit_closure0, A._percentage_closure0, A._randomFunction_closure0, A._div_closure0, A._singleArgumentMathFunc_closure0, A._numberFunction_closure0, A._shared_closure3, A._shared_closure4, A._shared_closure5, A._shared_closure6, A.moduleFunctions_closure2, A.moduleFunctions_closure3, A.moduleFunctions__closure0, A.moduleFunctions_closure4, A.mixinClass__closure, A.mixinClass__closure0, A.ModifiableCssNode_hasFollowingSibling_closure0, A.NodePackageImporter__nodePackageExportsResolve_closure3, A.NodePackageImporter__nodePackageExportsResolve_closure4, A.NodePackageImporter__nodePackageExportsResolve_closure5, A.NodePackageImporter__nodePackageExportsResolve_closure6, A.NodePackageImporter__nodePackageExportsResolve__closure1, A.NodePackageImporter__nodePackageExportsResolve__closure2, A.NodePackageImporter__getMainExport_closure0, A.legacyNullClass__closure, A.numberClass__closure, A.numberClass__closure0, A.numberClass__closure1, A.numberClass__closure2, A.numberClass__closure3, A.numberClass__closure4, A.numberClass__closure5, A.numberClass__closure6, A.numberClass__closure7, A.numberClass__closure8, A.numberClass__closure9, A.numberClass__closure12, A.numberClass__closure13, A.numberClass__closure14, A.numberClass__closure15, A.numberClass__closure16, A.numberClass__closure17, A.numberClass__closure18, A.numberClass__closure19, A.legacyNumberClass_closure, A.legacyNumberClass_closure0, A.legacyNumberClass_closure2, A._parseNumber_closure, A._parseNumber_closure0, A.SassNumber__coerceOrConvertValue_closure3, A.SassNumber__coerceOrConvertValue_closure5, A.SassNumber_multiplyUnits_closure3, A.SassNumber_multiplyUnits_closure5, A.SassNumber__areAnyConvertible_closure0, A.SassNumber__canonicalizeUnitList_closure0, A.SassNumber_unitSuggestion_closure1, A.SassNumber_unitSuggestion_closure2, A.ParameterList_verify_closure1, A.ParameterList_verify_closure2, A.ParentStatement_closure0, A.ParentStatement__closure0, A.loadParserExports_closure, A.loadParserExports_closure0, A.loadParserExports_closure1, A._updateAstPrototypes_closure, A._updateAstPrototypes_closure0, A._updateAstPrototypes_closure1, A._updateAstPrototypes_closure4, A._updateAstPrototypes_closure5, A._updateAstPrototypes_closure6, A._updateAstPrototypes_closure7, A._updateAstPrototypes_closure8, A._updateAstPrototypes_closure9, A._addSupportsConditionToInterpolation_closure, A.Parser_escape_closure0, A.Parser_scanIdentChar_matches0, A._PrefixedKeys_iterator_closure0, A.PseudoSelector_specificity__closure1, A.PseudoSelector_specificity__closure2, A.PseudoSelector_unify_closure0, A.JSClassExtension_setCustomInspect_closure, A.ReplaceExpressionVisitor_visitListExpression_closure0, A.ReplaceExpressionVisitor_visitArgumentList_closure0, A.ReplaceExpressionVisitor_visitInterpolation_closure0, A.SassParser_styleRuleSelector_closure0, A.SassParser__peekIndentation_closure1, A.SassParser__peekIndentation_closure2, A.SassParser__tryTrailingSemicolon_closure0, A._wrapMain_closure, A._wrapMain_closure0, A._IsBogusVisitor_visitComplexSelector_closure0, A._IsUselessVisitor_visitComplexSelector_closure0, A._nest_closure0, A._nest__closure1, A._append_closure1, A._append__closure1, A._append___closure0, A._extend_closure0, A._replace_closure0, A._unify_closure0, A._isSuperselector_closure0, A._simpleSelectors_closure0, A._simpleSelectors__closure0, A._parse_closure0, A.SelectorSearchVisitor_visitComplexSelector_closure0, A.SelectorSearchVisitor_visitCompoundSelector_closure0, A.serialize_closure0, A._SerializeVisitor_visitList_closure2, A._SerializeVisitor_visitList_closure3, A._SerializeVisitor_visitList_closure4, A._SerializeVisitor_visitMap_closure0, A._SerializeVisitor_visitSelectorList_closure0, A.SimpleSelector_isSuperselector_closure0, A.SimpleSelector_isSuperselector__closure0, A.SingleUnitSassNumber__coerceToUnit_closure0, A.SingleUnitSassNumber__coerceValueToUnit_closure0, A.SingleUnitSassNumber_multiplyUnits_closure1, A.SourceMapBuffer_buildSourceMap_closure0, A.updateSourceSpanPrototype_closure0, A.updateSourceSpanPrototype_closure1, A.updateSourceSpanPrototype_closure2, A.updateSourceSpanPrototype__closure, A.updateSourceSpanPrototype_closure3, A.updateSourceSpanPrototype_closure4, A.updateSourceSpanPrototype_closure5, A.updateSourceSpanPrototype_closure6, A.StatementSearchVisitor_visitIfRule_closure1, A.StatementSearchVisitor_visitIfRule__closure2, A.StatementSearchVisitor_visitIfRule_closure2, A.StatementSearchVisitor_visitIfRule__closure1, A.StatementSearchVisitor_visitChildren_closure0, A.module_closure25, A.module__closure3, A.module__closure4, A._unquote_closure0, A._quote_closure0, A._length_closure1, A._insert_closure0, A._index_closure1, A._slice_closure0, A._toUpperCase_closure0, A._toLowerCase_closure0, A._uniqueId_closure0, A.StringExtension_toCssIdentifier_writeEscape, A.StringExtension_toCssIdentifier_consumeSurrogatePair, A.stringClass__closure, A.stringClass__closure0, A.stringClass__closure1, A.stringClass__closure2, A.stringClass__closure3, A.legacyStringClass_closure, A.legacyStringClass_closure0, A.StylesheetParser__expression_addSingleExpression0, A.StylesheetParser__expression_addOperator0, A.StylesheetParser__isHexColor_closure0, A.StylesheetParser__unicodeRange_closure1, A.StylesheetParser__unicodeRange_closure2, A.StylesheetParser_trySpecialFunction_closure0, A._UnprefixedKeys_iterator_closure1, A._UnprefixedKeys_iterator_closure2, A._exactlyOne_closure0, A.futureToPromise__closure0, A.indent_closure0, A.flattenVertically_closure1, A.flattenVertically_closure2, A.valueClass__closure, A.valueClass__closure0, A.valueClass__closure1, A.valueClass__closure2, A.valueClass__closure3, A.valueClass__closure4, A.valueClass__closure5, A.valueClass__closure7, A.valueClass__closure8, A.valueClass__closure9, A.valueClass__closure10, A.valueClass__closure11, A.valueClass__closure12, A.valueClass__closure13, A.valueClass__closure14, A.valueClass__closure15, A.valueClass__closure17, A.valueClass__closure18]); + _inheritMany(A.Closure2Args, [A._CastListBase_sort_closure, A.CastMap_forEach_closure, A.Primitives_functionNoSuchMethod_closure, A.JsLinkedHashMap_addAll_closure, A.initHooks_closure0, A._awaitOnObject_closure0, A._wrapJsFunctionForAsync_closure, A.Future_wait_handleError, A._Future__chainForeignFuture_closure0, A._Future__propagateToListeners_handleWhenCompleteCallback_closure0, A.Stream_Stream$fromFuture_closure0, A._AddStreamState_makeErrorHandler_closure, A._HashMap_addAll_closure, A.HashMap_HashMap$from_closure, A.LinkedHashMap_LinkedHashMap$from_closure, A.MapBase_addAll_closure, A.MapBase_mapToString_closure, A._JsonMap_addAll_closure, A._JsonStringifier_writeMap_closure, A.NoSuchMethodError_toString_closure, A.Uri__parseIPv4Address_error, A.Uri_parseIPv6Address_error, A.Uri_parseIPv6Address_parseHex, A.Parser_parse_closure, A.FutureGroup_add_closure0, A.StreamQueue__ensureListening_closure1, A.futureToPromise_closure, A.PathMap__create_closure, A.IfRule_toString_closure, A.ComplexSelector_specificity_closure, A.CompoundSelector_specificity_closure, A.ExtensionStore_clone_closure, A._weaveParents_closure, A.paths_closure, A._nest__closure0, A._append__closure0, A.watchDir_closure0, A.ParcelWatcher_subscribe_closure, A.StylesheetParser__styleRule_closure, A.StylesheetParser__tryDeclarationChildren_closure, A.StylesheetParser__atRootRule_closure, A.StylesheetParser__atRootRule_closure0, A.StylesheetParser__eachRule_closure, A.StylesheetParser__functionRule_closure, A.StylesheetParser__forRule_closure0, A.StylesheetParser__includeRule_closure, A.StylesheetParser_mediaRule_closure, A.StylesheetParser__mixinRule_closure, A.StylesheetParser_mozDocumentRule_closure0, A.StylesheetParser_supportsRule_closure, A.StylesheetParser__whileRule_closure, A.StylesheetParser_unknownAtRule_closure, A.longestCommonSubsequence_backtrack, A.mapAddAll2_closure, A.SassNumber_plus_closure, A.SassNumber_minus_closure, A.SassNumber__canonicalMultiplier_closure, A._EvaluateVisitor__closure3, A._EvaluateVisitor__closure4, A._EvaluateVisitor_visitForwardRule_closure1, A._EvaluateVisitor_visitForwardRule_closure2, A._EvaluateVisitor_visitUseRule_closure0, A._EvaluateVisitor__evaluateArguments_closure5, A._EvaluateVisitor__evaluateMacroArguments_closure5, A._EvaluateVisitor__addRestMap_closure0, A._EvaluateVisitor__closure, A._EvaluateVisitor__closure0, A._EvaluateVisitor_visitForwardRule_closure, A._EvaluateVisitor_visitForwardRule_closure0, A._EvaluateVisitor_visitUseRule_closure, A._EvaluateVisitor__evaluateArguments_closure1, A._EvaluateVisitor__evaluateMacroArguments_closure1, A._EvaluateVisitor__addRestMap_closure, A.SingleMapping_toJson_closure0, A.Highlighter__collateLines_closure0, A.Frame_Frame$parseV8_closure_parseJsLocation, A.TransformByHandlers_transformByHandlers__closure1, A.RateLimit__debounceAggregate_closure, A._EvaluateVisitor__closure11, A._EvaluateVisitor__closure12, A._EvaluateVisitor_visitForwardRule_closure5, A._EvaluateVisitor_visitForwardRule_closure6, A._EvaluateVisitor_visitUseRule_closure2, A._EvaluateVisitor__evaluateArguments_closure13, A._EvaluateVisitor__evaluateMacroArguments_closure13, A._EvaluateVisitor__addRestMap_closure2, A.calculationOperationClass__closure0, A.calculationInterpolationClass__closure, A.calculationInterpolationClass__closure0, A.colorClass__closure, A.colorClass__closure0, A.colorClass__closure2, A.colorClass__closure4, A.colorClass__closure6, A.colorClass__closure8, A.legacyColorClass_closure4, A.legacyColorClass_closure5, A.legacyColorClass_closure6, A.legacyColorClass_closure7, A._parseFunctions_closure0, A.ComplexSelector_specificity_closure0, A.CompoundSelector_specificity_closure0, A._EvaluateVisitor__closure7, A._EvaluateVisitor__closure8, A._EvaluateVisitor_visitForwardRule_closure3, A._EvaluateVisitor_visitForwardRule_closure4, A._EvaluateVisitor_visitUseRule_closure1, A._EvaluateVisitor__evaluateArguments_closure9, A._EvaluateVisitor__evaluateMacroArguments_closure9, A._EvaluateVisitor__addRestMap_closure1, A.ExtensionStore_clone_closure0, A._weaveParents_closure3, A.paths_closure0, A.IfRule_toString_closure0, A.main_closure, A.main_closure0, A.render_closure1, A._parseFunctions_closure, A.listClass__closure0, A.legacyListClass_closure0, A.legacyListClass_closure3, A.mapClass__closure1, A.legacyMapClass_closure0, A.legacyMapClass_closure1, A.numberClass__closure10, A.numberClass__closure11, A.legacyNumberClass_closure1, A.legacyNumberClass_closure3, A.SassNumber_plus_closure0, A.SassNumber_minus_closure0, A.SassNumber__canonicalMultiplier_closure0, A._updateAstPrototypes_closure2, A._updateAstPrototypes_closure3, A.JSClassExtension_get_defineStaticMethod_closure, A.JSClassExtension_get_defineMethod_closure, A.JSClassExtension_get_defineGetter_closure, A._nest__closure2, A._append__closure2, A.legacyStringClass_closure1, A.StylesheetParser__styleRule_closure0, A.StylesheetParser__tryDeclarationChildren_closure0, A.StylesheetParser__atRootRule_closure1, A.StylesheetParser__atRootRule_closure2, A.StylesheetParser__eachRule_closure0, A.StylesheetParser__functionRule_closure0, A.StylesheetParser__forRule_closure2, A.StylesheetParser__includeRule_closure0, A.StylesheetParser_mediaRule_closure0, A.StylesheetParser__mixinRule_closure0, A.StylesheetParser_mozDocumentRule_closure2, A.StylesheetParser_supportsRule_closure0, A.StylesheetParser__whileRule_closure0, A.StylesheetParser_unknownAtRule_closure0, A.futureToPromise_closure0, A.futureToPromise__closure1, A.objectToMap_closure, A.longestCommonSubsequence_backtrack0, A.mapAddAll2_closure0, A.valueClass__closure6, A.valueClass__closure16]); + _inherit(A.CastList, A._CastListBase); + _inheritMany(A.MapBase, [A.CastMap, A.JsLinkedHashMap, A._HashMap, A.UnmodifiableMapBase, A._JsonMap, A.MergedMapView, A.MergedMapView0]); + _inheritMany(A.Error, [A.LateError, A.TypeError, A.JsNoSuchMethodError, A.UnknownJsTypeError, A._CyclicInitializationError, A.RuntimeError, A._Error, A.JsonUnsupportedObjectError, A.AssertionError, A.ArgumentError, A.NoSuchMethodError, A.UnsupportedError, A.UnimplementedError, A.StateError, A.ConcurrentModificationError]); + _inherit(A.UnmodifiableListBase, A.ListBase); + _inheritMany(A.UnmodifiableListBase, [A.CodeUnits, A.UnmodifiableListView]); + _inheritMany(A.Closure0Args, [A.nullFuture_closure, A._AsyncRun__scheduleImmediateJsOverride_internalCallback, A._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback, A._TimerImpl_internalCallback, A._TimerImpl$periodic_closure, A._Future__addListener_closure, A._Future__prependListeners_closure, A._Future__chainForeignFuture_closure1, A._Future__chainCoreFuture_closure, A._Future__asyncCompleteWithValue_closure, A._Future__asyncCompleteError_closure, A._Future__propagateToListeners_handleWhenCompleteCallback, A._Future__propagateToListeners_handleValueCallback, A._Future__propagateToListeners_handleError, A.Stream_length_closure0, A._StreamController__subscribe_closure, A._StreamController__recordCancel_complete, A._AddStreamState_cancel_closure, A._BufferingStreamSubscription__sendError_sendError, A._BufferingStreamSubscription__sendDone_sendDone, A._PendingEvents_schedule_closure, A._CustomZone_bindCallback_closure, A._CustomZone_bindCallbackGuarded_closure, A._rootHandleError_closure, A._RootZone_bindCallback_closure, A._RootZone_bindCallbackGuarded_closure, A._Utf8Decoder__decoder_closure, A._Utf8Decoder__decoderNonfatal_closure, A.Parser__setOption_closure, A.StreamGroup_add_closure, A.StreamGroup_add_closure0, A.StreamGroup__listenToStream_closure, A.StreamQueue__ensureListening_closure0, A._isStrictMode_closure, A.ReplAdapter_runAsync_closure, A.ParsedPath__splitExtension_closure0, A.PseudoSelector_specificity_closure, A.AsyncEnvironment_setVariable_closure, A.AsyncEnvironment_setVariable_closure1, A.AsyncImportCache_canonicalize_closure, A.AsyncImportCache__canonicalize_closure, A.AsyncImportCache_importCanonical_closure, A.Environment_setVariable_closure, A.Environment_setVariable_closure1, A.ExecutableOptions__parser_closure, A.ExecutableOptions_interactive_closure, A.ExecutableOptions_fatalDeprecations_closure, A.ExtensionStore__registerSelector_closure, A.ExtensionStore_addExtension_closure, A.ExtensionStore_addExtension_closure0, A.ExtensionStore_addExtension_closure1, A.ExtensionStore__extendExistingExtensions_closure, A.ExtensionStore__extendExistingExtensions_closure0, A.ExtensionStore_addExtensions_closure, A._changeColor_closure, A.ImportCache_canonicalize_closure, A.ImportCache__canonicalize_closure, A.ImportCache_importCanonical_closure, A.resolveImportPath_closure, A.resolveImportPath_closure0, A._tryPathAsDirectory_closure, A._realCasePath_helper_closure, A._readFile_closure, A.writeFile_closure, A.deleteFile_closure, A.fileExists_closure, A.dirExists_closure, A.linkExists_closure, A.ensureDir_closure, A.listDir_closure, A.realpath_closure, A.modificationTime_closure, A.watchDir_closure, A.watchDir_closure5, A.watchDir__closure, A.AtRootQueryParser_parse_closure, A.KeyframeSelectorParser_parse_closure, A.MediaQueryParser_parse_closure, A.Parser__parseIdentifier_closure, A.Parser_spanFrom_closure, A.SassParser_children_closure, A.SelectorParser_parse_closure, A.SelectorParser_parseCompoundSelector_closure, A.StylesheetParser_parse_closure, A.StylesheetParser_parse__closure, A.StylesheetParser_parseParameterList_closure, A.StylesheetParser_parseVariableDeclaration_closure, A.StylesheetParser_parseUseRule_closure, A.StylesheetParser__parseSingleProduction_closure, A.StylesheetParser__statement_closure, A.StylesheetParser_variableDeclarationWithoutNamespace_closure, A.StylesheetParser_variableDeclarationWithoutNamespace_closure0, A.StylesheetParser__declarationOrBuffer_closure, A.StylesheetParser__declarationOrBuffer_closure0, A.StylesheetParser__declarationOrBuffer_closure1, A.StylesheetParser__propertyOrVariableDeclaration_closure, A.StylesheetParser__forRule_closure, A.StylesheetParser__memberList_closure, A.StylesheetParser_mozDocumentRule_closure, A.StylesheetParser__expression_resetState, A.StylesheetParser__expression_resolveOneOperation, A.StylesheetParser__expression_resolveOperations, A.StylesheetParser__expression_resolveSpaceExpressions, A.StylesheetParser_expressionUntilComma_closure, A.StylesheetParser_namespacedExpression_closure, A.StylesheetParser__expressionUntilComparison_closure, A.StylesheetParser__publicIdentifier_closure, A.StylesheetGraph_modifiedSince_transitiveModificationTime_closure, A.StylesheetGraph__add_closure, A.StylesheetGraph_addCanonical_closure, A.StylesheetGraph_reload_closure, A.StylesheetGraph__nodeFor_closure, A.StylesheetGraph__nodeFor_closure0, A.SassNumber__coerceOrConvertValue_compatibilityException, A.SassNumber__coerceOrConvertValue_closure0, A.SassNumber__coerceOrConvertValue_closure2, A.SassNumber_multiplyUnits_closure0, A.SassNumber_multiplyUnits_closure2, A.SingleUnitSassNumber_multiplyUnits_closure0, A._EvaluateVisitor__closure6, A._EvaluateVisitor__closure5, A._EvaluateVisitor_run_closure0, A._EvaluateVisitor_run__closure0, A._EvaluateVisitor__loadModule_closure1, A._EvaluateVisitor__loadModule_closure2, A._EvaluateVisitor__loadModule__closure2, A._EvaluateVisitor__execute_closure0, A._EvaluateVisitor__extendModules_closure2, A._EvaluateVisitor_visitAtRootRule_closure1, A._EvaluateVisitor_visitAtRootRule_closure2, A._EvaluateVisitor__scopeForAtRoot__closure0, A._EvaluateVisitor_visitContentRule_closure0, A._EvaluateVisitor_visitDeclaration_closure0, A._EvaluateVisitor_visitEachRule_closure4, A._EvaluateVisitor_visitAtRule_closure3, A._EvaluateVisitor_visitAtRule__closure0, A._EvaluateVisitor_visitForRule_closure4, A._EvaluateVisitor_visitForRule_closure5, A._EvaluateVisitor_visitForRule_closure6, A._EvaluateVisitor_visitForRule_closure7, A._EvaluateVisitor_visitForRule_closure8, A._EvaluateVisitor__registerCommentsForModule_closure0, A._EvaluateVisitor_visitIfRule__closure0, A._EvaluateVisitor__visitDynamicImport_closure0, A._EvaluateVisitor__visitDynamicImport__closure6, A._EvaluateVisitor__applyMixin_closure1, A._EvaluateVisitor__applyMixin__closure2, A._EvaluateVisitor__applyMixin_closure2, A._EvaluateVisitor__applyMixin__closure1, A._EvaluateVisitor__applyMixin___closure0, A._EvaluateVisitor__applyMixin____closure0, A._EvaluateVisitor_visitIncludeRule_closure2, A._EvaluateVisitor_visitIncludeRule_closure4, A._EvaluateVisitor_visitMediaRule_closure3, A._EvaluateVisitor_visitMediaRule__closure0, A._EvaluateVisitor_visitMediaRule___closure0, A._EvaluateVisitor_visitStyleRule_closure3, A._EvaluateVisitor_visitStyleRule_closure6, A._EvaluateVisitor_visitStyleRule__closure0, A._EvaluateVisitor_visitSupportsRule_closure1, A._EvaluateVisitor_visitSupportsRule__closure0, A._EvaluateVisitor__visitSupportsCondition_closure0, A._EvaluateVisitor_visitVariableDeclaration_closure2, A._EvaluateVisitor_visitVariableDeclaration_closure3, A._EvaluateVisitor_visitVariableDeclaration_closure4, A._EvaluateVisitor_visitWarnRule_closure0, A._EvaluateVisitor_visitWhileRule_closure0, A._EvaluateVisitor_visitBinaryOperationExpression_closure0, A._EvaluateVisitor_visitVariableExpression_closure0, A._EvaluateVisitor_visitUnaryOperationExpression_closure0, A._EvaluateVisitor_visitFunctionExpression_closure2, A._EvaluateVisitor_visitFunctionExpression_closure4, A._EvaluateVisitor__visitCalculationExpression_closure0, A._EvaluateVisitor_visitInterpolatedFunctionExpression_closure0, A._EvaluateVisitor__runUserDefinedCallable_closure0, A._EvaluateVisitor__runUserDefinedCallable__closure0, A._EvaluateVisitor__runUserDefinedCallable___closure0, A._EvaluateVisitor__runFunctionCallable_closure0, A._EvaluateVisitor__runBuiltInCallable_closure2, A._EvaluateVisitor__runBuiltInCallable_closure3, A._EvaluateVisitor__verifyArguments_closure0, A._EvaluateVisitor_visitCssAtRule_closure1, A._EvaluateVisitor_visitCssKeyframeBlock_closure1, A._EvaluateVisitor_visitCssMediaRule_closure3, A._EvaluateVisitor_visitCssMediaRule__closure0, A._EvaluateVisitor_visitCssMediaRule___closure0, A._EvaluateVisitor_visitCssStyleRule_closure2, A._EvaluateVisitor_visitCssStyleRule__closure0, A._EvaluateVisitor_visitCssSupportsRule_closure1, A._EvaluateVisitor_visitCssSupportsRule__closure0, A._EvaluateVisitor__serialize_closure0, A._EvaluateVisitor__expressionNode_closure0, A._EvaluateVisitor__closure2, A._EvaluateVisitor__closure1, A._EvaluateVisitor_run_closure, A._EvaluateVisitor_run__closure, A._EvaluateVisitor_runExpression_closure, A._EvaluateVisitor_runExpression__closure, A._EvaluateVisitor_runExpression___closure, A._EvaluateVisitor_runStatement_closure, A._EvaluateVisitor_runStatement__closure, A._EvaluateVisitor_runStatement___closure, A._EvaluateVisitor__loadModule_closure, A._EvaluateVisitor__loadModule_closure0, A._EvaluateVisitor__loadModule__closure0, A._EvaluateVisitor__execute_closure, A._EvaluateVisitor__extendModules_closure0, A._EvaluateVisitor_visitAtRootRule_closure, A._EvaluateVisitor_visitAtRootRule_closure0, A._EvaluateVisitor__scopeForAtRoot__closure, A._EvaluateVisitor_visitContentRule_closure, A._EvaluateVisitor_visitDeclaration_closure, A._EvaluateVisitor_visitEachRule_closure1, A._EvaluateVisitor_visitAtRule_closure0, A._EvaluateVisitor_visitAtRule__closure, A._EvaluateVisitor_visitForRule_closure, A._EvaluateVisitor_visitForRule_closure0, A._EvaluateVisitor_visitForRule_closure1, A._EvaluateVisitor_visitForRule_closure2, A._EvaluateVisitor_visitForRule_closure3, A._EvaluateVisitor__registerCommentsForModule_closure, A._EvaluateVisitor_visitIfRule__closure, A._EvaluateVisitor__visitDynamicImport_closure, A._EvaluateVisitor__visitDynamicImport__closure2, A._EvaluateVisitor__applyMixin_closure, A._EvaluateVisitor__applyMixin__closure0, A._EvaluateVisitor__applyMixin_closure0, A._EvaluateVisitor__applyMixin__closure, A._EvaluateVisitor__applyMixin___closure, A._EvaluateVisitor__applyMixin____closure, A._EvaluateVisitor_visitIncludeRule_closure, A._EvaluateVisitor_visitIncludeRule_closure1, A._EvaluateVisitor_visitMediaRule_closure0, A._EvaluateVisitor_visitMediaRule__closure, A._EvaluateVisitor_visitMediaRule___closure, A._EvaluateVisitor_visitStyleRule_closure, A._EvaluateVisitor_visitStyleRule_closure2, A._EvaluateVisitor_visitStyleRule__closure, A._EvaluateVisitor_visitSupportsRule_closure, A._EvaluateVisitor_visitSupportsRule__closure, A._EvaluateVisitor__visitSupportsCondition_closure, A._EvaluateVisitor_visitVariableDeclaration_closure, A._EvaluateVisitor_visitVariableDeclaration_closure0, A._EvaluateVisitor_visitVariableDeclaration_closure1, A._EvaluateVisitor_visitWarnRule_closure, A._EvaluateVisitor_visitWhileRule_closure, A._EvaluateVisitor_visitBinaryOperationExpression_closure, A._EvaluateVisitor_visitVariableExpression_closure, A._EvaluateVisitor_visitUnaryOperationExpression_closure, A._EvaluateVisitor_visitFunctionExpression_closure, A._EvaluateVisitor_visitFunctionExpression_closure1, A._EvaluateVisitor__visitCalculationExpression_closure, A._EvaluateVisitor_visitInterpolatedFunctionExpression_closure, A._EvaluateVisitor__runUserDefinedCallable_closure, A._EvaluateVisitor__runUserDefinedCallable__closure, A._EvaluateVisitor__runUserDefinedCallable___closure, A._EvaluateVisitor__runFunctionCallable_closure, A._EvaluateVisitor__runBuiltInCallable_closure, A._EvaluateVisitor__runBuiltInCallable_closure0, A._EvaluateVisitor__verifyArguments_closure, A._EvaluateVisitor_visitCssAtRule_closure, A._EvaluateVisitor_visitCssKeyframeBlock_closure, A._EvaluateVisitor_visitCssMediaRule_closure0, A._EvaluateVisitor_visitCssMediaRule__closure, A._EvaluateVisitor_visitCssMediaRule___closure, A._EvaluateVisitor_visitCssStyleRule_closure0, A._EvaluateVisitor_visitCssStyleRule__closure, A._EvaluateVisitor_visitCssSupportsRule_closure, A._EvaluateVisitor_visitCssSupportsRule__closure, A._EvaluateVisitor__serialize_closure, A._EvaluateVisitor__expressionNode_closure, A._SerializeVisitor_visitCssComment_closure, A._SerializeVisitor_visitCssAtRule_closure, A._SerializeVisitor_visitCssMediaRule_closure, A._SerializeVisitor_visitCssImport_closure, A._SerializeVisitor_visitCssImport__closure, A._SerializeVisitor_visitCssKeyframeBlock_closure, A._SerializeVisitor_visitCssStyleRule_closure, A._SerializeVisitor_visitCssSupportsRule_closure, A._SerializeVisitor_visitCssDeclaration_closure, A._SerializeVisitor_visitCssDeclaration_closure0, A._SerializeVisitor__write_closure, A._SerializeVisitor__visitChildren_closure, A._SerializeVisitor__visitChildren_closure0, A.SingleMapping_SingleMapping$fromEntries_closure, A.SingleMapping_SingleMapping$fromEntries_closure0, A.Highlighter_closure, A.Highlighter__writeFileStart_closure, A.Highlighter__writeMultilineHighlights_closure, A.Highlighter__writeMultilineHighlights_closure0, A.Highlighter__writeMultilineHighlights_closure1, A.Highlighter__writeMultilineHighlights_closure2, A.Highlighter__writeMultilineHighlights__closure, A.Highlighter__writeMultilineHighlights__closure0, A.Highlighter__writeHighlightedText_closure, A.Highlighter__writeIndicator_closure, A.Highlighter__writeIndicator_closure0, A.Highlighter__writeIndicator_closure1, A.Highlighter__writeLabel_closure, A.Highlighter__writeLabel_closure0, A.Highlighter__writeSidebar_closure, A._Highlight_closure, A.Frame_Frame$parseVM_closure, A.Frame_Frame$parseV8_closure, A.Frame_Frame$_parseFirefoxEval_closure, A.Frame_Frame$parseFirefox_closure, A.Frame_Frame$parseFriendly_closure, A.LazyTrace_terse_closure, A.Trace_Trace$from_closure, A.TransformByHandlers_transformByHandlers_closure, A.TransformByHandlers_transformByHandlers__closure0, A.TransformByHandlers_transformByHandlers__closure2, A.RateLimit__debounceAggregate_closure_emit, A.RateLimit__debounceAggregate__closure, A.argumentListClass_closure, A.JSToDartAsyncImporter_canonicalize_closure, A.JSToDartAsyncImporter_load_closure, A.AsyncEnvironment_setVariable_closure2, A.AsyncEnvironment_setVariable_closure4, A._EvaluateVisitor__closure14, A._EvaluateVisitor__closure13, A._EvaluateVisitor_run_closure2, A._EvaluateVisitor_run__closure2, A._EvaluateVisitor__loadModule_closure5, A._EvaluateVisitor__loadModule_closure6, A._EvaluateVisitor__loadModule__closure6, A._EvaluateVisitor__execute_closure2, A._EvaluateVisitor__extendModules_closure6, A._EvaluateVisitor_visitAtRootRule_closure5, A._EvaluateVisitor_visitAtRootRule_closure6, A._EvaluateVisitor__scopeForAtRoot__closure2, A._EvaluateVisitor_visitContentRule_closure2, A._EvaluateVisitor_visitDeclaration_closure2, A._EvaluateVisitor_visitEachRule_closure10, A._EvaluateVisitor_visitAtRule_closure9, A._EvaluateVisitor_visitAtRule__closure2, A._EvaluateVisitor_visitForRule_closure14, A._EvaluateVisitor_visitForRule_closure15, A._EvaluateVisitor_visitForRule_closure16, A._EvaluateVisitor_visitForRule_closure17, A._EvaluateVisitor_visitForRule_closure18, A._EvaluateVisitor__registerCommentsForModule_closure2, A._EvaluateVisitor_visitIfRule__closure2, A._EvaluateVisitor__visitDynamicImport_closure2, A._EvaluateVisitor__visitDynamicImport__closure14, A._EvaluateVisitor__applyMixin_closure5, A._EvaluateVisitor__applyMixin__closure6, A._EvaluateVisitor__applyMixin_closure6, A._EvaluateVisitor__applyMixin__closure5, A._EvaluateVisitor__applyMixin___closure2, A._EvaluateVisitor__applyMixin____closure2, A._EvaluateVisitor_visitIncludeRule_closure8, A._EvaluateVisitor_visitIncludeRule_closure10, A._EvaluateVisitor_visitMediaRule_closure9, A._EvaluateVisitor_visitMediaRule__closure2, A._EvaluateVisitor_visitMediaRule___closure2, A._EvaluateVisitor_visitStyleRule_closure11, A._EvaluateVisitor_visitStyleRule_closure14, A._EvaluateVisitor_visitStyleRule__closure2, A._EvaluateVisitor_visitSupportsRule_closure5, A._EvaluateVisitor_visitSupportsRule__closure2, A._EvaluateVisitor__visitSupportsCondition_closure2, A._EvaluateVisitor_visitVariableDeclaration_closure8, A._EvaluateVisitor_visitVariableDeclaration_closure9, A._EvaluateVisitor_visitVariableDeclaration_closure10, A._EvaluateVisitor_visitWarnRule_closure2, A._EvaluateVisitor_visitWhileRule_closure2, A._EvaluateVisitor_visitBinaryOperationExpression_closure2, A._EvaluateVisitor_visitVariableExpression_closure2, A._EvaluateVisitor_visitUnaryOperationExpression_closure2, A._EvaluateVisitor_visitFunctionExpression_closure8, A._EvaluateVisitor_visitFunctionExpression_closure10, A._EvaluateVisitor__visitCalculationExpression_closure2, A._EvaluateVisitor_visitInterpolatedFunctionExpression_closure2, A._EvaluateVisitor__runUserDefinedCallable_closure2, A._EvaluateVisitor__runUserDefinedCallable__closure2, A._EvaluateVisitor__runUserDefinedCallable___closure2, A._EvaluateVisitor__runFunctionCallable_closure2, A._EvaluateVisitor__runBuiltInCallable_closure8, A._EvaluateVisitor__runBuiltInCallable_closure9, A._EvaluateVisitor__verifyArguments_closure2, A._EvaluateVisitor_visitCssAtRule_closure5, A._EvaluateVisitor_visitCssKeyframeBlock_closure5, A._EvaluateVisitor_visitCssMediaRule_closure9, A._EvaluateVisitor_visitCssMediaRule__closure2, A._EvaluateVisitor_visitCssMediaRule___closure2, A._EvaluateVisitor_visitCssStyleRule_closure6, A._EvaluateVisitor_visitCssStyleRule__closure2, A._EvaluateVisitor_visitCssSupportsRule_closure5, A._EvaluateVisitor_visitCssSupportsRule__closure2, A._EvaluateVisitor__serialize_closure2, A._EvaluateVisitor__expressionNode_closure2, A.JSToDartAsyncFileImporter_canonicalize_closure, A.AsyncImportCache_canonicalize_closure0, A.AsyncImportCache__canonicalize_closure0, A.AsyncImportCache_importCanonical_closure0, A.AtRootQueryParser_parse_closure0, A.booleanClass_closure, A.legacyBooleanClass_closure, A.calculationClass_closure, A.calculationOperationClass_closure, A.calculationInterpolationClass_closure, A._changeColor_closure0, A.colorClass_closure, A.compileAsync_closure, A.compileStringAsync_closure, A._parseFunctions___closure6, A._parseFunctions___closure5, A.nodePackageImporterClass_closure, A.compilerClass_closure, A.asyncCompilerClass_closure, A.asyncCompilerClass___closure, A.initAsyncCompiler_closure, A.deprecations_closure, A.parseDeprecations_closure, A.versionClass_closure, A.Environment_setVariable_closure2, A.Environment_setVariable_closure4, A._EvaluateVisitor__closure10, A._EvaluateVisitor__closure9, A._EvaluateVisitor_run_closure1, A._EvaluateVisitor_run__closure1, A._EvaluateVisitor__loadModule_closure3, A._EvaluateVisitor__loadModule_closure4, A._EvaluateVisitor__loadModule__closure4, A._EvaluateVisitor__execute_closure1, A._EvaluateVisitor__extendModules_closure4, A._EvaluateVisitor_visitAtRootRule_closure3, A._EvaluateVisitor_visitAtRootRule_closure4, A._EvaluateVisitor__scopeForAtRoot__closure1, A._EvaluateVisitor_visitContentRule_closure1, A._EvaluateVisitor_visitDeclaration_closure1, A._EvaluateVisitor_visitEachRule_closure7, A._EvaluateVisitor_visitAtRule_closure6, A._EvaluateVisitor_visitAtRule__closure1, A._EvaluateVisitor_visitForRule_closure9, A._EvaluateVisitor_visitForRule_closure10, A._EvaluateVisitor_visitForRule_closure11, A._EvaluateVisitor_visitForRule_closure12, A._EvaluateVisitor_visitForRule_closure13, A._EvaluateVisitor__registerCommentsForModule_closure1, A._EvaluateVisitor_visitIfRule__closure1, A._EvaluateVisitor__visitDynamicImport_closure1, A._EvaluateVisitor__visitDynamicImport__closure10, A._EvaluateVisitor__applyMixin_closure3, A._EvaluateVisitor__applyMixin__closure4, A._EvaluateVisitor__applyMixin_closure4, A._EvaluateVisitor__applyMixin__closure3, A._EvaluateVisitor__applyMixin___closure1, A._EvaluateVisitor__applyMixin____closure1, A._EvaluateVisitor_visitIncludeRule_closure5, A._EvaluateVisitor_visitIncludeRule_closure7, A._EvaluateVisitor_visitMediaRule_closure6, A._EvaluateVisitor_visitMediaRule__closure1, A._EvaluateVisitor_visitMediaRule___closure1, A._EvaluateVisitor_visitStyleRule_closure7, A._EvaluateVisitor_visitStyleRule_closure10, A._EvaluateVisitor_visitStyleRule__closure1, A._EvaluateVisitor_visitSupportsRule_closure3, A._EvaluateVisitor_visitSupportsRule__closure1, A._EvaluateVisitor__visitSupportsCondition_closure1, A._EvaluateVisitor_visitVariableDeclaration_closure5, A._EvaluateVisitor_visitVariableDeclaration_closure6, A._EvaluateVisitor_visitVariableDeclaration_closure7, A._EvaluateVisitor_visitWarnRule_closure1, A._EvaluateVisitor_visitWhileRule_closure1, A._EvaluateVisitor_visitBinaryOperationExpression_closure1, A._EvaluateVisitor_visitVariableExpression_closure1, A._EvaluateVisitor_visitUnaryOperationExpression_closure1, A._EvaluateVisitor_visitFunctionExpression_closure5, A._EvaluateVisitor_visitFunctionExpression_closure7, A._EvaluateVisitor__visitCalculationExpression_closure1, A._EvaluateVisitor_visitInterpolatedFunctionExpression_closure1, A._EvaluateVisitor__runUserDefinedCallable_closure1, A._EvaluateVisitor__runUserDefinedCallable__closure1, A._EvaluateVisitor__runUserDefinedCallable___closure1, A._EvaluateVisitor__runFunctionCallable_closure1, A._EvaluateVisitor__runBuiltInCallable_closure5, A._EvaluateVisitor__runBuiltInCallable_closure6, A._EvaluateVisitor__verifyArguments_closure1, A._EvaluateVisitor_visitCssAtRule_closure3, A._EvaluateVisitor_visitCssKeyframeBlock_closure3, A._EvaluateVisitor_visitCssMediaRule_closure6, A._EvaluateVisitor_visitCssMediaRule__closure1, A._EvaluateVisitor_visitCssMediaRule___closure1, A._EvaluateVisitor_visitCssStyleRule_closure4, A._EvaluateVisitor_visitCssStyleRule__closure1, A._EvaluateVisitor_visitCssSupportsRule_closure3, A._EvaluateVisitor_visitCssSupportsRule__closure1, A._EvaluateVisitor__serialize_closure1, A._EvaluateVisitor__expressionNode_closure1, A.exceptionClass_closure, A.ExtensionStore__registerSelector_closure0, A.ExtensionStore_addExtension_closure2, A.ExtensionStore_addExtension_closure3, A.ExtensionStore_addExtension_closure4, A.ExtensionStore__extendExistingExtensions_closure1, A.ExtensionStore__extendExistingExtensions_closure2, A.ExtensionStore_addExtensions_closure0, A.JSToDartFileImporter_canonicalize_closure, A.functionClass_closure, A.NodeImporter_load_closure, A.NodeImporter__tryPath_closure, A.NodeImporter__callImporterAsync_closure, A.ImportCache_canonicalize_closure0, A.ImportCache__canonicalize_closure0, A.ImportCache_importCanonical_closure0, A._realCasePath_helper_closure0, A._readFile_closure0, A.fileExists_closure0, A.dirExists_closure0, A.linkExists_closure0, A.listDir_closure0, A.realpath_closure0, A.JSToDartLogger_internalWarn_closure, A.JSToDartLogger_debug_closure, A.KeyframeSelectorParser_parse_closure0, A.render_closure, A._parseFunctions____closure, A._parseFunctions___closure3, A._parseFunctions___closure4, A._parseFunctions___closure1, A._parseFunctions___closure0, A._parseImporter____closure, A._parseImporter___closure0, A.listClass_closure, A.mapClass_closure, A.MediaQueryParser_parse_closure0, A.mixinClass_closure, A.legacyNullClass_closure, A.numberClass_closure, A.SassNumber__coerceOrConvertValue_compatibilityException0, A.SassNumber__coerceOrConvertValue_closure4, A.SassNumber__coerceOrConvertValue_closure6, A.SassNumber_multiplyUnits_closure4, A.SassNumber_multiplyUnits_closure6, A.Parser__parseIdentifier_closure0, A.Parser_spanFrom_closure0, A.PseudoSelector_specificity_closure0, A.SassParser_children_closure0, A.SelectorParser_parse_closure0, A.SelectorParser_parseCompoundSelector_closure0, A._SerializeVisitor_visitCssComment_closure0, A._SerializeVisitor_visitCssAtRule_closure0, A._SerializeVisitor_visitCssMediaRule_closure0, A._SerializeVisitor_visitCssImport_closure0, A._SerializeVisitor_visitCssImport__closure0, A._SerializeVisitor_visitCssKeyframeBlock_closure0, A._SerializeVisitor_visitCssStyleRule_closure0, A._SerializeVisitor_visitCssSupportsRule_closure0, A._SerializeVisitor_visitCssDeclaration_closure1, A._SerializeVisitor_visitCssDeclaration_closure2, A._SerializeVisitor__write_closure0, A._SerializeVisitor__visitChildren_closure1, A._SerializeVisitor__visitChildren_closure2, A.SingleUnitSassNumber_multiplyUnits_closure2, A.updateSourceSpanPrototype_closure, A.stringClass_closure, A.StylesheetParser_parse_closure0, A.StylesheetParser_parse__closure0, A.StylesheetParser_parseParameterList_closure0, A.StylesheetParser__parseSingleProduction_closure0, A.StylesheetParser_parseSignature_closure, A.StylesheetParser__statement_closure0, A.StylesheetParser_variableDeclarationWithoutNamespace_closure1, A.StylesheetParser_variableDeclarationWithoutNamespace_closure2, A.StylesheetParser__declarationOrBuffer_closure2, A.StylesheetParser__declarationOrBuffer_closure3, A.StylesheetParser__declarationOrBuffer_closure4, A.StylesheetParser__propertyOrVariableDeclaration_closure0, A.StylesheetParser__forRule_closure1, A.StylesheetParser__memberList_closure0, A.StylesheetParser_mozDocumentRule_closure1, A.StylesheetParser__expression_resetState0, A.StylesheetParser__expression_resolveOneOperation0, A.StylesheetParser__expression_resolveOperations0, A.StylesheetParser__expression_resolveSpaceExpressions0, A.StylesheetParser_expressionUntilComma_closure0, A.StylesheetParser_namespacedExpression_closure0, A.StylesheetParser__expressionUntilComparison_closure0, A.StylesheetParser__publicIdentifier_closure0, A.JSToDartImporter_canonicalize_closure, A.JSToDartImporter_load_closure, A.resolveImportPath_closure1, A.resolveImportPath_closure2, A._tryPathAsDirectory_closure0, A.valueClass_closure]); + _inheritMany(A.EfficientLengthIterable, [A.ListIterable, A.EmptyIterable, A.LinkedHashMapKeysIterable, A.LinkedHashMapValuesIterable, A.LinkedHashMapEntriesIterable, A._HashMapKeyIterable, A._MapBaseValueIterable]); + _inheritMany(A.ListIterable, [A.SubListIterable, A.MappedListIterable, A.ReversedListIterable, A.ListQueue, A._JsonMapKeyIterable, A._GeneratorIterable]); + _inherit(A.EfficientLengthMappedIterable, A.MappedIterable); + _inherit(A.EfficientLengthTakeIterable, A.TakeIterable); + _inherit(A.EfficientLengthSkipIterable, A.SkipIterable); + _inherit(A.EfficientLengthFollowedByIterable, A.FollowedByIterable); + _inheritMany(A._Record, [A._Record1, A._Record2, A._Record3, A._RecordN]); + _inherit(A._Record_1, A._Record1); + _inheritMany(A._Record2, [A._Record_2, A._Record_2_forImport, A._Record_2_imports_modules, A._Record_2_loadedUrls_stylesheet, A._Record_2_sourceMap]); + _inheritMany(A._Record3, [A._Record_3, A._Record_3_deprecation_message_span, A._Record_3_forImport, A._Record_3_importer_isDependency, A._Record_3_originalUrl]); + _inherit(A._Record_5_named_namedNodes_positional_positionalNodes_separator, A._RecordN); + _inheritMany(A.MapView, [A._UnmodifiableMapView_MapView__UnmodifiableMapMixin, A.PathMap]); + _inherit(A.UnmodifiableMapView, A._UnmodifiableMapView_MapView__UnmodifiableMapMixin); + _inherit(A.ConstantMapView, A.UnmodifiableMapView); + _inherit(A.ConstantStringMap, A.ConstantMap); + _inheritMany(A.SetBase, [A.ConstantSet, A._SetBase, A._UnmodifiableSetView_SetBase__UnmodifiableSetMixin, A._UnionSet_SetBase_UnmodifiableSetMixin]); + _inheritMany(A.ConstantSet, [A.ConstantStringSet, A.GeneralConstantSet]); + _inherit(A.Instantiation1, A.Instantiation); + _inherit(A.NullError, A.TypeError); + _inheritMany(A.TearOffClosure, [A.StaticClosure, A.BoundClosure]); + _inheritMany(A.JsLinkedHashMap, [A.JsIdentityLinkedHashMap, A.JsConstantLinkedHashMap, A._LinkedCustomHashMap]); + _inheritMany(A.NativeTypedData, [A.NativeByteData, A.NativeTypedArray]); + _inheritMany(A.NativeTypedArray, [A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin, A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin]); + _inherit(A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin, A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin); + _inherit(A.NativeTypedArrayOfDouble, A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin); + _inherit(A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin, A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin); + _inherit(A.NativeTypedArrayOfInt, A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin); + _inheritMany(A.NativeTypedArrayOfDouble, [A.NativeFloat32List, A.NativeFloat64List]); + _inheritMany(A.NativeTypedArrayOfInt, [A.NativeInt16List, A.NativeInt32List, A.NativeInt8List, A.NativeUint16List, A.NativeUint32List, A.NativeUint8ClampedList, A.NativeUint8List]); + _inherit(A._TypeError, A._Error); + _inheritMany(A._Completer, [A._AsyncCompleter, A._SyncCompleter]); + _inheritMany(A._StreamController, [A._AsyncStreamController, A._SyncStreamController]); + _inheritMany(A.Stream, [A._StreamImpl, A._ForwardingStream, A._CompleterStream]); + _inherit(A._ControllerStream, A._StreamImpl); + _inheritMany(A._BufferingStreamSubscription, [A._ControllerSubscription, A._ForwardingStreamSubscription]); + _inherit(A._StreamControllerAddStreamState, A._AddStreamState); + _inheritMany(A._DelayedEvent, [A._DelayedData, A._DelayedError]); + _inherit(A._MapStream, A._ForwardingStream); + _inheritMany(A._Zone, [A._CustomZone, A._RootZone]); + _inherit(A._IdentityHashMap, A._HashMap); + _inherit(A._LinkedHashSet, A._SetBase); + _inherit(A._LinkedIdentityHashSet, A._LinkedHashSet); + _inherit(A.UnmodifiableSetView, A._UnmodifiableSetView_SetBase__UnmodifiableSetMixin); + _inheritMany(A.Codec, [A.Encoding, A.Base64Codec, A.JsonCodec]); + _inheritMany(A.Encoding, [A.AsciiCodec, A.Utf8Codec]); + _inheritMany(A.Converter, [A._UnicodeSubsetEncoder, A.Base64Encoder, A.JsonEncoder, A.JsonDecoder, A.Utf8Encoder, A.Utf8Decoder]); + _inherit(A.AsciiEncoder, A._UnicodeSubsetEncoder); + _inheritMany(A.ByteConversionSink, [A._Base64EncoderSink, A._Utf8StringSinkAdapter]); + _inherit(A._Utf8Base64EncoderSink, A._Base64EncoderSink); + _inherit(A.JsonCyclicError, A.JsonUnsupportedObjectError); + _inherit(A._JsonStringStringifier, A._JsonStringifier); + _inherit(A._StringSinkConversionSink, A.StringConversionSink); + _inherit(A._StringCallbackSink, A._StringSinkConversionSink); + _inheritMany(A.ArgumentError, [A.RangeError, A.IndexError]); + _inherit(A._DataUri, A._Uri); + _inherit(A.ArgParserException, A.FormatException); + _inherit(A.EmptyUnmodifiableSet, A._EmptyUnmodifiableSet_IterableBase_UnmodifiableSetMixin); + _inherit(A.QueueList, A._QueueList_Object_ListMixin); + _inherit(A._CastQueueList, A.QueueList); + _inherit(A.UnionSet, A._UnionSet_SetBase_UnmodifiableSetMixin); + _inheritMany(A._DelegatingIterableBase, [A.DelegatingSet, A._MapKeySet__DelegatingIterableBase_UnmodifiableSetMixin]); + _inherit(A._UnmodifiableSetView_DelegatingSet_UnmodifiableSetMixin, A.DelegatingSet); + _inherit(A.UnmodifiableSetView0, A._UnmodifiableSetView_DelegatingSet_UnmodifiableSetMixin); + _inherit(A.MapKeySet, A._MapKeySet__DelegatingIterableBase_UnmodifiableSetMixin); + _inheritMany(A.NodeJsError, [A.JsAssertionError, A.JsRangeError, A.JsReferenceError, A.JsSyntaxError, A.JsTypeError, A.JsSystemError]); + _inheritMany(A.Socket, [A.TTYReadStream, A.TTYWriteStream]); + _inherit(A.InternalStyle, A.Style); + _inheritMany(A.InternalStyle, [A.PosixStyle, A.UrlStyle, A.WindowsStyle]); + _inheritMany(A._Enum, [A._SingletonCssMediaQueryMergeResult, A.BinaryOperator, A.UnaryOperator, A.AttributeOperator, A.Combinator, A.Deprecation, A.ExtendMode, A.Syntax, A.CalculationOperator, A.HueInterpolationMethod, A.ListSeparator, A.OutputStyle, A.LineFeed, A.AttributeOperator0, A.BinaryOperator0, A.CalculationOperator0, A.Combinator0, A.Deprecation0, A.HueInterpolationMethod0, A.ListSeparator0, A._SingletonCssMediaQueryMergeResult0, A.ExtendMode0, A.OutputStyle0, A.LineFeed0, A.Syntax0, A.UnaryOperator0]); + _inheritMany(A.CssNode, [A.ModifiableCssNode, A.CssParentNode]); + _inheritMany(A.ModifiableCssNode, [A.ModifiableCssParentNode, A.ModifiableCssComment, A.ModifiableCssDeclaration, A.ModifiableCssImport]); + _inheritMany(A.ModifiableCssParentNode, [A.ModifiableCssAtRule, A.ModifiableCssKeyframeBlock, A.ModifiableCssMediaRule, A.ModifiableCssStyleRule, A.ModifiableCssStylesheet, A.ModifiableCssSupportsRule]); + _inherit(A._IsInvisibleVisitor, A.__IsInvisibleVisitor_Object_EveryCssVisitor); + _inherit(A.CssStylesheet, A.CssParentNode); + _inheritMany(A.Expression, [A.BinaryOperationExpression, A.BooleanExpression, A.ColorExpression, A.FunctionExpression, A.IfExpression, A.InterpolatedFunctionExpression, A.ListExpression, A.MapExpression, A.NullExpression, A.NumberExpression, A.ParenthesizedExpression, A.SelectorExpression, A.StringExpression, A.SupportsExpression, A.UnaryOperationExpression, A.ValueExpression, A.VariableExpression]); + _inheritMany(A.Statement, [A.ParentStatement, A.ContentRule, A.DebugRule, A.ErrorRule, A.ExtendRule, A.ForwardRule, A.IfRule, A.ImportRule, A.IncludeRule, A.LoudComment, A.ReturnRule, A.SilentComment, A.UseRule, A.VariableDeclaration, A.WarnRule]); + _inheritMany(A.ParentStatement, [A.AtRootRule, A.AtRule, A.CallableDeclaration, A.Declaration, A.EachRule, A.ForRule, A.MediaRule, A.StyleRule, A.Stylesheet, A.SupportsRule, A.WhileRule]); + _inheritMany(A.CallableDeclaration, [A.ContentBlock, A.FunctionRule, A.MixinRule]); + _inheritMany(A.IfRuleClause, [A.IfClause, A.ElseClause]); + _inherit(A._HasContentVisitor, A.__HasContentVisitor_Object_StatementSearchVisitor); + _inherit(A._IsInvisibleVisitor0, A.__IsInvisibleVisitor_Object_AnySelectorVisitor); + _inherit(A._IsBogusVisitor, A.__IsBogusVisitor_Object_AnySelectorVisitor); + _inherit(A._IsUselessVisitor, A.__IsUselessVisitor_Object_AnySelectorVisitor); + _inheritMany(A.Selector, [A.SimpleSelector, A.ComplexSelector, A.CompoundSelector, A.SelectorList]); + _inheritMany(A.SimpleSelector, [A.AttributeSelector, A.ClassSelector, A.IDSelector, A.ParentSelector, A.PlaceholderSelector, A.PseudoSelector, A.TypeSelector, A.UniversalSelector]); + _inherit(A._ParentSelectorVisitor, A.__ParentSelectorVisitor_Object_SelectorSearchVisitor); + _inherit(A.ExplicitConfiguration, A.Configuration); + _inheritMany(A.SourceSpanException, [A.SassException, A.SourceSpanFormatException, A.MultiSourceSpanException, A.SassException0]); + _inheritMany(A.SassException, [A.MultiSpanSassException, A.SassRuntimeException, A.SassFormatException]); + _inheritMany(A.MultiSpanSassException, [A.MultiSpanSassRuntimeException, A.MultiSpanSassFormatException]); + _inherit(A.MultiSpanSassScriptException, A.SassScriptException); + _inherit(A.MergedExtension, A.Extension); + _inherit(A.Importer, A.AsyncImporter); + _inheritMany(A.Importer, [A.FilesystemImporter, A.NoOpImporter, A.NodePackageImporter]); + _inheritMany(A.LoggerWithDeprecationType, [A.DeprecationProcessingLogger, A.StderrLogger]); + _inheritMany(A.Parser, [A.AtRootQueryParser, A.StylesheetParser, A.KeyframeSelectorParser, A.MediaQueryParser, A.SelectorParser]); + _inheritMany(A.StylesheetParser, [A.ScssParser, A.SassParser]); + _inherit(A.CssParser, A.ScssParser); + _inheritMany(A.UnmodifiableMapBase, [A.LimitedMapView, A.PrefixedMapView, A.PublicMemberMapView, A.UnprefixedMapView, A.LimitedMapView0, A.PrefixedMapView0, A.PublicMemberMapView0, A.UnprefixedMapView0]); + _inheritMany(A.Value, [A.SassList, A.SassBoolean, A.SassCalculation, A.SassColor, A.SassFunction, A.SassMap, A.SassMixin, A._SassNull, A.SassNumber, A.SassString]); + _inherit(A.SassArgumentList, A.SassList); + _inherit(A.LinearChannel, A.ColorChannel); + _inheritMany(A.GamutMapMethod, [A.ClipGamutMap, A.LocalMindeGamutMap]); + _inheritMany(A.ColorSpace, [A.A98RgbColorSpace, A.DisplayP3ColorSpace, A.HslColorSpace, A.HwbColorSpace, A.LabColorSpace, A.LchColorSpace, A.LmsColorSpace, A.OklabColorSpace, A.OklchColorSpace, A.ProphotoRgbColorSpace, A.Rec2020ColorSpace, A.RgbColorSpace, A.SrgbColorSpace, A.SrgbLinearColorSpace, A.XyzD50ColorSpace, A.XyzD65ColorSpace]); + _inheritMany(A.SassNumber, [A.ComplexSassNumber, A.SingleUnitSassNumber, A.UnitlessSassNumber]); + _inherit(A._MakeExpressionCalculationSafe, A.__MakeExpressionCalculationSafe_Object_ReplaceExpressionVisitor); + _inherit(A._FindDependenciesVisitor, A.__FindDependenciesVisitor_Object_RecursiveStatementVisitor); + _inherit(A.SingleMapping, A.Mapping); + _inherit(A.FileLocation, A.SourceLocationMixin); + _inheritMany(A.SourceSpanMixin, [A._FileSpan, A.SourceSpanBase]); + _inherit(A.MultiSourceSpanFormatException, A.MultiSourceSpanException); + _inherit(A.SourceSpanWithContext, A.SourceSpanBase); + _inherit(A.StringScannerException, A.SourceSpanFormatException); + _inheritMany(A.StringScanner, [A.LineScanner, A.SpanScanner]); + _inheritMany(A.ColorSpace0, [A.A98RgbColorSpace0, A.DisplayP3ColorSpace0, A.HslColorSpace0, A.HwbColorSpace0, A.LabColorSpace0, A.LchColorSpace0, A.LmsColorSpace0, A.OklabColorSpace0, A.OklchColorSpace0, A.ProphotoRgbColorSpace0, A.Rec2020ColorSpace0, A.RgbColorSpace0, A.SrgbColorSpace0, A.SrgbLinearColorSpace0, A.XyzD50ColorSpace0, A.XyzD65ColorSpace0]); + _inheritMany(A.Value0, [A.SassList0, A.SassBoolean0, A.SassCalculation0, A.SassColor0, A.SassNumber0, A.SassFunction0, A.SassMap0, A.SassMixin0, A._SassNull0, A.SassString0]); + _inherit(A.SassArgumentList0, A.SassList0); + _inheritMany(A.AsyncImporter0, [A.JSToDartAsyncImporter, A.JSToDartAsyncFileImporter, A.Importer0]); + _inheritMany(A.Parser1, [A.AtRootQueryParser0, A.StylesheetParser0, A.KeyframeSelectorParser0, A.MediaQueryParser0, A.SelectorParser0]); + _inheritMany(A.Statement0, [A.ParentStatement0, A.ContentRule0, A.DebugRule0, A.ErrorRule0, A.ExtendRule0, A.ForwardRule0, A.IfRule0, A.ImportRule0, A.IncludeRule0, A.LoudComment0, A.ReturnRule0, A.SilentComment0, A.UseRule0, A.VariableDeclaration0, A.WarnRule0]); + _inheritMany(A.ParentStatement0, [A.AtRootRule0, A.AtRule0, A.CallableDeclaration0, A.Declaration0, A.EachRule0, A.ForRule0, A.MediaRule0, A.StyleRule0, A.Stylesheet0, A.SupportsRule0, A.WhileRule0]); + _inheritMany(A.CssNode0, [A.ModifiableCssNode0, A.CssParentNode0]); + _inheritMany(A.ModifiableCssNode0, [A.ModifiableCssParentNode0, A.ModifiableCssComment0, A.ModifiableCssDeclaration0, A.ModifiableCssImport0]); + _inheritMany(A.ModifiableCssParentNode0, [A.ModifiableCssAtRule0, A.ModifiableCssKeyframeBlock0, A.ModifiableCssMediaRule0, A.ModifiableCssStyleRule0, A.ModifiableCssStylesheet0, A.ModifiableCssSupportsRule0]); + _inheritMany(A.Selector0, [A.SimpleSelector0, A.ComplexSelector0, A.CompoundSelector0, A.SelectorList0]); + _inheritMany(A.SimpleSelector0, [A.AttributeSelector0, A.ClassSelector0, A.IDSelector0, A.ParentSelector0, A.PlaceholderSelector0, A.PseudoSelector0, A.TypeSelector0, A.UniversalSelector0]); + _inheritMany(A.Expression0, [A.BinaryOperationExpression0, A.BooleanExpression0, A.ColorExpression0, A.FunctionExpression0, A.IfExpression0, A.InterpolatedFunctionExpression0, A.ListExpression0, A.MapExpression0, A.NullExpression0, A.NumberExpression0, A.ParenthesizedExpression0, A.SelectorExpression0, A.StringExpression0, A.SupportsExpression0, A.UnaryOperationExpression0, A.ValueExpression0, A.VariableExpression0]); + _inherit(A.LinearChannel0, A.ColorChannel0); + _inheritMany(A.GamutMapMethod0, [A.ClipGamutMap0, A.LocalMindeGamutMap0]); + _inherit(A._ConstructionOptions, A._Channels); + _inherit(A.CompileStringOptions, A.CompileOptions); + _inherit(A.AsyncCompiler, A.Compiler); + _inheritMany(A.SassNumber0, [A.ComplexSassNumber0, A.SingleUnitSassNumber0, A.UnitlessSassNumber0]); + _inherit(A.ExplicitConfiguration0, A.Configuration0); + _inheritMany(A.CallableDeclaration0, [A.ContentBlock0, A.FunctionRule0, A.MixinRule0]); + _inheritMany(A.StylesheetParser0, [A.ScssParser0, A.SassParser0]); + _inherit(A.CssParser0, A.ScssParser0); + _inheritMany(A.LoggerWithDeprecationType0, [A.DeprecationProcessingLogger0, A.JSToDartLogger, A.StderrLogger0]); + _inherit(A._NodeException, A.JsError); + _inheritMany(A.SassException0, [A.MultiSpanSassException0, A.SassRuntimeException0, A.SassFormatException0]); + _inheritMany(A.MultiSpanSassException0, [A.MultiSpanSassRuntimeException0, A.MultiSpanSassFormatException0]); + _inherit(A.MultiSpanSassScriptException0, A.SassScriptException0); + _inherit(A._MakeExpressionCalculationSafe0, A.__MakeExpressionCalculationSafe_Object_ReplaceExpressionVisitor0); + _inheritMany(A.Importer0, [A.JSToDartFileImporter, A.FilesystemImporter0, A.NoOpImporter0, A.NodePackageImporter0, A.JSToDartImporter]); + _inheritMany(A.IfRuleClause0, [A.IfClause0, A.ElseClause0]); + _inherit(A._ParentSelectorVisitor0, A.__ParentSelectorVisitor_Object_SelectorSearchVisitor0); + _inherit(A.MergedExtension0, A.Extension0); + _inherit(A._HasContentVisitor0, A.__HasContentVisitor_Object_StatementSearchVisitor0); + _inherit(A._IsInvisibleVisitor1, A.__IsInvisibleVisitor_Object_EveryCssVisitor0); + _inherit(A._IsInvisibleVisitor2, A.__IsInvisibleVisitor_Object_AnySelectorVisitor0); + _inherit(A._IsBogusVisitor0, A.__IsBogusVisitor_Object_AnySelectorVisitor0); + _inherit(A._IsUselessVisitor0, A.__IsUselessVisitor_Object_AnySelectorVisitor0); + _inherit(A.CssStylesheet0, A.CssParentNode0); + _mixin(A.UnmodifiableListBase, A.UnmodifiableListMixin); + _mixin(A.__CastListBase__CastIterableBase_ListMixin, A.ListBase); + _mixin(A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin, A.ListBase); + _mixin(A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin, A.FixedLengthListMixin); + _mixin(A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin, A.ListBase); + _mixin(A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin, A.FixedLengthListMixin); + _mixin(A._AsyncStreamController, A._AsyncStreamControllerDispatch); + _mixin(A._SyncStreamController, A._SyncStreamControllerDispatch); + _mixin(A.UnmodifiableMapBase, A._UnmodifiableMapMixin); + _mixin(A._UnmodifiableMapView_MapView__UnmodifiableMapMixin, A._UnmodifiableMapMixin); + _mixin(A._UnmodifiableSetView_SetBase__UnmodifiableSetMixin, A._UnmodifiableSetMixin); + _mixin(A._EmptyUnmodifiableSet_IterableBase_UnmodifiableSetMixin, A.UnmodifiableSetMixin); + _mixin(A._QueueList_Object_ListMixin, A.ListBase); + _mixin(A._UnionSet_SetBase_UnmodifiableSetMixin, A.UnmodifiableSetMixin); + _mixin(A._UnmodifiableSetView_DelegatingSet_UnmodifiableSetMixin, A.UnmodifiableSetMixin); + _mixin(A._MapKeySet__DelegatingIterableBase_UnmodifiableSetMixin, A.UnmodifiableSetMixin); + _mixin(A.__IsInvisibleVisitor_Object_EveryCssVisitor, A.EveryCssVisitor); + _mixin(A.__HasContentVisitor_Object_StatementSearchVisitor, A.StatementSearchVisitor); + _mixin(A.__IsBogusVisitor_Object_AnySelectorVisitor, A.AnySelectorVisitor); + _mixin(A.__IsInvisibleVisitor_Object_AnySelectorVisitor, A.AnySelectorVisitor); + _mixin(A.__IsUselessVisitor_Object_AnySelectorVisitor, A.AnySelectorVisitor); + _mixin(A.__ParentSelectorVisitor_Object_SelectorSearchVisitor, A.SelectorSearchVisitor); + _mixin(A.__MakeExpressionCalculationSafe_Object_ReplaceExpressionVisitor, A.ReplaceExpressionVisitor); + _mixin(A.__FindDependenciesVisitor_Object_RecursiveStatementVisitor, A.RecursiveStatementVisitor); + _mixin(A.__MakeExpressionCalculationSafe_Object_ReplaceExpressionVisitor0, A.ReplaceExpressionVisitor0); + _mixin(A.__ParentSelectorVisitor_Object_SelectorSearchVisitor0, A.SelectorSearchVisitor0); + _mixin(A.__HasContentVisitor_Object_StatementSearchVisitor0, A.StatementSearchVisitor0); + _mixin(A.__IsInvisibleVisitor_Object_EveryCssVisitor0, A.EveryCssVisitor0); + _mixin(A.__IsBogusVisitor_Object_AnySelectorVisitor0, A.AnySelectorVisitor0); + _mixin(A.__IsInvisibleVisitor_Object_AnySelectorVisitor0, A.AnySelectorVisitor0); + _mixin(A.__IsUselessVisitor_Object_AnySelectorVisitor0, A.AnySelectorVisitor0); + })(); + var init = { + typeUniverse: {eC: new Map(), tR: {}, eT: {}, tPV: {}, sEA: []}, + mangledGlobalNames: {int: "int", double: "double", num: "num", String: "String", bool: "bool", Null: "Null", List: "List", Object: "Object", Map: "Map"}, + mangledNames: {}, + types: ["~()", "Null()", "Future()", "Value0(List)", "Value(List)", "bool(String)", "String(String)", "bool(CssNode0)", "bool(CssNode)", "bool(Object?)", "int()", "SassBoolean0(List)", "SassBoolean(List)", "bool(SimpleSelector)", "bool(SimpleSelector0)", "JSClass0()", "double(double)", "SassString(List)", "SassString0(List)", "bool()", "bool(ComplexSelector)", "bool(ComplexSelector0)", "SassNumber0(List)", "SassColor0(List)", "SassNumber(List)", "SassColor(List)", "String()", "SassList(List)", "SassList0(List)", "FileSpan()", "bool(int?)", "double(SassColor0)", "Future<~>()", "Value()", "~(Object?)", "Null(~())", "Object?()", "SassMap0(List)", "SassMap(List)", "int(SassColor0)", "Future(Future<~>())", "Value?()", "Value(Value)", "Value0(Value0)", "Value0?()", "bool(num,num)", "Null(Object,StackTrace)", "String?()", "bool(int)", "Value0()", "Uri(Uri)", "double(SassColor)", "SassNumber(SassNumber)", "bool(ComplexSelectorComponent)", "bool(Value0)", "Null(@)", "SassNumber0(SassNumber0)", "bool(ComplexSelectorComponent0)", "ComplexSelector0(ComplexSelector0)", "@()", "ComplexSelector(ComplexSelector)", "double(double,double)", "~(Value)", "int(SassColor)", "ValueExpression(Value)", "ValueExpression0(Value0)", "~(Value0)", "Future()", "Future()", "Frame()", "bool(ColorChannel0)", "~(@)", "bool(Value)", "bool(SelectorList)", "Future()", "~(Object,StackTrace)", "bool(SelectorList0)", "bool(Object)", "Future()", "Object(Object)", "int(Uri)", "Callable0?()", "~(Module0,bool)", "Value?(Statement)", "Object()", "SassRuntimeException(AstNode)", "Future(List)", "Null(_NodeSassColor,num)", "Future(Statement0)", "double(SassNumber0)", "@(@)", "Null([Object?])", "Frame(String)", "Future(Statement)", "Value0?(Statement0)", "~(Object)", "List?(List)", "AsyncCallable0?()", "~(Value0,Value0)", "SassRuntimeException0(AstNode0)", "AsyncCallable?()", "~(Value,Value)", "~(Module1,bool)", "Callable?()", "List?(List)", "~(String[Deprecation?])", "~([int?])", "~(String,Value)", "bool(ColorChannel)", "~(String,Value0)", "~(String[Deprecation0?])", "~(String)", "Stylesheet?()", "String(Expression0)", "Null(Module1,bool)", "SassCalculation0(Object)", "bool(Module1)", "bool(_Highlight)", "bool(Expression)", "Null(Module0,bool)", "String(String{color:Object?})", "Statement()", "Uri(String)", "+originalUrl(Importer,Uri,Uri)?()", "int(_NodeSassColor)", "double(SassNumber)", "~(String,Object?)", "bool(Module1)", "Map()", "bool(Module0)", "bool(Module0)", "Map()", "String(Object)", "String(Expression)", "String(@)", "~(String,Function)", "Statement0()", "~(~())", "List()", "~(String,@)", "bool(Expression0)", "List()", "AstNode?()", "SelectorList(SelectorList,SelectorList)", "Uri?()", "~(Object[StackTrace?])", "int(String,String)", "String?(String?)", "String?(Object)", "String(String[String?])", "bool(Statement)", "bool(Import)", "Iterable()", "Iterable(String)", "Iterable(@)", "DateTime()", "~(String[~])", "int(int)", "0&(String,FileSpan[StackTrace?])", "Set<0^>()", "AtRootRule(List,FileSpan)", "AtRule(List,FileSpan)", "~(@,@)", "String(String{color:@})", "Entry(Entry)", "double(double,String)", "AstNode(AstNode)", "SassFunction(List)", "SassMixin(List)", "Future<~>(List)", "~(Object?,Object?)", "int(ComplexSelector)", "bool(ModifiableCssParentNode)", "AsyncCallable?(Module0)", "~(int)", "MapKeySet>(Map,AstNode>)", "Future()", "List()", "bool(UseRule)", "bool(ForwardRule)", "Map(Module0)", "Future()", "Uri?/()", "Future()", "InterpolationMap(List)", "Trace(String)", "String(SassNumber)", "Future(List)", "~(List)", "SassNumber()", "Expression(Expression)", "~(double?[String?])", "int(Frame)", "String(Frame)", "Callable0?(Module0)", "Trace()", "bool(Frame)", "MapKeySet>(Map,AstNode>)", "Map(Module0)", "@(String)", "AsyncCallable0?(Module1)", "MapKeySet>(Map,AstNode0>)", "Map(Module1)", "AstNode0(AstNode0)", "SelectorList(Value)", "SassFunction0(List)", "SassMixin0(List)", "Future<~>(List)", "~(Iterable)", "List()", "bool(ModifiableCssParentNode0)", "bool(Queue>)", "List()", "Future()", "List()", "bool(UseRule0)", "bool(ForwardRule0)", "~([Object?])", "InterpolationMap0(List)", "AstNode0?()", "String(SassNumber0)", "0&(Object[Object?])", "0&(@[@])", "Object(CalculationOperation0)", "Future<~>?()", "String(Value0)", "double(Value0)", "int(Object?)", "ImmutableList0(SassColor0)", "String(double)", "Future()", "AsyncImporter0(Object?)", "Set<0&>(Object)", "Version(String)", "~(Iterable)", "Callable?(Module1)", "MapKeySet>(Map,AstNode0>)", "Map(Module1)", "double()", "~(List)", "Value0?(Value0)", "SassNumber0()", "String(_NodeException)", "double(Value)", "List()", "bool(Queue>)", "bool(Statement0)", "bool(Import0)", "Value0?(Value0,num)", "Value0(int)", "Object(_NodeSassMap,int)", "Null(_NodeSassMap,int,Object)", "bool(SassNumber0)", "ImmutableList0(SassNumber0)", "bool(SassNumber0,String)", "SassNumber0(SassNumber0,Object,Object[String?])", "SassNumber0(SassNumber0,SassNumber0[String?,String?])", "double(SassNumber0,Object,Object[String?])", "double(SassNumber0,SassNumber0[String?,String?])", "int(ComplexSelector0)", "Expression0(Expression0)", "SelectorList0(Value0)", "SelectorList0(SelectorList0,SelectorList0)", "FileLocation(FileSpan)", "JSUrl0(Uri)", "String(FileSpan)", "int(SourceLocation)", "AtRootRule0(List,FileSpan)", "AtRule0(List,FileSpan)", "int(@,@)", "bool(Object?,Object?)", "bool(String?)", "~(+deprecation,message,span(Deprecation?,String,FileSpan))", "~(List)", "Declaration(List,FileSpan)", "Value?(Module0)", "~(CssMediaQuery)", "Set(CssParentNode)", "Uri(+originalUrl(Importer,Uri,Uri))", "~(SelectorList)", "~(MapEntry)", "SourceFile()", "SourceFile?(int)", "String?(SourceFile?)", "int(_Line)", "Module0?(Module0)", "Object(_Line)", "Object(_Highlight)", "int(_Highlight,_Highlight)", "List<_Line>(MapEntry>)", "SourceSpanWithContext()", "List(Trace)", "int(Trace)", "EachRule(List,FileSpan)", "String(Trace)", "FunctionRule(List,FileSpan)", "ForRule(List,FileSpan)", "Frame(String,String)", "ContentBlock(List,FileSpan)", "MediaRule(List,FileSpan)", "Frame(Frame)", "MixinRule(List,FileSpan)", "Map(Module0)", "Map(Module0)", "~([Future<~>?])", "SassArgumentList0(Object,Object,Object[String?])", "ImmutableMap0(SassArgumentList0)", "SupportsRule(List,FileSpan)", "ArgParser()", "Value0/(List)", "Value0?(Module1)", "Module1?(Module1)", "WhileRule(List,FileSpan)", "~(Expression)", "Map(Module1)", "Map(Module1)", "~(BinaryOperator)", "Set()", "Future>(Interpolation0{trim:bool,warnForColor:bool})", "StringExpression(Interpolation)", "DateTime(StylesheetNode)", "Future<~>(String)", "Future<@>()", "List(List)", "SassString(String)", "bool(ModifiableCssNode)", "SassScriptException()", "~(Module1,bool)", "Future<+loadedUrls,stylesheet(Set,CssStylesheet0)>()", "Future>()", "bool(Extension)", "~(Module1)", "SassList(ComplexSelector)", "SassString(SimpleSelector)", "Set>()", "Object?(Object?)", "Future(Value0)", "SingleUnitSassNumber(double)", "Future>(Interpolation0)", "Future>(Interpolation{trim:bool,warnForColor:bool})", "~(Object?,List)", "Iterable(List)", "String(Parameter)", "Future(IfRuleClause0)", "Iterable(ComplexSelector)", "~(@,StackTrace)", "UserDefinedCallable0(ContentBlock0)", "List(Extender)", "List?(SimpleSelector)", "List(PseudoSelector)", "List>(List)", "List(ComplexSelector)", "Future(Expression0)", "PseudoSelector(ComplexSelector)", "~(SimpleSelector,Set>)", "Value0/()", "List?(List,List)", "Null(JSObject?,JSArray)", "bool(List>)", "int(int,ComplexSelectorComponent)", "~(Module0,bool)", "Future<+loadedUrls,stylesheet(Set,CssStylesheet)>()", "Future<+originalUrl(AsyncImporter0,Uri,Uri)?>()", "Future()", "bool(+originalUrl(AsyncImporter0,Uri,Uri))", "Uri(+originalUrl(AsyncImporter0,Uri,Uri))", "AtRootQuery0()", "Future>()", "SimpleSelector(SimpleSelector)", "bool(PseudoSelector)", "SelectorList?(PseudoSelector)", "SassCalculation0(Object[Object?,Object?])", "SassCalculation0(SassCalculation0[String?])", "ImmutableList(SassCalculation0)", "Object(Object,String,Object,Object)", "bool(CalculationOperator0)", "bool(CalculationOperation0,Object)", "int(CalculationOperation0)", "String(CalculationOperation0)", "~(int,@)", "CalculationInterpolation(Object,String)", "bool(CalculationInterpolation,Object)", "int(CalculationInterpolation)", "String(CalculationInterpolation)", "bool(CanonicalizeContext0)", "JSUrl0?(CanonicalizeContext0)", "~(String,Option)", "@(@,String)", "Null(@,@)", "~(Module0)", "Null(@,StackTrace)", "Null(Function,Function)", "String(String?)", "SassColor0(SassColor0)", "SassColor0(ColorSpace0)", "String(int,IfClause)", "0&(List)", "Value?(Module0)", "AtRootQuery()", "SassColor0(Object,_ConstructionOptions)", "bool(SassColor0,Object)", "SassColor0(SassColor0,String)", "bool(SassColor0[String?])", "SassColor0(SassColor0,_ToGamutOptions)", "double(SassColor0,String[_ChannelOptions?])", "bool(SassColor0,String)", "bool(SassColor0,String[_ChannelOptions?])", "SassColor0(SassColor0,_ConstructionOptions)", "double?(String)", "SassColor0(SassColor0,SassColor0[_InterpolationOptions?])", "String(SassColor0)", "bool(SassColor0)", "Module0?(Module0)", "Null(_NodeSassColor,num?[num?,num?,num?,SassColor0?])", "double(num)", "SassColor(SassColor)", "double(_NodeSassColor)", "String(BuiltInCallable)", "List()", "SassString(int)", "AsyncImporter0(JSImporter)", "0&(@)", "SassColor(ColorSpace)", "NodePackageImporter0(Object[String?])", "Future>(Interpolation)", "NodeCompileResult(Compiler,String[CompileOptions?])", "NodeCompileResult(Compiler,String[CompileStringOptions?])", "Null(Compiler)", "Promise(AsyncCompiler,String[CompileOptions?])", "Promise(AsyncCompiler,String[CompileStringOptions?])", "Promise(AsyncCompiler)", "Future()", "int(int,ComplexSelectorComponent0)", "String(CssValue0)", "int(int,SimpleSelector0)", "String(BuiltInCallable0)", "bool(Deprecation0)", "Iterable()", "Version(Object,int,int,int)", "Map(Module0)", "String(CssValue)", "Value0?(Module1)", "Module1?(Module1)", "Map(Module0)", "int(int,SimpleSelector)", "Map(Module1)", "Map(Module1)", "Future(IfRuleClause)", "SelectorList()", "Object(Value0)", "bool(String?,String?)", "CompoundSelector()", "String(Value)", "+loadedUrls,stylesheet(Set,CssStylesheet0)()", "Module1()", "~(Module1)", "UserDefinedCallable(ContentBlock)", "0&(List)", "CssValue0(Interpolation0)", "Statement({root:bool})", "Value0?(IfRuleClause0)", "UserDefinedCallable0(ContentBlock0)", "Value0(Expression0)", "bool(+originalUrl(Importer,Uri,Uri))", "FileSpan(_NodeException)", "bool(Extension0)", "Set>()", "~(Symbol0,@)", "Future<+originalUrl(AsyncImporter,Uri,Uri)?>()", "Iterable(List)", "int(String?)", "List(Extender0)", "List?(SimpleSelector0)", "List(PseudoSelector0)", "List>(List)", "List(ComplexSelector0)", "PseudoSelector0(ComplexSelector0)", "~(SimpleSelector0,Set>)", "SassFunction0(Object,String,Value0(List))", "List?(List,List)", "Expression({bracketList:bool,consumeNewlines:bool,singleEquals:bool,until:bool()?})", "bool(List>)", "bool(@)", "bool(PseudoSelector0)", "SelectorList0?(PseudoSelector0)", "String(int,IfClause0)", "Future(Expression)", "Future()", "~(Object?,Object,Object?)", "+(String,String)(String)", "+originalUrl(Importer0,Uri,Uri)?()", "Stylesheet0?()", "bool(+originalUrl(Importer0,Uri,Uri))", "Uri(+originalUrl(Importer0,Uri,Uri))", "~(String,WarnOptions)", "~(String,DebugOptions)", "Future<~>(List)", "JSFunction0(JSFunction0)", "Object?(Object,String,String[Object?])", "Null(Object)", "List(Value)", "List(Value0)", "bool(List)", "SassList0(ComplexSelector0)", "Iterable(ComplexSelector0)", "SimpleSelector0(SimpleSelector0)", "SassList0(Object[Object?,_ConstructorOptions?])", "bool(+originalUrl(AsyncImporter,Uri,Uri))", "Null(_NodeSassList,int?[bool?,SassList0?])", "Uri(+originalUrl(AsyncImporter,Uri,Uri))", "Object(_NodeSassList,int)", "Null(_NodeSassList,int,Object)", "bool(_NodeSassList)", "Null(_NodeSassList,bool)", "int(_NodeSassList)", "SassMap0(Value0)", "SassMap0(SassMap0)", "SassMap0(Object[ImmutableMap0?])", "ImmutableMap0(SassMap0)", "Value0?(SassMap0,Object)", "Null(_NodeSassMap,int?[SassMap0?])", "SassNumber0(int)", "NumberExpression()", "int(_NodeSassMap)", "Value/()", "SassNumber0(Value0)", "List()", "Value0(Object)", "0&(Object)", "bool(ModifiableCssNode0)", "SassNumber0(Object,num[Object?])", "~(String,int)", "int?(SassNumber0)", "~(String,int?)", "int(SassNumber0[String?])", "double(SassNumber0,num,num[String?])", "SassNumber0(SassNumber0[String?])", "SassNumber0(SassNumber0,String[String?])", "Stylesheet()", "Statement?()", "ParameterList()", "CssValue(Interpolation{trim:bool,warnForColor:bool})", "VariableDeclaration()", "Null(_NodeSassNumber,num?[String?,SassNumber0?])", "double(_NodeSassNumber)", "Null(_NodeSassNumber,num)", "String(_NodeSassNumber)", "Null(_NodeSassNumber,String)", "SassScriptException0()", "String(Parameter0)", "JSExpressionVisitor(JSExpressionVisitorObject)", "JSStatementVisitor(JSStatementVisitorObject)", "JSSet(Set)", "String(SourceFile,int[int?])", "List(SourceFile)", "String?(Interpolation0)", "Object?(Statement0,StatementVisitor)", "Object?(Expression0,ExpressionVisitor)", "ArgumentList0(IncludeRule0)", "ArgumentList0(ContentRule0)", "ArgumentList0(FunctionExpression0)", "ArgumentList0(IfExpression0)", "ArgumentList0(InterpolatedFunctionExpression0)", "FileSpan(SassNode)", "Interpolation0(SupportsCondition)", "UseRule()", "String(Object,@,@[@])", "bool(List)", "Value/(List)", "+loadedUrls,stylesheet(Set,CssStylesheet)()", "Module0()", "SassString0(SimpleSelector0)", "SelectorList0()", "CompoundSelector0()", "~(CssMediaQuery0)", "Set(CssParentNode0)", "~(SelectorList0)", "~(MapEntry)", "SingleUnitSassNumber0(double)", "~(Module0)", "JSUrl0?(FileSpan)", "Value?(Value)", "int(int,int)", "CssValue(Interpolation)", "SassString0(int)", "SassString0(String)", "Null(RenderResult)", "SassString0(Object[Object?,_ConstructorOptions1?])", "String(SassString0)", "bool(SassString0)", "int(SassString0)", "int(SassString0,Value0[String?])", "Null(_NodeSassString,String?[SassString0?])", "String(_NodeSassString)", "Null(_NodeSassString,String)", "Statement0({root:bool})", "Object(String)", "NumberExpression0()", "Stylesheet0()", "Statement0?()", "ParameterList0()", "+(String,ParameterList0)()", "StyleRule0(List,FileSpan)", "Declaration0(List,FileSpan)", "StyleRule(List,FileSpan)", "EachRule0(List,FileSpan)", "FunctionRule0(List,FileSpan)", "ForRule0(List,FileSpan)", "ContentBlock0(List,FileSpan)", "MediaRule0(List,FileSpan)", "MixinRule0(List,FileSpan)", "Value?(IfRuleClause)", "SupportsRule0(List,FileSpan)", "WhileRule0(List,FileSpan)", "~(Expression0)", "~(BinaryOperator0)", "StringExpression0(Interpolation0)", "Null(~(Object?),~(Object?))", "ImmutableList0(Value0)", "String?(Value0)", "int(Value0,Value0[String?])", "SassBoolean0(Value0[String?])", "SassCalculation0(Value0[String?])", "SassColor0(Value0[String?])", "SassFunction0(Value0[String?])", "SassMap0(Value0[String?])", "SassMixin0(Value0[String?])", "SassNumber0(Value0[String?])", "SassString0(Value0[String?])", "SassMap0?(Value0)", "bool(Value0,Object?)", "int(Value0[Object?])", "UserDefinedCallable(ContentBlock)", "bool(Version)", "~(Zone?,ZoneDelegate?,Zone,Object,StackTrace)", "0^(Zone?,ZoneDelegate?,Zone,0^())", "0^(Zone?,ZoneDelegate?,Zone,0^(1^),1^)", "0^(Zone?,ZoneDelegate?,Zone,0^(1^,2^),1^,2^)", "0^()(Zone,ZoneDelegate,Zone,0^())", "0^(1^)(Zone,ZoneDelegate,Zone,0^(1^))", "0^(1^,2^)(Zone,ZoneDelegate,Zone,0^(1^,2^))", "AsyncError?(Zone,ZoneDelegate,Zone,Object,StackTrace?)", "~(Zone?,ZoneDelegate?,Zone,~())", "Timer(Zone,ZoneDelegate,Zone,Duration,~())", "Timer(Zone,ZoneDelegate,Zone,Duration,~(Timer))", "~(Zone,ZoneDelegate,Zone,String)", "Zone(Zone?,ZoneDelegate?,Zone,ZoneSpecification?,Map?)", "Value(Expression)", "bool(Deprecation)", "0^(0^,0^)", "SassMap(Value)", "~(ContentBlock)", "~(Object,StackTrace,EventSink<0^>)", "List<0^>(0^,List<0^>?)", "NodeCompileResult(String[CompileOptions?])", "NodeCompileResult(String[CompileStringOptions?])", "Promise(String[CompileOptions?])", "Promise(String[CompileStringOptions?])", "Importer0(Object?)", "Compiler()", "Promise()", "List(Object?)", "~(RenderOptions,~(Object?,RenderResult?))", "RenderResult(RenderOptions)", "ParserExports()", "Stylesheet0(String,String,String?)", "String?(String)", "Uri(JSUrl0)", "Object(Map)", "String(String[String?,String?,String?,String?,String?,String?,String?,String?,String?,String?,String?,String?,String?,String?])", "String(Object?)", "SassMap(SassMap)", "SassNumber(Value)", "Value(Object)", "Future(Value)", "CssValue0(Interpolation0{trim:bool,warnForColor:bool})"], + interceptorsByTag: null, + leafTags: null, + arrayRti: Symbol("$ti"), + rttc: { + "1;": t1 => o => o instanceof A._Record_1 && t1._is(o._0), + "2;": (t1, t2) => o => o instanceof A._Record_2 && t1._is(o._0) && t2._is(o._1), + "2;forImport": (t1, t2) => o => o instanceof A._Record_2_forImport && t1._is(o._0) && t2._is(o._1), + "2;sourceMap": (t1, t2) => o => o instanceof A._Record_2_sourceMap && t1._is(o._0) && t2._is(o._1), + "2;imports,modules": (t1, t2) => o => o instanceof A._Record_2_imports_modules && t1._is(o._0) && t2._is(o._1), + "2;loadedUrls,stylesheet": (t1, t2) => o => o instanceof A._Record_2_loadedUrls_stylesheet && t1._is(o._0) && t2._is(o._1), + "3;": (t1, t2, t3) => o => o instanceof A._Record_3 && t1._is(o._0) && t2._is(o._1) && t3._is(o._2), + "3;forImport": (t1, t2, t3) => o => o instanceof A._Record_3_forImport && t1._is(o._0) && t2._is(o._1) && t3._is(o._2), + "3;originalUrl": (t1, t2, t3) => o => o instanceof A._Record_3_originalUrl && t1._is(o._0) && t2._is(o._1) && t3._is(o._2), + "3;importer,isDependency": (t1, t2, t3) => o => o instanceof A._Record_3_importer_isDependency && t1._is(o._0) && t2._is(o._1) && t3._is(o._2), + "3;deprecation,message,span": (t1, t2, t3) => o => o instanceof A._Record_3_deprecation_message_span && t1._is(o._0) && t2._is(o._1) && t3._is(o._2), + "5;named,namedNodes,positional,positionalNodes,separator": types => o => o instanceof A._Record_5_named_namedNodes_positional_positionalNodes_separator && A.pairwiseIsTest(types, o._values) + } + }; + A._Universe_addRules(init.typeUniverse, JSON.parse('{"PlainJavaScriptObject":"LegacyJavaScriptObject","UnknownJavaScriptObject":"LegacyJavaScriptObject","JavaScriptFunction":"LegacyJavaScriptObject","Stdin":"LegacyJavaScriptObject","Stdout":"LegacyJavaScriptObject","ReadlineModule":"LegacyJavaScriptObject","ReadlineOptions":"LegacyJavaScriptObject","ReadlineInterface":"LegacyJavaScriptObject","BufferModule":"LegacyJavaScriptObject","BufferConstants":"LegacyJavaScriptObject","Buffer":"LegacyJavaScriptObject","ConsoleModule":"LegacyJavaScriptObject","Console":"LegacyJavaScriptObject","EventEmitter":"LegacyJavaScriptObject","FS":"LegacyJavaScriptObject","FSConstants":"LegacyJavaScriptObject","Realpath":"LegacyJavaScriptObject","RealpathSync":"LegacyJavaScriptObject","FSWatcher":"LegacyJavaScriptObject","ReadStream":"LegacyJavaScriptObject","ReadStreamOptions":"LegacyJavaScriptObject","WriteStream":"LegacyJavaScriptObject","WriteStreamOptions":"LegacyJavaScriptObject","FileOptions":"LegacyJavaScriptObject","StatOptions":"LegacyJavaScriptObject","MkdirOptions":"LegacyJavaScriptObject","RmdirOptions":"LegacyJavaScriptObject","WatchOptions":"LegacyJavaScriptObject","WatchFileOptions":"LegacyJavaScriptObject","Stats":"LegacyJavaScriptObject","Promise":"LegacyJavaScriptObject","Date":"LegacyJavaScriptObject","JsError":"LegacyJavaScriptObject","Atomics":"LegacyJavaScriptObject","Modules":"LegacyJavaScriptObject","Module":"LegacyJavaScriptObject","Net":"LegacyJavaScriptObject","Socket":"LegacyJavaScriptObject","NetAddress":"LegacyJavaScriptObject","NetServer":"LegacyJavaScriptObject","NodeJsError":"LegacyJavaScriptObject","JsAssertionError":"LegacyJavaScriptObject","JsRangeError":"LegacyJavaScriptObject","JsReferenceError":"LegacyJavaScriptObject","JsSyntaxError":"LegacyJavaScriptObject","JsTypeError":"LegacyJavaScriptObject","JsSystemError":"LegacyJavaScriptObject","Process":"LegacyJavaScriptObject","CPUUsage":"LegacyJavaScriptObject","Release":"LegacyJavaScriptObject","StreamModule":"LegacyJavaScriptObject","Readable":"LegacyJavaScriptObject","Writable":"LegacyJavaScriptObject","Duplex":"LegacyJavaScriptObject","Transform":"LegacyJavaScriptObject","WritableOptions":"LegacyJavaScriptObject","ReadableOptions":"LegacyJavaScriptObject","Immediate":"LegacyJavaScriptObject","Timeout":"LegacyJavaScriptObject","TTY":"LegacyJavaScriptObject","TTYReadStream":"LegacyJavaScriptObject","TTYWriteStream":"LegacyJavaScriptObject","Util":"LegacyJavaScriptObject","JSArray0":"LegacyJavaScriptObject","Chokidar":"LegacyJavaScriptObject","ChokidarOptions":"LegacyJavaScriptObject","ChokidarWatcher":"LegacyJavaScriptObject","JSFunction":"LegacyJavaScriptObject","ImmutableList":"LegacyJavaScriptObject","ImmutableMap":"LegacyJavaScriptObject","NodeImporterResult":"LegacyJavaScriptObject","RenderContext":"LegacyJavaScriptObject","RenderContextOptions":"LegacyJavaScriptObject","RenderContextResult":"LegacyJavaScriptObject","RenderContextResultStats":"LegacyJavaScriptObject","JSModule":"LegacyJavaScriptObject","JSModuleRequire":"LegacyJavaScriptObject","JSClass":"LegacyJavaScriptObject","JSUrl":"LegacyJavaScriptObject","_PropertyDescriptor":"LegacyJavaScriptObject","_RequireMain":"LegacyJavaScriptObject","JSArray1":"LegacyJavaScriptObject","Chokidar0":"LegacyJavaScriptObject","ChokidarOptions0":"LegacyJavaScriptObject","ChokidarWatcher0":"LegacyJavaScriptObject","_ConstructionOptions":"LegacyJavaScriptObject","_ChannelOptions":"LegacyJavaScriptObject","_ToGamutOptions":"LegacyJavaScriptObject","_InterpolationOptions":"LegacyJavaScriptObject","_Channels":"LegacyJavaScriptObject","_NodeSassColor":"LegacyJavaScriptObject","CompileOptions":"LegacyJavaScriptObject","CompileStringOptions":"LegacyJavaScriptObject","NodeCompileResult":"LegacyJavaScriptObject","Deprecation1":"LegacyJavaScriptObject","_NodeException":"LegacyJavaScriptObject","Exports":"LegacyJavaScriptObject","LoggerNamespace":"LegacyJavaScriptObject","JSExpressionVisitorObject":"LegacyJavaScriptObject","Fiber":"LegacyJavaScriptObject","FiberClass":"LegacyJavaScriptObject","JSFunction0":"LegacyJavaScriptObject","ImmutableList0":"LegacyJavaScriptObject","ImmutableMap0":"LegacyJavaScriptObject","JSImporter":"LegacyJavaScriptObject","JSImporterResult":"LegacyJavaScriptObject","NodeImporterResult0":"LegacyJavaScriptObject","_ConstructorOptions":"LegacyJavaScriptObject","_NodeSassList":"LegacyJavaScriptObject","WarnOptions":"LegacyJavaScriptObject","DebugOptions":"LegacyJavaScriptObject","JSLogger":"LegacyJavaScriptObject","_NodeSassMap":"LegacyJavaScriptObject","JSModule0":"LegacyJavaScriptObject","JSModuleRequire0":"LegacyJavaScriptObject","_ConstructorOptions0":"LegacyJavaScriptObject","_NodeSassNumber":"LegacyJavaScriptObject","ParserExports":"LegacyJavaScriptObject","JSClass0":"LegacyJavaScriptObject","RenderContext0":"LegacyJavaScriptObject","RenderContextOptions0":"LegacyJavaScriptObject","RenderContextResult0":"LegacyJavaScriptObject","RenderContextResultStats0":"LegacyJavaScriptObject","RenderOptions":"LegacyJavaScriptObject","RenderResult":"LegacyJavaScriptObject","RenderResultStats":"LegacyJavaScriptObject","_Exports":"LegacyJavaScriptObject","JSSet":"LegacyJavaScriptObject","JSStatementVisitorObject":"LegacyJavaScriptObject","_ConstructorOptions1":"LegacyJavaScriptObject","_NodeSassString":"LegacyJavaScriptObject","Types":"LegacyJavaScriptObject","JSUrl0":"LegacyJavaScriptObject","_PropertyDescriptor0":"LegacyJavaScriptObject","_RequireMain0":"LegacyJavaScriptObject","JSArray":{"List":["1"],"EfficientLengthIterable":["1"],"JSObject":[],"Iterable":["1"]},"JSBool":{"bool":[],"TrustedGetRuntimeType":[]},"JSNull":{"Null":[],"TrustedGetRuntimeType":[]},"JavaScriptObject":{"JSObject":[]},"LegacyJavaScriptObject":{"JSObject":[],"Promise":[],"JsSystemError":[],"ImmutableList":[],"_ConstructionOptions":[],"_ChannelOptions":[],"_ToGamutOptions":[],"_InterpolationOptions":[],"_NodeSassColor":[],"CompileOptions":[],"CompileStringOptions":[],"NodeCompileResult":[],"Deprecation1":[],"_NodeException":[],"JSExpressionVisitorObject":[],"Fiber":[],"JSFunction0":[],"ImmutableList0":[],"ImmutableMap0":[],"JSImporter":[],"JSImporterResult":[],"NodeImporterResult0":[],"_ConstructorOptions":[],"_NodeSassList":[],"WarnOptions":[],"DebugOptions":[],"_NodeSassMap":[],"_ConstructorOptions0":[],"_NodeSassNumber":[],"ParserExports":[],"JSClass0":[],"RenderContextOptions0":[],"RenderOptions":[],"RenderResult":[],"JSSet":[],"JSStatementVisitorObject":[],"_ConstructorOptions1":[],"_NodeSassString":[],"JSUrl0":[]},"JSUnmodifiableArray":{"JSArray":["1"],"List":["1"],"EfficientLengthIterable":["1"],"JSObject":[],"Iterable":["1"]},"JSNumber":{"double":[],"num":[],"Comparable":["num"]},"JSInt":{"double":[],"int":[],"num":[],"Comparable":["num"],"TrustedGetRuntimeType":[]},"JSNumNotInt":{"double":[],"num":[],"Comparable":["num"],"TrustedGetRuntimeType":[]},"JSString":{"String":[],"Comparable":["String"],"TrustedGetRuntimeType":[]},"_CastIterableBase":{"Iterable":["2"]},"CastIterable":{"_CastIterableBase":["1","2"],"Iterable":["2"],"Iterable.E":"2"},"_EfficientLengthCastIterable":{"CastIterable":["1","2"],"_CastIterableBase":["1","2"],"EfficientLengthIterable":["2"],"Iterable":["2"],"Iterable.E":"2"},"_CastListBase":{"ListBase":["2"],"List":["2"],"_CastIterableBase":["1","2"],"EfficientLengthIterable":["2"],"Iterable":["2"]},"CastList":{"_CastListBase":["1","2"],"ListBase":["2"],"List":["2"],"_CastIterableBase":["1","2"],"EfficientLengthIterable":["2"],"Iterable":["2"],"ListBase.E":"2","Iterable.E":"2"},"CastSet":{"Set":["2"],"_CastIterableBase":["1","2"],"EfficientLengthIterable":["2"],"Iterable":["2"],"Iterable.E":"2"},"CastMap":{"MapBase":["3","4"],"Map":["3","4"],"MapBase.V":"4","MapBase.K":"3"},"LateError":{"Error":[]},"CodeUnits":{"ListBase":["int"],"List":["int"],"EfficientLengthIterable":["int"],"Iterable":["int"],"ListBase.E":"int"},"EfficientLengthIterable":{"Iterable":["1"]},"ListIterable":{"EfficientLengthIterable":["1"],"Iterable":["1"]},"SubListIterable":{"ListIterable":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"],"ListIterable.E":"1","Iterable.E":"1"},"MappedIterable":{"Iterable":["2"],"Iterable.E":"2"},"EfficientLengthMappedIterable":{"MappedIterable":["1","2"],"EfficientLengthIterable":["2"],"Iterable":["2"],"Iterable.E":"2"},"MappedListIterable":{"ListIterable":["2"],"EfficientLengthIterable":["2"],"Iterable":["2"],"ListIterable.E":"2","Iterable.E":"2"},"WhereIterable":{"Iterable":["1"],"Iterable.E":"1"},"ExpandIterable":{"Iterable":["2"],"Iterable.E":"2"},"TakeIterable":{"Iterable":["1"],"Iterable.E":"1"},"EfficientLengthTakeIterable":{"TakeIterable":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"],"Iterable.E":"1"},"SkipIterable":{"Iterable":["1"],"Iterable.E":"1"},"EfficientLengthSkipIterable":{"SkipIterable":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"],"Iterable.E":"1"},"SkipWhileIterable":{"Iterable":["1"],"Iterable.E":"1"},"EmptyIterable":{"EfficientLengthIterable":["1"],"Iterable":["1"],"Iterable.E":"1"},"FollowedByIterable":{"Iterable":["1"],"Iterable.E":"1"},"EfficientLengthFollowedByIterable":{"FollowedByIterable":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"],"Iterable.E":"1"},"WhereTypeIterable":{"Iterable":["1"],"Iterable.E":"1"},"NonNullsIterable":{"Iterable":["1"],"Iterable.E":"1"},"UnmodifiableListBase":{"ListBase":["1"],"List":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"]},"ReversedListIterable":{"ListIterable":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"],"ListIterable.E":"1","Iterable.E":"1"},"Symbol":{"Symbol0":[]},"ConstantMapView":{"UnmodifiableMapView":["1","2"],"Map":["1","2"]},"ConstantMap":{"Map":["1","2"]},"ConstantStringMap":{"ConstantMap":["1","2"],"Map":["1","2"]},"_KeysOrValues":{"Iterable":["1"],"Iterable.E":"1"},"ConstantSet":{"SetBase":["1"],"Set":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"]},"ConstantStringSet":{"SetBase":["1"],"Set":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"]},"GeneralConstantSet":{"SetBase":["1"],"Set":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"]},"Instantiation":{"Function":[]},"Instantiation1":{"Function":[]},"NullError":{"TypeError":[],"Error":[]},"JsNoSuchMethodError":{"Error":[]},"UnknownJsTypeError":{"Error":[]},"NullThrownFromJavaScriptException":{"Exception":[]},"_StackTrace":{"StackTrace":[]},"Closure":{"Function":[]},"Closure0Args":{"Function":[]},"Closure2Args":{"Function":[]},"TearOffClosure":{"Function":[]},"StaticClosure":{"Function":[]},"BoundClosure":{"Function":[]},"_CyclicInitializationError":{"Error":[]},"RuntimeError":{"Error":[]},"JsLinkedHashMap":{"MapBase":["1","2"],"Map":["1","2"],"MapBase.V":"2","MapBase.K":"1"},"LinkedHashMapKeysIterable":{"EfficientLengthIterable":["1"],"Iterable":["1"],"Iterable.E":"1"},"LinkedHashMapValuesIterable":{"EfficientLengthIterable":["1"],"Iterable":["1"],"Iterable.E":"1"},"LinkedHashMapEntriesIterable":{"EfficientLengthIterable":["MapEntry<1,2>"],"Iterable":["MapEntry<1,2>"],"Iterable.E":"MapEntry<1,2>"},"JsIdentityLinkedHashMap":{"JsLinkedHashMap":["1","2"],"MapBase":["1","2"],"Map":["1","2"],"MapBase.V":"2","MapBase.K":"1"},"JsConstantLinkedHashMap":{"JsLinkedHashMap":["1","2"],"MapBase":["1","2"],"Map":["1","2"],"MapBase.V":"2","MapBase.K":"1"},"_MatchImplementation":{"RegExpMatch":[],"Match":[]},"_AllMatchesIterable":{"Iterable":["RegExpMatch"],"Iterable.E":"RegExpMatch"},"StringMatch":{"Match":[]},"_StringAllMatchesIterable":{"Iterable":["Match"],"Iterable.E":"Match"},"NativeByteBuffer":{"JSObject":[],"ByteBuffer":[],"TrustedGetRuntimeType":[]},"NativeTypedData":{"JSObject":[]},"NativeByteData":{"ByteData":[],"JSObject":[],"TrustedGetRuntimeType":[]},"NativeTypedArray":{"JavaScriptIndexingBehavior":["1"],"JSObject":[]},"NativeTypedArrayOfDouble":{"ListBase":["double"],"List":["double"],"JavaScriptIndexingBehavior":["double"],"EfficientLengthIterable":["double"],"JSObject":[],"Iterable":["double"]},"NativeTypedArrayOfInt":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"Iterable":["int"]},"NativeFloat32List":{"NativeTypedArrayOfDouble":[],"Float32List":[],"ListBase":["double"],"List":["double"],"JavaScriptIndexingBehavior":["double"],"EfficientLengthIterable":["double"],"JSObject":[],"Iterable":["double"],"TrustedGetRuntimeType":[],"ListBase.E":"double"},"NativeFloat64List":{"NativeTypedArrayOfDouble":[],"Float64List":[],"ListBase":["double"],"List":["double"],"JavaScriptIndexingBehavior":["double"],"EfficientLengthIterable":["double"],"JSObject":[],"Iterable":["double"],"TrustedGetRuntimeType":[],"ListBase.E":"double"},"NativeInt16List":{"NativeTypedArrayOfInt":[],"Int16List":[],"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"Iterable":["int"],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeInt32List":{"NativeTypedArrayOfInt":[],"Int32List":[],"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"Iterable":["int"],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeInt8List":{"NativeTypedArrayOfInt":[],"Int8List":[],"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"Iterable":["int"],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint16List":{"NativeTypedArrayOfInt":[],"Uint16List":[],"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"Iterable":["int"],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint32List":{"NativeTypedArrayOfInt":[],"Uint32List":[],"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"Iterable":["int"],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint8ClampedList":{"NativeTypedArrayOfInt":[],"Uint8ClampedList":[],"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"Iterable":["int"],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint8List":{"NativeTypedArrayOfInt":[],"Uint8List":[],"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"Iterable":["int"],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"_Error":{"Error":[]},"_TypeError":{"TypeError":[],"Error":[]},"AsyncError":{"Error":[]},"_SyncStarIterable":{"Iterable":["1"],"Iterable.E":"1"},"_AsyncCompleter":{"_Completer":["1"]},"_SyncCompleter":{"_Completer":["1"]},"_Future":{"Future":["1"]},"_StreamController":{"EventSink":["1"]},"_AsyncStreamController":{"_StreamController":["1"],"EventSink":["1"]},"_SyncStreamController":{"_StreamController":["1"],"EventSink":["1"]},"_ControllerStream":{"_StreamImpl":["1"],"Stream":["1"],"Stream.T":"1"},"_ControllerSubscription":{"_BufferingStreamSubscription":["1"],"StreamSubscription":["1"],"_BufferingStreamSubscription.T":"1"},"_BufferingStreamSubscription":{"StreamSubscription":["1"],"_BufferingStreamSubscription.T":"1"},"_StreamImpl":{"Stream":["1"]},"_ForwardingStream":{"Stream":["2"]},"_ForwardingStreamSubscription":{"_BufferingStreamSubscription":["2"],"StreamSubscription":["2"],"_BufferingStreamSubscription.T":"2"},"_MapStream":{"_ForwardingStream":["1","2"],"Stream":["2"],"Stream.T":"2"},"_ZoneSpecification":{"ZoneSpecification":[]},"_ZoneDelegate":{"ZoneDelegate":[]},"_Zone":{"Zone":[]},"_CustomZone":{"Zone":[]},"_RootZone":{"Zone":[]},"Queue":{"EfficientLengthIterable":["1"],"Iterable":["1"]},"_HashMap":{"MapBase":["1","2"],"Map":["1","2"],"MapBase.V":"2","MapBase.K":"1"},"_IdentityHashMap":{"_HashMap":["1","2"],"MapBase":["1","2"],"Map":["1","2"],"MapBase.V":"2","MapBase.K":"1"},"_HashMapKeyIterable":{"EfficientLengthIterable":["1"],"Iterable":["1"],"Iterable.E":"1"},"_LinkedCustomHashMap":{"JsLinkedHashMap":["1","2"],"MapBase":["1","2"],"Map":["1","2"],"MapBase.V":"2","MapBase.K":"1"},"_LinkedHashSet":{"_SetBase":["1"],"SetBase":["1"],"Set":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"]},"_LinkedIdentityHashSet":{"_LinkedHashSet":["1"],"_SetBase":["1"],"SetBase":["1"],"Set":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"]},"UnmodifiableListView":{"ListBase":["1"],"List":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"],"ListBase.E":"1"},"ListBase":{"List":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"]},"MapBase":{"Map":["1","2"]},"UnmodifiableMapBase":{"MapBase":["1","2"],"Map":["1","2"]},"_MapBaseValueIterable":{"EfficientLengthIterable":["2"],"Iterable":["2"],"Iterable.E":"2"},"MapView":{"Map":["1","2"]},"UnmodifiableMapView":{"Map":["1","2"]},"ListQueue":{"Queue":["1"],"ListIterable":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"],"ListIterable.E":"1","Iterable.E":"1"},"SetBase":{"Set":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"]},"_SetBase":{"SetBase":["1"],"Set":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"]},"UnmodifiableSetView":{"SetBase":["1"],"Set":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"]},"_JsonMap":{"MapBase":["String","@"],"Map":["String","@"],"MapBase.V":"@","MapBase.K":"String"},"_JsonMapKeyIterable":{"ListIterable":["String"],"EfficientLengthIterable":["String"],"Iterable":["String"],"ListIterable.E":"String","Iterable.E":"String"},"AsciiCodec":{"Codec":["String","List"]},"_UnicodeSubsetEncoder":{"Converter":["String","List"]},"AsciiEncoder":{"Converter":["String","List"]},"Base64Codec":{"Codec":["List","String"]},"Base64Encoder":{"Converter":["List","String"]},"Encoding":{"Codec":["String","List"]},"JsonUnsupportedObjectError":{"Error":[]},"JsonCyclicError":{"Error":[]},"JsonCodec":{"Codec":["Object?","String"]},"JsonEncoder":{"Converter":["Object?","String"]},"JsonDecoder":{"Converter":["String","Object?"]},"Utf8Codec":{"Codec":["String","List"]},"Utf8Encoder":{"Converter":["String","List"]},"Utf8Decoder":{"Converter":["List","String"]},"DateTime":{"Comparable":["DateTime"]},"double":{"num":[],"Comparable":["num"]},"Duration":{"Comparable":["Duration"]},"int":{"num":[],"Comparable":["num"]},"List":{"EfficientLengthIterable":["1"],"Iterable":["1"]},"num":{"Comparable":["num"]},"RegExpMatch":{"Match":[]},"Set":{"EfficientLengthIterable":["1"],"Iterable":["1"]},"String":{"Comparable":["String"]},"AssertionError":{"Error":[]},"TypeError":{"Error":[]},"ArgumentError":{"Error":[]},"RangeError":{"Error":[]},"IndexError":{"RangeError":[],"Error":[]},"NoSuchMethodError":{"Error":[]},"UnsupportedError":{"Error":[]},"UnimplementedError":{"Error":[]},"StateError":{"Error":[]},"ConcurrentModificationError":{"Error":[]},"OutOfMemoryError":{"Error":[]},"StackOverflowError":{"Error":[]},"_Exception":{"Exception":[]},"FormatException":{"Exception":[]},"_GeneratorIterable":{"ListIterable":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"],"ListIterable.E":"1","Iterable.E":"1"},"_StringStackTrace":{"StackTrace":[]},"Runes":{"Iterable":["int"],"Iterable.E":"int"},"_Uri":{"_PlatformUri":[],"Uri":[]},"_SimpleUri":{"_PlatformUri":[],"Uri":[]},"_DataUri":{"_PlatformUri":[],"Uri":[]},"NullRejectionException":{"Exception":[]},"ArgParserException":{"FormatException":[],"Exception":[]},"ErrorResult":{"Result":["0&"]},"ValueResult":{"Result":["1"]},"_CompleterStream":{"Stream":["1"],"Stream.T":"1"},"_NextRequest":{"_EventRequest":["1"]},"EmptyUnmodifiableSet":{"Set":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"],"Iterable.E":"1"},"QueueList":{"ListBase":["1"],"List":["1"],"Queue":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"],"ListBase.E":"1","QueueList.E":"1"},"_CastQueueList":{"QueueList":["2"],"ListBase":["2"],"List":["2"],"Queue":["2"],"EfficientLengthIterable":["2"],"Iterable":["2"],"ListBase.E":"2","QueueList.E":"2"},"UnionSet":{"SetBase":["1"],"Set":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"]},"UnmodifiableSetView0":{"DelegatingSet":["1"],"Set":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"]},"MapKeySet":{"Set":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"]},"_DelegatingIterableBase":{"Iterable":["1"]},"DelegatingSet":{"Set":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"]},"PathException":{"Exception":[]},"PathMap":{"Map":["String?","1"]},"Version":{"VersionRange":[],"Comparable":["VersionRange"]},"VersionRange":{"Comparable":["VersionRange"]},"ModifiableCssAtRule":{"ModifiableCssParentNode":[],"ModifiableCssNode":[],"CssParentNode":[],"CssNode":[],"AstNode":[]},"ModifiableCssComment":{"ModifiableCssNode":[],"CssComment":[],"CssNode":[],"AstNode":[]},"ModifiableCssDeclaration":{"ModifiableCssNode":[],"CssNode":[],"AstNode":[]},"ModifiableCssImport":{"ModifiableCssNode":[],"CssNode":[],"AstNode":[]},"ModifiableCssKeyframeBlock":{"ModifiableCssParentNode":[],"ModifiableCssNode":[],"CssParentNode":[],"CssNode":[],"AstNode":[]},"ModifiableCssMediaRule":{"ModifiableCssParentNode":[],"ModifiableCssNode":[],"CssParentNode":[],"CssNode":[],"AstNode":[]},"ModifiableCssNode":{"CssNode":[],"AstNode":[]},"ModifiableCssParentNode":{"ModifiableCssNode":[],"CssParentNode":[],"CssNode":[],"AstNode":[]},"ModifiableCssStyleRule":{"ModifiableCssParentNode":[],"CssStyleRule":[],"ModifiableCssNode":[],"CssParentNode":[],"CssNode":[],"AstNode":[]},"ModifiableCssStylesheet":{"ModifiableCssParentNode":[],"CssStylesheet":[],"ModifiableCssNode":[],"CssParentNode":[],"CssNode":[],"AstNode":[]},"ModifiableCssSupportsRule":{"ModifiableCssParentNode":[],"ModifiableCssNode":[],"CssParentNode":[],"CssNode":[],"AstNode":[]},"CssNode":{"AstNode":[]},"CssParentNode":{"CssNode":[],"AstNode":[]},"CssStylesheet":{"CssParentNode":[],"CssNode":[],"AstNode":[]},"CssValue":{"AstNode":[]},"_FakeAstNode":{"AstNode":[]},"ArgumentList":{"AstNode":[]},"ConfiguredVariable":{"AstNode":[]},"Expression":{"AstNode":[]},"BinaryOperationExpression":{"Expression":[],"AstNode":[]},"BooleanExpression":{"Expression":[],"AstNode":[]},"ColorExpression":{"Expression":[],"AstNode":[]},"FunctionExpression":{"Expression":[],"AstNode":[]},"IfExpression":{"Expression":[],"AstNode":[]},"InterpolatedFunctionExpression":{"Expression":[],"AstNode":[]},"ListExpression":{"Expression":[],"AstNode":[]},"MapExpression":{"Expression":[],"AstNode":[]},"NullExpression":{"Expression":[],"AstNode":[]},"NumberExpression":{"Expression":[],"AstNode":[]},"ParenthesizedExpression":{"Expression":[],"AstNode":[]},"SelectorExpression":{"Expression":[],"AstNode":[]},"StringExpression":{"Expression":[],"AstNode":[]},"SupportsExpression":{"Expression":[],"AstNode":[]},"UnaryOperationExpression":{"Expression":[],"AstNode":[]},"ValueExpression":{"Expression":[],"AstNode":[]},"VariableExpression":{"Expression":[],"AstNode":[]},"DynamicImport":{"Import":[],"AstNode":[]},"StaticImport":{"Import":[],"AstNode":[]},"Interpolation":{"AstNode":[]},"Parameter":{"AstNode":[]},"ParameterList":{"AstNode":[]},"Statement":{"AstNode":[]},"AtRootRule":{"Statement":[],"AstNode":[]},"AtRule":{"Statement":[],"AstNode":[]},"CallableDeclaration":{"Statement":[],"AstNode":[]},"ContentBlock":{"Statement":[],"AstNode":[]},"ContentRule":{"Statement":[],"AstNode":[]},"DebugRule":{"Statement":[],"AstNode":[]},"Declaration":{"Statement":[],"AstNode":[]},"EachRule":{"Statement":[],"AstNode":[]},"ErrorRule":{"Statement":[],"AstNode":[]},"ExtendRule":{"Statement":[],"AstNode":[]},"ForRule":{"Statement":[],"AstNode":[]},"ForwardRule":{"Statement":[],"AstNode":[]},"FunctionRule":{"Statement":[],"AstNode":[]},"IfClause":{"IfRuleClause":[]},"ElseClause":{"IfRuleClause":[]},"IfRule":{"Statement":[],"AstNode":[]},"ImportRule":{"Statement":[],"AstNode":[]},"IncludeRule":{"Statement":[],"AstNode":[]},"LoudComment":{"Statement":[],"AstNode":[]},"MediaRule":{"Statement":[],"AstNode":[]},"MixinRule":{"Statement":[],"AstNode":[]},"_HasContentVisitor":{"StatementSearchVisitor":["bool"],"StatementSearchVisitor.T":"bool"},"ParentStatement":{"Statement":[],"AstNode":[]},"ReturnRule":{"Statement":[],"AstNode":[]},"SilentComment":{"Statement":[],"AstNode":[]},"StyleRule":{"Statement":[],"AstNode":[]},"Stylesheet":{"Statement":[],"AstNode":[]},"SupportsRule":{"Statement":[],"AstNode":[]},"UseRule":{"Statement":[],"AstNode":[]},"VariableDeclaration":{"Statement":[],"AstNode":[]},"WarnRule":{"Statement":[],"AstNode":[]},"WhileRule":{"Statement":[],"AstNode":[]},"SupportsAnything":{"AstNode":[]},"SupportsDeclaration":{"AstNode":[]},"SupportsFunction":{"AstNode":[]},"SupportsInterpolation":{"AstNode":[]},"SupportsNegation":{"AstNode":[]},"SupportsOperation":{"AstNode":[]},"Selector":{"AstNode":[]},"AttributeSelector":{"SimpleSelector":[],"AstNode":[]},"ClassSelector":{"SimpleSelector":[],"AstNode":[]},"ComplexSelector":{"AstNode":[]},"CompoundSelector":{"AstNode":[]},"IDSelector":{"SimpleSelector":[],"AstNode":[]},"SelectorList":{"AstNode":[]},"_ParentSelectorVisitor":{"SelectorSearchVisitor":["ParentSelector"],"SelectorSearchVisitor.T":"ParentSelector"},"ParentSelector":{"SimpleSelector":[],"AstNode":[]},"PlaceholderSelector":{"SimpleSelector":[],"AstNode":[]},"PseudoSelector":{"SimpleSelector":[],"AstNode":[]},"SimpleSelector":{"AstNode":[]},"TypeSelector":{"SimpleSelector":[],"AstNode":[]},"UniversalSelector":{"SimpleSelector":[],"AstNode":[]},"_EnvironmentModule0":{"Module0":["AsyncCallable"]},"AsyncBuiltInCallable":{"AsyncCallable":[]},"BuiltInCallable":{"Callable0":[],"AsyncBuiltInCallable":[],"AsyncCallable":[]},"PlainCssCallable":{"Callable0":[],"AsyncCallable":[]},"UserDefinedCallable":{"Callable0":[],"AsyncCallable":[]},"ExplicitConfiguration":{"Configuration":[]},"_EnvironmentModule":{"Module0":["Callable0"]},"SassRuntimeException":{"Exception":[]},"SassException":{"Exception":[]},"MultiSpanSassException":{"Exception":[]},"MultiSpanSassRuntimeException":{"SassRuntimeException":[],"Exception":[]},"SassFormatException":{"SourceSpanFormatException":[],"FormatException":[],"Exception":[]},"MultiSpanSassFormatException":{"MultiSourceSpanFormatException":[],"SassFormatException":[],"SourceSpanFormatException":[],"FormatException":[],"Exception":[]},"UsageException":{"Exception":[]},"EmptyExtensionStore":{"ExtensionStore":[]},"MergedExtension":{"Extension":[]},"Importer":{"AsyncImporter":[]},"FilesystemImporter":{"Importer":[],"AsyncImporter":[]},"NodePackageImporter":{"Importer":[],"AsyncImporter":[]},"BuiltInModule":{"Module0":["1"]},"ForwardedModuleView":{"Module0":["1"]},"ShadowedModuleView":{"Module0":["1"]},"LazyFileSpan":{"FileSpan":[],"SourceSpanWithContext":[],"SourceSpan":[],"Comparable":["SourceSpan"]},"LimitedMapView":{"MapBase":["1","2"],"Map":["1","2"],"MapBase.V":"2","MapBase.K":"1"},"MergedMapView":{"MapBase":["1","2"],"Map":["1","2"],"MapBase.V":"2","MapBase.K":"1"},"MultiSpan":{"FileSpan":[],"SourceSpanWithContext":[],"SourceSpan":[],"Comparable":["SourceSpan"]},"PrefixedMapView":{"MapBase":["String","1"],"Map":["String","1"],"MapBase.V":"1","MapBase.K":"String"},"_PrefixedKeys":{"Iterable":["String"],"Iterable.E":"String"},"PublicMemberMapView":{"MapBase":["String","1"],"Map":["String","1"],"MapBase.V":"1","MapBase.K":"String"},"UnprefixedMapView":{"MapBase":["String","1"],"Map":["String","1"],"MapBase.V":"1","MapBase.K":"String"},"_UnprefixedKeys":{"Iterable":["String"],"Iterable.E":"String"},"SassArgumentList":{"SassList":[],"Value":[]},"SassBoolean":{"Value":[]},"SassCalculation":{"Value":[]},"SassColor":{"Value":[]},"LinearChannel":{"ColorChannel":[]},"A98RgbColorSpace":{"ColorSpace":[]},"DisplayP3ColorSpace":{"ColorSpace":[]},"HslColorSpace":{"ColorSpace":[]},"HwbColorSpace":{"ColorSpace":[]},"LabColorSpace":{"ColorSpace":[]},"LchColorSpace":{"ColorSpace":[]},"LmsColorSpace":{"ColorSpace":[]},"OklabColorSpace":{"ColorSpace":[]},"OklchColorSpace":{"ColorSpace":[]},"ProphotoRgbColorSpace":{"ColorSpace":[]},"Rec2020ColorSpace":{"ColorSpace":[]},"RgbColorSpace":{"ColorSpace":[]},"SrgbColorSpace":{"ColorSpace":[]},"SrgbLinearColorSpace":{"ColorSpace":[]},"XyzD50ColorSpace":{"ColorSpace":[]},"XyzD65ColorSpace":{"ColorSpace":[]},"SassFunction":{"Value":[]},"SassList":{"Value":[]},"SassMap":{"Value":[]},"SassMixin":{"Value":[]},"_SassNull":{"Value":[]},"SassNumber":{"Value":[]},"ComplexSassNumber":{"SassNumber":[],"Value":[]},"SingleUnitSassNumber":{"SassNumber":[],"Value":[]},"UnitlessSassNumber":{"SassNumber":[],"Value":[]},"SassString":{"Value":[]},"_EvaluationContext0":{"EvaluationContext":[]},"_EvaluationContext":{"EvaluationContext":[]},"Entry":{"Comparable":["Entry"]},"FileLocation":{"SourceLocation":[],"Comparable":["SourceLocation"]},"FileSpan":{"SourceSpanWithContext":[],"SourceSpan":[],"Comparable":["SourceSpan"]},"_FileSpan":{"FileSpan":[],"SourceSpanWithContext":[],"SourceSpan":[],"Comparable":["SourceSpan"]},"SourceLocation":{"Comparable":["SourceLocation"]},"SourceLocationMixin":{"SourceLocation":[],"Comparable":["SourceLocation"]},"SourceSpan":{"Comparable":["SourceSpan"]},"SourceSpanBase":{"SourceSpan":[],"Comparable":["SourceSpan"]},"SourceSpanException":{"Exception":[]},"SourceSpanFormatException":{"FormatException":[],"Exception":[]},"MultiSourceSpanException":{"Exception":[]},"MultiSourceSpanFormatException":{"FormatException":[],"Exception":[]},"SourceSpanMixin":{"SourceSpan":[],"Comparable":["SourceSpan"]},"SourceSpanWithContext":{"SourceSpan":[],"Comparable":["SourceSpan"]},"Chain":{"StackTrace":[]},"LazyTrace":{"Trace":[],"StackTrace":[]},"Trace":{"StackTrace":[]},"UnparsedFrame":{"Frame":[]},"StringScannerException":{"SourceSpanFormatException":[],"FormatException":[],"Exception":[]},"A98RgbColorSpace0":{"ColorSpace0":[]},"SupportsAnything0":{"SupportsCondition":[],"SassNode":[],"AstNode0":[]},"ArgumentList0":{"SassNode":[],"AstNode0":[]},"SassArgumentList0":{"SassList0":[],"Value0":[]},"JSToDartAsyncImporter":{"AsyncImporter0":[]},"AsyncBuiltInCallable0":{"AsyncCallable0":[]},"_EnvironmentModule2":{"Module1":["AsyncCallable0"]},"_EvaluateVisitor2":{"StatementVisitor":["Future"],"ExpressionVisitor":["Future"]},"_EvaluationContext2":{"EvaluationContext0":[]},"JSToDartAsyncFileImporter":{"AsyncImporter0":[]},"AtRootRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"ModifiableCssAtRule0":{"ModifiableCssParentNode0":[],"ModifiableCssNode0":[],"CssParentNode0":[],"CssNode0":[],"AstNode0":[]},"AtRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"AttributeSelector0":{"SimpleSelector0":[],"AstNode0":[]},"BinaryOperationExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"BooleanExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"SassBoolean0":{"Value0":[]},"BuiltInCallable0":{"Callable":[],"AsyncBuiltInCallable0":[],"AsyncCallable0":[]},"BuiltInModule0":{"Module1":["1"]},"SassCalculation0":{"Value0":[]},"CallableDeclaration0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"LinearChannel0":{"ColorChannel0":[]},"ClassSelector0":{"SimpleSelector0":[],"AstNode0":[]},"ColorExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"SassColor0":{"Value0":[]},"ModifiableCssComment0":{"ModifiableCssNode0":[],"CssComment0":[],"CssNode0":[],"AstNode0":[]},"AsyncCompiler":{"Compiler":[]},"ComplexSassNumber0":{"SassNumber0":[],"Value0":[]},"ComplexSelector0":{"AstNode0":[]},"CompoundSelector0":{"AstNode0":[]},"ExplicitConfiguration0":{"Configuration0":[]},"ConfiguredVariable0":{"SassNode":[],"AstNode0":[]},"ContentBlock0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"ContentRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"DebugRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"ModifiableCssDeclaration0":{"ModifiableCssNode0":[],"CssNode0":[],"AstNode0":[]},"Declaration0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"SupportsDeclaration0":{"SupportsCondition":[],"SassNode":[],"AstNode0":[]},"DisplayP3ColorSpace0":{"ColorSpace0":[]},"DynamicImport0":{"Import0":[],"SassNode":[],"AstNode0":[]},"EachRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"EmptyExtensionStore0":{"ExtensionStore0":[]},"_EnvironmentModule1":{"Module1":["Callable"]},"ErrorRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"_EvaluateVisitor1":{"StatementVisitor":["Value0?"],"ExpressionVisitor":["Value0"]},"_EvaluationContext1":{"EvaluationContext0":[]},"SassRuntimeException0":{"Exception":[]},"SassException0":{"Exception":[]},"MultiSpanSassException0":{"Exception":[]},"MultiSpanSassRuntimeException0":{"SassRuntimeException0":[],"Exception":[]},"SassFormatException0":{"SourceSpanFormatException":[],"FormatException":[],"Exception":[]},"MultiSpanSassFormatException0":{"MultiSourceSpanFormatException":[],"SassFormatException0":[],"SourceSpanFormatException":[],"FormatException":[],"Exception":[]},"Expression0":{"SassNode":[],"AstNode0":[]},"JSExpressionVisitor":{"ExpressionVisitor":["Object?"]},"_MakeExpressionCalculationSafe0":{"ExpressionVisitor":["Expression0"]},"ExtendRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"JSToDartFileImporter":{"Importer0":[],"AsyncImporter0":[]},"FilesystemImporter0":{"Importer0":[],"AsyncImporter0":[]},"ForRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"ForwardRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"ForwardedModuleView0":{"Module1":["1"]},"FunctionExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"SupportsFunction0":{"SupportsCondition":[],"SassNode":[],"AstNode0":[]},"SassFunction0":{"Value0":[]},"FunctionRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"HslColorSpace0":{"ColorSpace0":[]},"HwbColorSpace0":{"ColorSpace0":[]},"IDSelector0":{"SimpleSelector0":[],"AstNode0":[]},"IfExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"IfClause0":{"IfRuleClause0":[]},"ElseClause0":{"IfRuleClause0":[]},"IfRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"ModifiableCssImport0":{"ModifiableCssNode0":[],"CssNode0":[],"AstNode0":[]},"ImportRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"Importer0":{"AsyncImporter0":[]},"IncludeRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"InterpolatedFunctionExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"Interpolation0":{"SassNode":[],"AstNode0":[]},"SupportsInterpolation0":{"SupportsCondition":[],"SassNode":[],"AstNode0":[]},"IsCalculationSafeVisitor0":{"ExpressionVisitor":["bool"]},"ModifiableCssKeyframeBlock0":{"ModifiableCssParentNode0":[],"ModifiableCssNode0":[],"CssParentNode0":[],"CssNode0":[],"AstNode0":[]},"LabColorSpace0":{"ColorSpace0":[]},"LazyFileSpan0":{"FileSpan":[],"SourceSpanWithContext":[],"SourceSpan":[],"Comparable":["SourceSpan"]},"LchColorSpace0":{"ColorSpace0":[]},"LimitedMapView0":{"MapBase":["1","2"],"Map":["1","2"],"MapBase.V":"2","MapBase.K":"1"},"ListExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"SelectorList0":{"AstNode0":[]},"_ParentSelectorVisitor0":{"SelectorSearchVisitor0":["ParentSelector0"],"SelectorSearchVisitor0.T":"ParentSelector0"},"SassList0":{"Value0":[]},"LmsColorSpace0":{"ColorSpace0":[]},"LoudComment0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"MapExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"SassMap0":{"Value0":[]},"ModifiableCssMediaRule0":{"ModifiableCssParentNode0":[],"ModifiableCssNode0":[],"CssParentNode0":[],"CssNode0":[],"AstNode0":[]},"MediaRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"MergedExtension0":{"Extension0":[]},"MergedMapView0":{"MapBase":["1","2"],"Map":["1","2"],"MapBase.V":"2","MapBase.K":"1"},"SassMixin0":{"Value0":[]},"MixinRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"_HasContentVisitor0":{"StatementSearchVisitor0":["bool"],"StatementVisitor":["bool?"],"StatementSearchVisitor0.T":"bool"},"MultiSpan0":{"FileSpan":[],"SourceSpanWithContext":[],"SourceSpan":[],"Comparable":["SourceSpan"]},"SupportsNegation0":{"SupportsCondition":[],"SassNode":[],"AstNode0":[]},"NoOpImporter0":{"Importer0":[],"AsyncImporter0":[]},"_FakeAstNode0":{"AstNode0":[]},"CssNode0":{"AstNode0":[]},"CssParentNode0":{"CssNode0":[],"AstNode0":[]},"ModifiableCssNode0":{"CssNode0":[],"AstNode0":[]},"ModifiableCssParentNode0":{"ModifiableCssNode0":[],"CssParentNode0":[],"CssNode0":[],"AstNode0":[]},"NodePackageImporter0":{"Importer0":[],"AsyncImporter0":[]},"NullExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"_SassNull0":{"Value0":[]},"NumberExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"SassNumber0":{"Value0":[]},"OklabColorSpace0":{"ColorSpace0":[]},"OklchColorSpace0":{"ColorSpace0":[]},"SupportsOperation0":{"SupportsCondition":[],"SassNode":[],"AstNode0":[]},"Parameter0":{"SassNode":[],"AstNode0":[]},"ParameterList0":{"SassNode":[],"AstNode0":[]},"ParentSelector0":{"SimpleSelector0":[],"AstNode0":[]},"ParentStatement0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"ParenthesizedExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"PlaceholderSelector0":{"SimpleSelector0":[],"AstNode0":[]},"PlainCssCallable0":{"Callable":[],"AsyncCallable0":[]},"PrefixedMapView0":{"MapBase":["String","1"],"Map":["String","1"],"MapBase.V":"1","MapBase.K":"String"},"_PrefixedKeys0":{"Iterable":["String"],"Iterable.E":"String"},"ProphotoRgbColorSpace0":{"ColorSpace0":[]},"PseudoSelector0":{"SimpleSelector0":[],"AstNode0":[]},"PublicMemberMapView0":{"MapBase":["String","1"],"Map":["String","1"],"MapBase.V":"1","MapBase.K":"String"},"Rec2020ColorSpace0":{"ColorSpace0":[]},"ReturnRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"RgbColorSpace0":{"ColorSpace0":[]},"Selector0":{"AstNode0":[]},"SelectorExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"ShadowedModuleView0":{"Module1":["1"]},"SilentComment0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"SimpleSelector0":{"AstNode0":[]},"SingleUnitSassNumber0":{"SassNumber0":[],"Value0":[]},"SourceInterpolationVisitor":{"ExpressionVisitor":["~"]},"SrgbColorSpace0":{"ColorSpace0":[]},"SrgbLinearColorSpace0":{"ColorSpace0":[]},"Statement0":{"SassNode":[],"AstNode0":[]},"JSStatementVisitor":{"StatementVisitor":["Object?"]},"StaticImport0":{"Import0":[],"SassNode":[],"AstNode0":[]},"StringExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"SassString0":{"Value0":[]},"ModifiableCssStyleRule0":{"ModifiableCssParentNode0":[],"CssStyleRule0":[],"ModifiableCssNode0":[],"CssParentNode0":[],"CssNode0":[],"AstNode0":[]},"StyleRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"CssStylesheet0":{"CssParentNode0":[],"CssNode0":[],"AstNode0":[]},"ModifiableCssStylesheet0":{"ModifiableCssParentNode0":[],"CssStylesheet0":[],"ModifiableCssNode0":[],"CssParentNode0":[],"CssNode0":[],"AstNode0":[]},"Stylesheet0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"SupportsExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"ModifiableCssSupportsRule0":{"ModifiableCssParentNode0":[],"ModifiableCssNode0":[],"CssParentNode0":[],"CssNode0":[],"AstNode0":[]},"SupportsRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"JSToDartImporter":{"Importer0":[],"AsyncImporter0":[]},"TypeSelector0":{"SimpleSelector0":[],"AstNode0":[]},"UnaryOperationExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"UnitlessSassNumber0":{"SassNumber0":[],"Value0":[]},"UniversalSelector0":{"SimpleSelector0":[],"AstNode0":[]},"UnprefixedMapView0":{"MapBase":["String","1"],"Map":["String","1"],"MapBase.V":"1","MapBase.K":"String"},"_UnprefixedKeys0":{"Iterable":["String"],"Iterable.E":"String"},"UseRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"UserDefinedCallable0":{"Callable":[],"AsyncCallable0":[]},"CssValue0":{"AstNode0":[]},"ValueExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"VariableExpression0":{"Expression0":[],"SassNode":[],"AstNode0":[]},"VariableDeclaration0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"WarnRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"WhileRule0":{"Statement0":[],"SassNode":[],"AstNode0":[]},"XyzD50ColorSpace0":{"ColorSpace0":[]},"XyzD65ColorSpace0":{"ColorSpace0":[]},"Int8List":{"List":["int"],"EfficientLengthIterable":["int"],"Iterable":["int"]},"Uint8List":{"List":["int"],"EfficientLengthIterable":["int"],"Iterable":["int"]},"Uint8ClampedList":{"List":["int"],"EfficientLengthIterable":["int"],"Iterable":["int"]},"Int16List":{"List":["int"],"EfficientLengthIterable":["int"],"Iterable":["int"]},"Uint16List":{"List":["int"],"EfficientLengthIterable":["int"],"Iterable":["int"]},"Int32List":{"List":["int"],"EfficientLengthIterable":["int"],"Iterable":["int"]},"Uint32List":{"List":["int"],"EfficientLengthIterable":["int"],"Iterable":["int"]},"Float32List":{"List":["double"],"EfficientLengthIterable":["double"],"Iterable":["double"]},"Float64List":{"List":["double"],"EfficientLengthIterable":["double"],"Iterable":["double"]},"CssComment":{"CssNode":[],"AstNode":[]},"CssStyleRule":{"CssParentNode":[],"CssNode":[],"AstNode":[]},"Import":{"AstNode":[]},"Callable0":{"AsyncCallable":[]},"Callable":{"AsyncCallable0":[]},"CssComment0":{"CssNode0":[],"AstNode0":[]},"Import0":{"SassNode":[],"AstNode0":[]},"SassNode":{"AstNode0":[]},"CssStyleRule0":{"CssParentNode0":[],"CssNode0":[],"AstNode0":[]},"SupportsCondition":{"SassNode":[],"AstNode0":[]}}')); + A._Universe_addErasedTypes(init.typeUniverse, JSON.parse('{"WhereIterator":1,"SkipIterator":1,"SkipWhileIterator":1,"EmptyIterator":1,"FollowedByIterator":1,"NonNullsIterator":1,"FixedLengthListMixin":1,"UnmodifiableListMixin":1,"UnmodifiableListBase":1,"__CastListBase__CastIterableBase_ListMixin":2,"ConstantSet":1,"LinkedHashMapKeyIterator":1,"LinkedHashMapValueIterator":1,"NativeTypedArray":1,"EventSink":1,"_SyncStarIterator":1,"_SyncStreamControllerDispatch":1,"_AsyncStreamControllerDispatch":1,"_AddStreamState":1,"_StreamControllerAddStreamState":1,"_DelayedEvent":1,"_DelayedData":1,"_PendingEvents":1,"_StreamIterator":1,"_ZoneFunction":1,"Queue":1,"UnmodifiableMapBase":2,"_UnmodifiableMapMixin":2,"MapView":2,"_UnmodifiableSetMixin":1,"_UnmodifiableMapView_MapView__UnmodifiableMapMixin":2,"_UnmodifiableSetView_SetBase__UnmodifiableSetMixin":1,"_StringSinkConversionSink":1,"Expando":1,"_EventRequest":1,"_EmptyUnmodifiableSet_IterableBase_UnmodifiableSetMixin":1,"DefaultEquality":1,"IterableEquality":1,"ListEquality":1,"_QueueList_Object_ListMixin":1,"_UnionSet_SetBase_UnmodifiableSetMixin":1,"UnmodifiableSetMixin":1,"_UnmodifiableSetView_DelegatingSet_UnmodifiableSetMixin":1,"_DelegatingIterableBase":1,"_MapKeySet__DelegatingIterableBase_UnmodifiableSetMixin":1,"ParentStatement":1,"ParentStatement0":1,"ExpressionVisitor":1}')); + var string$ = { + x00_____: "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\u03f6\x00\u0404\u03f4 \u03f4\u03f6\u01f6\u01f6\u03f6\u03fc\u01f4\u03ff\u03ff\u0584\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u05d4\u01f4\x00\u01f4\x00\u0504\u05c4\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u0400\x00\u0400\u0200\u03f7\u0200\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u03ff\u0200\u0200\u0200\u03f7\x00", + x0a_BUG_: "\n\nBUG: This should include a source span!", + x0a_Morex20: "\n\nMore info and automated migrator: https://sass-lang.com/d/slash-div", + x0a_Morex3ac: "\n\nMore info: https://sass-lang.com/d/color-functions", + x0a_Morex3af: "\n\nMore info: https://sass-lang.com/d/function-units", + x0a_See_: "\n\nSee https://sass-lang.com/d/function-units", + x0a_This: "\n\nThis is only an error because you've set the ", + x0a_To_p: "\n\nTo preserve current behavior: math.random(math.div($limit, 1", + x0a_but_: "\n\nbut you may have intended it to mean:\n\n ", + x0aRun_i: "\nRun in verbose mode to see all warnings.", + x0aThis_: "\nThis will be an error in Dart Sass 2.0.0.\n\nMore info: https://sass-lang.com/d/bogus-combinators", + x0aYou_m: "\nYou may not @extend the same selector from within different media queries.", + x20It_wi: " It will be omitted from the generated CSS.", + x20be_an: " be an extender.\nThis will be an error in Dart Sass 2.0.0.\n\nMore info: https://sass-lang.com/d/bogus-combinators", + x20can_n: " can not have both conditions and paths at the same level.\nFound ", + x20deprex20: " deprecation to be fatal.\nRemove this setting if you need to keep using this feature.", + x20deprex2c: " deprecation, since it has also been made fatal.", + x20hue__: ' hue" may not be set for rectangular color space ', + x20in_in: " in interpolation here.\nIt may end up represented as ", + x20inste: " instead.\n\nMore info and automated migrator: https://sass-lang.com/d/import", + x20is_as: " is asynchronous.\nThis is probably caused by a bug in a Sass plugin.", + x20is_av: " is available from multiple global modules.", + x20is_de: " is deprecated.\n\nTo preserve current behavior: ", + x20is_noaf: " is not a future deprecation, so it does not need to be explicitly enabled.", + x20is_noav: " is not a valid selector: it must be a string,\na list of strings, or a list of lists of strings.", + x20is_nov: " is not valid CSS.\nThis will be an error in Dart Sass 2.0.0.\n\nMore info: https://sass-lang.com/d/bogus-combinators", + x20must_b: " must be either nearest, up, down or to-zero.", + x20must_n: " must not be greater than the number of characters in the file, ", + x20repet: " repetitive deprecation warnings omitted.", + x20targe: " targetLocations if the interpolation has ", + x20to_be: " to be in the legacy RGB, HSL, or HWB color space.", + x20to_be_: " to be in the legacy RGB, HSL, or HWB color space.\n\nRecommendation: color.change(", + x20to_cl: " to clarify that it's meant to be a binary operation, or wrap\nit in parentheses to make it a unary operation. This will be an error in future\nversions of Sass.\n\nMore info and automated migrator: https://sass-lang.com/d/strict-unary", + x20to_co: " to color.opacity() is deprecated.\n\nRecommendation: ", + x20was_a: ' was already loaded, so it can\'t be configured using "with".', + x20was_n: " was not declared with !default in the @used module.", + x20was_p: " was passed both by position and by name.", + x21defau: "!default should only be written once for each variable.\nThis will be an error in Dart Sass 2.0.0.", + x21globai: "!global isn't allowed for variables in other modules.", + x21globas: "!global should only be written once for each variable.\nThis will be an error in Dart Sass 2.0.0.", + x22x20can_: "\" can't be used as a parent in a compound selector.", + x22x20is_ix0a: '" is invalid CSS.\nThis will be an error in Dart Sass 2.0.0.\n\nMore info: https://sass-lang.com/d/bogus-combinators', + x22x20is_ix20: '" is invalid CSS. It will be omitted from the generated CSS.\nThis will be an error in Dart Sass 2.0.0.\n\nMore info: https://sass-lang.com/d/bogus-combinators', + x22x20is_n: '" is not a valid Sass identifier.\n\nRecommendation: add an "as" clause to define an explicit namespace.', + x22x20is_o: "\" is only valid for nesting and shouldn't\nhave children other than style rules.", + x22x26__ma: '"&" may only used at the beginning of a compound selector.', + x22x29__If: "\").\nIf you really want to use the color value here, use '", + x22x2b__an: '"+" and "-" must be surrounded by whitespace in calculations.', + x22packa: '"package:" URLs aren\'t supported on this platform.', + x24color: "$color1, $color2, $weight: 50%, $method: null", + x24css_a: "$css and $module may not both be passed at once.", + x24list1: "$list1, $list2, $separator: auto, $bracketed: auto", + x24selec: "$selectors: At least one selector must be passed.", + x24separ: '$separator: Must be "space", "comma", "slash", or "auto".', + x27x20must: "' must be a path relative to the package root at '", + x27x2c_whi: "', which is not a '.scss', '.sass', or '.css' file.", + x28__cal: "() calculation. This doesn't allow unitless numbers to be mixed with numbers with units. If you want to use the Sass function, call math.", + x28__ins: "() instead.\n\nSee https://sass-lang.com/d/import", + x28__is_d: '() is deprecated. Suggestion:\n\ncolor.channel($color, "', + x28__is_oa: "() is only supported for legacy colors. Please use color.adjust() instead with an explicit $space argument.", + x28__is_oc: "() is only supported for legacy colors. Please use color.channel() instead with an explicit $space argument.", + x28__isn: "() isn't in the sass:color module.\n\nRecommendation: color.adjust(", + x29x0a_Mor_: ")\n\nMore info: https://sass-lang.com/d/color-functions", + x29x0a_Moro: ")\n\nMore info: https://sass-lang.com/documentation/functions/color#", + x29x20in_a: ") in a future release.\n\nRecommendation: math.random(math.div($limit, 1", + x29x20is_d: ") is deprecated.\n\nTo preserve current behavior: ", + x29x20to_cg: ") to color.grayscale() is deprecated.\n\nRecommendation: ", + x29x20to_ci: ") to color.invert() is deprecated.\n\nRecommendation: ", + x29x29__Mo: "))\n\nMore info: https://sass-lang.com/d/function-units", + x2c_whicu: ", which uses a scheme declared as non-canonical.", + x2c_whicw: ', which will likely produce invalid CSS.\nAlways quote color names when using them as strings or map keys (for example, "', + x2e_Rela: ".\nRelative canonical URLs are deprecated and will eventually be disallowed.", + x3d_____: "===== asynchronous gap ===========================\n", + x40_moz_: "@-moz-document is deprecated and support will be removed in Dart Sass 2.0.0.\n\nFor details, see https://sass-lang.com/d/moz-document.", + x40conte: "@content is only allowed within mixin declarations.", + x40elsei: "@elseif is deprecated and will not be supported in future Sass versions.\n\nRecommendation: @else if", + x40exten: "@extend may only be used within style rules.", + x40forwa: "@forward rules must be written before any other rules.", + x40funct: "@function if($condition, $if-true, $if-false) {", + x40use_r: "@use rules must be written before any other rules.", + A_list: "A list with more than one element must have an explicit separator.", + A_pkg_h: "A pkg: URL must not have a host, port, username or password.", + A_pkg_q: "A pkg: URL must not have a query or fragment.", + ABCDEF: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", + An_impa: "An importer may not have a findFileUrl method as well as canonicalize and load methods.", + An_impu: "An importer must have either canonicalize and load methods, or a findFileUrl method.", + As_of_R: "As of Dart Sass 2.0.0, !global assignments won't be able to declare new variables.\n\nRecommendation: add `", + As_of_S: "As of Dart Sass 2.0.0, !global assignments won't be able to declare new variables.\n\nSince this assignment is at the root of the stylesheet, the !global flag is\nunnecessary and can safely be removed.", + At_rul: "At-rules may not be used within nested declarations.", + Becaus: "Because the CSS working group is still deciding on the best behavior, Sass doesn't currently support modifying missing channels (color: ", + Cannotff: "Cannot extract a file path from a URI with a fragment component", + Cannotfq: "Cannot extract a file path from a URI with a query component", + Cannotn: "Cannot extract a non-Windows file path from a file URI with an authority", + Comple: "ComplexSassNumber.hasPossiblyCompatibleUnits is not implemented.", + Could_: 'Could not find an option with short name "-', + CssNod: "CssNodes must have a CssStylesheet transitive parent node.", + Custom: "Custom importers are required to load stylesheets when compiling in the browser.", + Declarm: "Declarations may only be used within style rules.", + Declarw: 'Declarations whose names begin with "--" may not be nested.', + Either: "Either options.data or options.file must be set.", + Entrie: "Entries may not be removed from MergedMapView.", + Error_: "Error handler must accept one Object or one Object and a StackTrace as arguments, and return a value of the returned future's type", + Evalua: "Evaluation handles @include and its content block together.", + Expecta: "Expected a color interpolation method, got an empty list.", + Expectu: 'Expected unquoted string "hue" at the end of ', + Expectv: "Expected variable, mixin, or function name", + Functi: "Functions may not be declared in control directives.", + Global: "Global built-in functions are deprecated and will be removed in Dart Sass 3.0.0.\nUse ", + Globalcad: "Global built-in functions are deprecated and will be removed in Dart Sass 3.0.0.\nUse color.adjust instead.\n\nMore info and automated migrator: https://sass-lang.com/d/import", + Globalcal: "Global built-in functions are deprecated and will be removed in Dart Sass 3.0.0.\nUse color.alpha instead.\n\nMore info and automated migrator: https://sass-lang.com/d/import", + Globalcg: "Global built-in functions are deprecated and will be removed in Dart Sass 3.0.0.\nUse color.grayscale instead.\n\nMore info and automated migrator: https://sass-lang.com/d/import", + Globalci: "Global built-in functions are deprecated and will be removed in Dart Sass 3.0.0.\nUse color.invert instead.\n\nMore info and automated migrator: https://sass-lang.com/d/import", + Globalco: "Global built-in functions are deprecated and will be removed in Dart Sass 3.0.0.\nUse color.opacity instead.\n\nMore info and automated migrator: https://sass-lang.com/d/import", + Globalm: "Global built-in functions are deprecated and will be removed in Dart Sass 3.0.0.\nUse math.abs instead.\n\nMore info and automated migrator: https://sass-lang.com/d/import", + Hue_in: "Hue interpolation method may not be set for rectangular color space ", + If_con: "If conditions is longer than one element, conjunction may not be null.", + If_par: "If parsedAsCustomProperty is true, value must contain a SassString (was `", + If_str: "If strategy is not null, step is required.", + In_Sas: 'In Sass, "&&" means two copies of the parent selector. You probably want to use "and" instead.', + In_fut: "In future versions of Sass, round() will be interpreted as a CSS round() calculation. This requires an explicit modulus when rounding numbers with units. If you want to use the Sass function, call math.round() instead.\n\nSee https://sass-lang.com/d/import", + Indent: "Indenting at the beginning of the document is illegal.", + Interpn: "Interpolation isn't allowed in namespaces.", + Interpp: "Interpolation isn't allowed in plain CSS.", + Invali: 'Invalid return value for custom function "', + It_s_n: "It's not clear which file to import. Found:\n", + Keywor: "Keyword arguments can't be used with calculations.", + May_no: "May not have a value for string elements (at index ", + Media_: "Media rules may not be used within nested declarations.", + Mixinsb: "Mixins may not be declared in control directives.", + Mixinscf: "Mixins may not contain function declarations.", + Mixinscm: "Mixins may not contain mixin declarations.", + Modulel: "Module loop: this module is already being loaded.", + Modulen: "Module namespaces aren't allowed in plain CSS.", + Must_n: "Must not have a value for expression elements (at index ", + Nested: "Nested declarations aren't allowed in plain CSS.", + New_en: "New entries may not be added to MergedMapView.", + No_Sasc: "No Sass callable is currently being evaluated.", + No_Sass: "No Sass stylesheet is currently being evaluated.", + NoSour: "NoSourceMapBuffer.buildSourceMap() is not supported.", + Number: "Number to round and step arguments are required.", + Only_2: "Only 2 slash-separated elements allowed, but ", + Only_oa: "Only one argument may be passed to the plain-CSS invert() function.", + Only_op: "Only one positional argument is allowed. All other arguments must be passed by name.", + Other_: "Other modules' members can't be defined with !global.", + Parent: "Parent selectors can't have suffixes in plain CSS.", + Passin_: "Passing `alpha: null` without setting `space` is deprecated.\nMore info: https://sass-lang.com/d/null-alpha", + Passina: "Passing a string to call() is deprecated and will be illegal in Dart Sass 2.0.0.\n\nRecommendation: call(get-function(", + Passinp: "Passing percentage units to the global abs() function is deprecated.\nIn the future, this will emit a CSS abs() function to be resolved by the browser.\nTo preserve current behavior: math.abs(", + Placeh: "Placeholder selectors aren't allowed in plain CSS.", + Plain_: "Plain CSS functions don't support keyword arguments.", + Positi: "Positional arguments must come before keyword arguments.", + Privat: "Private members can't be accessed from outside their modules.", + Rest_a: "Rest arguments can't be used with calculations.", + Sassx20_f_: "Sass @function names beginning with -- are deprecated for forward-compatibility with plain CSS functions.\n\nFor details, see https://sass-lang.com/d/css-function-mixin", + Sassx20_fs: 'Sass @functions named "type" are deprecated for forward-compatibility with the plain CSS type() function.\n\nFor details, see https://sass-lang.com/d/type-function', + Sassx20_i: "Sass @import rules are deprecated and will be removed in Dart Sass 3.0.0.\n\nMore info and automated migrator: https://sass-lang.com/d/import", + Sassx20_m: "Sass @mixin names beginning with -- are deprecated for forward-compatibility with plain CSS mixins.\n\nFor details, see https://sass-lang.com/d/css-function-mixin", + Sassx20v: "Sass variables aren't allowed in plain CSS.", + Sassx27s: "Sass's behavior for declarations that appear after nested\nrules will be changing to match the behavior specified by CSS in an upcoming\nversion. To keep the existing behavior, move the declaration above the nested\nrule. To opt into the new behavior, wrap the declaration in `& {}`.\n\nMore info: https://sass-lang.com/d/mixed-decls", + Silent: "Silent comments aren't allowed in plain CSS.", + Style_k: "Style rules may not be used within keyframe blocks.", + Style_n: "Style rules may not be used within nested declarations.", + Suppor: "Supports rules may not be used within nested declarations.", + The_Ex: "The ExtensionStore and CssStylesheet passed to cloneCssStylesheet() must come from the same compilation.", + The_No: "The Node package importer cannot be used without a filesystem.", + The_ca: "The canonicalize() method must return a URL.", + The_co: "The color() function doesn't support the color space ", + The_fe: "The feature-exists() function is deprecated.\n\nMore info: https://sass-lang.com/d/feature-exists", + The_fie: "The findFileUrl() method must return a URL.", + The_fiu: 'The findFileUrl() must return a URL with scheme file://, was "', + The_gi: "The given LineScannerState was not returned by this LineScanner.", + The_le: "The legacy JS API is deprecated and will be removed in Dart Sass 2.0.0.\n\nMore info: https://sass-lang.com/d/legacy-js-api", + The_lo: "The load() function must return an object with contents and syntax fields.", + The_pa: "The parent selector isn't allowed in plain CSS.", + The_sa: "The same variable may only be configured once.", + The_ta: 'The target selector was not found.\nUse "@extend ', + There_: "There's already a module with namespace \"", + This_d: 'This declaration has no parameter named "$', + This_e: "This expression can't be used in a calculation.", + This_f: "This function isn't allowed in plain CSS.", + This_ma: 'This module and the new module both define a variable named "$', + This_mw: 'This module was already loaded, so it can\'t be configured using "with".', + This_o: "This operation can't be used in a calculation.", + This_s: "This selector doesn't have any properties and won't be rendered.", + This_v: "This variable was not declared with !default in the @used module.", + To_usei: "To use color.invert() with non-legacy color ", + To_usem: "To use color.mix() with non-legacy color ", + Top_lel: "Top-level leading combinators aren't allowed in plain CSS.", + Top_les: 'Top-level selectors may not contain the parent selector "&".', + Unable: "Unable to determine which of multiple potential resolutions found for ", + Unexpe: "Unexpected Zone.current[#_canonicalizeContext] value ", + User_a: "User-authored deprecations should not be silenced.", + Using__i: "Using / for division is deprecated and will be removed in Dart Sass 2.0.0.\n\nRecommendation: ", + Using__o: "Using / for division outside of calc() is deprecated and will be removed in Dart Sass 2.0.0.\n\nRecommendation: ", + Using_c: "Using color.alpha() for a Microsoft filter is deprecated.\n\nRecommendation: ", + Using_t: "Using the current working directory as an implicit load path is deprecated. Either add it as an explicit load path or importer, or load this stylesheet from a different URL.", + Variab_: "Variable keyword argument map must have string keys.\n", + Variabs: "Variable keyword arguments must be a map (was ", + You_ma: "You may not @extend selectors across media queries.", + You_pr: "You probably don't mean to use the color value ", + x60_inst: "` instead.\nSee https://sass-lang.com/d/extend-compound for details.\n", + addExt: "addExtensions() can't be called for a const ExtensionStore.", + adjustd: "adjust-hue() is deprecated. Suggestion:\n\ncolor.adjust($color, $hue: ", + adjusto: "adjust-hue() is only supported for legacy colors. Please use color.adjust() instead with an explicit $space argument.", + alpha_: "alpha() is only supported for legacy colors. Please use color.channel() instead.", + canoni: "canonicalizeContext may only be accessed within a call to canonicalize().", + color_a: "color.alpha() is only supported for legacy colors. Please use color.channel() instead.", + color_c: "color.changeHsl() is only supported for legacy colors. Please use color.changeChannels() instead with an explicit $space argument.", + color_t: "color.to-gamut() requires a $method argument for forwards-compatibility with changes in the CSS spec. Suggestion:\n\n$method: local-minde", + compou: "compound selectors may no longer be extended.\nConsider `@extend ", + conten: "content-exists() may only be called within a mixin.", + darken: "darken() is only supported for legacy colors. Please use color.adjust() instead with an explicit $space argument.", + desatu: "desaturate() is only supported for legacy colors. Please use color.adjust() instead with an explicit $space argument.", + fileEx: "fileExists() is only supported on Node.js", + leadin: "leadingCombinators and components may not both be empty.", + lighte: "lighten() is only supported for legacy colors. Please use color.adjust() instead with an explicit $space argument.", + linkEx: "linkExists() is only supported on Node.js", + math_d: "math.div() will only support number arguments in a future release.\nUse list.slash() instead for a slash separator.", + math_r: "math.random() will no longer ignore $limit units (", + multip: "multiple statements on one line are not supported in the indented syntax.", + must_b: "must be a UniversalSelector or a TypeSelector", + parsed: 'parsedAsCustomProperty must be false if name doesn\'t begin with "--".', + satura: "saturate() is only supported for legacy colors. Please use color.adjust() instead with an explicit $space argument.", + throug: "through() must return false for at least one parent of ", + x7d__Mor: "})\nMore info: https://sass-lang.com/d/abs-percent" + }; + var type$ = (function rtii() { + var findType = A.findType; + return { + $env_1_1_String: findType("@"), + ArgParser: findType("ArgParser"), + AstNode: findType("AstNode"), + AstNode_2: findType("AstNode0"), + AsyncBuiltInCallable: findType("AsyncBuiltInCallable"), + AsyncBuiltInCallable_2: findType("AsyncBuiltInCallable0"), + AsyncCallable: findType("AsyncCallable"), + AsyncCallable_2: findType("AsyncCallable0"), + AsyncCompiler: findType("AsyncCompiler"), + AsyncImporter: findType("AsyncImporter0"), + Box_SelectorList: findType("Box"), + Box_SelectorList_2: findType("Box0"), + BuiltInCallable: findType("BuiltInCallable"), + BuiltInCallable_2: findType("BuiltInCallable0"), + BuiltInModule_AsyncCallable: findType("BuiltInModule"), + BuiltInModule_AsyncCallable_2: findType("BuiltInModule0"), + BuiltInModule_Callable: findType("BuiltInModule"), + BuiltInModule_Callable_2: findType("BuiltInModule0"), + ByteBuffer: findType("ByteBuffer"), + ByteData: findType("ByteData"), + Callable: findType("Callable0"), + Callable_2: findType("Callable"), + ChangeType: findType("ChangeType"), + CodeUnits: findType("CodeUnits"), + Combinator: findType("Combinator"), + Combinator_2: findType("Combinator0"), + Comparable_dynamic: findType("Comparable<@>"), + Comparable_nullable_Object: findType("Comparable"), + CompileResult: findType("CompileResult"), + CompileResult_2: findType("CompileResult0"), + ComplexSelector: findType("ComplexSelector"), + ComplexSelectorComponent: findType("ComplexSelectorComponent"), + ComplexSelectorComponent_2: findType("ComplexSelectorComponent0"), + ComplexSelector_2: findType("ComplexSelector0"), + Configuration: findType("Configuration"), + Configuration_2: findType("Configuration0"), + ConfiguredValue: findType("ConfiguredValue"), + ConfiguredValue_2: findType("ConfiguredValue0"), + ConfiguredVariable: findType("ConfiguredVariable"), + ConfiguredVariable_2: findType("ConfiguredVariable0"), + ConstantMapView_Symbol_dynamic: findType("ConstantMapView"), + ConstantStringMap_String_double: findType("ConstantStringMap"), + ConstantStringSet_String: findType("ConstantStringSet"), + CssComment: findType("CssComment"), + CssComment_2: findType("CssComment0"), + CssMediaQuery: findType("CssMediaQuery"), + CssMediaQuery_2: findType("CssMediaQuery0"), + CssParentNode: findType("CssParentNode"), + CssParentNode_2: findType("CssParentNode0"), + CssStyleRule: findType("CssStyleRule"), + CssStyleRule_2: findType("CssStyleRule0"), + CssStylesheet: findType("CssStylesheet"), + CssStylesheet_2: findType("CssStylesheet0"), + CssValue_Combinator: findType("CssValue"), + CssValue_Combinator_2: findType("CssValue0"), + CssValue_List_String: findType("CssValue>"), + CssValue_List_String_2: findType("CssValue0>"), + CssValue_String: findType("CssValue"), + CssValue_String_2: findType("CssValue0"), + CssValue_Value: findType("CssValue"), + CssValue_Value_2: findType("CssValue0"), + DateTime: findType("DateTime"), + Deprecation: findType("Deprecation"), + Deprecation_2: findType("Deprecation1"), + Deprecation_3: findType("Deprecation0"), + EfficientLengthIterable_dynamic: findType("EfficientLengthIterable<@>"), + Error: findType("Error"), + EvaluationContext: findType("EvaluationContext"), + EvaluationContext_2: findType("EvaluationContext0"), + Exception: findType("Exception"), + Expression: findType("Expression"), + Expression_2: findType("Expression0"), + Extender: findType("Extender"), + Extender_2: findType("Extender0"), + Extension: findType("Extension"), + Extension_2: findType("Extension0"), + FileLocation: findType("FileLocation"), + FileSpan: findType("FileSpan"), + Float32List: findType("Float32List"), + Float64List: findType("Float64List"), + FormatException: findType("FormatException"), + Frame: findType("Frame"), + Function: findType("Function"), + FutureGroup_void: findType("FutureGroup<~>"), + FutureOr_Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet: findType("+loadedUrls,stylesheet(Set,CssStylesheet)/"), + FutureOr_Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet_2: findType("+loadedUrls,stylesheet(Set,CssStylesheet0)/"), + FutureOr_nullable_Uri: findType("Uri?/"), + Future_Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet: findType("Future<+loadedUrls,stylesheet(Set,CssStylesheet)>"), + Future_Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet_2: findType("Future<+loadedUrls,stylesheet(Set,CssStylesheet0)>"), + Future_Value: findType("Future"), + Future_Value_2: findType("Future"), + Future_nullable_CssValue_String: findType("Future?>"), + Future_nullable_CssValue_String_2: findType("Future?>"), + Future_nullable_ImporterResult: findType("Future"), + Future_nullable_Uri: findType("Future"), + Future_nullable_Value: findType("Future"), + Future_nullable_Value_2: findType("Future"), + IfClause: findType("IfClause"), + IfClause_2: findType("IfClause0"), + ImmutableList: findType("ImmutableList0"), + ImmutableList_2: findType("ImmutableList"), + ImmutableMap: findType("ImmutableMap0"), + Import: findType("Import"), + Import_2: findType("Import0"), + Importer: findType("Importer0"), + ImporterResult: findType("ImporterResult"), + ImporterResult_2: findType("ImporterResult0"), + Importer_2: findType("Importer"), + Int16List: findType("Int16List"), + Int32List: findType("Int32List"), + Int8List: findType("Int8List"), + Interpolation: findType("Interpolation"), + InterpolationBuffer: findType("InterpolationBuffer"), + InterpolationBuffer_2: findType("InterpolationBuffer0"), + InterpolationMap: findType("InterpolationMap"), + InterpolationMap_2: findType("InterpolationMap0"), + Interpolation_2: findType("Interpolation0"), + Iterable_ComplexSelectorComponent: findType("Iterable"), + Iterable_ComplexSelectorComponent_2: findType("Iterable"), + Iterable_dynamic: findType("Iterable<@>"), + Iterable_nullable_Object: findType("Iterable"), + JSArray_AstNode: findType("JSArray"), + JSArray_AstNode_2: findType("JSArray"), + JSArray_AsyncBuiltInCallable: findType("JSArray"), + JSArray_AsyncBuiltInCallable_2: findType("JSArray"), + JSArray_AsyncCallable: findType("JSArray"), + JSArray_AsyncCallable_2: findType("JSArray"), + JSArray_AsyncImporter: findType("JSArray"), + JSArray_AsyncImporter_2: findType("JSArray"), + JSArray_BinaryOperator: findType("JSArray"), + JSArray_BinaryOperator_2: findType("JSArray"), + JSArray_BuiltInCallable: findType("JSArray"), + JSArray_BuiltInCallable_2: findType("JSArray"), + JSArray_Callable: findType("JSArray"), + JSArray_Callable_2: findType("JSArray"), + JSArray_ColorChannel: findType("JSArray"), + JSArray_ColorChannel_2: findType("JSArray"), + JSArray_ComplexSelector: findType("JSArray"), + JSArray_ComplexSelectorComponent: findType("JSArray"), + JSArray_ComplexSelectorComponent_2: findType("JSArray"), + JSArray_ComplexSelector_2: findType("JSArray"), + JSArray_ConfiguredVariable: findType("JSArray"), + JSArray_ConfiguredVariable_2: findType("JSArray"), + JSArray_CssComment: findType("JSArray"), + JSArray_CssComment_2: findType("JSArray"), + JSArray_CssMediaQuery: findType("JSArray"), + JSArray_CssMediaQuery_2: findType("JSArray"), + JSArray_CssNode: findType("JSArray"), + JSArray_CssNode_2: findType("JSArray"), + JSArray_CssStyleRule: findType("JSArray"), + JSArray_CssStyleRule_2: findType("JSArray"), + JSArray_CssValue_Combinator: findType("JSArray>"), + JSArray_CssValue_Combinator_2: findType("JSArray>"), + JSArray_Entry: findType("JSArray"), + JSArray_Expression: findType("JSArray"), + JSArray_Expression_2: findType("JSArray"), + JSArray_Extender: findType("JSArray"), + JSArray_Extender_2: findType("JSArray"), + JSArray_Extension: findType("JSArray"), + JSArray_ExtensionStore: findType("JSArray"), + JSArray_ExtensionStore_2: findType("JSArray"), + JSArray_Extension_2: findType("JSArray"), + JSArray_ForwardRule: findType("JSArray"), + JSArray_ForwardRule_2: findType("JSArray"), + JSArray_Frame: findType("JSArray"), + JSArray_Future_nullable_Record_3_int_and_String_and_nullable_String: findType("JSArray>"), + JSArray_IfClause: findType("JSArray"), + JSArray_IfClause_2: findType("JSArray"), + JSArray_Import: findType("JSArray"), + JSArray_Import_2: findType("JSArray"), + JSArray_Importer: findType("JSArray"), + JSArray_Importer_2: findType("JSArray"), + JSArray_Iterable_ComplexSelectorComponent: findType("JSArray>"), + JSArray_Iterable_ComplexSelectorComponent_2: findType("JSArray>"), + JSArray_JSFunction: findType("JSArray"), + JSArray_LinearChannel: findType("JSArray"), + JSArray_LinearChannel_2: findType("JSArray"), + JSArray_List_ComplexSelector: findType("JSArray>"), + JSArray_List_ComplexSelectorComponent: findType("JSArray>"), + JSArray_List_ComplexSelectorComponent_2: findType("JSArray>"), + JSArray_List_ComplexSelector_2: findType("JSArray>"), + JSArray_List_Extender: findType("JSArray>"), + JSArray_List_Extender_2: findType("JSArray>"), + JSArray_List_Iterable_ComplexSelectorComponent: findType("JSArray>>"), + JSArray_List_Iterable_ComplexSelectorComponent_2: findType("JSArray>>"), + JSArray_Map_String_AstNode: findType("JSArray>"), + JSArray_Map_String_AstNode_2: findType("JSArray>"), + JSArray_Map_String_AsyncCallable: findType("JSArray>"), + JSArray_Map_String_AsyncCallable_2: findType("JSArray>"), + JSArray_Map_String_Callable: findType("JSArray>"), + JSArray_Map_String_Callable_2: findType("JSArray>"), + JSArray_Map_String_Value: findType("JSArray>"), + JSArray_Map_String_Value_2: findType("JSArray>"), + JSArray_ModifiableCssImport: findType("JSArray"), + JSArray_ModifiableCssImport_2: findType("JSArray"), + JSArray_ModifiableCssNode: findType("JSArray"), + JSArray_ModifiableCssNode_2: findType("JSArray"), + JSArray_ModifiableCssParentNode: findType("JSArray"), + JSArray_ModifiableCssParentNode_2: findType("JSArray"), + JSArray_Module_AsyncCallable: findType("JSArray>"), + JSArray_Module_AsyncCallable_2: findType("JSArray>"), + JSArray_Module_Callable: findType("JSArray>"), + JSArray_Module_Callable_2: findType("JSArray>"), + JSArray_Object: findType("JSArray"), + JSArray_Parameter: findType("JSArray"), + JSArray_Parameter_2: findType("JSArray"), + JSArray_PseudoSelector: findType("JSArray"), + JSArray_PseudoSelector_2: findType("JSArray"), + JSArray_Record_2_Expression_and_Expression: findType("JSArray<+(Expression,Expression)>"), + JSArray_Record_2_Expression_and_Expression_2: findType("JSArray<+(Expression0,Expression0)>"), + JSArray_Record_2_ParameterList_and_Value_Function_List_Value: findType("JSArray<+(ParameterList,Value(List))>"), + JSArray_Record_2_ParameterList_and_Value_Function_List_Value_2: findType("JSArray<+(ParameterList0,Value0(List))>"), + JSArray_Record_2_String_and_AstNode: findType("JSArray<+(String,AstNode)>"), + JSArray_Record_2_String_and_AstNode_2: findType("JSArray<+(String,AstNode0)>"), + JSArray_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span: findType("JSArray<+deprecation,message,span(Deprecation?,String,FileSpan)>"), + JSArray_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span_2: findType("JSArray<+deprecation,message,span(Deprecation0?,String,FileSpan)>"), + JSArray_SassList: findType("JSArray"), + JSArray_SassList_2: findType("JSArray"), + JSArray_SimpleSelector: findType("JSArray"), + JSArray_SimpleSelector_2: findType("JSArray"), + JSArray_SourceLocation: findType("JSArray"), + JSArray_Statement: findType("JSArray"), + JSArray_Statement_2: findType("JSArray"), + JSArray_String: findType("JSArray"), + JSArray_StylesheetNode: findType("JSArray"), + JSArray_TargetEntry: findType("JSArray"), + JSArray_TargetLineEntry: findType("JSArray"), + JSArray_Trace: findType("JSArray"), + JSArray_UseRule: findType("JSArray"), + JSArray_UseRule_2: findType("JSArray"), + JSArray_Value: findType("JSArray"), + JSArray_Value_2: findType("JSArray"), + JSArray_WatchEvent: findType("JSArray"), + JSArray__Highlight: findType("JSArray<_Highlight>"), + JSArray__Line: findType("JSArray<_Line>"), + JSArray_double: findType("JSArray"), + JSArray_dynamic: findType("JSArray<@>"), + JSArray_int: findType("JSArray"), + JSArray_nullable_FileSpan: findType("JSArray"), + JSArray_nullable_Record_3_int_and_String_and_nullable_String: findType("JSArray<+(int,String,String?)?>"), + JSArray_nullable_SassNumber: findType("JSArray"), + JSArray_nullable_SassNumber_2: findType("JSArray"), + JSArray_nullable_String: findType("JSArray"), + JSClass: findType("JSClass0"), + JSFunction: findType("JSFunction0"), + JSImporter: findType("JSImporter"), + JSImporterResult: findType("JSImporterResult"), + JSNull: findType("JSNull"), + JSObject: findType("JSObject"), + JSUrl: findType("JSUrl0"), + JavaScriptFunction: findType("JavaScriptFunction"), + JavaScriptIndexingBehavior_dynamic: findType("JavaScriptIndexingBehavior<@>"), + JsIdentityLinkedHashMap_SimpleSelector_int: findType("JsIdentityLinkedHashMap"), + JsIdentityLinkedHashMap_SimpleSelector_int_2: findType("JsIdentityLinkedHashMap"), + JsIdentityLinkedHashMap_of_SelectorList_and_Box_SelectorList: findType("JsIdentityLinkedHashMap>"), + JsIdentityLinkedHashMap_of_SelectorList_and_Box_SelectorList_2: findType("JsIdentityLinkedHashMap>"), + JsLinkedHashMap_Symbol_dynamic: findType("JsLinkedHashMap"), + JsSystemError: findType("JsSystemError"), + LimitedMapView_String_ConfiguredValue: findType("LimitedMapView"), + LimitedMapView_String_ConfiguredValue_2: findType("LimitedMapView0"), + LinearChannel: findType("LinearChannel"), + LinearChannel_2: findType("LinearChannel0"), + List_ComplexSelectorComponent: findType("List"), + List_ComplexSelectorComponent_2: findType("List"), + List_CssComment: findType("List"), + List_CssComment_2: findType("List"), + List_CssMediaQuery: findType("List"), + List_CssMediaQuery_2: findType("List"), + List_CssValue_Combinator: findType("List>"), + List_CssValue_Combinator_2: findType("List>"), + List_Extension: findType("List"), + List_ExtensionStore: findType("List"), + List_ExtensionStore_2: findType("List"), + List_Extension_2: findType("List"), + List_JSObject: findType("List"), + List_List_ComplexSelectorComponent: findType("List>"), + List_List_ComplexSelectorComponent_2: findType("List>"), + List_Module_AsyncCallable: findType("List>"), + List_Module_AsyncCallable_2: findType("List>"), + List_Module_Callable: findType("List>"), + List_Module_Callable_2: findType("List>"), + List_String: findType("List"), + List_WatchEvent: findType("List"), + List_dynamic: findType("List<@>"), + List_int: findType("List"), + List_nullable_Object: findType("List"), + MapKeySet_Module_AsyncCallable: findType("MapKeySet>"), + MapKeySet_Module_AsyncCallable_2: findType("MapKeySet>"), + MapKeySet_Module_Callable: findType("MapKeySet>"), + MapKeySet_Module_Callable_2: findType("MapKeySet>"), + MapKeySet_SimpleSelector: findType("MapKeySet"), + MapKeySet_SimpleSelector_2: findType("MapKeySet"), + MapKeySet_String: findType("MapKeySet"), + MapKeySet_nullable_Object: findType("MapKeySet"), + Map_ComplexSelector_Extension: findType("Map"), + Map_ComplexSelector_Extension_2: findType("Map"), + Map_String_AstNode: findType("Map"), + Map_String_AstNode_2: findType("Map"), + Map_String_AsyncCallable: findType("Map"), + Map_String_AsyncCallable_2: findType("Map"), + Map_String_Callable: findType("Map"), + Map_String_Callable_2: findType("Map"), + Map_String_Value: findType("Map"), + Map_String_Value_2: findType("Map"), + Map_String_dynamic: findType("Map"), + Map_dynamic_dynamic: findType("Map<@,@>"), + Map_of_nullable_Object_and_nullable_Object: findType("Map"), + MappedIterable_String_Frame: findType("MappedIterable"), + MappedListIterable_Frame_Frame: findType("MappedListIterable"), + MappedListIterable_String_Object: findType("MappedListIterable"), + MappedListIterable_String_String: findType("MappedListIterable"), + MappedListIterable_String_Trace: findType("MappedListIterable"), + MappedListIterable_String_Value: findType("MappedListIterable"), + MappedListIterable_String_Value_2: findType("MappedListIterable"), + MappedListIterable_String_dynamic: findType("MappedListIterable"), + MixinRule: findType("MixinRule"), + MixinRule_2: findType("MixinRule0"), + ModifiableBox_SelectorList: findType("ModifiableBox"), + ModifiableBox_SelectorList_2: findType("ModifiableBox0"), + ModifiableCssAtRule: findType("ModifiableCssAtRule"), + ModifiableCssAtRule_2: findType("ModifiableCssAtRule0"), + ModifiableCssKeyframeBlock: findType("ModifiableCssKeyframeBlock"), + ModifiableCssKeyframeBlock_2: findType("ModifiableCssKeyframeBlock0"), + ModifiableCssMediaRule: findType("ModifiableCssMediaRule"), + ModifiableCssMediaRule_2: findType("ModifiableCssMediaRule0"), + ModifiableCssNode: findType("ModifiableCssNode"), + ModifiableCssNode_2: findType("ModifiableCssNode0"), + ModifiableCssParentNode: findType("ModifiableCssParentNode"), + ModifiableCssParentNode_2: findType("ModifiableCssParentNode0"), + ModifiableCssStyleRule: findType("ModifiableCssStyleRule"), + ModifiableCssStyleRule_2: findType("ModifiableCssStyleRule0"), + ModifiableCssSupportsRule: findType("ModifiableCssSupportsRule"), + ModifiableCssSupportsRule_2: findType("ModifiableCssSupportsRule0"), + Module_AsyncCallable: findType("Module0"), + Module_AsyncCallable_2: findType("Module1"), + Module_Callable: findType("Module0"), + Module_Callable_2: findType("Module1"), + MultiSourceSpanFormatException: findType("MultiSourceSpanFormatException"), + NativeTypedArrayOfDouble: findType("NativeTypedArrayOfDouble"), + NativeTypedArrayOfInt: findType("NativeTypedArrayOfInt"), + NativeUint8List: findType("NativeUint8List"), + Never: findType("0&"), + NodeCompileResult: findType("NodeCompileResult"), + NodeImporterResult: findType("NodeImporterResult0"), + NonNullsIterable_Future_void: findType("NonNullsIterable>"), + NonNullsIterable_Object: findType("NonNullsIterable"), + NonNullsIterable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl: findType("NonNullsIterable<+originalUrl(AsyncImporter,Uri,Uri)>"), + NonNullsIterable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_2: findType("NonNullsIterable<+originalUrl(AsyncImporter0,Uri,Uri)>"), + NonNullsIterable_Record_3_Importer_and_Uri_and_Uri_originalUrl: findType("NonNullsIterable<+originalUrl(Importer,Uri,Uri)>"), + NonNullsIterable_Record_3_Importer_and_Uri_and_Uri_originalUrl_2: findType("NonNullsIterable<+originalUrl(Importer0,Uri,Uri)>"), + NonNullsIterable_SelectorList: findType("NonNullsIterable"), + NonNullsIterable_SelectorList_2: findType("NonNullsIterable"), + NonNullsIterable_String: findType("NonNullsIterable"), + Null: findType("Null"), + NumberExpression: findType("NumberExpression"), + NumberExpression_2: findType("NumberExpression0"), + Object: findType("Object"), + Option: findType("Option"), + Parameter: findType("Parameter"), + ParameterList: findType("ParameterList"), + ParameterList_2: findType("ParameterList0"), + Parameter_2: findType("Parameter0"), + PathMap_ChangeType: findType("PathMap"), + PathMap_Stream_WatchEvent: findType("PathMap>"), + PathMap_String: findType("PathMap"), + PathMap_nullable_String: findType("PathMap"), + Promise: findType("Promise"), + PseudoSelector: findType("PseudoSelector"), + PseudoSelector_2: findType("PseudoSelector0"), + RangeError: findType("RangeError"), + Record: findType("Record"), + Record_0: findType("+()"), + Record_1_nullable_Object: findType("+(Object?)"), + Record_2_Expression_and_Expression: findType("+(Expression,Expression)"), + Record_2_Expression_and_Expression_2: findType("+(Expression0,Expression0)"), + Record_2_List_Expression_and_Map_String_Expression: findType("+(List,Map)"), + Record_2_List_Expression_and_Map_String_Expression_2: findType("+(List,Map)"), + Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet: findType("+loadedUrls,stylesheet(Set,CssStylesheet)"), + Record_2_Set_Uri_loadedUrls_and_CssStylesheet_stylesheet_2: findType("+loadedUrls,stylesheet(Set,CssStylesheet0)"), + Record_2_String_and_InterpolationMap: findType("+(String,InterpolationMap)"), + Record_2_String_and_InterpolationMap_2: findType("+(String,InterpolationMap0)"), + Record_2_String_and_SourceSpan: findType("+(String,SourceSpan)"), + Record_2_String_and_nullable_InterpolationMap: findType("+(String,InterpolationMap?)"), + Record_2_String_and_nullable_InterpolationMap_2: findType("+(String,InterpolationMap0?)"), + Record_2_Uri_and_bool_forImport: findType("+forImport(Uri,bool)"), + Record_2_nullable_Object_and_nullable_Object: findType("+(Object?,Object?)"), + Record_2_nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_and_bool: findType("+(+originalUrl(AsyncImporter,Uri,Uri)?,bool)"), + Record_2_nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_and_bool_2: findType("+(+originalUrl(AsyncImporter0,Uri,Uri)?,bool)"), + Record_2_nullable_String_and_nullable_String: findType("+(String?,String?)"), + Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl: findType("+originalUrl(AsyncImporter,Uri,Uri)"), + Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_2: findType("+originalUrl(AsyncImporter0,Uri,Uri)"), + Record_3_AsyncImporter_and_Uri_and_bool_forImport: findType("+forImport(AsyncImporter,Uri,bool)"), + Record_3_AsyncImporter_and_Uri_and_bool_forImport_2: findType("+forImport(AsyncImporter0,Uri,bool)"), + Record_3_Importer_and_Uri_and_Uri_originalUrl: findType("+originalUrl(Importer,Uri,Uri)"), + Record_3_Importer_and_Uri_and_Uri_originalUrl_2: findType("+originalUrl(Importer0,Uri,Uri)"), + Record_3_Importer_and_Uri_and_bool_forImport: findType("+forImport(Importer,Uri,bool)"), + Record_3_Importer_and_Uri_and_bool_forImport_2: findType("+forImport(Importer0,Uri,bool)"), + Record_3_Stylesheet_and_nullable_AsyncImporter_importer_and_bool_isDependency: findType("+importer,isDependency(Stylesheet,AsyncImporter?,bool)"), + Record_3_Stylesheet_and_nullable_AsyncImporter_importer_and_bool_isDependency_2: findType("+importer,isDependency(Stylesheet0,AsyncImporter0?,bool)"), + Record_3_nullable_Object_and_nullable_Object_and_nullable_Object_originalUrl: findType("+originalUrl(Object?,Object?,Object?)"), + Record_5_Map_String_Value_named_and_Map_String_AstNode_namedNodes_and_List_Value_positional_and_List_AstNode_positionalNodes_and_ListSeparator_separator: findType("+named,namedNodes,positional,positionalNodes,separator(Map,Map,List,List,ListSeparator)"), + Record_5_Map_String_Value_named_and_Map_String_AstNode_namedNodes_and_List_Value_positional_and_List_AstNode_positionalNodes_and_ListSeparator_separator_2: findType("+named,namedNodes,positional,positionalNodes,separator(Map,Map,List,List,ListSeparator0)"), + RegExpMatch: findType("RegExpMatch"), + RenderContextOptions: findType("RenderContextOptions0"), + RenderResult: findType("RenderResult"), + Result_String: findType("Result"), + ReversedListIterable_Frame: findType("ReversedListIterable"), + Runes: findType("Runes"), + SassArgumentList: findType("SassArgumentList"), + SassArgumentList_2: findType("SassArgumentList0"), + SassBoolean: findType("SassBoolean"), + SassBoolean_2: findType("SassBoolean0"), + SassColor: findType("SassColor"), + SassColor_2: findType("SassColor0"), + SassFormatException: findType("SassFormatException"), + SassFormatException_2: findType("SassFormatException0"), + SassList: findType("SassList"), + SassList_2: findType("SassList0"), + SassMap: findType("SassMap"), + SassMap_2: findType("SassMap0"), + SassNumber: findType("SassNumber"), + SassNumber_2: findType("SassNumber0"), + SassRuntimeException: findType("SassRuntimeException"), + SassRuntimeException_2: findType("SassRuntimeException0"), + SassString: findType("SassString"), + SassString_2: findType("SassString0"), + SelectorList: findType("SelectorList"), + SelectorList_2: findType("SelectorList0"), + Set_ModifiableBox_SelectorList: findType("Set>"), + Set_ModifiableBox_SelectorList_2: findType("Set>"), + Set_Uri: findType("Set"), + SimpleSelector: findType("SimpleSelector"), + SimpleSelector_2: findType("SimpleSelector0"), + SourceFile: findType("SourceFile"), + SourceLocation: findType("SourceLocation"), + SourceSpan: findType("SourceSpan"), + SourceSpanFormatException: findType("SourceSpanFormatException"), + SourceSpanWithContext: findType("SourceSpanWithContext"), + StackTrace: findType("StackTrace"), + Statement: findType("Statement"), + Statement_2: findType("Statement0"), + StaticImport: findType("StaticImport"), + StaticImport_2: findType("StaticImport0"), + StreamCompleter_WatchEvent: findType("StreamCompleter"), + StreamGroup_WatchEvent: findType("StreamGroup"), + StreamQueue_String: findType("StreamQueue"), + Stream_WatchEvent: findType("Stream"), + String: findType("String"), + StringExpression: findType("StringExpression"), + StringExpression_2: findType("StringExpression0"), + StylesheetNode: findType("StylesheetNode"), + Timer: findType("Timer"), + Trace: findType("Trace"), + TrustedGetRuntimeType: findType("TrustedGetRuntimeType"), + TypeError: findType("TypeError"), + TypeSelector: findType("TypeSelector"), + TypeSelector_2: findType("TypeSelector0"), + Uint16List: findType("Uint16List"), + Uint32List: findType("Uint32List"), + Uint8ClampedList: findType("Uint8ClampedList"), + Uint8List: findType("Uint8List"), + UnionSet_Uri: findType("UnionSet"), + UnknownJavaScriptObject: findType("UnknownJavaScriptObject"), + UnmodifiableListView_CssComment: findType("UnmodifiableListView"), + UnmodifiableListView_CssComment_2: findType("UnmodifiableListView"), + UnmodifiableListView_CssNode: findType("UnmodifiableListView"), + UnmodifiableListView_CssNode_2: findType("UnmodifiableListView"), + UnmodifiableListView_ForwardRule: findType("UnmodifiableListView"), + UnmodifiableListView_ForwardRule_2: findType("UnmodifiableListView"), + UnmodifiableListView_ModifiableCssNode: findType("UnmodifiableListView"), + UnmodifiableListView_ModifiableCssNode_2: findType("UnmodifiableListView"), + UnmodifiableListView_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span: findType("UnmodifiableListView<+deprecation,message,span(Deprecation?,String,FileSpan)>"), + UnmodifiableListView_Record_3_nullable_Deprecation_deprecation_and_String_message_and_FileSpan_span_2: findType("UnmodifiableListView<+deprecation,message,span(Deprecation0?,String,FileSpan)>"), + UnmodifiableListView_String: findType("UnmodifiableListView"), + UnmodifiableListView_UseRule: findType("UnmodifiableListView"), + UnmodifiableListView_UseRule_2: findType("UnmodifiableListView"), + UnmodifiableMapView_String_ArgParser: findType("UnmodifiableMapView"), + UnmodifiableMapView_String_ConfiguredValue: findType("UnmodifiableMapView"), + UnmodifiableMapView_String_ConfiguredValue_2: findType("UnmodifiableMapView"), + UnmodifiableMapView_String_Option: findType("UnmodifiableMapView"), + UnmodifiableMapView_String_Value: findType("UnmodifiableMapView"), + UnmodifiableMapView_String_Value_2: findType("UnmodifiableMapView"), + UnmodifiableMapView_of_Uri_and_nullable_StylesheetNode: findType("UnmodifiableMapView"), + UnmodifiableMapView_of_nullable_String_and_String: findType("UnmodifiableMapView"), + UnmodifiableMapView_of_nullable_String_and_nullable_String: findType("UnmodifiableMapView"), + UnmodifiableSetView_String: findType("UnmodifiableSetView0"), + UnmodifiableSetView_StylesheetNode: findType("UnmodifiableSetView0"), + UnmodifiableSetView_Uri: findType("UnmodifiableSetView0"), + UnprefixedMapView_ConfiguredValue: findType("UnprefixedMapView"), + UnprefixedMapView_ConfiguredValue_2: findType("UnprefixedMapView0"), + Uri: findType("Uri"), + UseRule: findType("UseRule"), + UserDefinedCallable_AsyncEnvironment: findType("UserDefinedCallable"), + UserDefinedCallable_AsyncEnvironment_2: findType("UserDefinedCallable0"), + UserDefinedCallable_Environment: findType("UserDefinedCallable"), + UserDefinedCallable_Environment_2: findType("UserDefinedCallable0"), + Value: findType("Value"), + Value_2: findType("Value0"), + Value_Function_List_Value: findType("Value(List)"), + Value_Function_List_Value_2: findType("Value0(List)"), + VariableDeclaration: findType("VariableDeclaration"), + VersionRange: findType("VersionRange"), + WatchEvent: findType("WatchEvent"), + WhereIterable_List_Iterable_ComplexSelectorComponent: findType("WhereIterable>>"), + WhereIterable_List_Iterable_ComplexSelectorComponent_2: findType("WhereIterable>>"), + WhereIterable_String: findType("WhereIterable"), + WhereTypeIterable_PseudoSelector: findType("WhereTypeIterable"), + WhereTypeIterable_PseudoSelector_2: findType("WhereTypeIterable"), + WhereTypeIterable_String: findType("WhereTypeIterable"), + _AsyncCompleter_List_void: findType("_AsyncCompleter>"), + _AsyncCompleter_Object: findType("_AsyncCompleter"), + _AsyncCompleter_Stream_WatchEvent: findType("_AsyncCompleter>"), + _AsyncCompleter_String: findType("_AsyncCompleter"), + _AsyncCompleter_nullable_Object: findType("_AsyncCompleter"), + _CompleterStream_WatchEvent: findType("_CompleterStream"), + _EventRequest_dynamic: findType("_EventRequest<@>"), + _Future_List_void: findType("_Future>"), + _Future_Object: findType("_Future"), + _Future_Stream_WatchEvent: findType("_Future>"), + _Future_String: findType("_Future"), + _Future_Value: findType("_Future"), + _Future_Value_2: findType("_Future"), + _Future_bool: findType("_Future"), + _Future_dynamic: findType("_Future<@>"), + _Future_int: findType("_Future"), + _Future_nullable_Object: findType("_Future"), + _Future_void: findType("_Future<~>"), + _Highlight: findType("_Highlight"), + _IdentityHashMap_of_nullable_Object_and_nullable_Object: findType("_IdentityHashMap"), + _LinkedIdentityHashSet_ComplexSelector: findType("_LinkedIdentityHashSet"), + _LinkedIdentityHashSet_ComplexSelector_2: findType("_LinkedIdentityHashSet"), + _LinkedIdentityHashSet_Extension: findType("_LinkedIdentityHashSet"), + _LinkedIdentityHashSet_Extension_2: findType("_LinkedIdentityHashSet"), + _MapEntry: findType("_MapEntry"), + _NodeException: findType("_NodeException"), + _PlatformUri: findType("_PlatformUri"), + _SyncStarIterable_Deprecation: findType("_SyncStarIterable"), + _SyncStarIterable_Extension: findType("_SyncStarIterable"), + _SyncStarIterable_Extension_2: findType("_SyncStarIterable"), + _SyncStarIterable_SimpleSelector: findType("_SyncStarIterable"), + _SyncStarIterable_SimpleSelector_2: findType("_SyncStarIterable"), + _SyncStarIterable_String: findType("_SyncStarIterable"), + bool: findType("bool"), + double: findType("double"), + dynamic: findType("@"), + dynamic_Function: findType("@()"), + dynamic_Function_Object: findType("@(Object)"), + dynamic_Function_Object_StackTrace: findType("@(Object,StackTrace)"), + int: findType("int"), + legacy_Never: findType("0&*"), + legacy_Object: findType("Object*"), + nullable_AstNode: findType("AstNode?"), + nullable_AstNode_2: findType("AstNode0?"), + nullable_CanonicalizeContext: findType("CanonicalizeContext?"), + nullable_CanonicalizeContext_2: findType("CanonicalizeContext0?"), + nullable_CssValue_String: findType("CssValue?"), + nullable_CssValue_String_2: findType("CssValue0?"), + nullable_FileSpan: findType("FileSpan?"), + nullable_Future_Null: findType("Future?"), + nullable_Future_void: findType("Future<~>?"), + nullable_ImporterResult: findType("ImporterResult?"), + nullable_ImporterResult_2: findType("ImporterResult0?"), + nullable_Object: findType("Object?"), + nullable_Record_2_String_and_String: findType("+(String,String)?"), + nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl: findType("+originalUrl(AsyncImporter,Uri,Uri)?"), + nullable_Record_3_AsyncImporter_and_Uri_and_Uri_originalUrl_2: findType("+originalUrl(AsyncImporter0,Uri,Uri)?"), + nullable_Record_3_Importer_and_Uri_and_Uri_originalUrl: findType("+originalUrl(Importer,Uri,Uri)?"), + nullable_Record_3_Importer_and_Uri_and_Uri_originalUrl_2: findType("+originalUrl(Importer0,Uri,Uri)?"), + nullable_Record_3_Stylesheet_and_nullable_AsyncImporter_importer_and_bool_isDependency: findType("+importer,isDependency(Stylesheet0,AsyncImporter0?,bool)?"), + nullable_Record_3_int_and_String_and_nullable_String: findType("+(int,String,String?)?"), + nullable_SourceFile: findType("SourceFile?"), + nullable_StreamSubscription_WatchEvent: findType("StreamSubscription?"), + nullable_String: findType("String?"), + nullable_Stylesheet: findType("Stylesheet?"), + nullable_StylesheetNode: findType("StylesheetNode?"), + nullable_Stylesheet_2: findType("Stylesheet0?"), + nullable_Uri: findType("Uri?"), + nullable_Value: findType("Value?"), + nullable_Value_2: findType("Value0?"), + nullable__ConstructorOptions: findType("_ConstructorOptions?"), + nullable__ConstructorOptions_2: findType("_ConstructorOptions0?"), + nullable__ConstructorOptions_3: findType("_ConstructorOptions1?"), + nullable__Highlight: findType("_Highlight?"), + nullable_double: findType("double?"), + num: findType("num"), + void: findType("~"), + void_Function_Object: findType("~(Object)"), + void_Function_Object_StackTrace: findType("~(Object,StackTrace)") + }; + })(); + (function constants() { + var makeConstList = hunkHelpers.makeConstList; + B.Interceptor_methods = J.Interceptor.prototype; + B.JSArray_methods = J.JSArray.prototype; + B.JSBool_methods = J.JSBool.prototype; + B.JSInt_methods = J.JSInt.prototype; + B.JSNull_methods = J.JSNull.prototype; + B.JSNumber_methods = J.JSNumber.prototype; + B.JSString_methods = J.JSString.prototype; + B.JavaScriptFunction_methods = J.JavaScriptFunction.prototype; + B.JavaScriptObject_methods = J.JavaScriptObject.prototype; + B.NativeUint32List_methods = A.NativeUint32List.prototype; + B.NativeUint8List_methods = A.NativeUint8List.prototype; + B.PlainJavaScriptObject_methods = J.PlainJavaScriptObject.prototype; + B.UnknownJavaScriptObject_methods = J.UnknownJavaScriptObject.prototype; + B.LinearChannel_Y0V = new A.LinearChannel(0, 1, false, false, false, "red", false, null); + B.LinearChannel_cPl = new A.LinearChannel(0, 1, false, false, false, "green", false, null); + B.LinearChannel_ABN = new A.LinearChannel(0, 1, false, false, false, "blue", false, null); + B.List_U47 = A._setArrayType(makeConstList([B.LinearChannel_Y0V, B.LinearChannel_cPl, B.LinearChannel_ABN]), type$.JSArray_LinearChannel); + B.A98RgbColorSpace_lf2 = new A.A98RgbColorSpace("a98-rgb", B.List_U47); + B.LinearChannel_Y0V0 = new A.LinearChannel0(0, 1, false, false, false, "red", false, null); + B.LinearChannel_cPl0 = new A.LinearChannel0(0, 1, false, false, false, "green", false, null); + B.LinearChannel_ABN0 = new A.LinearChannel0(0, 1, false, false, false, "blue", false, null); + B.List_U470 = A._setArrayType(makeConstList([B.LinearChannel_Y0V0, B.LinearChannel_cPl0, B.LinearChannel_ABN0]), type$.JSArray_LinearChannel_2); + B.A98RgbColorSpace_lf20 = new A.A98RgbColorSpace0("a98-rgb", B.List_U470); + B.AsciiEncoder_127 = new A.AsciiEncoder(127); + B.C_EmptyUnmodifiableSet1 = new A.EmptyUnmodifiableSet(A.findType("EmptyUnmodifiableSet")); + B.AtRootQuery_bfj = new A.AtRootQuery(false, B.C_EmptyUnmodifiableSet1, false, true); + B.AtRootQuery_bfj0 = new A.AtRootQuery0(false, B.C_EmptyUnmodifiableSet1, false, true); + B.AttributeOperator_GWq = new A.AttributeOperator("*=", "substring"); + B.AttributeOperator_GWq0 = new A.AttributeOperator0("*=", "substring"); + B.AttributeOperator_JzP = new A.AttributeOperator("^=", "prefix"); + B.AttributeOperator_JzP0 = new A.AttributeOperator0("^=", "prefix"); + B.AttributeOperator_Lvy = new A.AttributeOperator("=", "equal"); + B.AttributeOperator_Lvy0 = new A.AttributeOperator0("=", "equal"); + B.AttributeOperator_U1W = new A.AttributeOperator("$=", "suffix"); + B.AttributeOperator_U1W0 = new A.AttributeOperator0("$=", "suffix"); + B.AttributeOperator_fp2 = new A.AttributeOperator("~=", "include"); + B.AttributeOperator_fp20 = new A.AttributeOperator0("~=", "include"); + B.AttributeOperator_iyP = new A.AttributeOperator("|=", "dash"); + B.AttributeOperator_iyP0 = new A.AttributeOperator0("|=", "dash"); + B.BinaryOperator_FPG = new A.BinaryOperator("less than or equals", "<=", 4, false, "lessThanOrEquals"); + B.BinaryOperator_FPG0 = new A.BinaryOperator0("less than or equals", "<=", 4, false, "lessThanOrEquals"); + B.BinaryOperator_JiR = new A.BinaryOperator("greater than or equals", ">=", 4, false, "greaterThanOrEquals"); + B.BinaryOperator_JiR0 = new A.BinaryOperator0("greater than or equals", ">=", 4, false, "greaterThanOrEquals"); + B.BinaryOperator_Kyq = new A.BinaryOperator("single equals", "=", 0, false, "singleEquals"); + B.BinaryOperator_Kyq0 = new A.BinaryOperator0("single equals", "=", 0, false, "singleEquals"); + B.BinaryOperator_Mh5 = new A.BinaryOperator("divided by", "/", 6, false, "dividedBy"); + B.BinaryOperator_Mh50 = new A.BinaryOperator0("divided by", "/", 6, false, "dividedBy"); + B.BinaryOperator_QG1 = new A.BinaryOperator("minus", "-", 5, false, "minus"); + B.BinaryOperator_QG10 = new A.BinaryOperator0("minus", "-", 5, false, "minus"); + B.BinaryOperator_Swh = new A.BinaryOperator("plus", "+", 5, true, "plus"); + B.BinaryOperator_Swh0 = new A.BinaryOperator0("plus", "+", 5, true, "plus"); + B.BinaryOperator_o8O = new A.BinaryOperator("greater than", ">", 4, false, "greaterThan"); + B.BinaryOperator_o8O0 = new A.BinaryOperator0("greater than", ">", 4, false, "greaterThan"); + B.BinaryOperator_qGq = new A.BinaryOperator("not equals", "!=", 3, false, "notEquals"); + B.BinaryOperator_qGq0 = new A.BinaryOperator0("not equals", "!=", 3, false, "notEquals"); + B.BinaryOperator_qHy = new A.BinaryOperator("less than", "<", 4, false, "lessThan"); + B.BinaryOperator_qHy0 = new A.BinaryOperator0("less than", "<", 4, false, "lessThan"); + B.BinaryOperator_r84 = new A.BinaryOperator("equals", "==", 3, false, "equals"); + B.BinaryOperator_r840 = new A.BinaryOperator0("equals", "==", 3, false, "equals"); + B.BinaryOperator_s7T = new A.BinaryOperator("modulo", "%", 6, false, "modulo"); + B.BinaryOperator_s7T0 = new A.BinaryOperator0("modulo", "%", 6, false, "modulo"); + B.BinaryOperator_tKu = new A.BinaryOperator("or", "or", 1, true, "or"); + B.BinaryOperator_tKu0 = new A.BinaryOperator0("or", "or", 1, true, "or"); + B.BinaryOperator_tht = new A.BinaryOperator("times", "*", 6, true, "times"); + B.BinaryOperator_tht0 = new A.BinaryOperator0("times", "*", 6, true, "times"); + B.BinaryOperator_uke = new A.BinaryOperator("and", "and", 2, true, "and"); + B.BinaryOperator_uke0 = new A.BinaryOperator0("and", "and", 2, true, "and"); + B.CONSTANT = new A.Instantiation1(A.math0__max$closure(), A.findType("Instantiation1")); + B.C_AsciiCodec = new A.AsciiCodec(); + B.C_AsciiGlyphSet = new A.AsciiGlyphSet(); + B.C_Base64Encoder = new A.Base64Encoder(); + B.C_Base64Codec = new A.Base64Codec(); + B.C_DefaultEquality = new A.DefaultEquality(); + B.C_EmptyExtensionStore = new A.EmptyExtensionStore(); + B.C_EmptyExtensionStore0 = new A.EmptyExtensionStore0(); + B.C_EmptyIterator = new A.EmptyIterator(); + B.C_EmptyUnmodifiableSet = new A.EmptyUnmodifiableSet(A.findType("EmptyUnmodifiableSet")); + B.C_EmptyUnmodifiableSet0 = new A.EmptyUnmodifiableSet(A.findType("EmptyUnmodifiableSet")); + B.C_IsCalculationSafeVisitor = new A.IsCalculationSafeVisitor(); + B.C_IsCalculationSafeVisitor0 = new A.IsCalculationSafeVisitor0(); + B.C_IterableEquality = new A.IterableEquality(); + B.C_JS_CONST = function getTagFallback(o) { + var s = Object.prototype.toString.call(o); + return s.substring(8, s.length - 1); +}; + B.C_JS_CONST0 = function() { + var toStringFunction = Object.prototype.toString; + function getTag(o) { + var s = toStringFunction.call(o); + return s.substring(8, s.length - 1); + } + function getUnknownTag(object, tag) { + if (/^HTML[A-Z].*Element$/.test(tag)) { + var name = toStringFunction.call(object); + if (name == "[object Object]") return null; + return "HTMLElement"; + } + } + function getUnknownTagGenericBrowser(object, tag) { + if (object instanceof HTMLElement) return "HTMLElement"; + return getUnknownTag(object, tag); + } + function prototypeForTag(tag) { + if (typeof window == "undefined") return null; + if (typeof window[tag] == "undefined") return null; + var constructor = window[tag]; + if (typeof constructor != "function") return null; + return constructor.prototype; + } + function discriminator(tag) { return null; } + var isBrowser = typeof HTMLElement == "function"; + return { + getTag: getTag, + getUnknownTag: isBrowser ? getUnknownTagGenericBrowser : getUnknownTag, + prototypeForTag: prototypeForTag, + discriminator: discriminator }; +}; + B.C_JS_CONST6 = function(getTagFallback) { + return function(hooks) { + if (typeof navigator != "object") return hooks; + var userAgent = navigator.userAgent; + if (typeof userAgent != "string") return hooks; + if (userAgent.indexOf("DumpRenderTree") >= 0) return hooks; + if (userAgent.indexOf("Chrome") >= 0) { + function confirm(p) { + return typeof window == "object" && window[p] && window[p].name == p; + } + if (confirm("Window") && confirm("HTMLElement")) return hooks; + } + hooks.getTag = getTagFallback; + }; +}; + B.C_JS_CONST1 = function(hooks) { + if (typeof dartExperimentalFixupGetTag != "function") return hooks; + hooks.getTag = dartExperimentalFixupGetTag(hooks.getTag); +}; + B.C_JS_CONST5 = function(hooks) { + if (typeof navigator != "object") return hooks; + var userAgent = navigator.userAgent; + if (typeof userAgent != "string") return hooks; + if (userAgent.indexOf("Firefox") == -1) return hooks; + var getTag = hooks.getTag; + var quickMap = { + "BeforeUnloadEvent": "Event", + "DataTransfer": "Clipboard", + "GeoGeolocation": "Geolocation", + "Location": "!Location", + "WorkerMessageEvent": "MessageEvent", + "XMLDocument": "!Document"}; + function getTagFirefox(o) { + var tag = getTag(o); + return quickMap[tag] || tag; + } + hooks.getTag = getTagFirefox; +}; + B.C_JS_CONST4 = function(hooks) { + if (typeof navigator != "object") return hooks; + var userAgent = navigator.userAgent; + if (typeof userAgent != "string") return hooks; + if (userAgent.indexOf("Trident/") == -1) return hooks; + var getTag = hooks.getTag; + var quickMap = { + "BeforeUnloadEvent": "Event", + "DataTransfer": "Clipboard", + "HTMLDDElement": "HTMLElement", + "HTMLDTElement": "HTMLElement", + "HTMLPhraseElement": "HTMLElement", + "Position": "Geoposition" + }; + function getTagIE(o) { + var tag = getTag(o); + var newTag = quickMap[tag]; + if (newTag) return newTag; + if (tag == "Object") { + if (window.DataView && (o instanceof window.DataView)) return "DataView"; + } + return tag; + } + function prototypeForTagIE(tag) { + var constructor = window[tag]; + if (constructor == null) return null; + return constructor.prototype; + } + hooks.getTag = getTagIE; + hooks.prototypeForTag = prototypeForTagIE; +}; + B.C_JS_CONST2 = function(hooks) { + var getTag = hooks.getTag; + var prototypeForTag = hooks.prototypeForTag; + function getTagFixed(o) { + var tag = getTag(o); + if (tag == "Document") { + if (!!o.xmlVersion) return "!Document"; + return "!HTMLDocument"; + } + return tag; + } + function prototypeForTagFixed(tag) { + if (tag == "Document") return null; + return prototypeForTag(tag); + } + hooks.getTag = getTagFixed; + hooks.prototypeForTag = prototypeForTagFixed; +}; + B.C_JS_CONST3 = function(hooks) { return hooks; } +; + B.C_JsonCodec = new A.JsonCodec(); + B.C_ListEquality0 = new A.ListEquality(); + B.C_ListEquality = new A.ListEquality(); + B.C_MapEquality = new A.MapEquality(A.findType("MapEquality")); + B.C_OutOfMemoryError = new A.OutOfMemoryError(); + B.C_SentinelValue = new A.SentinelValue(); + B.C_UnicodeGlyphSet = new A.UnicodeGlyphSet(); + B.C_Utf8Codec = new A.Utf8Codec(); + B.C_Utf8Encoder = new A.Utf8Encoder(); + B.C__ColorFormatEnum = new A._ColorFormatEnum(); + B.C__ColorFormatEnum0 = new A._ColorFormatEnum0(); + B.C__DelayedDone = new A._DelayedDone(); + B.C__HasContentVisitor = new A._HasContentVisitor(); + B.C__HasContentVisitor0 = new A._HasContentVisitor0(); + B.C__IsUselessVisitor = new A._IsUselessVisitor(); + B.C__IsUselessVisitor0 = new A._IsUselessVisitor0(); + B.C__JSRandom = new A._JSRandom(); + B.C__MakeExpressionCalculationSafe = new A._MakeExpressionCalculationSafe(); + B.C__MakeExpressionCalculationSafe0 = new A._MakeExpressionCalculationSafe0(); + B.C__ParentSelectorVisitor = new A._ParentSelectorVisitor(); + B.C__ParentSelectorVisitor0 = new A._ParentSelectorVisitor0(); + B.C__Required = new A._Required(); + B.C__RootZone = new A._RootZone(); + B.C__SassNull = new A._SassNull(); + B.C__SassNull0 = new A._SassNull0(); + B.CalculationOperator_F7i = new A.CalculationOperator("plus", "+", 1, "plus"); + B.CalculationOperator_F7i0 = new A.CalculationOperator0("plus", "+", 1, "plus"); + B.CalculationOperator_bo5 = new A.CalculationOperator("divided by", "/", 2, "dividedBy"); + B.CalculationOperator_bo50 = new A.CalculationOperator0("divided by", "/", 2, "dividedBy"); + B.CalculationOperator_kkN = new A.CalculationOperator("times", "*", 2, "times"); + B.CalculationOperator_kkN0 = new A.CalculationOperator0("times", "*", 2, "times"); + B.CalculationOperator_oum = new A.CalculationOperator("minus", "-", 1, "minus"); + B.CalculationOperator_oum0 = new A.CalculationOperator0("minus", "-", 1, "minus"); + B.ChangeType_add = new A.ChangeType("add"); + B.ChangeType_modify = new A.ChangeType("modify"); + B.ChangeType_remove = new A.ChangeType("remove"); + B.ClipGamutMap_clip = new A.ClipGamutMap("clip"); + B.ClipGamutMap_clip0 = new A.ClipGamutMap0("clip"); + B.Combinator_0mp = new A.Combinator(">", "child"); + B.Combinator_0mp0 = new A.Combinator0(">", "child"); + B.Combinator_55N = new A.Combinator("~", "followingSibling"); + B.Combinator_55N0 = new A.Combinator0("~", "followingSibling"); + B.Combinator_bOP = new A.Combinator("+", "nextSibling"); + B.Combinator_bOP0 = new A.Combinator0("+", "nextSibling"); + B.Object_empty = {}; + B.Map_empty18 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap")); + B.Configuration_Map_empty_null = new A.Configuration(B.Map_empty18, null); + B.Map_empty19 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap")); + B.Configuration_Map_empty_null0 = new A.Configuration0(B.Map_empty19, null); + B.Deprecation_0NP = new A.Deprecation("duplicate-var-flags", "1.62.0", "duplicateVarFlags"); + B.Deprecation_1AX = new A.Deprecation("global-builtin", "1.80.0", "globalBuiltin"); + B.Deprecation_2g5 = new A.Deprecation("import", "1.80.0", "import"); + B.Deprecation_39u = new A.Deprecation("mixed-decls", "1.77.7", "mixedDecls"); + B.Deprecation_746 = new A.Deprecation("relative-canonical", "1.14.2", "relativeCanonical"); + B.Deprecation_89v = new A.Deprecation("moz-document", "1.7.2", "mozDocument"); + B.Deprecation_8ki = new A.Deprecation0("elseif", "1.3.2", "@elseif.", "elseif"); + B.Deprecation_9hF = new A.Deprecation("bogus-combinators", "1.54.0", "bogusCombinators"); + B.Deprecation_BvP = new A.Deprecation("slash-div", "1.33.0", "slashDiv"); + B.Deprecation_BzI = new A.Deprecation0("duplicate-var-flags", "1.62.0", "Using !default or !global multiple times for one variable.", "duplicateVarFlags"); + B.Deprecation_CRw = new A.Deprecation0("strict-unary", "1.55.0", "Ambiguous + and - operators.", "strictUnary"); + B.Deprecation_Ds6 = new A.Deprecation0("fs-importer-cwd", "1.73.0", "Using the current working directory as an implicit load path.", "fsImporterCwd"); + B.Deprecation_F8y = new A.Deprecation0("legacy-js-api", "1.79.0", "Legacy JS API.", "legacyJsApi"); + B.Deprecation_FD1 = new A.Deprecation0("color-4-api", "1.79.0", "Certain uses of built-in sass:color functions.", "color4Api"); + B.Deprecation_FyB = new A.Deprecation0("slash-div", "1.33.0", "/ operator for division.", "slashDiv"); + B.Deprecation_HIp = new A.Deprecation0("feature-exists", "1.78.0", "meta.feature-exists", "featureExists"); + B.Deprecation_Kg6 = new A.Deprecation("css-function-mixin", "1.76.0", "cssFunctionMixin"); + B.Deprecation_Kry = new A.Deprecation0("color-module-compat", "1.23.0", "Using color module functions in place of plain CSS functions.", "colorModuleCompat"); + B.Deprecation_KtC = new A.Deprecation("user-authored", null, "userAuthored"); + B.Deprecation_L0R = new A.Deprecation0("moz-document", "1.7.2", "@-moz-document.", "mozDocument"); + B.Deprecation_MSr = new A.Deprecation0("mixed-decls", "1.77.7", "Declarations after or between nested rules.", "mixedDecls"); + B.Deprecation_OHJ = new A.Deprecation0("import", "1.80.0", "@import rules.", "import"); + B.Deprecation_Ord = new A.Deprecation0("relative-canonical", "1.14.2", "Imports using relative canonical URLs.", "relativeCanonical"); + B.Deprecation_Rg0 = new A.Deprecation("new-global", "1.17.2", "newGlobal"); + B.Deprecation_SHb = new A.Deprecation0("bogus-combinators", "1.54.0", "Leading, trailing, and repeated combinators.", "bogusCombinators"); + B.Deprecation_UYp = new A.Deprecation0("abs-percent", "1.65.0", "Passing percentages to the Sass abs() function.", "absPercent"); + B.Deprecation_ZDV = new A.Deprecation0("global-builtin", "1.80.0", "Global built-in functions that are available in sass: modules.", "globalBuiltin"); + B.Deprecation_ZVM = new A.Deprecation0("user-authored", null, null, "userAuthored"); + B.Deprecation_aM0 = new A.Deprecation0("call-string", "0.0.0", "Passing a string directly to meta.call().", "callString"); + B.Deprecation_cyE = new A.Deprecation("color-functions", "1.79.0", "colorFunctions"); + B.Deprecation_d4j = new A.Deprecation0("css-function-mixin", "1.76.0", "Function and mixin names beginning with --.", "cssFunctionMixin"); + B.Deprecation_dAn = new A.Deprecation("call-string", "0.0.0", "callString"); + B.Deprecation_f5Y = new A.Deprecation0("calc-interp", null, null, "calcInterp"); + B.Deprecation_fdF = new A.Deprecation0("color-functions", "1.79.0", "Using global color functions instead of sass:color.", "colorFunctions"); + B.Deprecation_hAa = new A.Deprecation("elseif", "1.3.2", "elseif"); + B.Deprecation_hcg = new A.Deprecation("feature-exists", "1.78.0", "featureExists"); + B.Deprecation_jG1 = new A.Deprecation("function-units", "1.56.0", "functionUnits"); + B.Deprecation_kms = new A.Deprecation("type-function", "1.86.0", "typeFunction"); + B.Deprecation_l0m = new A.Deprecation0("null-alpha", "1.62.3", "Passing null as alpha in the JS API.", "nullAlpha"); + B.Deprecation_mSy = new A.Deprecation0("new-global", "1.17.2", "Declaring new variables with !global.", "newGlobal"); + B.Deprecation_pLJ = new A.Deprecation("abs-percent", "1.65.0", "absPercent"); + B.Deprecation_t60 = new A.Deprecation("strict-unary", "1.55.0", "strictUnary"); + B.Deprecation_tms = new A.Deprecation("fs-importer-cwd", "1.73.0", "fsImporterCwd"); + B.Deprecation_u0j = new A.Deprecation("color-module-compat", "1.23.0", "colorModuleCompat"); + B.Deprecation_vQt = new A.Deprecation0("type-function", "1.86.0", 'Functions named "type".', "typeFunction"); + B.Deprecation_vn5 = new A.Deprecation0("function-units", "1.56.0", "Passing invalid units to built-in functions.", "functionUnits"); + B.DisplayP3ColorSpace_MmT = new A.DisplayP3ColorSpace("display-p3", B.List_U47); + B.DisplayP3ColorSpace_MmT0 = new A.DisplayP3ColorSpace0("display-p3", B.List_U470); + B.Duration_0 = new A.Duration(0); + B.ExtendMode_allTargets_allTargets = new A.ExtendMode("allTargets", "allTargets"); + B.ExtendMode_allTargets_allTargets0 = new A.ExtendMode0("allTargets", "allTargets"); + B.ExtendMode_normal_normal = new A.ExtendMode("normal", "normal"); + B.ExtendMode_normal_normal0 = new A.ExtendMode0("normal", "normal"); + B.ExtendMode_replace_replace = new A.ExtendMode("replace", "replace"); + B.ExtendMode_replace_replace0 = new A.ExtendMode0("replace", "replace"); + B.ColorChannel_hue_true_deg = new A.ColorChannel("hue", true, "deg"); + B.LinearChannel_Cal = new A.LinearChannel(0, 100, true, true, false, "saturation", false, "%"); + B.LinearChannel_w1m = new A.LinearChannel(0, 100, true, false, false, "lightness", false, "%"); + B.List_oAL = A._setArrayType(makeConstList([B.ColorChannel_hue_true_deg, B.LinearChannel_Cal, B.LinearChannel_w1m]), type$.JSArray_ColorChannel); + B.HslColorSpace_JQ2 = new A.HslColorSpace("hsl", B.List_oAL); + B.ColorChannel_hue_true_deg0 = new A.ColorChannel0("hue", true, "deg"); + B.LinearChannel_Cal0 = new A.LinearChannel0(0, 100, true, true, false, "saturation", false, "%"); + B.LinearChannel_w1m0 = new A.LinearChannel0(0, 100, true, false, false, "lightness", false, "%"); + B.List_oAL0 = A._setArrayType(makeConstList([B.ColorChannel_hue_true_deg0, B.LinearChannel_Cal0, B.LinearChannel_w1m0]), type$.JSArray_ColorChannel_2); + B.HslColorSpace_JQ20 = new A.HslColorSpace0("hsl", B.List_oAL0); + B.HueInterpolationMethod_0 = new A.HueInterpolationMethod("shorter"); + B.HueInterpolationMethod_00 = new A.HueInterpolationMethod0("shorter"); + B.HueInterpolationMethod_1 = new A.HueInterpolationMethod("longer"); + B.HueInterpolationMethod_10 = new A.HueInterpolationMethod0("longer"); + B.HueInterpolationMethod_2 = new A.HueInterpolationMethod("increasing"); + B.HueInterpolationMethod_20 = new A.HueInterpolationMethod0("increasing"); + B.HueInterpolationMethod_3 = new A.HueInterpolationMethod("decreasing"); + B.HueInterpolationMethod_30 = new A.HueInterpolationMethod0("decreasing"); + B.LinearChannel_mPM = new A.LinearChannel(0, 100, true, false, false, "whiteness", false, "%"); + B.LinearChannel_NBP = new A.LinearChannel(0, 100, true, false, false, "blackness", false, "%"); + B.List_Ar1 = A._setArrayType(makeConstList([B.ColorChannel_hue_true_deg, B.LinearChannel_mPM, B.LinearChannel_NBP]), type$.JSArray_ColorChannel); + B.HwbColorSpace_guQ = new A.HwbColorSpace("hwb", B.List_Ar1); + B.LinearChannel_mPM0 = new A.LinearChannel0(0, 100, true, false, false, "whiteness", false, "%"); + B.LinearChannel_NBP0 = new A.LinearChannel0(0, 100, true, false, false, "blackness", false, "%"); + B.List_Ar10 = A._setArrayType(makeConstList([B.ColorChannel_hue_true_deg0, B.LinearChannel_mPM0, B.LinearChannel_NBP0]), type$.JSArray_ColorChannel_2); + B.HwbColorSpace_guQ0 = new A.HwbColorSpace0("hwb", B.List_Ar10); + B.JsonDecoder_null = new A.JsonDecoder(null); + B.JsonEncoder_null = new A.JsonEncoder(null); + B.LinearChannel_rY5 = new A.LinearChannel(0, 100, false, true, true, "lightness", false, "%"); + B.LinearChannel_vtc = new A.LinearChannel(-125, 125, false, false, false, "a", false, null); + B.LinearChannel_r83 = new A.LinearChannel(-125, 125, false, false, false, "b", false, null); + B.List_KEo = A._setArrayType(makeConstList([B.LinearChannel_rY5, B.LinearChannel_vtc, B.LinearChannel_r83]), type$.JSArray_ColorChannel); + B.LabColorSpace_2nT = new A.LabColorSpace("lab", B.List_KEo); + B.LinearChannel_rY50 = new A.LinearChannel0(0, 100, false, true, true, "lightness", false, "%"); + B.LinearChannel_vtc0 = new A.LinearChannel0(-125, 125, false, false, false, "a", false, null); + B.LinearChannel_r830 = new A.LinearChannel0(-125, 125, false, false, false, "b", false, null); + B.List_KEo0 = A._setArrayType(makeConstList([B.LinearChannel_rY50, B.LinearChannel_vtc0, B.LinearChannel_r830]), type$.JSArray_ColorChannel_2); + B.LabColorSpace_2nT0 = new A.LabColorSpace0("lab", B.List_KEo0); + B.LinearChannel_JUs = new A.LinearChannel(0, 150, false, true, false, "chroma", false, null); + B.List_grF = A._setArrayType(makeConstList([B.LinearChannel_rY5, B.LinearChannel_JUs, B.ColorChannel_hue_true_deg]), type$.JSArray_ColorChannel); + B.LchColorSpace_Bpv = new A.LchColorSpace("lch", B.List_grF); + B.LinearChannel_JUs0 = new A.LinearChannel0(0, 150, false, true, false, "chroma", false, null); + B.List_grF0 = A._setArrayType(makeConstList([B.LinearChannel_rY50, B.LinearChannel_JUs0, B.ColorChannel_hue_true_deg0]), type$.JSArray_ColorChannel_2); + B.LchColorSpace_Bpv0 = new A.LchColorSpace0("lch", B.List_grF0); + B.LineFeed_9HY = new A.LineFeed0("lf", "\n", "lf"); + B.LineFeed_G7N = new A.LineFeed0("lfcr", "\n\r", "lfcr"); + B.LineFeed_Pcs = new A.LineFeed0("crlf", "\r\n", "crlf"); + B.LineFeed_lf = new A.LineFeed("lf"); + B.LineFeed_ybQ = new A.LineFeed0("cr", "\r", "cr"); + B.LinearChannel_XL8 = new A.LinearChannel(0, 1, false, false, false, "alpha", false, null); + B.LinearChannel_XL80 = new A.LinearChannel0(0, 1, false, false, false, "alpha", false, null); + B.LinearChannel_Z5r = new A.LinearChannel(0, 255, false, true, true, "green", false, null); + B.LinearChannel_Z5r0 = new A.LinearChannel0(0, 255, false, true, true, "green", false, null); + B.LinearChannel_qXC = new A.LinearChannel(0, 255, false, true, true, "red", false, null); + B.LinearChannel_qXC0 = new A.LinearChannel0(0, 255, false, true, true, "red", false, null); + B.LinearChannel_vJ3 = new A.LinearChannel(0, 255, false, true, true, "blue", false, null); + B.LinearChannel_vJ30 = new A.LinearChannel0(0, 255, false, true, true, "blue", false, null); + B.ListSeparator_bRz = new A.ListSeparator("slash", "/", "slash"); + B.ListSeparator_bRz0 = new A.ListSeparator0("slash", "/", "slash"); + B.ListSeparator_qSL = new A.ListSeparator("space", " ", "space"); + B.ListSeparator_qSL0 = new A.ListSeparator0("space", " ", "space"); + B.ListSeparator_qVN = new A.ListSeparator("comma", ",", "comma"); + B.ListSeparator_qVN0 = new A.ListSeparator0("comma", ",", "comma"); + B.ListSeparator_undecided_null_undecided = new A.ListSeparator("undecided", null, "undecided"); + B.ListSeparator_undecided_null_undecided0 = new A.ListSeparator0("undecided", null, "undecided"); + B.Object_84Z = {em: 0, rem: 1, ex: 2, rex: 3, cap: 4, rcap: 5, ch: 6, rch: 7, ic: 8, ric: 9, lh: 10, rlh: 11, vw: 12, lvw: 13, svw: 14, dvw: 15, vh: 16, lvh: 17, svh: 18, dvh: 19, vi: 20, lvi: 21, svi: 22, dvi: 23, vb: 24, lvb: 25, svb: 26, dvb: 27, vmin: 28, lvmin: 29, svmin: 30, dvmin: 31, vmax: 32, lvmax: 33, svmax: 34, dvmax: 35, cqw: 36, cqh: 37, cqi: 38, cqb: 39, cqmin: 40, cqmax: 41, cm: 42, mm: 43, q: 44, in: 45, pt: 46, pc: 47, px: 48}; + B.Set_V30th = new A.ConstantStringSet(B.Object_84Z, 49, type$.ConstantStringSet_String); + B.Object_a6W = {deg: 0, grad: 1, rad: 2, turn: 3}; + B.Set_5FBBb = new A.ConstantStringSet(B.Object_a6W, 4, type$.ConstantStringSet_String); + B.Object_s_0_ms_1 = {s: 0, ms: 1}; + B.Set_cXesm = new A.ConstantStringSet(B.Object_s_0_ms_1, 2, type$.ConstantStringSet_String); + B.Object_hz_0_khz_1 = {hz: 0, khz: 1}; + B.Set_1Tayw = new A.ConstantStringSet(B.Object_hz_0_khz_1, 2, type$.ConstantStringSet_String); + B.Object_CHz = {dpi: 0, dpcm: 1, dppx: 2}; + B.Set_w2NC6 = new A.ConstantStringSet(B.Object_CHz, 3, type$.ConstantStringSet_String); + B.List_BFg = A._setArrayType(makeConstList([B.Set_V30th, B.Set_5FBBb, B.Set_cXesm, B.Set_1Tayw, B.Set_w2NC6]), A.findType("JSArray>")); + B.List_MG2 = A._setArrayType(makeConstList([B.Deprecation_aM0, B.Deprecation_8ki, B.Deprecation_L0R, B.Deprecation_Ord, B.Deprecation_mSy, B.Deprecation_Kry, B.Deprecation_FyB, B.Deprecation_SHb, B.Deprecation_CRw, B.Deprecation_vn5, B.Deprecation_BzI, B.Deprecation_l0m, B.Deprecation_UYp, B.Deprecation_Ds6, B.Deprecation_d4j, B.Deprecation_MSr, B.Deprecation_HIp, B.Deprecation_FD1, B.Deprecation_fdF, B.Deprecation_F8y, B.Deprecation_OHJ, B.Deprecation_ZDV, B.Deprecation_vQt, B.Deprecation_ZVM, B.Deprecation_f5Y]), A.findType("JSArray")); + B.Deprecation_MJf = new A.Deprecation("null-alpha", "1.62.3", "nullAlpha"); + B.Deprecation_Nem = new A.Deprecation("color-4-api", "1.79.0", "color4Api"); + B.Deprecation_fsU = new A.Deprecation("legacy-js-api", "1.79.0", "legacyJsApi"); + B.Deprecation_ggp = new A.Deprecation("calc-interp", null, "calcInterp"); + B.List_dCD = A._setArrayType(makeConstList([B.Deprecation_dAn, B.Deprecation_hAa, B.Deprecation_89v, B.Deprecation_746, B.Deprecation_Rg0, B.Deprecation_u0j, B.Deprecation_BvP, B.Deprecation_9hF, B.Deprecation_t60, B.Deprecation_jG1, B.Deprecation_0NP, B.Deprecation_MJf, B.Deprecation_pLJ, B.Deprecation_tms, B.Deprecation_Kg6, B.Deprecation_39u, B.Deprecation_hcg, B.Deprecation_Nem, B.Deprecation_cyE, B.Deprecation_fsU, B.Deprecation_2g5, B.Deprecation_1AX, B.Deprecation_kms, B.Deprecation_KtC, B.Deprecation_ggp]), A.findType("JSArray")); + B.List_empty26 = A._setArrayType(makeConstList([]), type$.JSArray_AsyncCallable_2); + B.List_empty27 = A._setArrayType(makeConstList([]), type$.JSArray_AsyncImporter); + B.List_empty1 = A._setArrayType(makeConstList([]), type$.JSArray_ComplexSelector); + B.List_empty15 = A._setArrayType(makeConstList([]), type$.JSArray_ComplexSelector_2); + B.List_empty2 = A._setArrayType(makeConstList([]), type$.JSArray_ComplexSelectorComponent); + B.List_empty16 = A._setArrayType(makeConstList([]), type$.JSArray_ComplexSelectorComponent_2); + B.List_empty10 = A._setArrayType(makeConstList([]), type$.JSArray_ConfiguredVariable); + B.List_empty22 = A._setArrayType(makeConstList([]), type$.JSArray_ConfiguredVariable_2); + B.List_empty3 = A._setArrayType(makeConstList([]), type$.JSArray_CssNode); + B.List_empty17 = A._setArrayType(makeConstList([]), type$.JSArray_CssNode_2); + B.List_empty11 = A._setArrayType(makeConstList([]), type$.JSArray_CssStyleRule); + B.List_empty23 = A._setArrayType(makeConstList([]), type$.JSArray_CssStyleRule_2); + B.List_empty0 = A._setArrayType(makeConstList([]), type$.JSArray_CssValue_Combinator); + B.List_empty14 = A._setArrayType(makeConstList([]), type$.JSArray_CssValue_Combinator_2); + B.List_empty9 = A._setArrayType(makeConstList([]), type$.JSArray_Expression); + B.List_empty21 = A._setArrayType(makeConstList([]), type$.JSArray_Expression_2); + B.List_empty5 = A._setArrayType(makeConstList([]), type$.JSArray_Extension); + B.List_empty18 = A._setArrayType(makeConstList([]), type$.JSArray_Extension_2); + B.List_empty25 = A._setArrayType(makeConstList([]), type$.JSArray_Importer_2); + B.List_empty7 = A._setArrayType(makeConstList([]), A.findType("JSArray>")); + B.List_empty19 = A._setArrayType(makeConstList([]), A.findType("JSArray>")); + B.List_empty28 = A._setArrayType(makeConstList([]), type$.JSArray_Object); + B.List_empty12 = A._setArrayType(makeConstList([]), type$.JSArray_Parameter); + B.List_empty24 = A._setArrayType(makeConstList([]), type$.JSArray_Parameter_2); + B.List_empty13 = A._setArrayType(makeConstList([]), type$.JSArray_Statement); + B.List_empty = A._setArrayType(makeConstList([]), type$.JSArray_String); + B.List_empty8 = A._setArrayType(makeConstList([]), type$.JSArray_Value); + B.List_empty20 = A._setArrayType(makeConstList([]), type$.JSArray_Value_2); + B.List_empty4 = A._setArrayType(makeConstList([]), type$.JSArray_int); + B.List_empty6 = A._setArrayType(makeConstList([]), type$.JSArray_dynamic); + B.List_empty29 = A._setArrayType(makeConstList([]), type$.JSArray_nullable_FileSpan); + B.List_g9w = A._setArrayType(makeConstList([B.CalculationOperator_F7i0, B.CalculationOperator_oum0, B.CalculationOperator_kkN0, B.CalculationOperator_bo50]), A.findType("JSArray")); + B.List_nm2 = A._setArrayType(makeConstList([B.HueInterpolationMethod_00, B.HueInterpolationMethod_10, B.HueInterpolationMethod_20, B.HueInterpolationMethod_30]), A.findType("JSArray")); + B.List_null = A._setArrayType(makeConstList([null]), type$.JSArray_nullable_FileSpan); + B.LinearChannel_n2W = new A.LinearChannel(0, 1, false, false, false, "long", false, null); + B.LinearChannel_ZmQ = new A.LinearChannel(0, 1, false, false, false, "medium", false, null); + B.LinearChannel_yJH = new A.LinearChannel(0, 1, false, false, false, "short", false, null); + B.List_wOx = A._setArrayType(makeConstList([B.LinearChannel_n2W, B.LinearChannel_ZmQ, B.LinearChannel_yJH]), type$.JSArray_ColorChannel); + B.LmsColorSpace_Os3 = new A.LmsColorSpace("lms", B.List_wOx); + B.LinearChannel_n2W0 = new A.LinearChannel0(0, 1, false, false, false, "long", false, null); + B.LinearChannel_ZmQ0 = new A.LinearChannel0(0, 1, false, false, false, "medium", false, null); + B.LinearChannel_yJH0 = new A.LinearChannel0(0, 1, false, false, false, "short", false, null); + B.List_wOx0 = A._setArrayType(makeConstList([B.LinearChannel_n2W0, B.LinearChannel_ZmQ0, B.LinearChannel_yJH0]), type$.JSArray_ColorChannel_2); + B.LmsColorSpace_Os30 = new A.LmsColorSpace0("lms", B.List_wOx0); + B.LocalMindeGamutMap_A2x = new A.LocalMindeGamutMap("local-minde"); + B.LocalMindeGamutMap_A2x0 = new A.LocalMindeGamutMap0("local-minde"); + B.Object_CSf = {in: 0, cm: 1, pc: 2, mm: 3, q: 4, pt: 5, px: 6, deg: 7, grad: 8, rad: 9, turn: 10, s: 11, ms: 12, Hz: 13, kHz: 14, dpi: 15, dpcm: 16, dppx: 17}; + B.Object_R4j = {in: 0, cm: 1, pc: 2, mm: 3, q: 4, pt: 5, px: 6}; + B.Map_LdTcR = new A.ConstantStringMap(B.Object_R4j, [1, 0.39370078740157477, 0.16666666666666666, 0.03937007874015748, 0.00984251968503937, 0.013888888888888888, 0.010416666666666666], type$.ConstantStringMap_String_double); + B.Map_LdCjQ = new A.ConstantStringMap(B.Object_R4j, [2.54, 1, 0.42333333333333334, 0.1, 0.025, 0.035277777777777776, 0.026458333333333334], type$.ConstantStringMap_String_double); + B.Map_Ldr6M = new A.ConstantStringMap(B.Object_R4j, [6, 2.3622047244094486, 1, 0.2362204724409449, 0.05905511811023623, 0.08333333333333333, 0.0625], type$.ConstantStringMap_String_double); + B.Map_LdTyG = new A.ConstantStringMap(B.Object_R4j, [25.4, 10, 4.233333333333333, 1, 0.25, 0.35277777777777775, 0.26458333333333334], type$.ConstantStringMap_String_double); + B.Map_Ld577 = new A.ConstantStringMap(B.Object_R4j, [101.6, 40, 16.933333333333334, 4, 1, 1.411111111111111, 1.0583333333333333], type$.ConstantStringMap_String_double); + B.Map_LdIVT = new A.ConstantStringMap(B.Object_R4j, [72, 28.346456692913385, 12, 2.834645669291339, 0.7086614173228347, 1, 0.75], type$.ConstantStringMap_String_double); + B.Map_Ld6L5 = new A.ConstantStringMap(B.Object_R4j, [96, 37.79527559055118, 16, 3.7795275590551185, 0.9448818897637796, 1.3333333333333333, 1], type$.ConstantStringMap_String_double); + B.Map_LjNxM = new A.ConstantStringMap(B.Object_a6W, [1, 0.9, 57.29577951308232, 360], type$.ConstantStringMap_String_double); + B.Map_Lj8V1 = new A.ConstantStringMap(B.Object_a6W, [1.1111111111111112, 1, 63.66197723675813, 400], type$.ConstantStringMap_String_double); + B.Map_LjePw = new A.ConstantStringMap(B.Object_a6W, [0.017453292519943295, 0.015707963267948967, 1, 6.283185307179586], type$.ConstantStringMap_String_double); + B.Map_LjtMd = new A.ConstantStringMap(B.Object_a6W, [0.002777777777777778, 0.0025, 0.15915494309189535, 1], type$.ConstantStringMap_String_double); + B.Map_Aezv1 = new A.ConstantStringMap(B.Object_s_0_ms_1, [1, 0.001], type$.ConstantStringMap_String_double); + B.Map_AeI7g = new A.ConstantStringMap(B.Object_s_0_ms_1, [1000, 1], type$.ConstantStringMap_String_double); + B.Object_Hz_0_kHz_1 = {Hz: 0, kHz: 1}; + B.Map_kdDCg = new A.ConstantStringMap(B.Object_Hz_0_kHz_1, [1, 1000], type$.ConstantStringMap_String_double); + B.Map_kdBEM = new A.ConstantStringMap(B.Object_Hz_0_kHz_1, [0.001, 1], type$.ConstantStringMap_String_double); + B.Map_vIkFS = new A.ConstantStringMap(B.Object_CHz, [1, 2.54, 96], type$.ConstantStringMap_String_double); + B.Map_vIY7E = new A.ConstantStringMap(B.Object_CHz, [0.39370078740157477, 1, 37.79527559055118], type$.ConstantStringMap_String_double); + B.Map_vIcSC = new A.ConstantStringMap(B.Object_CHz, [0.010416666666666666, 0.026458333333333334, 1], type$.ConstantStringMap_String_double); + B.Map_NtHoP = new A.ConstantStringMap(B.Object_CSf, [B.Map_LdTcR, B.Map_LdCjQ, B.Map_Ldr6M, B.Map_LdTyG, B.Map_Ld577, B.Map_LdIVT, B.Map_Ld6L5, B.Map_LjNxM, B.Map_Lj8V1, B.Map_LjePw, B.Map_LjtMd, B.Map_Aezv1, B.Map_AeI7g, B.Map_kdDCg, B.Map_kdBEM, B.Map_vIkFS, B.Map_vIY7E, B.Map_vIcSC], A.findType("ConstantStringMap>")); + B.Object_J3y = {length: 0, angle: 1, time: 2, frequency: 3, "pixel density": 4}; + B.List_Ldp = A._setArrayType(makeConstList(["in", "cm", "pc", "mm", "q", "pt", "px"]), type$.JSArray_String); + B.List_deg_grad_rad_turn = A._setArrayType(makeConstList(["deg", "grad", "rad", "turn"]), type$.JSArray_String); + B.List_s_ms = A._setArrayType(makeConstList(["s", "ms"]), type$.JSArray_String); + B.List_Hz_kHz = A._setArrayType(makeConstList(["Hz", "kHz"]), type$.JSArray_String); + B.List_dpi_dpcm_dppx = A._setArrayType(makeConstList(["dpi", "dpcm", "dppx"]), type$.JSArray_String); + B.Map_Sr65K = new A.ConstantStringMap(B.Object_J3y, [B.List_Ldp, B.List_deg_grad_rad_turn, B.List_s_ms, B.List_Hz_kHz, B.List_dpi_dpcm_dppx], A.findType("ConstantStringMap>")); + B.Map_empty8 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap,List>")); + B.Map_empty0 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap,List>")); + B.Map_empty2 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap,List>")); + B.Map_empty16 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap,List>")); + B.Map_empty10 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap,List>")); + B.Map_empty12 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap,List>")); + B.Map_empty4 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap")); + B.Map_empty13 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap")); + B.Map_empty5 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap")); + B.Map_empty14 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap")); + B.Map_empty7 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap")); + B.Map_empty9 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap>")); + B.Map_empty1 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap>")); + B.Map_empty17 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap>")); + B.Map_empty11 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap>")); + B.Map_empty6 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap")); + B.Map_empty15 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap")); + B.Map_empty3 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap")); + B.Map_empty = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap")); + B.LinearChannel_fS8 = new A.LinearChannel(0, 1, false, true, true, "lightness", false, "%"); + B.LinearChannel_ffI = new A.LinearChannel(-0.4, 0.4, false, false, false, "a", false, null); + B.LinearChannel_Y6D = new A.LinearChannel(-0.4, 0.4, false, false, false, "b", false, null); + B.List_ZWr = A._setArrayType(makeConstList([B.LinearChannel_fS8, B.LinearChannel_ffI, B.LinearChannel_Y6D]), type$.JSArray_ColorChannel); + B.OklabColorSpace_540 = new A.OklabColorSpace("oklab", B.List_ZWr); + B.LinearChannel_fS80 = new A.LinearChannel0(0, 1, false, true, true, "lightness", false, "%"); + B.LinearChannel_ffI0 = new A.LinearChannel0(-0.4, 0.4, false, false, false, "a", false, null); + B.LinearChannel_Y6D0 = new A.LinearChannel0(-0.4, 0.4, false, false, false, "b", false, null); + B.List_ZWr0 = A._setArrayType(makeConstList([B.LinearChannel_fS80, B.LinearChannel_ffI0, B.LinearChannel_Y6D0]), type$.JSArray_ColorChannel_2); + B.OklabColorSpace_5400 = new A.OklabColorSpace0("oklab", B.List_ZWr0); + B.LinearChannel_HTj = new A.LinearChannel(0, 0.4, false, true, false, "chroma", false, null); + B.List_g5j = A._setArrayType(makeConstList([B.LinearChannel_fS8, B.LinearChannel_HTj, B.ColorChannel_hue_true_deg]), type$.JSArray_ColorChannel); + B.OklchColorSpace_9Gj = new A.OklchColorSpace("oklch", B.List_g5j); + B.LinearChannel_HTj0 = new A.LinearChannel0(0, 0.4, false, true, false, "chroma", false, null); + B.List_g5j0 = A._setArrayType(makeConstList([B.LinearChannel_fS80, B.LinearChannel_HTj0, B.ColorChannel_hue_true_deg0]), type$.JSArray_ColorChannel_2); + B.OklchColorSpace_9Gj0 = new A.OklchColorSpace0("oklch", B.List_g5j0); + B.OptionType_1Ol = new A.OptionType("OptionType.multiple"); + B.OptionType_tI9 = new A.OptionType("OptionType.flag"); + B.OptionType_zZK = new A.OptionType("OptionType.single"); + B.OutputStyle_0 = new A.OutputStyle("expanded"); + B.OutputStyle_00 = new A.OutputStyle0("expanded"); + B.OutputStyle_1 = new A.OutputStyle("compressed"); + B.OutputStyle_10 = new A.OutputStyle0("compressed"); + B.ProphotoRgbColorSpace_BDz = new A.ProphotoRgbColorSpace("prophoto-rgb", B.List_U47); + B.ProphotoRgbColorSpace_BDz0 = new A.ProphotoRgbColorSpace0("prophoto-rgb", B.List_U470); + B.Rec2020ColorSpace_6oo = new A.Rec2020ColorSpace("rec2020", B.List_U47); + B.Rec2020ColorSpace_6oo0 = new A.Rec2020ColorSpace0("rec2020", B.List_U470); + B.Map_empty20 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap>")); + B.Record2_EmptyExtensionStore_Map_empty = new A._Record_2(B.C_EmptyExtensionStore, B.Map_empty20); + B.Map_empty21 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap>")); + B.Record2_EmptyExtensionStore_Map_empty0 = new A._Record_2(B.C_EmptyExtensionStore0, B.Map_empty21); + B.List_Ds2 = A._setArrayType(makeConstList([B.LinearChannel_qXC, B.LinearChannel_Z5r, B.LinearChannel_vJ3]), type$.JSArray_ColorChannel); + B.RgbColorSpace_i0P = new A.RgbColorSpace("rgb", B.List_Ds2); + B.List_Ds20 = A._setArrayType(makeConstList([B.LinearChannel_qXC0, B.LinearChannel_Z5r0, B.LinearChannel_vJ30]), type$.JSArray_ColorChannel_2); + B.RgbColorSpace_i0P0 = new A.RgbColorSpace0("rgb", B.List_Ds20); + B.SassBoolean_false = new A.SassBoolean(false); + B.SassBoolean_false0 = new A.SassBoolean0(false); + B.SassBoolean_true = new A.SassBoolean(true); + B.SassBoolean_true0 = new A.SassBoolean0(true); + B.SassList_BlY = new A.SassList(B.List_empty8, B.ListSeparator_qVN, false); + B.SassList_BlY0 = new A.SassList0(B.List_empty20, B.ListSeparator_qVN0, false); + B.SassList_apG = new A.SassList0(B.List_empty20, B.ListSeparator_undecided_null_undecided0, false); + B.SassList_qAD = new A.SassList(B.List_empty8, B.ListSeparator_qVN, true); + B.SassList_qAD0 = new A.SassList0(B.List_empty20, B.ListSeparator_qVN0, true); + B.Map_empty22 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap")); + B.SassMap_Map_empty = new A.SassMap(B.Map_empty22); + B.Map_empty23 = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap")); + B.SassMap_Map_empty0 = new A.SassMap0(B.Map_empty23); + B.Object_Tro = {is: 0, matches: 1, where: 2}; + B.Set_0egh6 = new A.ConstantStringSet(B.Object_Tro, 3, type$.ConstantStringSet_String); + B.Object_ssn = {sass: 0, style: 1, default: 2}; + B.Set_8229z = new A.ConstantStringSet(B.Object_ssn, 3, type$.ConstantStringSet_String); + B.Set_9FDyj = new A.GeneralConstantSet([B.RgbColorSpace_i0P, B.HslColorSpace_JQ2], A.findType("GeneralConstantSet")); + B.Set_9FDyj0 = new A.GeneralConstantSet([B.RgbColorSpace_i0P0, B.HslColorSpace_JQ20], A.findType("GeneralConstantSet")); + B.Object_BKa = {".scss": 0, ".sass": 1, ".css": 2}; + B.Set_FTDN4 = new A.ConstantStringSet(B.Object_BKa, 3, type$.ConstantStringSet_String); + B.Object_GR4 = {calc: 0, clamp: 1, hypot: 2, sin: 3, cos: 4, tan: 5, asin: 6, acos: 7, atan: 8, sqrt: 9, exp: 10, sign: 11, mod: 12, rem: 13, atan2: 14, pow: 15, log: 16, "calc-size": 17}; + B.Set_Pr3yj = new A.ConstantStringSet(B.Object_GR4, 18, type$.ConstantStringSet_String); + B.Set_WDSXk = new A.GeneralConstantSet([0], A.findType("GeneralConstantSet")); + B.Set_empty1 = new A.ConstantStringSet(B.Object_empty, 0, A.findType("ConstantStringSet")); + B.Set_empty5 = new A.ConstantStringSet(B.Object_empty, 0, A.findType("ConstantStringSet")); + B.Set_empty2 = new A.ConstantStringSet(B.Object_empty, 0, A.findType("ConstantStringSet>")); + B.Set_empty0 = new A.ConstantStringSet(B.Object_empty, 0, A.findType("ConstantStringSet>")); + B.Set_empty6 = new A.ConstantStringSet(B.Object_empty, 0, A.findType("ConstantStringSet>")); + B.Set_empty4 = new A.ConstantStringSet(B.Object_empty, 0, A.findType("ConstantStringSet>")); + B.Set_empty7 = new A.ConstantStringSet(B.Object_empty, 0, type$.ConstantStringSet_String); + B.Set_empty3 = new A.ConstantStringSet(B.Object_empty, 0, A.findType("ConstantStringSet")); + B.Set_empty = new A.ConstantStringSet(B.Object_empty, 0, A.findType("ConstantStringSet")); + B.Set_oQTdo = new A.GeneralConstantSet([B.BinaryOperator_tht, B.BinaryOperator_Mh5, B.BinaryOperator_Swh, B.BinaryOperator_QG1], A.findType("GeneralConstantSet")); + B.Set_oQTdo0 = new A.GeneralConstantSet([B.BinaryOperator_tht0, B.BinaryOperator_Mh50, B.BinaryOperator_Swh0, B.BinaryOperator_QG10], A.findType("GeneralConstantSet")); + B.SrgbColorSpace_thf = new A.SrgbColorSpace("srgb", B.List_U47); + B.SrgbColorSpace_thf0 = new A.SrgbColorSpace0("srgb", B.List_U470); + B.SrgbLinearColorSpace_kUj = new A.SrgbLinearColorSpace("srgb-linear", B.List_U47); + B.SrgbLinearColorSpace_kUj0 = new A.SrgbLinearColorSpace0("srgb-linear", B.List_U470); + B.StderrLogger_false = new A.StderrLogger(false); + B.StderrLogger_false0 = new A.StderrLogger0(false); + B.Symbol__canonicalizeContext = new A.Symbol("_canonicalizeContext"); + B.Symbol__evaluationContext = new A.Symbol("_evaluationContext"); + B.Symbol__extensions = new A.Symbol("_extensions"); + B.Symbol__sourceSpecificity = new A.Symbol("_sourceSpecificity"); + B.Symbol_call = new A.Symbol("call"); + B.Syntax_CSS_css = new A.Syntax("CSS", "css"); + B.Syntax_CSS_css0 = new A.Syntax0("CSS", "css"); + B.Syntax_SCSS_scss = new A.Syntax("SCSS", "scss"); + B.Syntax_SCSS_scss0 = new A.Syntax0("SCSS", "scss"); + B.Syntax_Sass_sass = new A.Syntax("Sass", "sass"); + B.Syntax_Sass_sass0 = new A.Syntax0("Sass", "sass"); + B.Type_ByteBuffer_rqD = A.typeLiteral("ByteBuffer"); + B.Type_ByteData_9dB = A.typeLiteral("ByteData"); + B.Type_Float32List_9Kz = A.typeLiteral("Float32List"); + B.Type_Float64List_9Kz = A.typeLiteral("Float64List"); + B.Type_Int16List_s5h = A.typeLiteral("Int16List"); + B.Type_Int32List_O8Z = A.typeLiteral("Int32List"); + B.Type_Int8List_rFV = A.typeLiteral("Int8List"); + B.Type_Object_A4p = A.typeLiteral("Object"); + B.Type_Uint16List_kmP = A.typeLiteral("Uint16List"); + B.Type_Uint32List_kmP = A.typeLiteral("Uint32List"); + B.Type_Uint8ClampedList_04U = A.typeLiteral("Uint8ClampedList"); + B.Type_Uint8List_8Eb = A.typeLiteral("Uint8List"); + B.UnaryOperator_Rbl = new A.UnaryOperator("plus", "+", "plus"); + B.UnaryOperator_Rbl0 = new A.UnaryOperator0("plus", "+", "plus"); + B.UnaryOperator_UCP = new A.UnaryOperator("minus", "-", "minus"); + B.UnaryOperator_UCP0 = new A.UnaryOperator0("minus", "-", "minus"); + B.UnaryOperator_lZV = new A.UnaryOperator("divide", "/", "divide"); + B.UnaryOperator_lZV0 = new A.UnaryOperator0("divide", "/", "divide"); + B.UnaryOperator_not_not_not = new A.UnaryOperator("not", "not", "not"); + B.UnaryOperator_not_not_not0 = new A.UnaryOperator0("not", "not", "not"); + B.Utf8Decoder_false = new A.Utf8Decoder(false); + B.LinearChannel_LYw = new A.LinearChannel(0, 1, false, false, false, "x", false, null); + B.LinearChannel_eR7 = new A.LinearChannel(0, 1, false, false, false, "y", false, null); + B.LinearChannel_gZl = new A.LinearChannel(0, 1, false, false, false, "z", false, null); + B.List_QRs = A._setArrayType(makeConstList([B.LinearChannel_LYw, B.LinearChannel_eR7, B.LinearChannel_gZl]), type$.JSArray_LinearChannel); + B.XyzD50ColorSpace_2OB = new A.XyzD50ColorSpace("xyz-d50", B.List_QRs); + B.LinearChannel_LYw0 = new A.LinearChannel0(0, 1, false, false, false, "x", false, null); + B.LinearChannel_eR70 = new A.LinearChannel0(0, 1, false, false, false, "y", false, null); + B.LinearChannel_gZl0 = new A.LinearChannel0(0, 1, false, false, false, "z", false, null); + B.List_QRs0 = A._setArrayType(makeConstList([B.LinearChannel_LYw0, B.LinearChannel_eR70, B.LinearChannel_gZl0]), type$.JSArray_LinearChannel_2); + B.XyzD50ColorSpace_2OB0 = new A.XyzD50ColorSpace0("xyz-d50", B.List_QRs0); + B.XyzD65ColorSpace_WiJ = new A.XyzD65ColorSpace("xyz", B.List_QRs); + B.XyzD65ColorSpace_WiJ0 = new A.XyzD65ColorSpace0("xyz", B.List_QRs0); + B._IsBogusVisitor_false = new A._IsBogusVisitor(false); + B._IsBogusVisitor_false0 = new A._IsBogusVisitor0(false); + B._IsBogusVisitor_true = new A._IsBogusVisitor(true); + B._IsBogusVisitor_true0 = new A._IsBogusVisitor0(true); + B._IsInvisibleVisitor_false = new A._IsInvisibleVisitor0(false); + B._IsInvisibleVisitor_false0 = new A._IsInvisibleVisitor2(false); + B._IsInvisibleVisitor_false_false = new A._IsInvisibleVisitor(false, false); + B._IsInvisibleVisitor_false_false0 = new A._IsInvisibleVisitor1(false, false); + B._IsInvisibleVisitor_true = new A._IsInvisibleVisitor0(true); + B._IsInvisibleVisitor_true0 = new A._IsInvisibleVisitor2(true); + B._IsInvisibleVisitor_true_false = new A._IsInvisibleVisitor(true, false); + B._IsInvisibleVisitor_true_false0 = new A._IsInvisibleVisitor1(true, false); + B._IsInvisibleVisitor_true_true = new A._IsInvisibleVisitor(true, true); + B._IsInvisibleVisitor_true_true0 = new A._IsInvisibleVisitor1(true, true); + B._PathDirection_6kc = new A._PathDirection("reaches root"); + B._PathDirection_Wme = new A._PathDirection("below root"); + B._PathDirection_dMN = new A._PathDirection("at root"); + B._PathDirection_vgO = new A._PathDirection("above root"); + B._PathRelation_different = new A._PathRelation("different"); + B._PathRelation_equal = new A._PathRelation("equal"); + B._PathRelation_inconclusive = new A._PathRelation("inconclusive"); + B._PathRelation_within = new A._PathRelation("within"); + B._SingletonCssMediaQueryMergeResult_0 = new A._SingletonCssMediaQueryMergeResult("empty"); + B._SingletonCssMediaQueryMergeResult_00 = new A._SingletonCssMediaQueryMergeResult0("empty"); + B._SingletonCssMediaQueryMergeResult_1 = new A._SingletonCssMediaQueryMergeResult("unrepresentable"); + B._SingletonCssMediaQueryMergeResult_10 = new A._SingletonCssMediaQueryMergeResult0("unrepresentable"); + B._StreamGroupState_canceled = new A._StreamGroupState("canceled"); + B._StreamGroupState_dormant = new A._StreamGroupState("dormant"); + B._StreamGroupState_listening = new A._StreamGroupState("listening"); + B._StreamGroupState_paused = new A._StreamGroupState("paused"); + B._StringStackTrace_OdL = new A._StringStackTrace(""); + B._ZoneFunction_KjJ = new A._ZoneFunction(B.C__RootZone, A.async___rootHandleUncaughtError$closure()); + B._ZoneFunction_PAY = new A._ZoneFunction(B.C__RootZone, A.async___rootCreatePeriodicTimer$closure()); + B._ZoneFunction_Xkh = new A._ZoneFunction(B.C__RootZone, A.async___rootRegisterUnaryCallback$closure()); + B._ZoneFunction__RootZone__rootCreateTimer = new A._ZoneFunction(B.C__RootZone, A.async___rootCreateTimer$closure()); + B._ZoneFunction__RootZone__rootErrorCallback = new A._ZoneFunction(B.C__RootZone, A.async___rootErrorCallback$closure()); + B._ZoneFunction__RootZone__rootFork = new A._ZoneFunction(B.C__RootZone, A.async___rootFork$closure()); + B._ZoneFunction__RootZone__rootPrint = new A._ZoneFunction(B.C__RootZone, A.async___rootPrint$closure()); + B._ZoneFunction__RootZone__rootRegisterCallback = new A._ZoneFunction(B.C__RootZone, A.async___rootRegisterCallback$closure()); + B._ZoneFunction__RootZone__rootRun = new A._ZoneFunction(B.C__RootZone, A.async___rootRun$closure()); + B._ZoneFunction__RootZone__rootRunBinary = new A._ZoneFunction(B.C__RootZone, A.async___rootRunBinary$closure()); + B._ZoneFunction__RootZone__rootRunUnary = new A._ZoneFunction(B.C__RootZone, A.async___rootRunUnary$closure()); + B._ZoneFunction__RootZone__rootScheduleMicrotask = new A._ZoneFunction(B.C__RootZone, A.async___rootScheduleMicrotask$closure()); + B._ZoneFunction_e9o = new A._ZoneFunction(B.C__RootZone, A.async___rootRegisterBinaryCallback$closure()); + B._ZoneSpecification_Ipa = new A._ZoneSpecification(null, null, null, null, null, null, null, null, null, null, null, null, null); + })(); + (function staticFields() { + $._JS_INTEROP_INTERCEPTOR_TAG = null; + $.toStringVisiting = A._setArrayType([], type$.JSArray_Object); + $.printToZone = null; + $.Primitives__identityHashCodeProperty = null; + $.BoundClosure__receiverFieldNameCache = null; + $.BoundClosure__interceptorFieldNameCache = null; + $.getTagFunction = null; + $.alternateTagFunction = null; + $.prototypeForTagFunction = null; + $.dispatchRecordsForInstanceTags = null; + $.interceptorsForUncacheableTags = null; + $.initNativeDispatchFlag = null; + $._Record__computedFieldKeys = A._setArrayType([], A.findType("JSArray?>")); + $._nextCallback = null; + $._lastCallback = null; + $._lastPriorityCallback = null; + $._isInCallbackLoop = false; + $.Zone__current = B.C__RootZone; + $._RootZone__rootDelegate = null; + $.Uri__cachedBaseString = ""; + $.Uri__cachedBaseUri = null; + $._fs = null; + $._currentUriBase = null; + $._current = null; + $._subselectorPseudos = A.LinkedHashSet_LinkedHashSet$_literal(["is", "matches", "where", "any", "nth-child", "nth-last-child"], type$.String); + $._rootishPseudoClasses = A.LinkedHashSet_LinkedHashSet$_literal(["root", "scope", "host", "host-context"], type$.String); + $._features = A.LinkedHashSet_LinkedHashSet$_literal(["global-variable-shadowing", "extend-selector-pseudoclass", "units-level-3", "at-error", "custom-property"], type$.String); + $._realCaseCache = function() { + var t1 = type$.String; + return A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + }(); + $._selectorPseudoClasses = A.LinkedHashSet_LinkedHashSet$_literal(["not", "is", "matches", "where", "current", "any", "has", "host", "host-context"], type$.String); + $._selectorPseudoElements = A.LinkedHashSet_LinkedHashSet$_literal(["slotted"], type$.String); + $._glyphs = B.C_UnicodeGlyphSet; + $._rootishPseudoClasses0 = A.LinkedHashSet_LinkedHashSet$_literal(["root", "scope", "host", "host-context"], type$.String); + $._realCaseCache0 = function() { + var t1 = type$.String; + return A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + }(); + $._features0 = A.LinkedHashSet_LinkedHashSet$_literal(["global-variable-shadowing", "extend-selector-pseudoclass", "units-level-3", "at-error", "custom-property"], type$.String); + $._selectorPseudoClasses0 = A.LinkedHashSet_LinkedHashSet$_literal(["not", "is", "matches", "where", "current", "any", "has", "host", "host-context"], type$.String); + $._selectorPseudoElements0 = A.LinkedHashSet_LinkedHashSet$_literal(["slotted"], type$.String); + $._subselectorPseudos0 = A.LinkedHashSet_LinkedHashSet$_literal(["is", "matches", "where", "any", "nth-child", "nth-last-child"], type$.String); + })(); + (function lazyInitializers() { + var _lazyFinal = hunkHelpers.lazyFinal, + _lazy = hunkHelpers.lazy; + _lazyFinal($, "DART_CLOSURE_PROPERTY_NAME", "$get$DART_CLOSURE_PROPERTY_NAME", () => A.getIsolateAffinityTag("_$dart_dartClosure")); + _lazyFinal($, "nullFuture", "$get$nullFuture", () => B.C__RootZone.run$1$1(0, new A.nullFuture_closure(), A.findType("Future<~>"))); + _lazyFinal($, "TypeErrorDecoder_noSuchMethodPattern", "$get$TypeErrorDecoder_noSuchMethodPattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokeCallErrorOn({ + toString: function() { + return "$receiver$"; + } + }))); + _lazyFinal($, "TypeErrorDecoder_notClosurePattern", "$get$TypeErrorDecoder_notClosurePattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokeCallErrorOn({$method$: null, + toString: function() { + return "$receiver$"; + } + }))); + _lazyFinal($, "TypeErrorDecoder_nullCallPattern", "$get$TypeErrorDecoder_nullCallPattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokeCallErrorOn(null))); + _lazyFinal($, "TypeErrorDecoder_nullLiteralCallPattern", "$get$TypeErrorDecoder_nullLiteralCallPattern", () => A.TypeErrorDecoder_extractPattern(function() { + var $argumentsExpr$ = "$arguments$"; + try { + null.$method$($argumentsExpr$); + } catch (e) { + return e.message; + } + }())); + _lazyFinal($, "TypeErrorDecoder_undefinedCallPattern", "$get$TypeErrorDecoder_undefinedCallPattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokeCallErrorOn(void 0))); + _lazyFinal($, "TypeErrorDecoder_undefinedLiteralCallPattern", "$get$TypeErrorDecoder_undefinedLiteralCallPattern", () => A.TypeErrorDecoder_extractPattern(function() { + var $argumentsExpr$ = "$arguments$"; + try { + (void 0).$method$($argumentsExpr$); + } catch (e) { + return e.message; + } + }())); + _lazyFinal($, "TypeErrorDecoder_nullPropertyPattern", "$get$TypeErrorDecoder_nullPropertyPattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokePropertyErrorOn(null))); + _lazyFinal($, "TypeErrorDecoder_nullLiteralPropertyPattern", "$get$TypeErrorDecoder_nullLiteralPropertyPattern", () => A.TypeErrorDecoder_extractPattern(function() { + try { + null.$method$; + } catch (e) { + return e.message; + } + }())); + _lazyFinal($, "TypeErrorDecoder_undefinedPropertyPattern", "$get$TypeErrorDecoder_undefinedPropertyPattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokePropertyErrorOn(void 0))); + _lazyFinal($, "TypeErrorDecoder_undefinedLiteralPropertyPattern", "$get$TypeErrorDecoder_undefinedLiteralPropertyPattern", () => A.TypeErrorDecoder_extractPattern(function() { + try { + (void 0).$method$; + } catch (e) { + return e.message; + } + }())); + _lazyFinal($, "_AsyncRun__scheduleImmediateClosure", "$get$_AsyncRun__scheduleImmediateClosure", () => A._AsyncRun__initializeScheduleImmediate()); + _lazyFinal($, "Future__nullFuture", "$get$Future__nullFuture", () => $.$get$nullFuture()); + _lazyFinal($, "Future__falseFuture", "$get$Future__falseFuture", () => A._Future$zoneValue(false, B.C__RootZone, type$.bool)); + _lazyFinal($, "_RootZone__rootMap", "$get$_RootZone__rootMap", () => { + var t1 = type$.dynamic; + return A.HashMap_HashMap(t1, t1); + }); + _lazyFinal($, "_Utf8Decoder__reusableBuffer", "$get$_Utf8Decoder__reusableBuffer", () => A.NativeUint8List_NativeUint8List(4096)); + _lazyFinal($, "_Utf8Decoder__decoder", "$get$_Utf8Decoder__decoder", () => new A._Utf8Decoder__decoder_closure().call$0()); + _lazyFinal($, "_Utf8Decoder__decoderNonfatal", "$get$_Utf8Decoder__decoderNonfatal", () => new A._Utf8Decoder__decoderNonfatal_closure().call$0()); + _lazyFinal($, "_Base64Decoder__inverseAlphabet", "$get$_Base64Decoder__inverseAlphabet", () => A.NativeInt8List__create1(A._ensureNativeList(A._setArrayType([-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -2, -2, -2, -2, -2, 62, -2, 62, -2, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -2, -2, -2, -1, -2, -2, -2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -2, -2, -2, -2, 63, -2, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -2, -2, -2, -2, -2], type$.JSArray_int)))); + _lazyFinal($, "_Uri__isWindowsCached", "$get$_Uri__isWindowsCached", () => { + var t1 = typeof process != "undefined" && Object.prototype.toString.call(process) == "[object process]" && process.platform == "win32"; + return t1; + }); + _lazyFinal($, "_Uri__needsNoEncoding", "$get$_Uri__needsNoEncoding", () => A.RegExp_RegExp("^[\\-\\.0-9A-Z_a-z~]*$", false)); + _lazyFinal($, "_hashSeed", "$get$_hashSeed", () => A.objectHashCode(B.Type_Object_A4p)); + _lazyFinal($, "Option__invalidChars", "$get$Option__invalidChars", () => A.RegExp_RegExp("[ \\t\\r\\n\"'\\\\/]", false)); + _lazyFinal($, "_isStrictMode", "$get$_isStrictMode", () => new A._isStrictMode_closure().call$0()); + _lazyFinal($, "alwaysValid", "$get$alwaysValid", () => new A.alwaysValid_closure()); + _lazyFinal($, "readline", "$get$readline", () => self.readline); + _lazyFinal($, "windows", "$get$windows", () => A.Context_Context($.$get$Style_windows())); + _lazyFinal($, "url", "$get$url", () => A.Context_Context($.$get$Style_url())); + _lazyFinal($, "context", "$get$context", () => new A.Context($.$get$Style_platform(), null)); + _lazyFinal($, "Style_posix", "$get$Style_posix", () => new A.PosixStyle(A.RegExp_RegExp("/", false), A.RegExp_RegExp("[^/]$", false), A.RegExp_RegExp("^/", false))); + _lazyFinal($, "Style_windows", "$get$Style_windows", () => new A.WindowsStyle(A.RegExp_RegExp("[/\\\\]", false), A.RegExp_RegExp("[^/\\\\]$", false), A.RegExp_RegExp("^(\\\\\\\\[^\\\\]+\\\\[^\\\\/]+|[a-zA-Z]:[/\\\\])", false), A.RegExp_RegExp("^[/\\\\](?![/\\\\])", false))); + _lazyFinal($, "Style_url", "$get$Style_url", () => new A.UrlStyle(A.RegExp_RegExp("/", false), A.RegExp_RegExp("(^[a-zA-Z][-+.a-zA-Z\\d]*://|[^/])$", false), A.RegExp_RegExp("[a-zA-Z][-+.a-zA-Z\\d]*://[^/]*", false), A.RegExp_RegExp("^/", false))); + _lazyFinal($, "Style_platform", "$get$Style_platform", () => A.Style__getPlatformStyle()); + _lazyFinal($, "startVersion", "$get$startVersion", () => A.RegExp_RegExp("^(\\d+)\\.(\\d+)\\.(\\d+)(-([0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*))?(\\+([0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*))?", false)); + _lazyFinal($, "completeVersion", "$get$completeVersion", () => A.RegExp_RegExp($.$get$startVersion().pattern + "$", false)); + _lazyFinal($, "IfExpression_declaration", "$get$IfExpression_declaration", () => A.ParameterList_ParameterList$parse(string$.x40funct, null)); + _lazyFinal($, "colorsByName", "$get$colorsByName", () => A.LinkedHashMap_LinkedHashMap$_literal(["yellowgreen", A.SassColor_SassColor$rgb(154, 205, 50, 1), "yellow", A.SassColor_SassColor$rgb(255, 255, 0, 1), "whitesmoke", A.SassColor_SassColor$rgb(245, 245, 245, 1), "white", A.SassColor_SassColor$rgb(255, 255, 255, 1), "wheat", A.SassColor_SassColor$rgb(245, 222, 179, 1), "violet", A.SassColor_SassColor$rgb(238, 130, 238, 1), "turquoise", A.SassColor_SassColor$rgb(64, 224, 208, 1), "transparent", A.SassColor_SassColor$rgb(0, 0, 0, 0), "tomato", A.SassColor_SassColor$rgb(255, 99, 71, 1), "thistle", A.SassColor_SassColor$rgb(216, 191, 216, 1), "teal", A.SassColor_SassColor$rgb(0, 128, 128, 1), "tan", A.SassColor_SassColor$rgb(210, 180, 140, 1), "steelblue", A.SassColor_SassColor$rgb(70, 130, 180, 1), "springgreen", A.SassColor_SassColor$rgb(0, 255, 127, 1), "snow", A.SassColor_SassColor$rgb(255, 250, 250, 1), "slategrey", A.SassColor_SassColor$rgb(112, 128, 144, 1), "slategray", A.SassColor_SassColor$rgb(112, 128, 144, 1), "slateblue", A.SassColor_SassColor$rgb(106, 90, 205, 1), "skyblue", A.SassColor_SassColor$rgb(135, 206, 235, 1), "silver", A.SassColor_SassColor$rgb(192, 192, 192, 1), "sienna", A.SassColor_SassColor$rgb(160, 82, 45, 1), "seashell", A.SassColor_SassColor$rgb(255, 245, 238, 1), "seagreen", A.SassColor_SassColor$rgb(46, 139, 87, 1), "sandybrown", A.SassColor_SassColor$rgb(244, 164, 96, 1), "salmon", A.SassColor_SassColor$rgb(250, 128, 114, 1), "saddlebrown", A.SassColor_SassColor$rgb(139, 69, 19, 1), "royalblue", A.SassColor_SassColor$rgb(65, 105, 225, 1), "rosybrown", A.SassColor_SassColor$rgb(188, 143, 143, 1), "red", A.SassColor_SassColor$rgb(255, 0, 0, 1), "rebeccapurple", A.SassColor_SassColor$rgb(102, 51, 153, 1), "purple", A.SassColor_SassColor$rgb(128, 0, 128, 1), "powderblue", A.SassColor_SassColor$rgb(176, 224, 230, 1), "plum", A.SassColor_SassColor$rgb(221, 160, 221, 1), "pink", A.SassColor_SassColor$rgb(255, 192, 203, 1), "peru", A.SassColor_SassColor$rgb(205, 133, 63, 1), "peachpuff", A.SassColor_SassColor$rgb(255, 218, 185, 1), "papayawhip", A.SassColor_SassColor$rgb(255, 239, 213, 1), "palevioletred", A.SassColor_SassColor$rgb(219, 112, 147, 1), "paleturquoise", A.SassColor_SassColor$rgb(175, 238, 238, 1), "palegreen", A.SassColor_SassColor$rgb(152, 251, 152, 1), "palegoldenrod", A.SassColor_SassColor$rgb(238, 232, 170, 1), "orchid", A.SassColor_SassColor$rgb(218, 112, 214, 1), "orangered", A.SassColor_SassColor$rgb(255, 69, 0, 1), "orange", A.SassColor_SassColor$rgb(255, 165, 0, 1), "olivedrab", A.SassColor_SassColor$rgb(107, 142, 35, 1), "olive", A.SassColor_SassColor$rgb(128, 128, 0, 1), "oldlace", A.SassColor_SassColor$rgb(253, 245, 230, 1), "navy", A.SassColor_SassColor$rgb(0, 0, 128, 1), "navajowhite", A.SassColor_SassColor$rgb(255, 222, 173, 1), "moccasin", A.SassColor_SassColor$rgb(255, 228, 181, 1), "mistyrose", A.SassColor_SassColor$rgb(255, 228, 225, 1), "mintcream", A.SassColor_SassColor$rgb(245, 255, 250, 1), "midnightblue", A.SassColor_SassColor$rgb(25, 25, 112, 1), "mediumvioletred", A.SassColor_SassColor$rgb(199, 21, 133, 1), "mediumturquoise", A.SassColor_SassColor$rgb(72, 209, 204, 1), "mediumspringgreen", A.SassColor_SassColor$rgb(0, 250, 154, 1), "mediumslateblue", A.SassColor_SassColor$rgb(123, 104, 238, 1), "mediumseagreen", A.SassColor_SassColor$rgb(60, 179, 113, 1), "mediumpurple", A.SassColor_SassColor$rgb(147, 112, 219, 1), "mediumorchid", A.SassColor_SassColor$rgb(186, 85, 211, 1), "mediumblue", A.SassColor_SassColor$rgb(0, 0, 205, 1), "mediumaquamarine", A.SassColor_SassColor$rgb(102, 205, 170, 1), "maroon", A.SassColor_SassColor$rgb(128, 0, 0, 1), "magenta", A.SassColor_SassColor$rgb(255, 0, 255, 1), "linen", A.SassColor_SassColor$rgb(250, 240, 230, 1), "limegreen", A.SassColor_SassColor$rgb(50, 205, 50, 1), "lime", A.SassColor_SassColor$rgb(0, 255, 0, 1), "lightyellow", A.SassColor_SassColor$rgb(255, 255, 224, 1), "lightsteelblue", A.SassColor_SassColor$rgb(176, 196, 222, 1), "lightslategrey", A.SassColor_SassColor$rgb(119, 136, 153, 1), "lightslategray", A.SassColor_SassColor$rgb(119, 136, 153, 1), "lightskyblue", A.SassColor_SassColor$rgb(135, 206, 250, 1), "lightseagreen", A.SassColor_SassColor$rgb(32, 178, 170, 1), "lightsalmon", A.SassColor_SassColor$rgb(255, 160, 122, 1), "lightpink", A.SassColor_SassColor$rgb(255, 182, 193, 1), "lightgrey", A.SassColor_SassColor$rgb(211, 211, 211, 1), "lightgreen", A.SassColor_SassColor$rgb(144, 238, 144, 1), "lightgray", A.SassColor_SassColor$rgb(211, 211, 211, 1), "lightgoldenrodyellow", A.SassColor_SassColor$rgb(250, 250, 210, 1), "lightcyan", A.SassColor_SassColor$rgb(224, 255, 255, 1), "lightcoral", A.SassColor_SassColor$rgb(240, 128, 128, 1), "lightblue", A.SassColor_SassColor$rgb(173, 216, 230, 1), "lemonchiffon", A.SassColor_SassColor$rgb(255, 250, 205, 1), "lawngreen", A.SassColor_SassColor$rgb(124, 252, 0, 1), "lavenderblush", A.SassColor_SassColor$rgb(255, 240, 245, 1), "lavender", A.SassColor_SassColor$rgb(230, 230, 250, 1), "khaki", A.SassColor_SassColor$rgb(240, 230, 140, 1), "ivory", A.SassColor_SassColor$rgb(255, 255, 240, 1), "indigo", A.SassColor_SassColor$rgb(75, 0, 130, 1), "indianred", A.SassColor_SassColor$rgb(205, 92, 92, 1), "hotpink", A.SassColor_SassColor$rgb(255, 105, 180, 1), "honeydew", A.SassColor_SassColor$rgb(240, 255, 240, 1), "grey", A.SassColor_SassColor$rgb(128, 128, 128, 1), "greenyellow", A.SassColor_SassColor$rgb(173, 255, 47, 1), "green", A.SassColor_SassColor$rgb(0, 128, 0, 1), "gray", A.SassColor_SassColor$rgb(128, 128, 128, 1), "goldenrod", A.SassColor_SassColor$rgb(218, 165, 32, 1), "gold", A.SassColor_SassColor$rgb(255, 215, 0, 1), "ghostwhite", A.SassColor_SassColor$rgb(248, 248, 255, 1), "gainsboro", A.SassColor_SassColor$rgb(220, 220, 220, 1), "fuchsia", A.SassColor_SassColor$rgb(255, 0, 255, 1), "forestgreen", A.SassColor_SassColor$rgb(34, 139, 34, 1), "floralwhite", A.SassColor_SassColor$rgb(255, 250, 240, 1), "firebrick", A.SassColor_SassColor$rgb(178, 34, 34, 1), "dodgerblue", A.SassColor_SassColor$rgb(30, 144, 255, 1), "dimgrey", A.SassColor_SassColor$rgb(105, 105, 105, 1), "dimgray", A.SassColor_SassColor$rgb(105, 105, 105, 1), "deepskyblue", A.SassColor_SassColor$rgb(0, 191, 255, 1), "deeppink", A.SassColor_SassColor$rgb(255, 20, 147, 1), "darkviolet", A.SassColor_SassColor$rgb(148, 0, 211, 1), "darkturquoise", A.SassColor_SassColor$rgb(0, 206, 209, 1), "darkslategrey", A.SassColor_SassColor$rgb(47, 79, 79, 1), "darkslategray", A.SassColor_SassColor$rgb(47, 79, 79, 1), "darkslateblue", A.SassColor_SassColor$rgb(72, 61, 139, 1), "darkseagreen", A.SassColor_SassColor$rgb(143, 188, 143, 1), "darksalmon", A.SassColor_SassColor$rgb(233, 150, 122, 1), "darkred", A.SassColor_SassColor$rgb(139, 0, 0, 1), "darkorchid", A.SassColor_SassColor$rgb(153, 50, 204, 1), "darkorange", A.SassColor_SassColor$rgb(255, 140, 0, 1), "darkolivegreen", A.SassColor_SassColor$rgb(85, 107, 47, 1), "darkmagenta", A.SassColor_SassColor$rgb(139, 0, 139, 1), "darkkhaki", A.SassColor_SassColor$rgb(189, 183, 107, 1), "darkgrey", A.SassColor_SassColor$rgb(169, 169, 169, 1), "darkgreen", A.SassColor_SassColor$rgb(0, 100, 0, 1), "darkgray", A.SassColor_SassColor$rgb(169, 169, 169, 1), "darkgoldenrod", A.SassColor_SassColor$rgb(184, 134, 11, 1), "darkcyan", A.SassColor_SassColor$rgb(0, 139, 139, 1), "darkblue", A.SassColor_SassColor$rgb(0, 0, 139, 1), "cyan", A.SassColor_SassColor$rgb(0, 255, 255, 1), "crimson", A.SassColor_SassColor$rgb(220, 20, 60, 1), "cornsilk", A.SassColor_SassColor$rgb(255, 248, 220, 1), "cornflowerblue", A.SassColor_SassColor$rgb(100, 149, 237, 1), "coral", A.SassColor_SassColor$rgb(255, 127, 80, 1), "chocolate", A.SassColor_SassColor$rgb(210, 105, 30, 1), "chartreuse", A.SassColor_SassColor$rgb(127, 255, 0, 1), "cadetblue", A.SassColor_SassColor$rgb(95, 158, 160, 1), "burlywood", A.SassColor_SassColor$rgb(222, 184, 135, 1), "brown", A.SassColor_SassColor$rgb(165, 42, 42, 1), "blueviolet", A.SassColor_SassColor$rgb(138, 43, 226, 1), "blue", A.SassColor_SassColor$rgb(0, 0, 255, 1), "blanchedalmond", A.SassColor_SassColor$rgb(255, 235, 205, 1), "black", A.SassColor_SassColor$rgb(0, 0, 0, 1), "bisque", A.SassColor_SassColor$rgb(255, 228, 196, 1), "beige", A.SassColor_SassColor$rgb(245, 245, 220, 1), "azure", A.SassColor_SassColor$rgb(240, 255, 255, 1), "aquamarine", A.SassColor_SassColor$rgb(127, 255, 212, 1), "aqua", A.SassColor_SassColor$rgb(0, 255, 255, 1), "antiquewhite", A.SassColor_SassColor$rgb(250, 235, 215, 1), "aliceblue", A.SassColor_SassColor$rgb(240, 248, 255, 1)], type$.String, type$.SassColor)); + _lazyFinal($, "namesByColor", "$get$namesByColor", () => { + var $name, + t1 = type$.SassColor, + t2 = type$.String, + t3 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t1 = A.MapExtensions_get_pairs($.$get$colorsByName(), t2, t1), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t2 = t1.get$current(t1); + $name = t2._0; + t3.$indexSet(0, t2._1, $name); + } + return t3; + }); + _lazyFinal($, "ExecutableOptions__separatorBar", "$get$ExecutableOptions__separatorBar", () => A.isWindows() ? "=" : "\u2501"); + _lazyFinal($, "ExecutableOptions__parser", "$get$ExecutableOptions__parser", () => new A.ExecutableOptions__parser_closure().call$0()); + _lazyFinal($, "globalFunctions", "$get$globalFunctions", () => { + var t1 = type$.BuiltInCallable, + t2 = A.List_List$of($.$get$global(), true, t1); + B.JSArray_methods.addAll$1(t2, $.$get$global0()); + B.JSArray_methods.addAll$1(t2, $.$get$global1()); + B.JSArray_methods.addAll$1(t2, $.$get$global2()); + B.JSArray_methods.addAll$1(t2, $.$get$global3()); + B.JSArray_methods.addAll$1(t2, $.$get$global4()); + B.JSArray_methods.addAll$1(t2, $.$get$global5()); + t2.push(A.BuiltInCallable$function("if", "$condition, $if-true, $if-false", new A.globalFunctions_closure(), null)); + return A.UnmodifiableListView$(t2, t1); + }); + _lazyFinal($, "coreModules", "$get$coreModules", () => A.UnmodifiableListView$(A._setArrayType([$.$get$module(), $.$get$module0(), $.$get$module1(), $.$get$module2(), $.$get$module3(), $.$get$module4()], A.findType("JSArray>")), type$.BuiltInModule_Callable)); + _lazyFinal($, "_microsoftFilterStart", "$get$_microsoftFilterStart", () => A.RegExp_RegExp("^[a-zA-Z]+\\s*=", false)); + _lazyFinal($, "global", "$get$global", () => { + var _s5_ = "color", + _s27_ = "$red, $green, $blue, $alpha", + _s19_ = "$red, $green, $blue", + _s9_ = "$channels", + _s37_ = "$hue, $saturation, $lightness, $alpha", + _s29_ = "$hue, $saturation, $lightness", + _s17_ = "$hue, $saturation", + _s6_ = "adjust", + _s15_ = "$color, $amount", + t1 = type$.String, + t2 = type$.Value_Function_List_Value; + return A.UnmodifiableListView$(A._setArrayType([A._channelFunction("red", B.RgbColorSpace_i0P, new A.global_closure0(), true, null).withDeprecationWarning$1(_s5_), A._channelFunction("green", B.RgbColorSpace_i0P, new A.global_closure1(), true, null).withDeprecationWarning$1(_s5_), A._channelFunction("blue", B.RgbColorSpace_i0P, new A.global_closure2(), true, null).withDeprecationWarning$1(_s5_), $.$get$_mix().withDeprecationWarning$1(_s5_), A.BuiltInCallable$overloadedFunction("rgb", A.LinkedHashMap_LinkedHashMap$_literal([_s27_, new A.global_closure3(), _s19_, new A.global_closure4(), "$color, $alpha", new A.global_closure5(), "$channels", new A.global_closure6()], t1, t2)), A.BuiltInCallable$overloadedFunction("rgba", A.LinkedHashMap_LinkedHashMap$_literal([_s27_, new A.global_closure7(), _s19_, new A.global_closure8(), "$color, $alpha", new A.global_closure9(), "$channels", new A.global_closure10()], t1, t2)), A._function5("invert", "$color, $weight: 100%, $space: null", new A.global_closure11()), A._channelFunction("hue", B.HslColorSpace_JQ2, new A.global_closure12(), true, "deg").withDeprecationWarning$1(_s5_), A._channelFunction("saturation", B.HslColorSpace_JQ2, new A.global_closure13(), true, "%").withDeprecationWarning$1(_s5_), A._channelFunction("lightness", B.HslColorSpace_JQ2, new A.global_closure14(), true, "%").withDeprecationWarning$1(_s5_), A.BuiltInCallable$overloadedFunction("hsl", A.LinkedHashMap_LinkedHashMap$_literal([_s37_, new A.global_closure15(), _s29_, new A.global_closure16(), _s17_, new A.global_closure17(), "$channels", new A.global_closure18()], t1, t2)), A.BuiltInCallable$overloadedFunction("hsla", A.LinkedHashMap_LinkedHashMap$_literal([_s37_, new A.global_closure19(), _s29_, new A.global_closure20(), _s17_, new A.global_closure21(), "$channels", new A.global_closure22()], t1, t2)), A._function5("grayscale", "$color", new A.global_closure23()), A._function5("adjust-hue", "$color, $degrees", new A.global_closure24()).withDeprecationWarning$2(_s5_, _s6_), A._function5("lighten", _s15_, new A.global_closure25()).withDeprecationWarning$2(_s5_, _s6_), A._function5("darken", _s15_, new A.global_closure26()).withDeprecationWarning$2(_s5_, _s6_), A.BuiltInCallable$overloadedFunction("saturate", A.LinkedHashMap_LinkedHashMap$_literal(["$amount", new A.global_closure27(), "$color, $amount", new A.global_closure28()], t1, t2)), A._function5("desaturate", _s15_, new A.global_closure29()).withDeprecationWarning$2(_s5_, _s6_), A._function5("opacify", _s15_, new A.global_closure30()).withDeprecationWarning$2(_s5_, _s6_), A._function5("fade-in", _s15_, new A.global_closure31()).withDeprecationWarning$2(_s5_, _s6_), A._function5("transparentize", _s15_, new A.global_closure32()).withDeprecationWarning$2(_s5_, _s6_), A._function5("fade-out", _s15_, new A.global_closure33()).withDeprecationWarning$2(_s5_, _s6_), A.BuiltInCallable$overloadedFunction("alpha", A.LinkedHashMap_LinkedHashMap$_literal(["$color", new A.global_closure34(), "$args...", new A.global_closure35()], t1, t2)), A._function5("opacity", "$color", new A.global_closure36()), A._function5(_s5_, "$description", new A.global_closure37()), A._function5("hwb", _s9_, new A.global_closure38()), A._function5("lab", _s9_, new A.global_closure39()), A._function5("lch", _s9_, new A.global_closure40()), A._function5("oklab", _s9_, new A.global_closure41()), A._function5("oklch", _s9_, new A.global_closure42()), $.$get$_complement().withDeprecationWarning$1(_s5_), $.$get$_ieHexStr(), $.$get$_adjust().withDeprecationWarning$1(_s5_).withName$1("adjust-color"), $.$get$_scale().withDeprecationWarning$1(_s5_).withName$1("scale-color"), $.$get$_change().withDeprecationWarning$1(_s5_).withName$1("change-color")], type$.JSArray_BuiltInCallable), type$.BuiltInCallable); + }); + _lazyFinal($, "module", "$get$module", () => { + var _null = null, + _s10_ = "saturation", + _s9_ = "lightness", + _s6_ = "$color", _s5_ = "alpha", + _s30_ = "$color, $channel, $space: null", + t1 = type$.String, + t2 = type$.Value_Function_List_Value; + return A.BuiltInModule$("color", A._setArrayType([A._channelFunction("red", B.RgbColorSpace_i0P, new A.module_closure1(), false, _null), A._channelFunction("green", B.RgbColorSpace_i0P, new A.module_closure2(), false, _null), A._channelFunction("blue", B.RgbColorSpace_i0P, new A.module_closure3(), false, _null), $.$get$_mix(), A._function5("invert", "$color, $weight: 100%, $space: null", new A.module_closure4()), A._channelFunction("hue", B.HslColorSpace_JQ2, new A.module_closure5(), false, "deg"), A._channelFunction(_s10_, B.HslColorSpace_JQ2, new A.module_closure6(), false, "%"), A._channelFunction(_s9_, B.HslColorSpace_JQ2, new A.module_closure7(), false, "%"), A._removedColorFunction("adjust-hue", "hue", false), A._removedColorFunction("lighten", _s9_, false), A._removedColorFunction("darken", _s9_, true), A._removedColorFunction("saturate", _s10_, false), A._removedColorFunction("desaturate", _s10_, true), A._function5("grayscale", _s6_, new A.module_closure8()), A.BuiltInCallable$overloadedFunction("hwb", A.LinkedHashMap_LinkedHashMap$_literal(["$hue, $whiteness, $blackness, $alpha: 1", new A.module_closure9(), "$channels", new A.module_closure10()], t1, t2)), A._channelFunction("whiteness", B.HwbColorSpace_guQ, new A.module_closure11(), false, "%"), A._channelFunction("blackness", B.HwbColorSpace_guQ, new A.module_closure12(), false, "%"), A._removedColorFunction("opacify", _s5_, false), A._removedColorFunction("fade-in", _s5_, false), A._removedColorFunction("transparentize", _s5_, true), A._removedColorFunction("fade-out", _s5_, true), A.BuiltInCallable$overloadedFunction(_s5_, A.LinkedHashMap_LinkedHashMap$_literal(["$color", new A.module_closure13(), "$args...", new A.module_closure14()], t1, t2)), A._function5("opacity", _s6_, new A.module_closure15()), A._function5("space", _s6_, new A.module_closure16()), A._function5("to-space", "$color, $space", new A.module_closure17()), A._function5("is-legacy", _s6_, new A.module_closure18()), A._function5("is-missing", "$color, $channel", new A.module_closure19()), A._function5("is-in-gamut", "$color, $space: null", new A.module_closure20()), A._function5("to-gamut", "$color, $space: null, $method: null", new A.module_closure21()), A._function5("channel", _s30_, new A.module_closure22()), A._function5("same", "$color1, $color2", new A.module_closure23()), A._function5("is-powerless", _s30_, new A.module_closure24()), $.$get$_complement(), $.$get$_adjust(), $.$get$_scale(), $.$get$_change(), $.$get$_ieHexStr()], type$.JSArray_Callable), _null, _null, type$.Callable); + }); + _lazyFinal($, "_mix", "$get$_mix", () => A._function5("mix", string$.x24color, new A._mix_closure())); + _lazyFinal($, "_complement", "$get$_complement", () => A._function5("complement", "$color, $space: null", new A._complement_closure())); + _lazyFinal($, "_adjust", "$get$_adjust", () => A._function5("adjust", "$color, $kwargs...", new A._adjust_closure())); + _lazyFinal($, "_scale", "$get$_scale", () => A._function5("scale", "$color, $kwargs...", new A._scale_closure())); + _lazyFinal($, "_change", "$get$_change", () => A._function5("change", "$color, $kwargs...", new A._change_closure())); + _lazyFinal($, "_ieHexStr", "$get$_ieHexStr", () => A._function5("ie-hex-str", "$color", new A._ieHexStr_closure())); + _lazyFinal($, "global0", "$get$global0", () => { + var _s4_ = "list"; + return A.UnmodifiableListView$(A._setArrayType([$.$get$_length0().withDeprecationWarning$1(_s4_), $.$get$_nth().withDeprecationWarning$1(_s4_), $.$get$_setNth().withDeprecationWarning$1(_s4_), $.$get$_join().withDeprecationWarning$1(_s4_), $.$get$_append0().withDeprecationWarning$1(_s4_), $.$get$_zip().withDeprecationWarning$1(_s4_), $.$get$_index0().withDeprecationWarning$1(_s4_), $.$get$_isBracketed().withDeprecationWarning$1(_s4_), $.$get$_separator().withDeprecationWarning$1(_s4_).withName$1("list-separator")], type$.JSArray_BuiltInCallable), type$.BuiltInCallable); + }); + _lazyFinal($, "module0", "$get$module0", () => A.BuiltInModule$("list", A._setArrayType([$.$get$_length0(), $.$get$_nth(), $.$get$_setNth(), $.$get$_join(), $.$get$_append0(), $.$get$_zip(), $.$get$_index0(), $.$get$_isBracketed(), $.$get$_separator(), $.$get$_slash()], type$.JSArray_Callable), null, null, type$.Callable)); + _lazyFinal($, "_length", "$get$_length0", () => A._function4("length", "$list", new A._length_closure0())); + _lazyFinal($, "_nth", "$get$_nth", () => A._function4("nth", "$list, $n", new A._nth_closure())); + _lazyFinal($, "_setNth", "$get$_setNth", () => A._function4("set-nth", "$list, $n, $value", new A._setNth_closure())); + _lazyFinal($, "_join", "$get$_join", () => A._function4("join", string$.x24list1, new A._join_closure())); + _lazyFinal($, "_append", "$get$_append0", () => A._function4("append", "$list, $val, $separator: auto", new A._append_closure0())); + _lazyFinal($, "_zip", "$get$_zip", () => A._function4("zip", "$lists...", new A._zip_closure())); + _lazyFinal($, "_index", "$get$_index0", () => A._function4("index", "$list, $value", new A._index_closure0())); + _lazyFinal($, "_separator", "$get$_separator", () => A._function4("separator", "$list", new A._separator_closure())); + _lazyFinal($, "_isBracketed", "$get$_isBracketed", () => A._function4("is-bracketed", "$list", new A._isBracketed_closure())); + _lazyFinal($, "_slash", "$get$_slash", () => A._function4("slash", "$elements...", new A._slash_closure())); + _lazyFinal($, "global1", "$get$global1", () => { + var _s3_ = "map"; + return A.UnmodifiableListView$(A._setArrayType([$.$get$_get().withDeprecationWarning$1(_s3_).withName$1("map-get"), $.$get$_merge().withDeprecationWarning$1(_s3_).withName$1("map-merge"), $.$get$_remove().withDeprecationWarning$1(_s3_).withName$1("map-remove"), $.$get$_keys().withDeprecationWarning$1(_s3_).withName$1("map-keys"), $.$get$_values().withDeprecationWarning$1(_s3_).withName$1("map-values"), $.$get$_hasKey().withDeprecationWarning$1(_s3_).withName$1("map-has-key")], type$.JSArray_BuiltInCallable), type$.BuiltInCallable); + }); + _lazyFinal($, "module1", "$get$module1", () => A.BuiltInModule$("map", A._setArrayType([$.$get$_get(), $.$get$_set(), $.$get$_merge(), $.$get$_remove(), $.$get$_keys(), $.$get$_values(), $.$get$_hasKey(), $.$get$_deepMerge(), $.$get$_deepRemove()], type$.JSArray_Callable), null, null, type$.Callable)); + _lazyFinal($, "_get", "$get$_get", () => A._function3("get", "$map, $key, $keys...", new A._get_closure())); + _lazyFinal($, "_set", "$get$_set", () => A.BuiltInCallable$overloadedFunction("set", A.LinkedHashMap_LinkedHashMap$_literal(["$map, $key, $value", new A._set_closure(), "$map, $args...", new A._set_closure0()], type$.String, type$.Value_Function_List_Value))); + _lazyFinal($, "_merge", "$get$_merge", () => A.BuiltInCallable$overloadedFunction("merge", A.LinkedHashMap_LinkedHashMap$_literal(["$map1, $map2", new A._merge_closure(), "$map1, $args...", new A._merge_closure0()], type$.String, type$.Value_Function_List_Value))); + _lazyFinal($, "_deepMerge", "$get$_deepMerge", () => A._function3("deep-merge", "$map1, $map2", new A._deepMerge_closure())); + _lazyFinal($, "_deepRemove", "$get$_deepRemove", () => A._function3("deep-remove", "$map, $key, $keys...", new A._deepRemove_closure())); + _lazyFinal($, "_remove", "$get$_remove", () => A.BuiltInCallable$overloadedFunction("remove", A.LinkedHashMap_LinkedHashMap$_literal(["$map", new A._remove_closure(), "$map, $key, $keys...", new A._remove_closure0()], type$.String, type$.Value_Function_List_Value))); + _lazyFinal($, "_keys", "$get$_keys", () => A._function3("keys", "$map", new A._keys_closure())); + _lazyFinal($, "_values", "$get$_values", () => A._function3("values", "$map", new A._values_closure())); + _lazyFinal($, "_hasKey", "$get$_hasKey", () => A._function3("has-key", "$map, $key, $keys...", new A._hasKey_closure())); + _lazyFinal($, "global2", "$get$global2", () => { + var _s4_ = "math"; + return A.UnmodifiableListView$(A._setArrayType([A._function2("abs", "$number", new A.global_closure()), $.$get$_ceil().withDeprecationWarning$1(_s4_), $.$get$_floor().withDeprecationWarning$1(_s4_), $.$get$_max().withDeprecationWarning$1(_s4_), $.$get$_min().withDeprecationWarning$1(_s4_), $.$get$_percentage().withDeprecationWarning$1(_s4_), $.$get$_randomFunction().withDeprecationWarning$1(_s4_), $.$get$_round().withDeprecationWarning$1(_s4_), $.$get$_unit().withDeprecationWarning$1(_s4_), $.$get$_compatible().withDeprecationWarning$1(_s4_).withName$1("comparable"), $.$get$_isUnitless().withDeprecationWarning$1(_s4_).withName$1("unitless")], type$.JSArray_BuiltInCallable), type$.BuiltInCallable); + }); + _lazyFinal($, "module2", "$get$module2", () => { + var _null = null; + return A.BuiltInModule$("math", A._setArrayType([A._numberFunction("abs", new A.module_closure0()), $.$get$_acos(), $.$get$_asin(), $.$get$_atan(), $.$get$_atan2(), $.$get$_ceil(), $.$get$_clamp(), $.$get$_cos(), $.$get$_compatible(), $.$get$_floor(), $.$get$_hypot(), $.$get$_isUnitless(), $.$get$_log(), $.$get$_max(), $.$get$_min(), $.$get$_percentage(), $.$get$_pow(), $.$get$_randomFunction(), $.$get$_round(), $.$get$_sin(), $.$get$_sqrt(), $.$get$_tan(), $.$get$_unit(), $.$get$_div()], type$.JSArray_Callable), _null, A.LinkedHashMap_LinkedHashMap$_literal(["e", A.SassNumber_SassNumber(2.718281828459045, _null), "pi", A.SassNumber_SassNumber(3.141592653589793, _null), "epsilon", A.SassNumber_SassNumber(2220446049250313e-31, _null), "max-safe-integer", A.SassNumber_SassNumber(9007199254740991, _null), "min-safe-integer", A.SassNumber_SassNumber(-9007199254740991, _null), "max-number", A.SassNumber_SassNumber(17976931348623157e292, _null), "min-number", A.SassNumber_SassNumber(5e-324, _null)], type$.String, type$.Value), type$.Callable); + }); + _lazyFinal($, "_ceil", "$get$_ceil", () => A._numberFunction("ceil", new A._ceil_closure())); + _lazyFinal($, "_clamp", "$get$_clamp", () => A._function2("clamp", "$min, $number, $max", new A._clamp_closure())); + _lazyFinal($, "_floor", "$get$_floor", () => A._numberFunction("floor", new A._floor_closure())); + _lazyFinal($, "_max", "$get$_max", () => A._function2("max", "$numbers...", new A._max_closure())); + _lazyFinal($, "_min", "$get$_min", () => A._function2("min", "$numbers...", new A._min_closure())); + _lazyFinal($, "_round", "$get$_round", () => A._numberFunction("round", new A._round_closure())); + _lazyFinal($, "_hypot", "$get$_hypot", () => A._function2("hypot", "$numbers...", new A._hypot_closure())); + _lazyFinal($, "_log", "$get$_log", () => A._function2("log", "$number, $base: null", new A._log_closure())); + _lazyFinal($, "_pow", "$get$_pow", () => A._function2("pow", "$base, $exponent", new A._pow_closure())); + _lazyFinal($, "_sqrt", "$get$_sqrt", () => A._singleArgumentMathFunc("sqrt", A.number0__sqrt$closure())); + _lazyFinal($, "_acos", "$get$_acos", () => A._singleArgumentMathFunc("acos", A.number0__acos$closure())); + _lazyFinal($, "_asin", "$get$_asin", () => A._singleArgumentMathFunc("asin", A.number0__asin$closure())); + _lazyFinal($, "_atan", "$get$_atan", () => A._singleArgumentMathFunc("atan", A.number0__atan$closure())); + _lazyFinal($, "_atan2", "$get$_atan2", () => A._function2("atan2", "$y, $x", new A._atan2_closure())); + _lazyFinal($, "_cos", "$get$_cos", () => A._singleArgumentMathFunc("cos", A.number0__cos$closure())); + _lazyFinal($, "_sin", "$get$_sin", () => A._singleArgumentMathFunc("sin", A.number0__sin$closure())); + _lazyFinal($, "_tan", "$get$_tan", () => A._singleArgumentMathFunc("tan", A.number0__tan$closure())); + _lazyFinal($, "_compatible", "$get$_compatible", () => A._function2("compatible", "$number1, $number2", new A._compatible_closure())); + _lazyFinal($, "_isUnitless", "$get$_isUnitless", () => A._function2("is-unitless", "$number", new A._isUnitless_closure())); + _lazyFinal($, "_unit", "$get$_unit", () => A._function2("unit", "$number", new A._unit_closure())); + _lazyFinal($, "_percentage", "$get$_percentage", () => A._function2("percentage", "$number", new A._percentage_closure())); + _lazyFinal($, "_random", "$get$_random0", () => A.Random_Random()); + _lazyFinal($, "_randomFunction", "$get$_randomFunction", () => A._function2("random", "$limit: null", new A._randomFunction_closure())); + _lazyFinal($, "_div", "$get$_div", () => A._function2("div", "$number1, $number2", new A._div_closure())); + _lazyFinal($, "_shared", "$get$_shared", () => A.UnmodifiableListView$(A._setArrayType([A._function("feature-exists", "$feature", new A._shared_closure()), A._function("inspect", "$value", new A._shared_closure0()), A._function("type-of", "$value", new A._shared_closure1()), A._function("keywords", "$args", new A._shared_closure2())], type$.JSArray_BuiltInCallable), type$.BuiltInCallable)); + _lazyFinal($, "global3", "$get$global5", () => { + var t2, + t1 = A._setArrayType([], type$.JSArray_BuiltInCallable); + for (t2 = $.$get$_shared(), t2 = t2.get$iterator(t2); t2.moveNext$0();) + t1.push(t2.get$current(0).withDeprecationWarning$1("meta")); + return A.UnmodifiableListView$(t1, type$.BuiltInCallable); + }); + _lazyFinal($, "moduleFunctions", "$get$moduleFunctions", () => { + var t1 = type$.BuiltInCallable, + t2 = A.List_List$of($.$get$_shared(), true, t1); + t2.push(A._function("calc-name", "$calc", new A.moduleFunctions_closure())); + t2.push(A._function("calc-args", "$calc", new A.moduleFunctions_closure0())); + t2.push(A._function("accepts-content", "$mixin", new A.moduleFunctions_closure1())); + return A.UnmodifiableListView$(t2, t1); + }); + _lazyFinal($, "global4", "$get$global3", () => { + var _s8_ = "selector"; + return A.UnmodifiableListView$(A._setArrayType([$.$get$_isSuperselector().withDeprecationWarning$1(_s8_), $.$get$_simpleSelectors().withDeprecationWarning$1(_s8_), $.$get$_parse().withDeprecationWarning$1(_s8_).withName$1("selector-parse"), $.$get$_nest().withDeprecationWarning$1(_s8_).withName$1("selector-nest"), $.$get$_append().withDeprecationWarning$1(_s8_).withName$1("selector-append"), $.$get$_extend().withDeprecationWarning$1(_s8_).withName$1("selector-extend"), $.$get$_replace().withDeprecationWarning$1(_s8_).withName$1("selector-replace"), $.$get$_unify().withDeprecationWarning$1(_s8_).withName$1("selector-unify")], type$.JSArray_BuiltInCallable), type$.BuiltInCallable); + }); + _lazyFinal($, "module3", "$get$module3", () => A.BuiltInModule$("selector", A._setArrayType([$.$get$_isSuperselector(), $.$get$_simpleSelectors(), $.$get$_parse(), $.$get$_nest(), $.$get$_append(), $.$get$_extend(), $.$get$_replace(), $.$get$_unify()], type$.JSArray_Callable), null, null, type$.Callable)); + _lazyFinal($, "_nest", "$get$_nest", () => A._function1("nest", "$selectors...", new A._nest_closure())); + _lazyFinal($, "_append0", "$get$_append", () => A._function1("append", "$selectors...", new A._append_closure())); + _lazyFinal($, "_extend", "$get$_extend", () => A._function1("extend", "$selector, $extendee, $extender", new A._extend_closure())); + _lazyFinal($, "_replace", "$get$_replace", () => A._function1("replace", "$selector, $original, $replacement", new A._replace_closure())); + _lazyFinal($, "_unify", "$get$_unify", () => A._function1("unify", "$selector1, $selector2", new A._unify_closure())); + _lazyFinal($, "_isSuperselector", "$get$_isSuperselector", () => A._function1("is-superselector", "$super, $sub", new A._isSuperselector_closure())); + _lazyFinal($, "_simpleSelectors", "$get$_simpleSelectors", () => A._function1("simple-selectors", "$selector", new A._simpleSelectors_closure())); + _lazyFinal($, "_parse0", "$get$_parse", () => A._function1("parse", "$selector", new A._parse_closure())); + _lazyFinal($, "_random0", "$get$_random", () => A.Random_Random()); + _lazy($, "_previousUniqueId", "$get$_previousUniqueId", () => $.$get$_random().nextInt$1(A._asInt(A.pow(36, 6)))); + _lazyFinal($, "global5", "$get$global4", () => { + var _s6_ = "string"; + return A.UnmodifiableListView$(A._setArrayType([$.$get$_unquote().withDeprecationWarning$1(_s6_), $.$get$_quote().withDeprecationWarning$1(_s6_), $.$get$_toUpperCase().withDeprecationWarning$1(_s6_), $.$get$_toLowerCase().withDeprecationWarning$1(_s6_), $.$get$_uniqueId().withDeprecationWarning$1(_s6_), $.$get$_length().withDeprecationWarning$1(_s6_).withName$1("str-length"), $.$get$_insert().withDeprecationWarning$1(_s6_).withName$1("str-insert"), $.$get$_index().withDeprecationWarning$1(_s6_).withName$1("str-index"), $.$get$_slice().withDeprecationWarning$1(_s6_).withName$1("str-slice")], type$.JSArray_BuiltInCallable), type$.BuiltInCallable); + }); + _lazyFinal($, "module4", "$get$module4", () => A.BuiltInModule$("string", A._setArrayType([$.$get$_unquote(), $.$get$_quote(), $.$get$_toUpperCase(), $.$get$_toLowerCase(), $.$get$_length(), $.$get$_insert(), $.$get$_index(), $.$get$_slice(), $.$get$_uniqueId(), A._function0("split", "$string, $separator, $limit: null", new A.module_closure())], type$.JSArray_Callable), null, null, type$.Callable)); + _lazyFinal($, "_unquote", "$get$_unquote", () => A._function0("unquote", "$string", new A._unquote_closure())); + _lazyFinal($, "_quote", "$get$_quote", () => A._function0("quote", "$string", new A._quote_closure())); + _lazyFinal($, "_length0", "$get$_length", () => A._function0("length", "$string", new A._length_closure())); + _lazyFinal($, "_insert", "$get$_insert", () => A._function0("insert", "$string, $insert, $index", new A._insert_closure())); + _lazyFinal($, "_index0", "$get$_index", () => A._function0("index", "$string, $substring", new A._index_closure())); + _lazyFinal($, "_slice", "$get$_slice", () => A._function0("slice", "$string, $start-at, $end-at: -1", new A._slice_closure())); + _lazyFinal($, "_toUpperCase", "$get$_toUpperCase", () => A._function0("to-upper-case", "$string", new A._toUpperCase_closure())); + _lazyFinal($, "_toLowerCase", "$get$_toLowerCase", () => A._function0("to-lower-case", "$string", new A._toLowerCase_closure())); + _lazyFinal($, "_uniqueId", "$get$_uniqueId", () => A._function0("unique-id", "", new A._uniqueId_closure())); + _lazyFinal($, "FilesystemImporter_cwd", "$get$FilesystemImporter_cwd", () => { + var _null = null; + return new A.FilesystemImporter(A.absolute(".", _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null), true); + }); + _lazyFinal($, "FilesystemImporter_noLoadPath", "$get$FilesystemImporter_noLoadPath", () => new A.FilesystemImporter(null, false)); + _lazyFinal($, "_jsThrow", "$get$_jsThrow0", () => new self.Function("error", "throw error;")); + _lazyFinal($, "Logger_quiet", "$get$Logger_quiet", () => new A._QuietLogger()); + _lazyFinal($, "_disallowedFunctionNames", "$get$_disallowedFunctionNames", () => { + var t1 = $.$get$globalFunctions(); + t1 = t1.map$1$1(t1, new A._disallowedFunctionNames_closure(), type$.String).toSet$0(0); + t1.add$1(0, "if"); + t1.remove$1(0, "abs"); + t1.remove$1(0, "alpha"); + t1.remove$1(0, "color"); + t1.remove$1(0, "grayscale"); + t1.remove$1(0, "hsl"); + t1.remove$1(0, "hsla"); + t1.remove$1(0, "hwb"); + t1.remove$1(0, "invert"); + t1.remove$1(0, "lab"); + t1.remove$1(0, "lch"); + t1.remove$1(0, "max"); + t1.remove$1(0, "min"); + t1.remove$1(0, "oklab"); + t1.remove$1(0, "oklch"); + t1.remove$1(0, "opacity"); + t1.remove$1(0, "rgb"); + t1.remove$1(0, "rgba"); + t1.remove$1(0, "round"); + t1.remove$1(0, "saturate"); + return t1; + }); + _lazyFinal($, "_epsilon", "$get$_epsilon", () => A.pow(10, -11)); + _lazyFinal($, "_inverseEpsilon", "$get$_inverseEpsilon", () => A.pow(10, 11)); + _lazyFinal($, "bogusSpan", "$get$bogusSpan", () => A.SourceFile$decoded(A._setArrayType([], type$.JSArray_int), null).span$1(0, 0)); + _lazyFinal($, "_noSourceUrl", "$get$_noSourceUrl", () => A.Uri_parse("-")); + _lazyFinal($, "_traces", "$get$_traces", () => A.Expando$()); + _lazyFinal($, "lmsToOklab", "$get$lmsToOklab", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.210454268309314, 0.7936177747023054, -0.0040720430116193, 1.9779985324311684, -2.42859224204858, 0.450593709617411, 0.0259040424655478, 0.7827717124575296, -0.8086757549230774], type$.JSArray_double))); + _lazyFinal($, "oklabToLms", "$get$oklabToLms", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.0000000000000002, 0.3963377773761749, 0.2158037573099136, 0.9999999999999998, -0.10556134581565854, -0.06385417282581334, 0.9999999999999999, -0.0894841775298118, -1.2914855480194094], type$.JSArray_double))); + _lazyFinal($, "linearSrgbToLinearDisplayP3", "$get$linearSrgbToLinearDisplayP3", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.8224619687143623, 0.17753803128563775, 0, 0.03319419885096161, 0.9668058011490384, 0, 0.01708263072112003, 0.07239744066396346, 0.9105199286149165], type$.JSArray_double))); + _lazyFinal($, "linearDisplayP3ToLinearSrgb", "$get$linearDisplayP3ToLinearSrgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.2249401762805598, -0.22494017628055996, 0, -0.04205695470968816, 1.042056954709688, 0, -0.01963755459033443, -0.07863604555063188, 1.0982736001409663], type$.JSArray_double))); + _lazyFinal($, "linearSrgbToLinearA98Rgb", "$get$linearSrgbToLinearA98Rgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.7151256068556247, 0.28487439314437535, 0, 0, 1, 0, 0, 0.04116194845011846, 0.9588380515498816], type$.JSArray_double))); + _lazyFinal($, "linearA98RgbToLinearSrgb", "$get$linearA98RgbToLinearSrgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.3983557439607783, -0.3983557439607783, 0, 0, 1, 0, 0, -0.04292898929447326, 1.0429289892944733], type$.JSArray_double))); + _lazyFinal($, "linearSrgbToLinearRec2020", "$get$linearSrgbToLinearRec2020", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.627403895934699, 0.3292830383778837, 0.04331306568741722, 0.06909728935823208, 0.9195403950754587, 0.01136231556630917, 0.01639143887515027, 0.08801330787722575, 0.895595253247624], type$.JSArray_double))); + _lazyFinal($, "linearRec2020ToLinearSrgb", "$get$linearRec2020ToLinearSrgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.6604910021084345, -0.5876411387885495, -0.07284986331988487, -0.12455047452159074, 1.1328998971259603, -0.00834942260436947, -0.0181507633549053, -0.10057889800800737, 1.1187296613629127], type$.JSArray_double))); + _lazyFinal($, "linearSrgbToXyzD65", "$get$linearSrgbToXyzD65", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.4123907992659595, 0.35758433938387796, 0.1804807884018343, 0.21263900587151036, 0.7151686787677559, 0.07219231536073371, 0.01933081871559185, 0.11919477979462598, 0.9505321522496606], type$.JSArray_double))); + _lazyFinal($, "xyzD65ToLinearSrgb", "$get$xyzD65ToLinearSrgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([3.2409699419045213, -1.5373831775700935, -0.4986107602930033, -0.9692436362808798, 1.8759675015077206, 0.04155505740717561, 0.0556300796969936, -0.20397695888897657, 1.0569715142428786], type$.JSArray_double))); + _lazyFinal($, "linearSrgbToLms", "$get$linearSrgbToLms", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.412221469470763, 0.5363325372617348, 0.0514459932675022, 0.2119034958178252, 0.6806995506452342, 0.1073969535369405, 0.08830245919005641, 0.2817188391361215, 0.6299787016738221], type$.JSArray_double))); + _lazyFinal($, "lmsToLinearSrgb", "$get$lmsToLinearSrgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([4.076741636075958, -3.307711539258062, 0.23096990318210417, -1.268437973285032, 2.609757349287689, -0.3413193760026571, -0.00419607613867551, -0.7034186179359363, 1.707614694074612], type$.JSArray_double))); + _lazyFinal($, "linearSrgbToLinearProphotoRgb", "$get$linearSrgbToLinearProphotoRgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.5292769776226116, 0.33015450197849283, 0.14056852039889556, 0.09836585954044917, 0.8734707129069618, 0.028163427552589, 0.01687534092138684, 0.11765941425612084, 0.8654652448224923], type$.JSArray_double))); + _lazyFinal($, "linearProphotoRgbToLinearSrgb", "$get$linearProphotoRgbToLinearSrgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([2.034380849516996, -0.7276357899341342, -0.3067450595828618, -0.22882573163305037, 1.2317425411901048, -0.00291680955705449, -0.00855882878391742, -0.1532667021380372, 1.1618255309219547], type$.JSArray_double))); + _lazyFinal($, "linearSrgbToXyzD50", "$get$linearSrgbToXyzD50", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.43606574687426936, 0.3851515095901596, 0.14307841996513868, 0.22249317711056518, 0.7168870130944824, 0.06061980979495235, 0.01392392146316939, 0.09708132423141015, 0.7140993568158807], type$.JSArray_double))); + _lazyFinal($, "xyzD50ToLinearSrgb", "$get$xyzD50ToLinearSrgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([3.1341358529001178, -1.617385998018042, -0.49066221791109754, -0.9787954765557777, 1.9162543773959884, 0.03344287339036693, 0.07195539255794733, -0.228976759815182, 1.4053860351131182], type$.JSArray_double))); + _lazyFinal($, "linearDisplayP3ToLinearA98Rgb", "$get$linearDisplayP3ToLinearA98Rgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.8640051374740484, 0.13599486252595164, 0, -0.04205695470968816, 1.042056954709688, 0, -0.02056038078232985, -0.03250613804550798, 1.0530665188278379], type$.JSArray_double))); + _lazyFinal($, "linearA98RgbToLinearDisplayP3", "$get$linearA98RgbToLinearDisplayP3", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.1500944181410184, -0.15009441814101834, 0, 0.04641729862941844, 0.9535827013705815, 0, 0.02388759479083904, 0.02650477632633013, 0.9496076288828308], type$.JSArray_double))); + _lazyFinal($, "linearDisplayP3ToLinearRec2020", "$get$linearDisplayP3ToLinearRec2020", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.7538330343617218, 0.1985973690526163, 0.04756959658566187, 0.04574384896535833, 0.9417772198116935, 0.01247893122294812, -0.00121034035451832, 0.01760171730108989, 0.9836086230534284], type$.JSArray_double))); + _lazyFinal($, "linearRec2020ToLinearDisplayP3", "$get$linearRec2020ToLinearDisplayP3", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.343578252584332, -0.2821796705261357, -0.06139858205819628, -0.06529745278911953, 1.0757879158485746, -0.01049046305945495, 0.00282178726170095, -0.01959849452449406, 1.0167767072627931], type$.JSArray_double))); + _lazyFinal($, "linearDisplayP3ToXyzD65", "$get$linearDisplayP3ToXyzD65", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.48657094864821626, 0.26566769316909294, 0.1982172852343625, 0.22897456406974884, 0.6917385218365062, 0.079286914093745, 0, 0.04511338185890257, 1.0439443689009757], type$.JSArray_double))); + _lazyFinal($, "xyzD65ToLinearDisplayP3", "$get$xyzD65ToLinearDisplayP3", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([2.4934969119414245, -0.9313836179191236, -0.40271078445071684, -0.8294889695615749, 1.7626640603183468, 0.02362468584194359, 0.03584583024378433, -0.0761723892680417, 0.9568845240076873], type$.JSArray_double))); + _lazyFinal($, "linearDisplayP3ToLms", "$get$linearDisplayP3ToLms", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.48137985274995443, 0.46211837101131803, 0.05650177623872756, 0.22883194181124472, 0.6532168193835676, 0.11795123880518774, 0.08394575232299319, 0.22416527097756642, 0.6918889766994404], type$.JSArray_double))); + _lazyFinal($, "lmsToLinearDisplayP3", "$get$lmsToLinearDisplayP3", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([3.1277689713618737, -2.2571357625916386, 0.12936679122976494, -1.0910090184377979, 2.4133317103069225, -0.32232269186912466, -0.02601080193857045, -0.508041331704167, 1.5340521336427373], type$.JSArray_double))); + _lazyFinal($, "linearDisplayP3ToLinearProphotoRgb", "$get$linearDisplayP3ToLinearProphotoRgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.6316869193403589, 0.21393038569465722, 0.1543826949649839, 0.08320371426648458, 0.8858651367630243, 0.03093114897049121, -0.00127273456473881, 0.05075510433665735, 0.9505176302280814], type$.JSArray_double))); + _lazyFinal($, "linearProphotoRgbToLinearDisplayP3", "$get$linearProphotoRgbToLinearDisplayP3", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.6325756087069179, -0.3797716184825984, -0.2528039902243195, -0.15370040233755072, 1.1667025472425014, -0.01300214490495082, 0.01039319529676572, -0.0628073126495944, 1.0524141173528287], type$.JSArray_double))); + _lazyFinal($, "linearDisplayP3ToXyzD50", "$get$linearDisplayP3ToXyzD50", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.515146442968116, 0.2920099820638577, 0.15713925139759397, 0.2412003221252552, 0.6922225411313818, 0.06657713674336294, -0.00105013914714014, 0.0418782701890746, 0.7842764714685257], type$.JSArray_double))); + _lazyFinal($, "xyzD50ToLinearDisplayP3", "$get$xyzD50ToLinearDisplayP3", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([2.4039341218554973, -0.9900304424955931, -0.39761363181465614, -0.8422700161454688, 1.7989580161067082, 0.01604562477090472, 0.04819381686413303, -0.09738519815446048, 1.2736713693321273], type$.JSArray_double))); + _lazyFinal($, "linearA98RgbToLinearRec2020", "$get$linearA98RgbToLinearRec2020", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.8773338416636568, 0.07749370651571998, 0.04517245182062317, 0.09662259146620378, 0.8915273202441805, 0.01185008828961569, 0.02292106270284839, 0.04303668501067932, 0.9340422522864723], type$.JSArray_double))); + _lazyFinal($, "linearRec2020ToLinearA98Rgb", "$get$linearRec2020ToLinearA98Rgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.1519783947159163, -0.0975030553024086, -0.05447533941350766, -0.12455047452159074, 1.1328998971259603, -0.00834942260436947, -0.0225303827810559, -0.04980650742838876, 1.0723368902094446], type$.JSArray_double))); + _lazyFinal($, "linearA98RgbToXyzD65", "$get$linearA98RgbToXyzD65", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.5766690429101308, 0.18555823790654627, 0.18822864623499472, 0.29734497525053616, 0.627363566255466, 0.07529145849399789, 0.02703136138641237, 0.07068885253582714, 0.9913375368376389], type$.JSArray_double))); + _lazyFinal($, "xyzD65ToLinearA98Rgb", "$get$xyzD65ToLinearA98Rgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([2.041587903810746, -0.5650069742788596, -0.3447313507783295, -0.9692436362808798, 1.8759675015077206, 0.04155505740717561, 0.01344428063203102, -0.11836239223101823, 1.0151749943912054], type$.JSArray_double))); + _lazyFinal($, "linearA98RgbToLms", "$get$linearA98RgbToLms", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.5764322596183941, 0.36991322261987963, 0.05365451776172635, 0.29631647054222465, 0.5916761332521885, 0.11200739620558686, 0.1234782510142776, 0.21949869837199862, 0.6570230506137238], type$.JSArray_double))); + _lazyFinal($, "lmsToLinearA98Rgb", "$get$lmsToLinearA98Rgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([2.5540368386115566, -1.6219761806828699, 0.06793934207131327, -1.268437973285032, 2.609757349287689, -0.3413193760026571, -0.05623473593749381, -0.5670418395669061, 1.6232765755043999], type$.JSArray_double))); + _lazyFinal($, "linearA98RgbToLinearProphotoRgb", "$get$linearA98RgbToLinearProphotoRgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.7401175018047792, 0.11327951328898105, 0.1466029849062397, 0.1375504646980262, 0.833077080269484, 0.02937245503248977, 0.02359772990871766, 0.07378347703906656, 0.9026187930522158], type$.JSArray_double))); + _lazyFinal($, "linearProphotoRgbToLinearA98Rgb", "$get$linearProphotoRgbToLinearA98Rgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.38965124815152, -0.16945907691487766, -0.22019217123664242, -0.22882573163305037, 1.2317425411901048, -0.00291680955705449, -0.01762544368426068, -0.09625702306122665, 1.1138824667454874], type$.JSArray_double))); + _lazyFinal($, "linearA98RgbToXyzD50", "$get$linearA98RgbToXyzD50", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.6097750418861814, 0.20530000261929401, 0.14922063192409227, 0.31112461220464155, 0.6256532308346856, 0.06322215696067286, 0.01947059555648168, 0.06087908649415867, 0.7447549204598198], type$.JSArray_double))); + _lazyFinal($, "xyzD50ToLinearA98Rgb", "$get$xyzD50ToLinearA98Rgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.9624670363768806, -0.6107423404815073, -0.3413580980827154, -0.9787954765557777, 1.9162543773959884, 0.03344287339036693, 0.02870443944957101, -0.1406748663317068, 1.3489141814137937], type$.JSArray_double))); + _lazyFinal($, "linearRec2020ToXyzD65", "$get$linearRec2020ToXyzD65", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.6369580483012913, 0.14461690358620838, 0.16888097516417205, 0.26270021201126703, 0.677998071518871, 0.05930171646986194, 0, 0.0280726930490875, 1.0609850577107909], type$.JSArray_double))); + _lazyFinal($, "xyzD65ToLinearRec2020", "$get$xyzD65ToLinearRec2020", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.7166511879712676, -0.3556707837763924, -0.2533662813736598, -0.666684351832489, 1.616481236634939, 0.01576854581391113, 0.01763985744531091, -0.04277061325780865, 0.942103121235474], type$.JSArray_double))); + _lazyFinal($, "linearRec2020ToLms", "$get$linearRec2020ToLms", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.6167557848654444, 0.36019840122646335, 0.02304581390809228, 0.2651330593926367, 0.6358393720678491, 0.09902756853951408, 0.10010262952034828, 0.20390652261661452, 0.6959908478630372], type$.JSArray_double))); + _lazyFinal($, "lmsToLinearRec2020", "$get$lmsToLinearRec2020", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([2.1399067304346513, -1.246389493760618, 0.10648276332596668, -0.8847358357577674, 2.1632309383612007, -0.2784951026034334, -0.04857374640044396, -0.4545031497140964, 1.5030768961145404], type$.JSArray_double))); + _lazyFinal($, "linearRec2020ToLinearProphotoRgb", "$get$linearRec2020ToLinearProphotoRgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.8351873331297235, 0.04886884858605698, 0.11594381828421951, 0.05403324519953363, 0.9289184085692044, 0.01704834623126199, -0.00234203897072539, 0.03633215316169465, 0.9660098858090307], type$.JSArray_double))); + _lazyFinal($, "linearProphotoRgbToLinearRec2020", "$get$linearProphotoRgbToLinearRec2020", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.200659329517408, -0.05756805370122346, -0.14309127581618444, -0.06994154955888504, 1.080617897597214, -0.01067634803832895, 0.00554147334294746, -0.04078219298657951, 1.035240719643632], type$.JSArray_double))); + _lazyFinal($, "linearRec2020ToXyzD50", "$get$linearRec2020ToXyzD50", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.673515463188276, 0.16569726370390453, 0.12508294953738705, 0.2790590051411206, 0.6753180057491098, 0.04562298910976962, -0.00193242713400438, 0.02997782679282923, 0.7970592028516355], type$.JSArray_double))); + _lazyFinal($, "xyzD50ToLinearRec2020", "$get$xyzD50ToLinearRec2020", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.647184904671766, -0.3936818981316471, -0.23595963848828266, -0.6826641074173818, 1.6477146127444076, 0.01281708338512084, 0.02966887665275675, -0.0629258964297003, 1.2535578201865771], type$.JSArray_double))); + _lazyFinal($, "xyzD65ToLms", "$get$xyzD65ToLms", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.819022437996703, 0.36190626005289034, -0.12887378152098788, 0.03298365393238846, 0.9292868615863433, 0.03614466635064235, 0.0481771893596242, 0.2642395317527308, 0.6335478284694308], type$.JSArray_double))); + _lazyFinal($, "lmsToXyzD65", "$get$lmsToXyzD65", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.2268798758459243, -0.5578149944602171, 0.2813910456659646, -0.04057574521480084, 1.1122868032803173, -0.07171105806551635, -0.07637293667466007, -0.42149333240224324, 1.5869240198367818], type$.JSArray_double))); + _lazyFinal($, "xyzD65ToLinearProphotoRgb", "$get$xyzD65ToLinearProphotoRgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.4031904633774979, -0.22301514479051668, -0.1016066850741379, -0.5262384021633072, 1.4816319629234644, 0.01701879027252688, -0.0112022652862215, 0.01824640347962099, 0.9112472274915048], type$.JSArray_double))); + _lazyFinal($, "linearProphotoRgbToXyzD65", "$get$linearProphotoRgbToXyzD65", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.755590742296921, 0.11271984265940525, 0.0821453420953454, 0.2683218435785719, 0.7151152566617912, 0.01656289975963685, 0.0039159727624258, -0.01293344283684181, 1.0980752208342945], type$.JSArray_double))); + _lazyFinal($, "xyzD65ToXyzD50", "$get$xyzD65ToXyzD50", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.0479297925449966, 0.02294687060160952, -0.05019226628920519, 0.02962780877005567, 0.99043442675388, -0.01707379906341879, -0.00924304064620452, 0.01505519149029816, 0.751874281428137], type$.JSArray_double))); + _lazyFinal($, "xyzD50ToXyzD65", "$get$xyzD50ToXyzD65", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.9554734214880752, -0.02309845494876452, 0.06325924320057065, -0.02836970933386358, 1.0099953980813041, 0.0210414411919173, 0.01231401486448199, -0.02050764929889898, 1.330365926242124], type$.JSArray_double))); + _lazyFinal($, "lmsToLinearProphotoRgb", "$get$lmsToLinearProphotoRgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.7383551481157207, -0.9879509427514458, 0.24959579463572504, -0.7070494015329266, 1.9343700444401382, -0.2273206429072115, -0.08407882206239634, -0.35754060521141334, 1.4416194272738097], type$.JSArray_double))); + _lazyFinal($, "linearProphotoRgbToLms", "$get$linearProphotoRgbToLms", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.7154484605655534, 0.35279155007721186, -0.0682400106427653, 0.2744116490015671, 0.6677976498412367, 0.05779070115719616, 0.10978443261622942, 0.18619829115002018, 0.7040172762337504], type$.JSArray_double))); + _lazyFinal($, "lmsToXyzD50", "$get$lmsToXyzD50", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.288586218172706, -0.5378717444973745, 0.2135812027542364, -0.00253387643187372, 1.0923167988719165, -0.08978292244004273, -0.06937382305734124, -0.29500839894431263, 1.1894868245121142], type$.JSArray_double))); + _lazyFinal($, "xyzD50ToLms", "$get$xyzD50ToLms", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.7707000420431172, 0.34924840261939616, -0.11202351884164681, 0.00559649248368848, 0.9370723401136769, 0.06972568836252771, 0.04633714262191069, 0.25277531574310524, 0.851458076746796], type$.JSArray_double))); + _lazyFinal($, "linearProphotoRgbToXyzD50", "$get$linearProphotoRgbToXyzD50", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.7977666449006423, 0.13518129740053308, 0.0313477341283922, 0.2880748288194013, 0.711835234241873, 0.00008993693872564, 0, 0, 0.8251046025104602], type$.JSArray_double))); + _lazyFinal($, "xyzD50ToLinearProphotoRgb", "$get$xyzD50ToLinearProphotoRgb", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.3457868816471583, -0.25557208737979464, -0.05110186497554526, -0.5446307051249019, 1.5082477428451468, 0.02052744743642139, 0, 0, 1.2119675456389452], type$.JSArray_double))); + _lazyFinal($, "_typesByUnit", "$get$_typesByUnit", () => { + var t3, type, + t1 = type$.String, + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t1 = A.MapExtensions_get_pairs(B.Map_Sr65K, t1, type$.List_String), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t3 = t1.get$current(t1); + type = t3._0; + for (t3 = J.get$iterator$ax(t3._1); t3.moveNext$0();) + t2.$indexSet(0, t3.get$current(t3), type); + } + return t2; + }); + _lazyFinal($, "_knownCompatibilitiesByUnit", "$get$_knownCompatibilitiesByUnit", () => { + var _i, set, t2, + t1 = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, A.findType("Set")); + for (_i = 0; _i < 5; ++_i) { + set = B.List_BFg[_i]; + for (t2 = set.get$iterator(set); t2.moveNext$0();) + t1.$indexSet(0, t2.get$current(0), set); + } + return t1; + }); + _lazyFinal($, "_emptyQuoted", "$get$_emptyQuoted", () => A.SassString$("", true)); + _lazyFinal($, "_emptyUnquoted", "$get$_emptyUnquoted", () => A.SassString$("", false)); + _lazyFinal($, "maxInt32", "$get$maxInt32", () => A._asInt(A.pow(2, 31)) - 1); + _lazyFinal($, "minInt32", "$get$minInt32", () => -A._asInt(A.pow(2, 31))); + _lazyFinal($, "_vmFrame", "$get$_vmFrame", () => A.RegExp_RegExp("^#\\d+\\s+(\\S.*) \\((.+?)((?::\\d+){0,2})\\)$", false)); + _lazyFinal($, "_v8JsFrame", "$get$_v8JsFrame", () => A.RegExp_RegExp("^\\s*at (?:(\\S.*?)(?: \\[as [^\\]]+\\])? \\((.*)\\)|(.*))$", false)); + _lazyFinal($, "_v8JsUrlLocation", "$get$_v8JsUrlLocation", () => A.RegExp_RegExp("^(.*?):(\\d+)(?::(\\d+))?$|native$", false)); + _lazyFinal($, "_v8WasmFrame", "$get$_v8WasmFrame", () => A.RegExp_RegExp("^\\s*at (?:(?.+) )?(?:\\(?(?:(?\\S+):wasm-function\\[(?\\d+)\\]\\:0x(?[0-9a-fA-F]+))\\)?)$", false)); + _lazyFinal($, "_v8EvalLocation", "$get$_v8EvalLocation", () => A.RegExp_RegExp("^eval at (?:\\S.*?) \\((.*)\\)(?:, .*?:\\d+:\\d+)?$", false)); + _lazyFinal($, "_firefoxEvalLocation", "$get$_firefoxEvalLocation", () => A.RegExp_RegExp("(\\S+)@(\\S+) line (\\d+) >.* (Function|eval):\\d+:\\d+", false)); + _lazyFinal($, "_firefoxSafariJSFrame", "$get$_firefoxSafariJSFrame", () => A.RegExp_RegExp("^(?:([^@(/]*)(?:\\(.*\\))?((?:/[^/]*)*)(?:\\(.*\\))?@)?(.*?):(\\d*)(?::(\\d*))?$", false)); + _lazyFinal($, "_firefoxWasmFrame", "$get$_firefoxWasmFrame", () => A.RegExp_RegExp("^(?.*?)@(?:(?\\S+).*?:wasm-function\\[(?\\d+)\\]:0x(?[0-9a-fA-F]+))$", false)); + _lazyFinal($, "_safariWasmFrame", "$get$_safariWasmFrame", () => A.RegExp_RegExp("^.*?wasm-function\\[(?.*)\\]@\\[wasm code\\]$", false)); + _lazyFinal($, "_friendlyFrame", "$get$_friendlyFrame", () => A.RegExp_RegExp("^(\\S+)(?: (\\d+)(?::(\\d+))?)?\\s+([^\\d].*)$", false)); + _lazyFinal($, "_asyncBody", "$get$_asyncBody", () => A.RegExp_RegExp("<(|[^>]+)_async_body>", false)); + _lazyFinal($, "_initialDot", "$get$_initialDot", () => A.RegExp_RegExp("^\\.", false)); + _lazyFinal($, "Frame__uriRegExp", "$get$Frame__uriRegExp", () => A.RegExp_RegExp("^[a-zA-Z][-+.a-zA-Z\\d]*://", false)); + _lazyFinal($, "Frame__windowsRegExp", "$get$Frame__windowsRegExp", () => A.RegExp_RegExp("^([a-zA-Z]:[\\\\/]|\\\\\\\\)", false)); + _lazyFinal($, "_terseRegExp", "$get$_terseRegExp", () => A.RegExp_RegExp("(-patch)?([/\\\\].*)?$", false)); + _lazyFinal($, "_v8Trace", "$get$_v8Trace", () => A.RegExp_RegExp("\\n ?at ", false)); + _lazyFinal($, "_v8TraceLine", "$get$_v8TraceLine", () => A.RegExp_RegExp(" ?at ", false)); + _lazyFinal($, "_firefoxEvalTrace", "$get$_firefoxEvalTrace", () => A.RegExp_RegExp("@\\S+ line \\d+ >.* (Function|eval):\\d+:\\d+", false)); + _lazyFinal($, "_firefoxSafariTrace", "$get$_firefoxSafariTrace", () => A.RegExp_RegExp("^(([.0-9A-Za-z_$/<]|\\(.*\\))*@)?[^\\s]*:\\d*$", true)); + _lazyFinal($, "_friendlyTrace", "$get$_friendlyTrace", () => A.RegExp_RegExp("^[^\\s<][^\\s]*( \\d+(:\\d+)?)?[ \\t]+[^\\s]+$", true)); + _lazyFinal($, "vmChainGap", "$get$vmChainGap", () => A.RegExp_RegExp("^\\n?$", true)); + _lazyFinal($, "_newlineRegExp", "$get$_newlineRegExp", () => A.RegExp_RegExp("\\n|\\r\\n|\\r(?!\\n)", false)); + _lazyFinal($, "argumentListClass", "$get$argumentListClass", () => new A.argumentListClass_closure().call$0()); + _lazyFinal($, "booleanClass", "$get$booleanClass", () => new A.booleanClass_closure().call$0()); + _lazyFinal($, "legacyBooleanClass", "$get$legacyBooleanClass", () => new A.legacyBooleanClass_closure().call$0()); + _lazyFinal($, "calculationClass", "$get$calculationClass", () => new A.calculationClass_closure().call$0()); + _lazyFinal($, "calculationOperationClass", "$get$calculationOperationClass", () => new A.calculationOperationClass_closure().call$0()); + _lazyFinal($, "calculationInterpolationClass", "$get$calculationInterpolationClass", () => new A.calculationInterpolationClass_closure().call$0()); + _lazyFinal($, "_microsoftFilterStart0", "$get$_microsoftFilterStart0", () => A.RegExp_RegExp("^[a-zA-Z]+\\s*=", false)); + _lazyFinal($, "global6", "$get$global6", () => { + var _s5_ = "color", + _s27_ = "$red, $green, $blue, $alpha", + _s19_ = "$red, $green, $blue", + _s9_ = "$channels", + _s37_ = "$hue, $saturation, $lightness, $alpha", + _s29_ = "$hue, $saturation, $lightness", + _s17_ = "$hue, $saturation", + _s6_ = "adjust", + _s15_ = "$color, $amount", + t1 = type$.String, + t2 = type$.Value_Function_List_Value_2; + return A.UnmodifiableListView$(A._setArrayType([A._channelFunction0("red", B.RgbColorSpace_i0P0, new A.global_closure44(), true, null).withDeprecationWarning$1(_s5_), A._channelFunction0("green", B.RgbColorSpace_i0P0, new A.global_closure45(), true, null).withDeprecationWarning$1(_s5_), A._channelFunction0("blue", B.RgbColorSpace_i0P0, new A.global_closure46(), true, null).withDeprecationWarning$1(_s5_), $.$get$_mix0().withDeprecationWarning$1(_s5_), A.BuiltInCallable$overloadedFunction0("rgb", A.LinkedHashMap_LinkedHashMap$_literal([_s27_, new A.global_closure47(), _s19_, new A.global_closure48(), "$color, $alpha", new A.global_closure49(), "$channels", new A.global_closure50()], t1, t2)), A.BuiltInCallable$overloadedFunction0("rgba", A.LinkedHashMap_LinkedHashMap$_literal([_s27_, new A.global_closure51(), _s19_, new A.global_closure52(), "$color, $alpha", new A.global_closure53(), "$channels", new A.global_closure54()], t1, t2)), A._function12("invert", "$color, $weight: 100%, $space: null", new A.global_closure55()), A._channelFunction0("hue", B.HslColorSpace_JQ20, new A.global_closure56(), true, "deg").withDeprecationWarning$1(_s5_), A._channelFunction0("saturation", B.HslColorSpace_JQ20, new A.global_closure57(), true, "%").withDeprecationWarning$1(_s5_), A._channelFunction0("lightness", B.HslColorSpace_JQ20, new A.global_closure58(), true, "%").withDeprecationWarning$1(_s5_), A.BuiltInCallable$overloadedFunction0("hsl", A.LinkedHashMap_LinkedHashMap$_literal([_s37_, new A.global_closure59(), _s29_, new A.global_closure60(), _s17_, new A.global_closure61(), "$channels", new A.global_closure62()], t1, t2)), A.BuiltInCallable$overloadedFunction0("hsla", A.LinkedHashMap_LinkedHashMap$_literal([_s37_, new A.global_closure63(), _s29_, new A.global_closure64(), _s17_, new A.global_closure65(), "$channels", new A.global_closure66()], t1, t2)), A._function12("grayscale", "$color", new A.global_closure67()), A._function12("adjust-hue", "$color, $degrees", new A.global_closure68()).withDeprecationWarning$2(_s5_, _s6_), A._function12("lighten", _s15_, new A.global_closure69()).withDeprecationWarning$2(_s5_, _s6_), A._function12("darken", _s15_, new A.global_closure70()).withDeprecationWarning$2(_s5_, _s6_), A.BuiltInCallable$overloadedFunction0("saturate", A.LinkedHashMap_LinkedHashMap$_literal(["$amount", new A.global_closure71(), "$color, $amount", new A.global_closure72()], t1, t2)), A._function12("desaturate", _s15_, new A.global_closure73()).withDeprecationWarning$2(_s5_, _s6_), A._function12("opacify", _s15_, new A.global_closure74()).withDeprecationWarning$2(_s5_, _s6_), A._function12("fade-in", _s15_, new A.global_closure75()).withDeprecationWarning$2(_s5_, _s6_), A._function12("transparentize", _s15_, new A.global_closure76()).withDeprecationWarning$2(_s5_, _s6_), A._function12("fade-out", _s15_, new A.global_closure77()).withDeprecationWarning$2(_s5_, _s6_), A.BuiltInCallable$overloadedFunction0("alpha", A.LinkedHashMap_LinkedHashMap$_literal(["$color", new A.global_closure78(), "$args...", new A.global_closure79()], t1, t2)), A._function12("opacity", "$color", new A.global_closure80()), A._function12(_s5_, "$description", new A.global_closure81()), A._function12("hwb", _s9_, new A.global_closure82()), A._function12("lab", _s9_, new A.global_closure83()), A._function12("lch", _s9_, new A.global_closure84()), A._function12("oklab", _s9_, new A.global_closure85()), A._function12("oklch", _s9_, new A.global_closure86()), $.$get$_complement0().withDeprecationWarning$1(_s5_), $.$get$_ieHexStr0(), $.$get$_adjust0().withDeprecationWarning$1(_s5_).withName$1("adjust-color"), $.$get$_scale0().withDeprecationWarning$1(_s5_).withName$1("scale-color"), $.$get$_change0().withDeprecationWarning$1(_s5_).withName$1("change-color")], type$.JSArray_BuiltInCallable_2), type$.BuiltInCallable_2); + }); + _lazyFinal($, "module5", "$get$module5", () => { + var _null = null, + _s10_ = "saturation", + _s9_ = "lightness", + _s6_ = "$color", _s5_ = "alpha", + _s30_ = "$color, $channel, $space: null", + t1 = type$.String, + t2 = type$.Value_Function_List_Value_2; + return A.BuiltInModule$0("color", A._setArrayType([A._channelFunction0("red", B.RgbColorSpace_i0P0, new A.module_closure27(), false, _null), A._channelFunction0("green", B.RgbColorSpace_i0P0, new A.module_closure28(), false, _null), A._channelFunction0("blue", B.RgbColorSpace_i0P0, new A.module_closure29(), false, _null), $.$get$_mix0(), A._function12("invert", "$color, $weight: 100%, $space: null", new A.module_closure30()), A._channelFunction0("hue", B.HslColorSpace_JQ20, new A.module_closure31(), false, "deg"), A._channelFunction0(_s10_, B.HslColorSpace_JQ20, new A.module_closure32(), false, "%"), A._channelFunction0(_s9_, B.HslColorSpace_JQ20, new A.module_closure33(), false, "%"), A._removedColorFunction0("adjust-hue", "hue", false), A._removedColorFunction0("lighten", _s9_, false), A._removedColorFunction0("darken", _s9_, true), A._removedColorFunction0("saturate", _s10_, false), A._removedColorFunction0("desaturate", _s10_, true), A._function12("grayscale", _s6_, new A.module_closure34()), A.BuiltInCallable$overloadedFunction0("hwb", A.LinkedHashMap_LinkedHashMap$_literal(["$hue, $whiteness, $blackness, $alpha: 1", new A.module_closure35(), "$channels", new A.module_closure36()], t1, t2)), A._channelFunction0("whiteness", B.HwbColorSpace_guQ0, new A.module_closure37(), false, "%"), A._channelFunction0("blackness", B.HwbColorSpace_guQ0, new A.module_closure38(), false, "%"), A._removedColorFunction0("opacify", _s5_, false), A._removedColorFunction0("fade-in", _s5_, false), A._removedColorFunction0("transparentize", _s5_, true), A._removedColorFunction0("fade-out", _s5_, true), A.BuiltInCallable$overloadedFunction0(_s5_, A.LinkedHashMap_LinkedHashMap$_literal(["$color", new A.module_closure39(), "$args...", new A.module_closure40()], t1, t2)), A._function12("opacity", _s6_, new A.module_closure41()), A._function12("space", _s6_, new A.module_closure42()), A._function12("to-space", "$color, $space", new A.module_closure43()), A._function12("is-legacy", _s6_, new A.module_closure44()), A._function12("is-missing", "$color, $channel", new A.module_closure45()), A._function12("is-in-gamut", "$color, $space: null", new A.module_closure46()), A._function12("to-gamut", "$color, $space: null, $method: null", new A.module_closure47()), A._function12("channel", _s30_, new A.module_closure48()), A._function12("same", "$color1, $color2", new A.module_closure49()), A._function12("is-powerless", _s30_, new A.module_closure50()), $.$get$_complement0(), $.$get$_adjust0(), $.$get$_scale0(), $.$get$_change0(), $.$get$_ieHexStr0()], type$.JSArray_Callable_2), _null, _null, type$.Callable_2); + }); + _lazyFinal($, "_mix0", "$get$_mix0", () => A._function12("mix", string$.x24color, new A._mix_closure0())); + _lazyFinal($, "_complement0", "$get$_complement0", () => A._function12("complement", "$color, $space: null", new A._complement_closure0())); + _lazyFinal($, "_adjust0", "$get$_adjust0", () => A._function12("adjust", "$color, $kwargs...", new A._adjust_closure0())); + _lazyFinal($, "_scale0", "$get$_scale0", () => A._function12("scale", "$color, $kwargs...", new A._scale_closure0())); + _lazyFinal($, "_change0", "$get$_change0", () => A._function12("change", "$color, $kwargs...", new A._change_closure0())); + _lazyFinal($, "_ieHexStr0", "$get$_ieHexStr0", () => A._function12("ie-hex-str", "$color", new A._ieHexStr_closure0())); + _lazyFinal($, "colorClass", "$get$colorClass", () => new A.colorClass_closure().call$0()); + _lazyFinal($, "legacyColorClass", "$get$legacyColorClass", () => { + var t1 = A.createJSClass("sass.types.Color", new A.legacyColorClass_closure()); + A.JSClassExtension_defineMethods(t1, A.LinkedHashMap_LinkedHashMap$_literal(["getR", new A.legacyColorClass_closure0(), "getG", new A.legacyColorClass_closure1(), "getB", new A.legacyColorClass_closure2(), "getA", new A.legacyColorClass_closure3(), "setR", new A.legacyColorClass_closure4(), "setG", new A.legacyColorClass_closure5(), "setB", new A.legacyColorClass_closure6(), "setA", new A.legacyColorClass_closure7()], type$.String, type$.Function)); + return t1; + }); + _lazyFinal($, "colorsByName0", "$get$colorsByName0", () => A.LinkedHashMap_LinkedHashMap$_literal(["yellowgreen", A.SassColor_SassColor$rgb0(154, 205, 50, 1), "yellow", A.SassColor_SassColor$rgb0(255, 255, 0, 1), "whitesmoke", A.SassColor_SassColor$rgb0(245, 245, 245, 1), "white", A.SassColor_SassColor$rgb0(255, 255, 255, 1), "wheat", A.SassColor_SassColor$rgb0(245, 222, 179, 1), "violet", A.SassColor_SassColor$rgb0(238, 130, 238, 1), "turquoise", A.SassColor_SassColor$rgb0(64, 224, 208, 1), "transparent", A.SassColor_SassColor$rgb0(0, 0, 0, 0), "tomato", A.SassColor_SassColor$rgb0(255, 99, 71, 1), "thistle", A.SassColor_SassColor$rgb0(216, 191, 216, 1), "teal", A.SassColor_SassColor$rgb0(0, 128, 128, 1), "tan", A.SassColor_SassColor$rgb0(210, 180, 140, 1), "steelblue", A.SassColor_SassColor$rgb0(70, 130, 180, 1), "springgreen", A.SassColor_SassColor$rgb0(0, 255, 127, 1), "snow", A.SassColor_SassColor$rgb0(255, 250, 250, 1), "slategrey", A.SassColor_SassColor$rgb0(112, 128, 144, 1), "slategray", A.SassColor_SassColor$rgb0(112, 128, 144, 1), "slateblue", A.SassColor_SassColor$rgb0(106, 90, 205, 1), "skyblue", A.SassColor_SassColor$rgb0(135, 206, 235, 1), "silver", A.SassColor_SassColor$rgb0(192, 192, 192, 1), "sienna", A.SassColor_SassColor$rgb0(160, 82, 45, 1), "seashell", A.SassColor_SassColor$rgb0(255, 245, 238, 1), "seagreen", A.SassColor_SassColor$rgb0(46, 139, 87, 1), "sandybrown", A.SassColor_SassColor$rgb0(244, 164, 96, 1), "salmon", A.SassColor_SassColor$rgb0(250, 128, 114, 1), "saddlebrown", A.SassColor_SassColor$rgb0(139, 69, 19, 1), "royalblue", A.SassColor_SassColor$rgb0(65, 105, 225, 1), "rosybrown", A.SassColor_SassColor$rgb0(188, 143, 143, 1), "red", A.SassColor_SassColor$rgb0(255, 0, 0, 1), "rebeccapurple", A.SassColor_SassColor$rgb0(102, 51, 153, 1), "purple", A.SassColor_SassColor$rgb0(128, 0, 128, 1), "powderblue", A.SassColor_SassColor$rgb0(176, 224, 230, 1), "plum", A.SassColor_SassColor$rgb0(221, 160, 221, 1), "pink", A.SassColor_SassColor$rgb0(255, 192, 203, 1), "peru", A.SassColor_SassColor$rgb0(205, 133, 63, 1), "peachpuff", A.SassColor_SassColor$rgb0(255, 218, 185, 1), "papayawhip", A.SassColor_SassColor$rgb0(255, 239, 213, 1), "palevioletred", A.SassColor_SassColor$rgb0(219, 112, 147, 1), "paleturquoise", A.SassColor_SassColor$rgb0(175, 238, 238, 1), "palegreen", A.SassColor_SassColor$rgb0(152, 251, 152, 1), "palegoldenrod", A.SassColor_SassColor$rgb0(238, 232, 170, 1), "orchid", A.SassColor_SassColor$rgb0(218, 112, 214, 1), "orangered", A.SassColor_SassColor$rgb0(255, 69, 0, 1), "orange", A.SassColor_SassColor$rgb0(255, 165, 0, 1), "olivedrab", A.SassColor_SassColor$rgb0(107, 142, 35, 1), "olive", A.SassColor_SassColor$rgb0(128, 128, 0, 1), "oldlace", A.SassColor_SassColor$rgb0(253, 245, 230, 1), "navy", A.SassColor_SassColor$rgb0(0, 0, 128, 1), "navajowhite", A.SassColor_SassColor$rgb0(255, 222, 173, 1), "moccasin", A.SassColor_SassColor$rgb0(255, 228, 181, 1), "mistyrose", A.SassColor_SassColor$rgb0(255, 228, 225, 1), "mintcream", A.SassColor_SassColor$rgb0(245, 255, 250, 1), "midnightblue", A.SassColor_SassColor$rgb0(25, 25, 112, 1), "mediumvioletred", A.SassColor_SassColor$rgb0(199, 21, 133, 1), "mediumturquoise", A.SassColor_SassColor$rgb0(72, 209, 204, 1), "mediumspringgreen", A.SassColor_SassColor$rgb0(0, 250, 154, 1), "mediumslateblue", A.SassColor_SassColor$rgb0(123, 104, 238, 1), "mediumseagreen", A.SassColor_SassColor$rgb0(60, 179, 113, 1), "mediumpurple", A.SassColor_SassColor$rgb0(147, 112, 219, 1), "mediumorchid", A.SassColor_SassColor$rgb0(186, 85, 211, 1), "mediumblue", A.SassColor_SassColor$rgb0(0, 0, 205, 1), "mediumaquamarine", A.SassColor_SassColor$rgb0(102, 205, 170, 1), "maroon", A.SassColor_SassColor$rgb0(128, 0, 0, 1), "magenta", A.SassColor_SassColor$rgb0(255, 0, 255, 1), "linen", A.SassColor_SassColor$rgb0(250, 240, 230, 1), "limegreen", A.SassColor_SassColor$rgb0(50, 205, 50, 1), "lime", A.SassColor_SassColor$rgb0(0, 255, 0, 1), "lightyellow", A.SassColor_SassColor$rgb0(255, 255, 224, 1), "lightsteelblue", A.SassColor_SassColor$rgb0(176, 196, 222, 1), "lightslategrey", A.SassColor_SassColor$rgb0(119, 136, 153, 1), "lightslategray", A.SassColor_SassColor$rgb0(119, 136, 153, 1), "lightskyblue", A.SassColor_SassColor$rgb0(135, 206, 250, 1), "lightseagreen", A.SassColor_SassColor$rgb0(32, 178, 170, 1), "lightsalmon", A.SassColor_SassColor$rgb0(255, 160, 122, 1), "lightpink", A.SassColor_SassColor$rgb0(255, 182, 193, 1), "lightgrey", A.SassColor_SassColor$rgb0(211, 211, 211, 1), "lightgreen", A.SassColor_SassColor$rgb0(144, 238, 144, 1), "lightgray", A.SassColor_SassColor$rgb0(211, 211, 211, 1), "lightgoldenrodyellow", A.SassColor_SassColor$rgb0(250, 250, 210, 1), "lightcyan", A.SassColor_SassColor$rgb0(224, 255, 255, 1), "lightcoral", A.SassColor_SassColor$rgb0(240, 128, 128, 1), "lightblue", A.SassColor_SassColor$rgb0(173, 216, 230, 1), "lemonchiffon", A.SassColor_SassColor$rgb0(255, 250, 205, 1), "lawngreen", A.SassColor_SassColor$rgb0(124, 252, 0, 1), "lavenderblush", A.SassColor_SassColor$rgb0(255, 240, 245, 1), "lavender", A.SassColor_SassColor$rgb0(230, 230, 250, 1), "khaki", A.SassColor_SassColor$rgb0(240, 230, 140, 1), "ivory", A.SassColor_SassColor$rgb0(255, 255, 240, 1), "indigo", A.SassColor_SassColor$rgb0(75, 0, 130, 1), "indianred", A.SassColor_SassColor$rgb0(205, 92, 92, 1), "hotpink", A.SassColor_SassColor$rgb0(255, 105, 180, 1), "honeydew", A.SassColor_SassColor$rgb0(240, 255, 240, 1), "grey", A.SassColor_SassColor$rgb0(128, 128, 128, 1), "greenyellow", A.SassColor_SassColor$rgb0(173, 255, 47, 1), "green", A.SassColor_SassColor$rgb0(0, 128, 0, 1), "gray", A.SassColor_SassColor$rgb0(128, 128, 128, 1), "goldenrod", A.SassColor_SassColor$rgb0(218, 165, 32, 1), "gold", A.SassColor_SassColor$rgb0(255, 215, 0, 1), "ghostwhite", A.SassColor_SassColor$rgb0(248, 248, 255, 1), "gainsboro", A.SassColor_SassColor$rgb0(220, 220, 220, 1), "fuchsia", A.SassColor_SassColor$rgb0(255, 0, 255, 1), "forestgreen", A.SassColor_SassColor$rgb0(34, 139, 34, 1), "floralwhite", A.SassColor_SassColor$rgb0(255, 250, 240, 1), "firebrick", A.SassColor_SassColor$rgb0(178, 34, 34, 1), "dodgerblue", A.SassColor_SassColor$rgb0(30, 144, 255, 1), "dimgrey", A.SassColor_SassColor$rgb0(105, 105, 105, 1), "dimgray", A.SassColor_SassColor$rgb0(105, 105, 105, 1), "deepskyblue", A.SassColor_SassColor$rgb0(0, 191, 255, 1), "deeppink", A.SassColor_SassColor$rgb0(255, 20, 147, 1), "darkviolet", A.SassColor_SassColor$rgb0(148, 0, 211, 1), "darkturquoise", A.SassColor_SassColor$rgb0(0, 206, 209, 1), "darkslategrey", A.SassColor_SassColor$rgb0(47, 79, 79, 1), "darkslategray", A.SassColor_SassColor$rgb0(47, 79, 79, 1), "darkslateblue", A.SassColor_SassColor$rgb0(72, 61, 139, 1), "darkseagreen", A.SassColor_SassColor$rgb0(143, 188, 143, 1), "darksalmon", A.SassColor_SassColor$rgb0(233, 150, 122, 1), "darkred", A.SassColor_SassColor$rgb0(139, 0, 0, 1), "darkorchid", A.SassColor_SassColor$rgb0(153, 50, 204, 1), "darkorange", A.SassColor_SassColor$rgb0(255, 140, 0, 1), "darkolivegreen", A.SassColor_SassColor$rgb0(85, 107, 47, 1), "darkmagenta", A.SassColor_SassColor$rgb0(139, 0, 139, 1), "darkkhaki", A.SassColor_SassColor$rgb0(189, 183, 107, 1), "darkgrey", A.SassColor_SassColor$rgb0(169, 169, 169, 1), "darkgreen", A.SassColor_SassColor$rgb0(0, 100, 0, 1), "darkgray", A.SassColor_SassColor$rgb0(169, 169, 169, 1), "darkgoldenrod", A.SassColor_SassColor$rgb0(184, 134, 11, 1), "darkcyan", A.SassColor_SassColor$rgb0(0, 139, 139, 1), "darkblue", A.SassColor_SassColor$rgb0(0, 0, 139, 1), "cyan", A.SassColor_SassColor$rgb0(0, 255, 255, 1), "crimson", A.SassColor_SassColor$rgb0(220, 20, 60, 1), "cornsilk", A.SassColor_SassColor$rgb0(255, 248, 220, 1), "cornflowerblue", A.SassColor_SassColor$rgb0(100, 149, 237, 1), "coral", A.SassColor_SassColor$rgb0(255, 127, 80, 1), "chocolate", A.SassColor_SassColor$rgb0(210, 105, 30, 1), "chartreuse", A.SassColor_SassColor$rgb0(127, 255, 0, 1), "cadetblue", A.SassColor_SassColor$rgb0(95, 158, 160, 1), "burlywood", A.SassColor_SassColor$rgb0(222, 184, 135, 1), "brown", A.SassColor_SassColor$rgb0(165, 42, 42, 1), "blueviolet", A.SassColor_SassColor$rgb0(138, 43, 226, 1), "blue", A.SassColor_SassColor$rgb0(0, 0, 255, 1), "blanchedalmond", A.SassColor_SassColor$rgb0(255, 235, 205, 1), "black", A.SassColor_SassColor$rgb0(0, 0, 0, 1), "bisque", A.SassColor_SassColor$rgb0(255, 228, 196, 1), "beige", A.SassColor_SassColor$rgb0(245, 245, 220, 1), "azure", A.SassColor_SassColor$rgb0(240, 255, 255, 1), "aquamarine", A.SassColor_SassColor$rgb0(127, 255, 212, 1), "aqua", A.SassColor_SassColor$rgb0(0, 255, 255, 1), "antiquewhite", A.SassColor_SassColor$rgb0(250, 235, 215, 1), "aliceblue", A.SassColor_SassColor$rgb0(240, 248, 255, 1)], type$.String, type$.SassColor_2)); + _lazyFinal($, "namesByColor0", "$get$namesByColor0", () => { + var $name, + t1 = type$.SassColor_2, + t2 = type$.String, + t3 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + for (t1 = A.MapExtensions_get_pairs0($.$get$colorsByName0(), t2, t1), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t2 = t1.get$current(t1); + $name = t2._0; + t3.$indexSet(0, t2._1, $name); + } + return t3; + }); + _lazyFinal($, "nodePackageImporterClass", "$get$nodePackageImporterClass", () => new A.nodePackageImporterClass_closure().call$0()); + _lazyFinal($, "compilerClass", "$get$compilerClass", () => new A.compilerClass_closure().call$0()); + _lazyFinal($, "asyncCompilerClass", "$get$asyncCompilerClass", () => new A.asyncCompilerClass_closure().call$0()); + _lazyFinal($, "lmsToOklab0", "$get$lmsToOklab0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.210454268309314, 0.7936177747023054, -0.0040720430116193, 1.9779985324311684, -2.42859224204858, 0.450593709617411, 0.0259040424655478, 0.7827717124575296, -0.8086757549230774], type$.JSArray_double))); + _lazyFinal($, "oklabToLms0", "$get$oklabToLms0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.0000000000000002, 0.3963377773761749, 0.2158037573099136, 0.9999999999999998, -0.10556134581565854, -0.06385417282581334, 0.9999999999999999, -0.0894841775298118, -1.2914855480194094], type$.JSArray_double))); + _lazyFinal($, "linearSrgbToLinearDisplayP30", "$get$linearSrgbToLinearDisplayP30", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.8224619687143623, 0.17753803128563775, 0, 0.03319419885096161, 0.9668058011490384, 0, 0.01708263072112003, 0.07239744066396346, 0.9105199286149165], type$.JSArray_double))); + _lazyFinal($, "linearDisplayP3ToLinearSrgb0", "$get$linearDisplayP3ToLinearSrgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.2249401762805598, -0.22494017628055996, 0, -0.04205695470968816, 1.042056954709688, 0, -0.01963755459033443, -0.07863604555063188, 1.0982736001409663], type$.JSArray_double))); + _lazyFinal($, "linearSrgbToLinearA98Rgb0", "$get$linearSrgbToLinearA98Rgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.7151256068556247, 0.28487439314437535, 0, 0, 1, 0, 0, 0.04116194845011846, 0.9588380515498816], type$.JSArray_double))); + _lazyFinal($, "linearA98RgbToLinearSrgb0", "$get$linearA98RgbToLinearSrgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.3983557439607783, -0.3983557439607783, 0, 0, 1, 0, 0, -0.04292898929447326, 1.0429289892944733], type$.JSArray_double))); + _lazyFinal($, "linearSrgbToLinearRec20200", "$get$linearSrgbToLinearRec20200", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.627403895934699, 0.3292830383778837, 0.04331306568741722, 0.06909728935823208, 0.9195403950754587, 0.01136231556630917, 0.01639143887515027, 0.08801330787722575, 0.895595253247624], type$.JSArray_double))); + _lazyFinal($, "linearRec2020ToLinearSrgb0", "$get$linearRec2020ToLinearSrgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.6604910021084345, -0.5876411387885495, -0.07284986331988487, -0.12455047452159074, 1.1328998971259603, -0.00834942260436947, -0.0181507633549053, -0.10057889800800737, 1.1187296613629127], type$.JSArray_double))); + _lazyFinal($, "linearSrgbToXyzD650", "$get$linearSrgbToXyzD650", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.4123907992659595, 0.35758433938387796, 0.1804807884018343, 0.21263900587151036, 0.7151686787677559, 0.07219231536073371, 0.01933081871559185, 0.11919477979462598, 0.9505321522496606], type$.JSArray_double))); + _lazyFinal($, "xyzD65ToLinearSrgb0", "$get$xyzD65ToLinearSrgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([3.2409699419045213, -1.5373831775700935, -0.4986107602930033, -0.9692436362808798, 1.8759675015077206, 0.04155505740717561, 0.0556300796969936, -0.20397695888897657, 1.0569715142428786], type$.JSArray_double))); + _lazyFinal($, "linearSrgbToLms0", "$get$linearSrgbToLms0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.412221469470763, 0.5363325372617348, 0.0514459932675022, 0.2119034958178252, 0.6806995506452342, 0.1073969535369405, 0.08830245919005641, 0.2817188391361215, 0.6299787016738221], type$.JSArray_double))); + _lazyFinal($, "lmsToLinearSrgb0", "$get$lmsToLinearSrgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([4.076741636075958, -3.307711539258062, 0.23096990318210417, -1.268437973285032, 2.609757349287689, -0.3413193760026571, -0.00419607613867551, -0.7034186179359363, 1.707614694074612], type$.JSArray_double))); + _lazyFinal($, "linearSrgbToLinearProphotoRgb0", "$get$linearSrgbToLinearProphotoRgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.5292769776226116, 0.33015450197849283, 0.14056852039889556, 0.09836585954044917, 0.8734707129069618, 0.028163427552589, 0.01687534092138684, 0.11765941425612084, 0.8654652448224923], type$.JSArray_double))); + _lazyFinal($, "linearProphotoRgbToLinearSrgb0", "$get$linearProphotoRgbToLinearSrgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([2.034380849516996, -0.7276357899341342, -0.3067450595828618, -0.22882573163305037, 1.2317425411901048, -0.00291680955705449, -0.00855882878391742, -0.1532667021380372, 1.1618255309219547], type$.JSArray_double))); + _lazyFinal($, "linearSrgbToXyzD500", "$get$linearSrgbToXyzD500", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.43606574687426936, 0.3851515095901596, 0.14307841996513868, 0.22249317711056518, 0.7168870130944824, 0.06061980979495235, 0.01392392146316939, 0.09708132423141015, 0.7140993568158807], type$.JSArray_double))); + _lazyFinal($, "xyzD50ToLinearSrgb0", "$get$xyzD50ToLinearSrgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([3.1341358529001178, -1.617385998018042, -0.49066221791109754, -0.9787954765557777, 1.9162543773959884, 0.03344287339036693, 0.07195539255794733, -0.228976759815182, 1.4053860351131182], type$.JSArray_double))); + _lazyFinal($, "linearDisplayP3ToLinearA98Rgb0", "$get$linearDisplayP3ToLinearA98Rgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.8640051374740484, 0.13599486252595164, 0, -0.04205695470968816, 1.042056954709688, 0, -0.02056038078232985, -0.03250613804550798, 1.0530665188278379], type$.JSArray_double))); + _lazyFinal($, "linearA98RgbToLinearDisplayP30", "$get$linearA98RgbToLinearDisplayP30", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.1500944181410184, -0.15009441814101834, 0, 0.04641729862941844, 0.9535827013705815, 0, 0.02388759479083904, 0.02650477632633013, 0.9496076288828308], type$.JSArray_double))); + _lazyFinal($, "linearDisplayP3ToLinearRec20200", "$get$linearDisplayP3ToLinearRec20200", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.7538330343617218, 0.1985973690526163, 0.04756959658566187, 0.04574384896535833, 0.9417772198116935, 0.01247893122294812, -0.00121034035451832, 0.01760171730108989, 0.9836086230534284], type$.JSArray_double))); + _lazyFinal($, "linearRec2020ToLinearDisplayP30", "$get$linearRec2020ToLinearDisplayP30", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.343578252584332, -0.2821796705261357, -0.06139858205819628, -0.06529745278911953, 1.0757879158485746, -0.01049046305945495, 0.00282178726170095, -0.01959849452449406, 1.0167767072627931], type$.JSArray_double))); + _lazyFinal($, "linearDisplayP3ToXyzD650", "$get$linearDisplayP3ToXyzD650", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.48657094864821626, 0.26566769316909294, 0.1982172852343625, 0.22897456406974884, 0.6917385218365062, 0.079286914093745, 0, 0.04511338185890257, 1.0439443689009757], type$.JSArray_double))); + _lazyFinal($, "xyzD65ToLinearDisplayP30", "$get$xyzD65ToLinearDisplayP30", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([2.4934969119414245, -0.9313836179191236, -0.40271078445071684, -0.8294889695615749, 1.7626640603183468, 0.02362468584194359, 0.03584583024378433, -0.0761723892680417, 0.9568845240076873], type$.JSArray_double))); + _lazyFinal($, "linearDisplayP3ToLms0", "$get$linearDisplayP3ToLms0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.48137985274995443, 0.46211837101131803, 0.05650177623872756, 0.22883194181124472, 0.6532168193835676, 0.11795123880518774, 0.08394575232299319, 0.22416527097756642, 0.6918889766994404], type$.JSArray_double))); + _lazyFinal($, "lmsToLinearDisplayP30", "$get$lmsToLinearDisplayP30", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([3.1277689713618737, -2.2571357625916386, 0.12936679122976494, -1.0910090184377979, 2.4133317103069225, -0.32232269186912466, -0.02601080193857045, -0.508041331704167, 1.5340521336427373], type$.JSArray_double))); + _lazyFinal($, "linearDisplayP3ToLinearProphotoRgb0", "$get$linearDisplayP3ToLinearProphotoRgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.6316869193403589, 0.21393038569465722, 0.1543826949649839, 0.08320371426648458, 0.8858651367630243, 0.03093114897049121, -0.00127273456473881, 0.05075510433665735, 0.9505176302280814], type$.JSArray_double))); + _lazyFinal($, "linearProphotoRgbToLinearDisplayP30", "$get$linearProphotoRgbToLinearDisplayP30", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.6325756087069179, -0.3797716184825984, -0.2528039902243195, -0.15370040233755072, 1.1667025472425014, -0.01300214490495082, 0.01039319529676572, -0.0628073126495944, 1.0524141173528287], type$.JSArray_double))); + _lazyFinal($, "linearDisplayP3ToXyzD500", "$get$linearDisplayP3ToXyzD500", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.515146442968116, 0.2920099820638577, 0.15713925139759397, 0.2412003221252552, 0.6922225411313818, 0.06657713674336294, -0.00105013914714014, 0.0418782701890746, 0.7842764714685257], type$.JSArray_double))); + _lazyFinal($, "xyzD50ToLinearDisplayP30", "$get$xyzD50ToLinearDisplayP30", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([2.4039341218554973, -0.9900304424955931, -0.39761363181465614, -0.8422700161454688, 1.7989580161067082, 0.01604562477090472, 0.04819381686413303, -0.09738519815446048, 1.2736713693321273], type$.JSArray_double))); + _lazyFinal($, "linearA98RgbToLinearRec20200", "$get$linearA98RgbToLinearRec20200", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.8773338416636568, 0.07749370651571998, 0.04517245182062317, 0.09662259146620378, 0.8915273202441805, 0.01185008828961569, 0.02292106270284839, 0.04303668501067932, 0.9340422522864723], type$.JSArray_double))); + _lazyFinal($, "linearRec2020ToLinearA98Rgb0", "$get$linearRec2020ToLinearA98Rgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.1519783947159163, -0.0975030553024086, -0.05447533941350766, -0.12455047452159074, 1.1328998971259603, -0.00834942260436947, -0.0225303827810559, -0.04980650742838876, 1.0723368902094446], type$.JSArray_double))); + _lazyFinal($, "linearA98RgbToXyzD650", "$get$linearA98RgbToXyzD650", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.5766690429101308, 0.18555823790654627, 0.18822864623499472, 0.29734497525053616, 0.627363566255466, 0.07529145849399789, 0.02703136138641237, 0.07068885253582714, 0.9913375368376389], type$.JSArray_double))); + _lazyFinal($, "xyzD65ToLinearA98Rgb0", "$get$xyzD65ToLinearA98Rgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([2.041587903810746, -0.5650069742788596, -0.3447313507783295, -0.9692436362808798, 1.8759675015077206, 0.04155505740717561, 0.01344428063203102, -0.11836239223101823, 1.0151749943912054], type$.JSArray_double))); + _lazyFinal($, "linearA98RgbToLms0", "$get$linearA98RgbToLms0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.5764322596183941, 0.36991322261987963, 0.05365451776172635, 0.29631647054222465, 0.5916761332521885, 0.11200739620558686, 0.1234782510142776, 0.21949869837199862, 0.6570230506137238], type$.JSArray_double))); + _lazyFinal($, "lmsToLinearA98Rgb0", "$get$lmsToLinearA98Rgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([2.5540368386115566, -1.6219761806828699, 0.06793934207131327, -1.268437973285032, 2.609757349287689, -0.3413193760026571, -0.05623473593749381, -0.5670418395669061, 1.6232765755043999], type$.JSArray_double))); + _lazyFinal($, "linearA98RgbToLinearProphotoRgb0", "$get$linearA98RgbToLinearProphotoRgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.7401175018047792, 0.11327951328898105, 0.1466029849062397, 0.1375504646980262, 0.833077080269484, 0.02937245503248977, 0.02359772990871766, 0.07378347703906656, 0.9026187930522158], type$.JSArray_double))); + _lazyFinal($, "linearProphotoRgbToLinearA98Rgb0", "$get$linearProphotoRgbToLinearA98Rgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.38965124815152, -0.16945907691487766, -0.22019217123664242, -0.22882573163305037, 1.2317425411901048, -0.00291680955705449, -0.01762544368426068, -0.09625702306122665, 1.1138824667454874], type$.JSArray_double))); + _lazyFinal($, "linearA98RgbToXyzD500", "$get$linearA98RgbToXyzD500", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.6097750418861814, 0.20530000261929401, 0.14922063192409227, 0.31112461220464155, 0.6256532308346856, 0.06322215696067286, 0.01947059555648168, 0.06087908649415867, 0.7447549204598198], type$.JSArray_double))); + _lazyFinal($, "xyzD50ToLinearA98Rgb0", "$get$xyzD50ToLinearA98Rgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.9624670363768806, -0.6107423404815073, -0.3413580980827154, -0.9787954765557777, 1.9162543773959884, 0.03344287339036693, 0.02870443944957101, -0.1406748663317068, 1.3489141814137937], type$.JSArray_double))); + _lazyFinal($, "linearRec2020ToXyzD650", "$get$linearRec2020ToXyzD650", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.6369580483012913, 0.14461690358620838, 0.16888097516417205, 0.26270021201126703, 0.677998071518871, 0.05930171646986194, 0, 0.0280726930490875, 1.0609850577107909], type$.JSArray_double))); + _lazyFinal($, "xyzD65ToLinearRec20200", "$get$xyzD65ToLinearRec20200", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.7166511879712676, -0.3556707837763924, -0.2533662813736598, -0.666684351832489, 1.616481236634939, 0.01576854581391113, 0.01763985744531091, -0.04277061325780865, 0.942103121235474], type$.JSArray_double))); + _lazyFinal($, "linearRec2020ToLms0", "$get$linearRec2020ToLms0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.6167557848654444, 0.36019840122646335, 0.02304581390809228, 0.2651330593926367, 0.6358393720678491, 0.09902756853951408, 0.10010262952034828, 0.20390652261661452, 0.6959908478630372], type$.JSArray_double))); + _lazyFinal($, "lmsToLinearRec20200", "$get$lmsToLinearRec20200", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([2.1399067304346513, -1.246389493760618, 0.10648276332596668, -0.8847358357577674, 2.1632309383612007, -0.2784951026034334, -0.04857374640044396, -0.4545031497140964, 1.5030768961145404], type$.JSArray_double))); + _lazyFinal($, "linearRec2020ToLinearProphotoRgb0", "$get$linearRec2020ToLinearProphotoRgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.8351873331297235, 0.04886884858605698, 0.11594381828421951, 0.05403324519953363, 0.9289184085692044, 0.01704834623126199, -0.00234203897072539, 0.03633215316169465, 0.9660098858090307], type$.JSArray_double))); + _lazyFinal($, "linearProphotoRgbToLinearRec20200", "$get$linearProphotoRgbToLinearRec20200", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.200659329517408, -0.05756805370122346, -0.14309127581618444, -0.06994154955888504, 1.080617897597214, -0.01067634803832895, 0.00554147334294746, -0.04078219298657951, 1.035240719643632], type$.JSArray_double))); + _lazyFinal($, "linearRec2020ToXyzD500", "$get$linearRec2020ToXyzD500", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.673515463188276, 0.16569726370390453, 0.12508294953738705, 0.2790590051411206, 0.6753180057491098, 0.04562298910976962, -0.00193242713400438, 0.02997782679282923, 0.7970592028516355], type$.JSArray_double))); + _lazyFinal($, "xyzD50ToLinearRec20200", "$get$xyzD50ToLinearRec20200", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.647184904671766, -0.3936818981316471, -0.23595963848828266, -0.6826641074173818, 1.6477146127444076, 0.01281708338512084, 0.02966887665275675, -0.0629258964297003, 1.2535578201865771], type$.JSArray_double))); + _lazyFinal($, "xyzD65ToLms0", "$get$xyzD65ToLms0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.819022437996703, 0.36190626005289034, -0.12887378152098788, 0.03298365393238846, 0.9292868615863433, 0.03614466635064235, 0.0481771893596242, 0.2642395317527308, 0.6335478284694308], type$.JSArray_double))); + _lazyFinal($, "lmsToXyzD650", "$get$lmsToXyzD650", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.2268798758459243, -0.5578149944602171, 0.2813910456659646, -0.04057574521480084, 1.1122868032803173, -0.07171105806551635, -0.07637293667466007, -0.42149333240224324, 1.5869240198367818], type$.JSArray_double))); + _lazyFinal($, "xyzD65ToLinearProphotoRgb0", "$get$xyzD65ToLinearProphotoRgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.4031904633774979, -0.22301514479051668, -0.1016066850741379, -0.5262384021633072, 1.4816319629234644, 0.01701879027252688, -0.0112022652862215, 0.01824640347962099, 0.9112472274915048], type$.JSArray_double))); + _lazyFinal($, "linearProphotoRgbToXyzD650", "$get$linearProphotoRgbToXyzD650", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.755590742296921, 0.11271984265940525, 0.0821453420953454, 0.2683218435785719, 0.7151152566617912, 0.01656289975963685, 0.0039159727624258, -0.01293344283684181, 1.0980752208342945], type$.JSArray_double))); + _lazyFinal($, "xyzD65ToXyzD500", "$get$xyzD65ToXyzD500", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.0479297925449966, 0.02294687060160952, -0.05019226628920519, 0.02962780877005567, 0.99043442675388, -0.01707379906341879, -0.00924304064620452, 0.01505519149029816, 0.751874281428137], type$.JSArray_double))); + _lazyFinal($, "xyzD50ToXyzD650", "$get$xyzD50ToXyzD650", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.9554734214880752, -0.02309845494876452, 0.06325924320057065, -0.02836970933386358, 1.0099953980813041, 0.0210414411919173, 0.01231401486448199, -0.02050764929889898, 1.330365926242124], type$.JSArray_double))); + _lazyFinal($, "lmsToLinearProphotoRgb0", "$get$lmsToLinearProphotoRgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.7383551481157207, -0.9879509427514458, 0.24959579463572504, -0.7070494015329266, 1.9343700444401382, -0.2273206429072115, -0.08407882206239634, -0.35754060521141334, 1.4416194272738097], type$.JSArray_double))); + _lazyFinal($, "linearProphotoRgbToLms0", "$get$linearProphotoRgbToLms0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.7154484605655534, 0.35279155007721186, -0.0682400106427653, 0.2744116490015671, 0.6677976498412367, 0.05779070115719616, 0.10978443261622942, 0.18619829115002018, 0.7040172762337504], type$.JSArray_double))); + _lazyFinal($, "lmsToXyzD500", "$get$lmsToXyzD500", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.288586218172706, -0.5378717444973745, 0.2135812027542364, -0.00253387643187372, 1.0923167988719165, -0.08978292244004273, -0.06937382305734124, -0.29500839894431263, 1.1894868245121142], type$.JSArray_double))); + _lazyFinal($, "xyzD50ToLms0", "$get$xyzD50ToLms0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.7707000420431172, 0.34924840261939616, -0.11202351884164681, 0.00559649248368848, 0.9370723401136769, 0.06972568836252771, 0.04633714262191069, 0.25277531574310524, 0.851458076746796], type$.JSArray_double))); + _lazyFinal($, "linearProphotoRgbToXyzD500", "$get$linearProphotoRgbToXyzD500", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([0.7977666449006423, 0.13518129740053308, 0.0313477341283922, 0.2880748288194013, 0.711835234241873, 0.00008993693872564, 0, 0, 0.8251046025104602], type$.JSArray_double))); + _lazyFinal($, "xyzD50ToLinearProphotoRgb0", "$get$xyzD50ToLinearProphotoRgb0", () => A.NativeFloat64List_NativeFloat64List$fromList(A._setArrayType([1.3457868816471583, -0.25557208737979464, -0.05110186497554526, -0.5446307051249019, 1.5082477428451468, 0.02052744743642139, 0, 0, 1.2119675456389452], type$.JSArray_double))); + _lazyFinal($, "_disallowedFunctionNames0", "$get$_disallowedFunctionNames0", () => { + var t1 = $.$get$globalFunctions0(); + t1 = t1.map$1$1(t1, new A._disallowedFunctionNames_closure0(), type$.String).toSet$0(0); + t1.add$1(0, "if"); + t1.remove$1(0, "abs"); + t1.remove$1(0, "alpha"); + t1.remove$1(0, "color"); + t1.remove$1(0, "grayscale"); + t1.remove$1(0, "hsl"); + t1.remove$1(0, "hsla"); + t1.remove$1(0, "hwb"); + t1.remove$1(0, "invert"); + t1.remove$1(0, "lab"); + t1.remove$1(0, "lch"); + t1.remove$1(0, "max"); + t1.remove$1(0, "min"); + t1.remove$1(0, "oklab"); + t1.remove$1(0, "oklch"); + t1.remove$1(0, "opacity"); + t1.remove$1(0, "rgb"); + t1.remove$1(0, "rgba"); + t1.remove$1(0, "round"); + t1.remove$1(0, "saturate"); + return t1; + }); + _lazyFinal($, "deprecations", "$get$deprecations", () => { + var _i, deprecation, t2, + t1 = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, A.findType("Deprecation1?")); + for (_i = 0; _i < 25; ++_i) { + deprecation = B.List_MG2[_i]; + if (deprecation !== B.Deprecation_f5Y) { + t2 = deprecation.id; + t1.$indexSet(0, t2, {id: t2, status: new A.deprecations_closure(deprecation).call$0(), description: deprecation.description, deprecatedIn: deprecation.get$deprecatedIn(0), obsoleteIn: deprecation.get$deprecatedIn(0)}); + } + } + return t1; + }); + _lazyFinal($, "versionClass", "$get$versionClass", () => new A.versionClass_closure().call$0()); + _lazyFinal($, "exceptionClass", "$get$exceptionClass", () => new A.exceptionClass_closure().call$0()); + _lazyFinal($, "FilesystemImporter_cwd0", "$get$FilesystemImporter_cwd0", () => { + var _null = null; + return new A.FilesystemImporter0(A.absolute(".", _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null, _null), true); + }); + _lazyFinal($, "functionClass", "$get$functionClass", () => new A.functionClass_closure().call$0()); + _lazyFinal($, "globalFunctions0", "$get$globalFunctions0", () => { + var t1 = type$.BuiltInCallable_2, + t2 = A.List_List$of($.$get$global6(), true, t1); + B.JSArray_methods.addAll$1(t2, $.$get$global7()); + B.JSArray_methods.addAll$1(t2, $.$get$global8()); + B.JSArray_methods.addAll$1(t2, $.$get$global9()); + B.JSArray_methods.addAll$1(t2, $.$get$global10()); + B.JSArray_methods.addAll$1(t2, $.$get$global11()); + B.JSArray_methods.addAll$1(t2, $.$get$global12()); + t2.push(A.BuiltInCallable$function0("if", "$condition, $if-true, $if-false", new A.globalFunctions_closure0(), null)); + return A.UnmodifiableListView$(t2, t1); + }); + _lazyFinal($, "coreModules0", "$get$coreModules0", () => A.UnmodifiableListView$(A._setArrayType([$.$get$module5(), $.$get$module6(), $.$get$module7(), $.$get$module8(), $.$get$module9(), $.$get$module10()], A.findType("JSArray>")), type$.BuiltInModule_Callable_2)); + _lazyFinal($, "IfExpression_declaration0", "$get$IfExpression_declaration0", () => A.ParameterList_ParameterList$parse0(string$.x40funct, null)); + _lazyFinal($, "global7", "$get$global7", () => { + var _s4_ = "list"; + return A.UnmodifiableListView$(A._setArrayType([$.$get$_length2().withDeprecationWarning$1(_s4_), $.$get$_nth0().withDeprecationWarning$1(_s4_), $.$get$_setNth0().withDeprecationWarning$1(_s4_), $.$get$_join0().withDeprecationWarning$1(_s4_), $.$get$_append2().withDeprecationWarning$1(_s4_), $.$get$_zip0().withDeprecationWarning$1(_s4_), $.$get$_index2().withDeprecationWarning$1(_s4_), $.$get$_isBracketed0().withDeprecationWarning$1(_s4_), $.$get$_separator0().withDeprecationWarning$1(_s4_).withName$1("list-separator")], type$.JSArray_BuiltInCallable_2), type$.BuiltInCallable_2); + }); + _lazyFinal($, "module6", "$get$module6", () => A.BuiltInModule$0("list", A._setArrayType([$.$get$_length2(), $.$get$_nth0(), $.$get$_setNth0(), $.$get$_join0(), $.$get$_append2(), $.$get$_zip0(), $.$get$_index2(), $.$get$_isBracketed0(), $.$get$_separator0(), $.$get$_slash0()], type$.JSArray_Callable_2), null, null, type$.Callable_2)); + _lazyFinal($, "_length1", "$get$_length2", () => A._function11("length", "$list", new A._length_closure2())); + _lazyFinal($, "_nth0", "$get$_nth0", () => A._function11("nth", "$list, $n", new A._nth_closure0())); + _lazyFinal($, "_setNth0", "$get$_setNth0", () => A._function11("set-nth", "$list, $n, $value", new A._setNth_closure0())); + _lazyFinal($, "_join0", "$get$_join0", () => A._function11("join", string$.x24list1, new A._join_closure0())); + _lazyFinal($, "_append1", "$get$_append2", () => A._function11("append", "$list, $val, $separator: auto", new A._append_closure2())); + _lazyFinal($, "_zip0", "$get$_zip0", () => A._function11("zip", "$lists...", new A._zip_closure0())); + _lazyFinal($, "_index1", "$get$_index2", () => A._function11("index", "$list, $value", new A._index_closure2())); + _lazyFinal($, "_separator0", "$get$_separator0", () => A._function11("separator", "$list", new A._separator_closure0())); + _lazyFinal($, "_isBracketed0", "$get$_isBracketed0", () => A._function11("is-bracketed", "$list", new A._isBracketed_closure0())); + _lazyFinal($, "_slash0", "$get$_slash0", () => A._function11("slash", "$elements...", new A._slash_closure0())); + _lazyFinal($, "listClass", "$get$listClass", () => new A.listClass_closure().call$0()); + _lazyFinal($, "legacyListClass", "$get$legacyListClass", () => { + var t1 = A.createJSClass("sass.types.List", new A.legacyListClass_closure()); + A.JSClassExtension_defineMethods(t1, A.LinkedHashMap_LinkedHashMap$_literal(["getValue", new A.legacyListClass_closure0(), "setValue", new A.legacyListClass_closure1(), "getSeparator", new A.legacyListClass_closure2(), "setSeparator", new A.legacyListClass_closure3(), "getLength", new A.legacyListClass_closure4()], type$.String, type$.Function)); + return t1; + }); + _lazyFinal($, "global8", "$get$global8", () => { + var _s3_ = "map"; + return A.UnmodifiableListView$(A._setArrayType([$.$get$_get0().withDeprecationWarning$1(_s3_).withName$1("map-get"), $.$get$_merge0().withDeprecationWarning$1(_s3_).withName$1("map-merge"), $.$get$_remove0().withDeprecationWarning$1(_s3_).withName$1("map-remove"), $.$get$_keys0().withDeprecationWarning$1(_s3_).withName$1("map-keys"), $.$get$_values0().withDeprecationWarning$1(_s3_).withName$1("map-values"), $.$get$_hasKey0().withDeprecationWarning$1(_s3_).withName$1("map-has-key")], type$.JSArray_BuiltInCallable_2), type$.BuiltInCallable_2); + }); + _lazyFinal($, "module7", "$get$module7", () => A.BuiltInModule$0("map", A._setArrayType([$.$get$_get0(), $.$get$_set0(), $.$get$_merge0(), $.$get$_remove0(), $.$get$_keys0(), $.$get$_values0(), $.$get$_hasKey0(), $.$get$_deepMerge0(), $.$get$_deepRemove0()], type$.JSArray_Callable_2), null, null, type$.Callable_2)); + _lazyFinal($, "_get0", "$get$_get0", () => A._function10("get", "$map, $key, $keys...", new A._get_closure0())); + _lazyFinal($, "_set0", "$get$_set0", () => A.BuiltInCallable$overloadedFunction0("set", A.LinkedHashMap_LinkedHashMap$_literal(["$map, $key, $value", new A._set_closure1(), "$map, $args...", new A._set_closure2()], type$.String, type$.Value_Function_List_Value_2))); + _lazyFinal($, "_merge0", "$get$_merge0", () => A.BuiltInCallable$overloadedFunction0("merge", A.LinkedHashMap_LinkedHashMap$_literal(["$map1, $map2", new A._merge_closure1(), "$map1, $args...", new A._merge_closure2()], type$.String, type$.Value_Function_List_Value_2))); + _lazyFinal($, "_deepMerge0", "$get$_deepMerge0", () => A._function10("deep-merge", "$map1, $map2", new A._deepMerge_closure0())); + _lazyFinal($, "_deepRemove0", "$get$_deepRemove0", () => A._function10("deep-remove", "$map, $key, $keys...", new A._deepRemove_closure0())); + _lazyFinal($, "_remove0", "$get$_remove0", () => A.BuiltInCallable$overloadedFunction0("remove", A.LinkedHashMap_LinkedHashMap$_literal(["$map", new A._remove_closure1(), "$map, $key, $keys...", new A._remove_closure2()], type$.String, type$.Value_Function_List_Value_2))); + _lazyFinal($, "_keys0", "$get$_keys0", () => A._function10("keys", "$map", new A._keys_closure0())); + _lazyFinal($, "_values0", "$get$_values0", () => A._function10("values", "$map", new A._values_closure0())); + _lazyFinal($, "_hasKey0", "$get$_hasKey0", () => A._function10("has-key", "$map, $key, $keys...", new A._hasKey_closure0())); + _lazyFinal($, "mapClass", "$get$mapClass", () => new A.mapClass_closure().call$0()); + _lazyFinal($, "legacyMapClass", "$get$legacyMapClass", () => { + var t1 = A.createJSClass("sass.types.Map", new A.legacyMapClass_closure()); + A.JSClassExtension_defineMethods(t1, A.LinkedHashMap_LinkedHashMap$_literal(["getKey", new A.legacyMapClass_closure0(), "getValue", new A.legacyMapClass_closure1(), "getLength", new A.legacyMapClass_closure2(), "setKey", new A.legacyMapClass_closure3(), "setValue", new A.legacyMapClass_closure4()], type$.String, type$.Function)); + return t1; + }); + _lazyFinal($, "global9", "$get$global9", () => { + var _s4_ = "math"; + return A.UnmodifiableListView$(A._setArrayType([A._function9("abs", "$number", new A.global_closure43()), $.$get$_ceil0().withDeprecationWarning$1(_s4_), $.$get$_floor0().withDeprecationWarning$1(_s4_), $.$get$_max0().withDeprecationWarning$1(_s4_), $.$get$_min0().withDeprecationWarning$1(_s4_), $.$get$_percentage0().withDeprecationWarning$1(_s4_), $.$get$_randomFunction0().withDeprecationWarning$1(_s4_), $.$get$_round0().withDeprecationWarning$1(_s4_), $.$get$_unit0().withDeprecationWarning$1(_s4_), $.$get$_compatible0().withDeprecationWarning$1(_s4_).withName$1("comparable"), $.$get$_isUnitless0().withDeprecationWarning$1(_s4_).withName$1("unitless")], type$.JSArray_BuiltInCallable_2), type$.BuiltInCallable_2); + }); + _lazyFinal($, "module8", "$get$module8", () => { + var _null = null; + return A.BuiltInModule$0("math", A._setArrayType([A._numberFunction0("abs", new A.module_closure26()), $.$get$_acos0(), $.$get$_asin0(), $.$get$_atan0(), $.$get$_atan20(), $.$get$_ceil0(), $.$get$_clamp0(), $.$get$_cos0(), $.$get$_compatible0(), $.$get$_floor0(), $.$get$_hypot0(), $.$get$_isUnitless0(), $.$get$_log0(), $.$get$_max0(), $.$get$_min0(), $.$get$_percentage0(), $.$get$_pow0(), $.$get$_randomFunction0(), $.$get$_round0(), $.$get$_sin0(), $.$get$_sqrt0(), $.$get$_tan0(), $.$get$_unit0(), $.$get$_div0()], type$.JSArray_Callable_2), _null, A.LinkedHashMap_LinkedHashMap$_literal(["e", A.SassNumber_SassNumber0(2.718281828459045, _null), "pi", A.SassNumber_SassNumber0(3.141592653589793, _null), "epsilon", A.SassNumber_SassNumber0(2220446049250313e-31, _null), "max-safe-integer", A.SassNumber_SassNumber0(9007199254740991, _null), "min-safe-integer", A.SassNumber_SassNumber0(-9007199254740991, _null), "max-number", A.SassNumber_SassNumber0(17976931348623157e292, _null), "min-number", A.SassNumber_SassNumber0(5e-324, _null)], type$.String, type$.Value_2), type$.Callable_2); + }); + _lazyFinal($, "_ceil0", "$get$_ceil0", () => A._numberFunction0("ceil", new A._ceil_closure0())); + _lazyFinal($, "_clamp0", "$get$_clamp0", () => A._function9("clamp", "$min, $number, $max", new A._clamp_closure0())); + _lazyFinal($, "_floor0", "$get$_floor0", () => A._numberFunction0("floor", new A._floor_closure0())); + _lazyFinal($, "_max0", "$get$_max0", () => A._function9("max", "$numbers...", new A._max_closure0())); + _lazyFinal($, "_min0", "$get$_min0", () => A._function9("min", "$numbers...", new A._min_closure0())); + _lazyFinal($, "_round0", "$get$_round0", () => A._numberFunction0("round", new A._round_closure0())); + _lazyFinal($, "_hypot0", "$get$_hypot0", () => A._function9("hypot", "$numbers...", new A._hypot_closure0())); + _lazyFinal($, "_log0", "$get$_log0", () => A._function9("log", "$number, $base: null", new A._log_closure0())); + _lazyFinal($, "_pow0", "$get$_pow0", () => A._function9("pow", "$base, $exponent", new A._pow_closure0())); + _lazyFinal($, "_sqrt0", "$get$_sqrt0", () => A._singleArgumentMathFunc0("sqrt", A.number2__sqrt$closure())); + _lazyFinal($, "_acos0", "$get$_acos0", () => A._singleArgumentMathFunc0("acos", A.number2__acos$closure())); + _lazyFinal($, "_asin0", "$get$_asin0", () => A._singleArgumentMathFunc0("asin", A.number2__asin$closure())); + _lazyFinal($, "_atan0", "$get$_atan0", () => A._singleArgumentMathFunc0("atan", A.number2__atan$closure())); + _lazyFinal($, "_atan20", "$get$_atan20", () => A._function9("atan2", "$y, $x", new A._atan2_closure0())); + _lazyFinal($, "_cos0", "$get$_cos0", () => A._singleArgumentMathFunc0("cos", A.number2__cos$closure())); + _lazyFinal($, "_sin0", "$get$_sin0", () => A._singleArgumentMathFunc0("sin", A.number2__sin$closure())); + _lazyFinal($, "_tan0", "$get$_tan0", () => A._singleArgumentMathFunc0("tan", A.number2__tan$closure())); + _lazyFinal($, "_compatible0", "$get$_compatible0", () => A._function9("compatible", "$number1, $number2", new A._compatible_closure0())); + _lazyFinal($, "_isUnitless0", "$get$_isUnitless0", () => A._function9("is-unitless", "$number", new A._isUnitless_closure0())); + _lazyFinal($, "_unit0", "$get$_unit0", () => A._function9("unit", "$number", new A._unit_closure0())); + _lazyFinal($, "_percentage0", "$get$_percentage0", () => A._function9("percentage", "$number", new A._percentage_closure0())); + _lazyFinal($, "_random1", "$get$_random2", () => A.Random_Random()); + _lazyFinal($, "_randomFunction0", "$get$_randomFunction0", () => A._function9("random", "$limit: null", new A._randomFunction_closure0())); + _lazyFinal($, "_div0", "$get$_div0", () => A._function9("div", "$number1, $number2", new A._div_closure0())); + _lazyFinal($, "_shared0", "$get$_shared0", () => A.UnmodifiableListView$(A._setArrayType([A._function6("feature-exists", "$feature", new A._shared_closure3()), A._function6("inspect", "$value", new A._shared_closure4()), A._function6("type-of", "$value", new A._shared_closure5()), A._function6("keywords", "$args", new A._shared_closure6())], type$.JSArray_BuiltInCallable_2), type$.BuiltInCallable_2)); + _lazyFinal($, "global10", "$get$global12", () => { + var t2, + t1 = A._setArrayType([], type$.JSArray_BuiltInCallable_2); + for (t2 = $.$get$_shared0(), t2 = t2.get$iterator(t2); t2.moveNext$0();) + t1.push(t2.get$current(0).withDeprecationWarning$1("meta")); + return A.UnmodifiableListView$(t1, type$.BuiltInCallable_2); + }); + _lazyFinal($, "moduleFunctions0", "$get$moduleFunctions0", () => { + var t1 = type$.BuiltInCallable_2, + t2 = A.List_List$of($.$get$_shared0(), true, t1); + t2.push(A._function6("calc-name", "$calc", new A.moduleFunctions_closure2())); + t2.push(A._function6("calc-args", "$calc", new A.moduleFunctions_closure3())); + t2.push(A._function6("accepts-content", "$mixin", new A.moduleFunctions_closure4())); + return A.UnmodifiableListView$(t2, t1); + }); + _lazyFinal($, "mixinClass", "$get$mixinClass", () => new A.mixinClass_closure().call$0()); + _lazyFinal($, "legacyNullClass", "$get$legacyNullClass", () => new A.legacyNullClass_closure().call$0()); + _lazyFinal($, "_epsilon0", "$get$_epsilon0", () => A.pow(10, -11)); + _lazyFinal($, "_inverseEpsilon0", "$get$_inverseEpsilon0", () => A.pow(10, 11)); + _lazyFinal($, "numberClass", "$get$numberClass", () => new A.numberClass_closure().call$0()); + _lazyFinal($, "legacyNumberClass", "$get$legacyNumberClass", () => { + var t1 = A.createJSClass("sass.types.Number", new A.legacyNumberClass_closure()); + A.JSClassExtension_defineMethods(t1, A.LinkedHashMap_LinkedHashMap$_literal(["getValue", new A.legacyNumberClass_closure0(), "setValue", new A.legacyNumberClass_closure1(), "getUnit", new A.legacyNumberClass_closure2(), "setUnit", new A.legacyNumberClass_closure3()], type$.String, type$.Function)); + return t1; + }); + _lazyFinal($, "_typesByUnit0", "$get$_typesByUnit0", () => { + var t3, type, + t1 = type$.String, + t2 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + for (t1 = A.MapExtensions_get_pairs0(B.Map_Sr65K, t1, type$.List_String), t1 = t1.get$iterator(t1); t1.moveNext$0();) { + t3 = t1.get$current(t1); + type = t3._0; + for (t3 = J.get$iterator$ax(t3._1); t3.moveNext$0();) + t2.$indexSet(0, t3.get$current(t3), type); + } + return t2; + }); + _lazyFinal($, "_interpolation", "$get$_interpolation", () => A.Interpolation$0(B.List_empty28, B.List_empty29, $.$get$bogusSpan0())); + _lazyFinal($, "_expression", "$get$_expression", () => A.NullExpression$($.$get$bogusSpan0())); + _lazyFinal($, "global11", "$get$global10", () => { + var _s8_ = "selector"; + return A.UnmodifiableListView$(A._setArrayType([$.$get$_isSuperselector0().withDeprecationWarning$1(_s8_), $.$get$_simpleSelectors0().withDeprecationWarning$1(_s8_), $.$get$_parse0().withDeprecationWarning$1(_s8_).withName$1("selector-parse"), $.$get$_nest0().withDeprecationWarning$1(_s8_).withName$1("selector-nest"), $.$get$_append1().withDeprecationWarning$1(_s8_).withName$1("selector-append"), $.$get$_extend0().withDeprecationWarning$1(_s8_).withName$1("selector-extend"), $.$get$_replace0().withDeprecationWarning$1(_s8_).withName$1("selector-replace"), $.$get$_unify0().withDeprecationWarning$1(_s8_).withName$1("selector-unify")], type$.JSArray_BuiltInCallable_2), type$.BuiltInCallable_2); + }); + _lazyFinal($, "module9", "$get$module9", () => A.BuiltInModule$0("selector", A._setArrayType([$.$get$_isSuperselector0(), $.$get$_simpleSelectors0(), $.$get$_parse0(), $.$get$_nest0(), $.$get$_append1(), $.$get$_extend0(), $.$get$_replace0(), $.$get$_unify0()], type$.JSArray_Callable_2), null, null, type$.Callable_2)); + _lazyFinal($, "_nest0", "$get$_nest0", () => A._function8("nest", "$selectors...", new A._nest_closure0())); + _lazyFinal($, "_append2", "$get$_append1", () => A._function8("append", "$selectors...", new A._append_closure1())); + _lazyFinal($, "_extend0", "$get$_extend0", () => A._function8("extend", "$selector, $extendee, $extender", new A._extend_closure0())); + _lazyFinal($, "_replace0", "$get$_replace0", () => A._function8("replace", "$selector, $original, $replacement", new A._replace_closure0())); + _lazyFinal($, "_unify0", "$get$_unify0", () => A._function8("unify", "$selector1, $selector2", new A._unify_closure0())); + _lazyFinal($, "_isSuperselector0", "$get$_isSuperselector0", () => A._function8("is-superselector", "$super, $sub", new A._isSuperselector_closure0())); + _lazyFinal($, "_simpleSelectors0", "$get$_simpleSelectors0", () => A._function8("simple-selectors", "$selector", new A._simpleSelectors_closure0())); + _lazyFinal($, "_parse1", "$get$_parse0", () => A._function8("parse", "$selector", new A._parse_closure0())); + _lazyFinal($, "_knownCompatibilitiesByUnit0", "$get$_knownCompatibilitiesByUnit0", () => { + var _i, set, t2, + t1 = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, A.findType("Set")); + for (_i = 0; _i < 5; ++_i) { + set = B.List_BFg[_i]; + for (t2 = set.get$iterator(set); t2.moveNext$0();) + t1.$indexSet(0, t2.get$current(0), set); + } + return t1; + }); + _lazyFinal($, "bogusSpan0", "$get$bogusSpan0", () => A.SourceFile$decoded(A._setArrayType([], type$.JSArray_int), null).span$1(0, 0)); + _lazyFinal($, "_random2", "$get$_random1", () => A.Random_Random()); + _lazy($, "_previousUniqueId0", "$get$_previousUniqueId0", () => $.$get$_random1().nextInt$1(A._asInt(A.pow(36, 6)))); + _lazyFinal($, "global12", "$get$global11", () => { + var _s6_ = "string"; + return A.UnmodifiableListView$(A._setArrayType([$.$get$_unquote0().withDeprecationWarning$1(_s6_), $.$get$_quote0().withDeprecationWarning$1(_s6_), $.$get$_toUpperCase0().withDeprecationWarning$1(_s6_), $.$get$_toLowerCase0().withDeprecationWarning$1(_s6_), $.$get$_uniqueId0().withDeprecationWarning$1(_s6_), $.$get$_length1().withDeprecationWarning$1(_s6_).withName$1("str-length"), $.$get$_insert0().withDeprecationWarning$1(_s6_).withName$1("str-insert"), $.$get$_index1().withDeprecationWarning$1(_s6_).withName$1("str-index"), $.$get$_slice0().withDeprecationWarning$1(_s6_).withName$1("str-slice")], type$.JSArray_BuiltInCallable_2), type$.BuiltInCallable_2); + }); + _lazyFinal($, "module10", "$get$module10", () => A.BuiltInModule$0("string", A._setArrayType([$.$get$_unquote0(), $.$get$_quote0(), $.$get$_toUpperCase0(), $.$get$_toLowerCase0(), $.$get$_length1(), $.$get$_insert0(), $.$get$_index1(), $.$get$_slice0(), $.$get$_uniqueId0(), A._function7("split", "$string, $separator, $limit: null", new A.module_closure25())], type$.JSArray_Callable_2), null, null, type$.Callable_2)); + _lazyFinal($, "_unquote0", "$get$_unquote0", () => A._function7("unquote", "$string", new A._unquote_closure0())); + _lazyFinal($, "_quote0", "$get$_quote0", () => A._function7("quote", "$string", new A._quote_closure0())); + _lazyFinal($, "_length2", "$get$_length1", () => A._function7("length", "$string", new A._length_closure1())); + _lazyFinal($, "_insert0", "$get$_insert0", () => A._function7("insert", "$string, $insert, $index", new A._insert_closure0())); + _lazyFinal($, "_index2", "$get$_index1", () => A._function7("index", "$string, $substring", new A._index_closure1())); + _lazyFinal($, "_slice0", "$get$_slice0", () => A._function7("slice", "$string, $start-at, $end-at: -1", new A._slice_closure0())); + _lazyFinal($, "_toUpperCase0", "$get$_toUpperCase0", () => A._function7("to-upper-case", "$string", new A._toUpperCase_closure0())); + _lazyFinal($, "_toLowerCase0", "$get$_toLowerCase0", () => A._function7("to-lower-case", "$string", new A._toLowerCase_closure0())); + _lazyFinal($, "_uniqueId0", "$get$_uniqueId0", () => A._function7("unique-id", "", new A._uniqueId_closure0())); + _lazyFinal($, "stringClass", "$get$stringClass", () => new A.stringClass_closure().call$0()); + _lazyFinal($, "legacyStringClass", "$get$legacyStringClass", () => { + var t1 = A.createJSClass("sass.types.String", new A.legacyStringClass_closure()); + A.JSClassExtension_defineMethods(t1, A.LinkedHashMap_LinkedHashMap$_literal(["getValue", new A.legacyStringClass_closure0(), "setValue", new A.legacyStringClass_closure1()], type$.String, type$.Function)); + return t1; + }); + _lazyFinal($, "_emptyQuoted0", "$get$_emptyQuoted0", () => A.SassString$0("", true)); + _lazyFinal($, "_emptyUnquoted0", "$get$_emptyUnquoted0", () => A.SassString$0("", false)); + _lazyFinal($, "_urlSchemeRegExp", "$get$_urlSchemeRegExp", () => A.RegExp_RegExp("^[a-z0-9+.-]+$", false)); + _lazyFinal($, "_jsThrow0", "$get$_jsThrow", () => new self.Function("error", "throw error;")); + _lazyFinal($, "_isUndefined", "$get$_isUndefined", () => new self.Function("value", "return value === undefined;")); + _lazyFinal($, "_isNull", "$get$_isNull", () => new self.Function("value", "return value === null;")); + _lazyFinal($, "_noSourceUrl0", "$get$_noSourceUrl0", () => A.Uri_parse("-")); + _lazyFinal($, "_traces0", "$get$_traces0", () => A.Expando$()); + _lazyFinal($, "valueClass", "$get$valueClass", () => new A.valueClass_closure().call$0()); + })(); + (function nativeSupport() { + !function() { + var intern = function(s) { + var o = {}; + o[s] = 1; + return Object.keys(hunkHelpers.convertToFastObject(o))[0]; + }; + init.getIsolateTag = function(name) { + return intern("___dart_" + name + init.isolateTag); + }; + var tableProperty = "___dart_isolate_tags_"; + var usedProperties = Object[tableProperty] || (Object[tableProperty] = Object.create(null)); + var rootProperty = "_ZxYxX"; + for (var i = 0;; i++) { + var property = intern(rootProperty + "_" + i + "_"); + if (!(property in usedProperties)) { + usedProperties[property] = 1; + init.isolateTag = property; + break; + } + } + init.dispatchPropertyName = init.getIsolateTag("dispatch_record"); + }(); + hunkHelpers.setOrUpdateInterceptorsByTag({ArrayBuffer: A.NativeByteBuffer, ArrayBufferView: A.NativeTypedData, DataView: A.NativeByteData, Float32Array: A.NativeFloat32List, Float64Array: A.NativeFloat64List, Int16Array: A.NativeInt16List, Int32Array: A.NativeInt32List, Int8Array: A.NativeInt8List, Uint16Array: A.NativeUint16List, Uint32Array: A.NativeUint32List, Uint8ClampedArray: A.NativeUint8ClampedList, CanvasPixelArray: A.NativeUint8ClampedList, Uint8Array: A.NativeUint8List}); + hunkHelpers.setOrUpdateLeafTags({ArrayBuffer: true, ArrayBufferView: false, DataView: true, Float32Array: true, Float64Array: true, Int16Array: true, Int32Array: true, Int8Array: true, Uint16Array: true, Uint32Array: true, Uint8ClampedArray: true, CanvasPixelArray: true, Uint8Array: false}); + A.NativeTypedArray.$nativeSuperclassTag = "ArrayBufferView"; + A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin.$nativeSuperclassTag = "ArrayBufferView"; + A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin.$nativeSuperclassTag = "ArrayBufferView"; + A.NativeTypedArrayOfDouble.$nativeSuperclassTag = "ArrayBufferView"; + A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin.$nativeSuperclassTag = "ArrayBufferView"; + A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin.$nativeSuperclassTag = "ArrayBufferView"; + A.NativeTypedArrayOfInt.$nativeSuperclassTag = "ArrayBufferView"; + })(); + Function.prototype.call$0 = function() { + return this(); + }; + Function.prototype.call$1 = function(a) { + return this(a); + }; + Function.prototype.call$2 = function(a, b) { + return this(a, b); + }; + Function.prototype.call$3$1 = function(a) { + return this(a); + }; + Function.prototype.call$2$1 = function(a) { + return this(a); + }; + Function.prototype.call$1$1 = function(a) { + return this(a); + }; + Function.prototype.call$3 = function(a, b, c) { + return this(a, b, c); + }; + Function.prototype.call$4 = function(a, b, c, d) { + return this(a, b, c, d); + }; + Function.prototype.call$3$3 = function(a, b, c) { + return this(a, b, c); + }; + Function.prototype.call$2$2 = function(a, b) { + return this(a, b); + }; + Function.prototype.call$5 = function(a, b, c, d, e) { + return this(a, b, c, d, e); + }; + Function.prototype.call$6 = function(a, b, c, d, e, f) { + return this(a, b, c, d, e, f); + }; + Function.prototype.call$2$0 = function() { + return this(); + }; + Function.prototype.call$1$0 = function() { + return this(); + }; + Function.prototype.call$1$2 = function(a, b) { + return this(a, b); + }; + Function.prototype.call$2$3 = function(a, b, c) { + return this(a, b, c); + }; + convertAllToFastObject(holders); + convertToFastObject($); + (function(callback) { + if (typeof document === "undefined") { + callback(null); + return; + } + if (typeof document.currentScript != "undefined") { + callback(document.currentScript); + return; + } + var scripts = document.scripts; + function onLoad(event) { + for (var i = 0; i < scripts.length; ++i) { + scripts[i].removeEventListener("load", onLoad, false); + } + callback(event.target); + } + for (var i = 0; i < scripts.length; ++i) { + scripts[i].addEventListener("load", onLoad, false); + } + })(function(currentScript) { + init.currentScript = currentScript; + var callMain = A.main2; + if (typeof dartMainRunner === "function") { + dartMainRunner(callMain, []); + } else { + callMain([]); + } + }); +})(); +} diff --git a/node_modules/sass/sass.default.cjs b/node_modules/sass/sass.default.cjs new file mode 100644 index 0000000..94d102a --- /dev/null +++ b/node_modules/sass/sass.default.cjs @@ -0,0 +1,8 @@ +require('./sass.dart.js'); +const library = globalThis._cliPkgExports.pop(); +if (globalThis._cliPkgExports.length === 0) delete globalThis._cliPkgExports; +library.load({ + immutable: require("immutable"), +}); + +module.exports = library; diff --git a/node_modules/sass/sass.default.js b/node_modules/sass/sass.default.js new file mode 100644 index 0000000..4a0540a --- /dev/null +++ b/node_modules/sass/sass.default.js @@ -0,0 +1,48 @@ +import * as immutable from "immutable" +import "./sass.dart.js"; + +const _cliPkgLibrary = globalThis._cliPkgExports.pop(); +if (globalThis._cliPkgExports.length === 0) delete globalThis._cliPkgExports; +const _cliPkgExports = {}; +_cliPkgLibrary.load({immutable}, _cliPkgExports); + +export const compile = _cliPkgExports.compile; +export const compileAsync = _cliPkgExports.compileAsync; +export const compileString = _cliPkgExports.compileString; +export const compileStringAsync = _cliPkgExports.compileStringAsync; +export const initCompiler = _cliPkgExports.initCompiler; +export const initAsyncCompiler = _cliPkgExports.initAsyncCompiler; +export const Compiler = _cliPkgExports.Compiler; +export const AsyncCompiler = _cliPkgExports.AsyncCompiler; +export const Logger = _cliPkgExports.Logger; +export const SassArgumentList = _cliPkgExports.SassArgumentList; +export const SassBoolean = _cliPkgExports.SassBoolean; +export const SassCalculation = _cliPkgExports.SassCalculation; +export const CalculationOperation = _cliPkgExports.CalculationOperation; +export const CalculationInterpolation = _cliPkgExports.CalculationInterpolation; +export const SassColor = _cliPkgExports.SassColor; +export const SassFunction = _cliPkgExports.SassFunction; +export const SassList = _cliPkgExports.SassList; +export const SassMap = _cliPkgExports.SassMap; +export const SassMixin = _cliPkgExports.SassMixin; +export const SassNumber = _cliPkgExports.SassNumber; +export const SassString = _cliPkgExports.SassString; +export const Value = _cliPkgExports.Value; +export const CustomFunction = _cliPkgExports.CustomFunction; +export const ListSeparator = _cliPkgExports.ListSeparator; +export const sassFalse = _cliPkgExports.sassFalse; +export const sassNull = _cliPkgExports.sassNull; +export const sassTrue = _cliPkgExports.sassTrue; +export const Exception = _cliPkgExports.Exception; +export const PromiseOr = _cliPkgExports.PromiseOr; +export const info = _cliPkgExports.info; +export const render = _cliPkgExports.render; +export const renderSync = _cliPkgExports.renderSync; +export const TRUE = _cliPkgExports.TRUE; +export const FALSE = _cliPkgExports.FALSE; +export const NULL = _cliPkgExports.NULL; +export const types = _cliPkgExports.types; +export const NodePackageImporter = _cliPkgExports.NodePackageImporter; +export const deprecations = _cliPkgExports.deprecations; +export const Version = _cliPkgExports.Version; +export const parser_ = _cliPkgExports.parser_; diff --git a/node_modules/sass/sass.js b/node_modules/sass/sass.js new file mode 100644 index 0000000..df287fc --- /dev/null +++ b/node_modules/sass/sass.js @@ -0,0 +1,18 @@ +#!/usr/bin/env node + +require('./sass.dart.js'); +var library = globalThis._cliPkgExports.pop(); +if (globalThis._cliPkgExports.length === 0) delete globalThis._cliPkgExports; + +library.load({ + readline: require("readline"), + chokidar: require("chokidar"), + parcel_watcher: (function(i){let r;return function parcel_watcher(){if(void 0!==r)return r;try{r=require(i)}catch(e){if('MODULE_NOT_FOUND'!==e.code)console.error(e);r=null}return r}})("@parcel/watcher"), + util: require("util"), + stream: require("stream"), + nodeModule: require("module"), + fs: require("fs"), + immutable: require("immutable"), +}); + +library.cli_pkg_main_0_(process.argv.slice(2)); diff --git a/node_modules/sass/sass.node.js b/node_modules/sass/sass.node.js new file mode 100644 index 0000000..204ae2c --- /dev/null +++ b/node_modules/sass/sass.node.js @@ -0,0 +1,12 @@ +require('./sass.dart.js'); +const library = globalThis._cliPkgExports.pop(); +if (globalThis._cliPkgExports.length === 0) delete globalThis._cliPkgExports; +library.load({ + util: require("util"), + stream: require("stream"), + nodeModule: require("module"), + fs: require("fs"), + immutable: require("immutable"), +}); + +module.exports = library; diff --git a/node_modules/sass/sass.node.mjs b/node_modules/sass/sass.node.mjs new file mode 100644 index 0000000..dfeadc4 --- /dev/null +++ b/node_modules/sass/sass.node.mjs @@ -0,0 +1,214 @@ +import cjs from "./sass.node.js"; + +export const compile = cjs.compile; +export const compileAsync = cjs.compileAsync; +export const compileString = cjs.compileString; +export const compileStringAsync = cjs.compileStringAsync; +export const initCompiler = cjs.initCompiler; +export const initAsyncCompiler = cjs.initAsyncCompiler; +export const Compiler = cjs.Compiler; +export const AsyncCompiler = cjs.AsyncCompiler; +export const Logger = cjs.Logger; +export const SassArgumentList = cjs.SassArgumentList; +export const SassBoolean = cjs.SassBoolean; +export const SassCalculation = cjs.SassCalculation; +export const CalculationOperation = cjs.CalculationOperation; +export const CalculationInterpolation = cjs.CalculationInterpolation; +export const SassColor = cjs.SassColor; +export const SassFunction = cjs.SassFunction; +export const SassList = cjs.SassList; +export const SassMap = cjs.SassMap; +export const SassMixin = cjs.SassMixin; +export const SassNumber = cjs.SassNumber; +export const SassString = cjs.SassString; +export const Value = cjs.Value; +export const CustomFunction = cjs.CustomFunction; +export const ListSeparator = cjs.ListSeparator; +export const sassFalse = cjs.sassFalse; +export const sassNull = cjs.sassNull; +export const sassTrue = cjs.sassTrue; +export const Exception = cjs.Exception; +export const PromiseOr = cjs.PromiseOr; +export const info = cjs.info; +export const render = cjs.render; +export const renderSync = cjs.renderSync; +export const TRUE = cjs.TRUE; +export const FALSE = cjs.FALSE; +export const NULL = cjs.NULL; +export const types = cjs.types; +export const NodePackageImporter = cjs.NodePackageImporter; +export const deprecations = cjs.deprecations; +export const Version = cjs.Version; +export const parser_ = cjs.parser_; + +let printedDefaultExportDeprecation = false; +function defaultExportDeprecation() { + if (printedDefaultExportDeprecation) return; + printedDefaultExportDeprecation = true; + console.error( + "`import sass from 'sass'` is deprecated.\n" + + "Please use `import * as sass from 'sass'` instead."); +} + +export default { + get compile() { + defaultExportDeprecation(); + return cjs.compile; + }, + get compileAsync() { + defaultExportDeprecation(); + return cjs.compileAsync; + }, + get compileString() { + defaultExportDeprecation(); + return cjs.compileString; + }, + get compileStringAsync() { + defaultExportDeprecation(); + return cjs.compileStringAsync; + }, + get initCompiler() { + defaultExportDeprecation(); + return cjs.initCompiler; + }, + get initAsyncCompiler() { + defaultExportDeprecation(); + return cjs.initAsyncCompiler; + }, + get Compiler() { + defaultExportDeprecation(); + return cjs.Compiler; + }, + get AsyncCompiler() { + defaultExportDeprecation(); + return cjs.AsyncCompiler; + }, + get Logger() { + defaultExportDeprecation(); + return cjs.Logger; + }, + get SassArgumentList() { + defaultExportDeprecation(); + return cjs.SassArgumentList; + }, + get SassBoolean() { + defaultExportDeprecation(); + return cjs.SassBoolean; + }, + get SassCalculation() { + defaultExportDeprecation(); + return cjs.SassCalculation; + }, + get CalculationOperation() { + defaultExportDeprecation(); + return cjs.CalculationOperation; + }, + get CalculationInterpolation() { + defaultExportDeprecation(); + return cjs.CalculationInterpolation; + }, + get SassColor() { + defaultExportDeprecation(); + return cjs.SassColor; + }, + get SassFunction() { + defaultExportDeprecation(); + return cjs.SassFunction; + }, + get SassList() { + defaultExportDeprecation(); + return cjs.SassList; + }, + get SassMap() { + defaultExportDeprecation(); + return cjs.SassMap; + }, + get SassMixin() { + defaultExportDeprecation(); + return cjs.SassMixin; + }, + get SassNumber() { + defaultExportDeprecation(); + return cjs.SassNumber; + }, + get SassString() { + defaultExportDeprecation(); + return cjs.SassString; + }, + get Value() { + defaultExportDeprecation(); + return cjs.Value; + }, + get CustomFunction() { + defaultExportDeprecation(); + return cjs.CustomFunction; + }, + get ListSeparator() { + defaultExportDeprecation(); + return cjs.ListSeparator; + }, + get sassFalse() { + defaultExportDeprecation(); + return cjs.sassFalse; + }, + get sassNull() { + defaultExportDeprecation(); + return cjs.sassNull; + }, + get sassTrue() { + defaultExportDeprecation(); + return cjs.sassTrue; + }, + get Exception() { + defaultExportDeprecation(); + return cjs.Exception; + }, + get PromiseOr() { + defaultExportDeprecation(); + return cjs.PromiseOr; + }, + get info() { + defaultExportDeprecation(); + return cjs.info; + }, + get render() { + defaultExportDeprecation(); + return cjs.render; + }, + get renderSync() { + defaultExportDeprecation(); + return cjs.renderSync; + }, + get TRUE() { + defaultExportDeprecation(); + return cjs.TRUE; + }, + get FALSE() { + defaultExportDeprecation(); + return cjs.FALSE; + }, + get NULL() { + defaultExportDeprecation(); + return cjs.NULL; + }, + get types() { + defaultExportDeprecation(); + return cjs.types; + }, + get NodePackageImporter() { + defaultExportDeprecation(); + return cjs.NodePackageImporter; + }, + get deprecations() { + defaultExportDeprecation(); + return cjs.deprecations; + }, + get Version() { + defaultExportDeprecation(); + return cjs.Version; + }, + get parser_() { + defaultExportDeprecation(); + return cjs.parser_; + }, +}; diff --git a/node_modules/sass/types/compile.d.ts b/node_modules/sass/types/compile.d.ts new file mode 100644 index 0000000..872754c --- /dev/null +++ b/node_modules/sass/types/compile.d.ts @@ -0,0 +1,342 @@ +import {RawSourceMap} from 'source-map-js'; + +import {Options, StringOptions} from './options'; + +/** + * The result of compiling Sass to CSS. Returned by {@link compile}, {@link + * compileAsync}, {@link compileString}, and {@link compileStringAsync}. + * + * @category Compile + */ +export interface CompileResult { + /** + * The generated CSS. + * + * Note that this *never* includes a `sourceMapUrl` comment—it's up to the + * caller to determine where to save the source map and how to link to it from + * the stylesheet. + */ + css: string; + + /** + * The canonical URLs of all the stylesheets that were loaded during the + * Sass compilation. The order of these URLs is not guaranteed. + */ + loadedUrls: URL[]; + + /** + * The object representation of the source map that maps locations in the + * generated CSS back to locations in the Sass source code. + * + * This typically uses absolute `file:` URLs to refer to Sass files, although + * this can be controlled by having a custom {@link Importer} return {@link + * ImporterResult.sourceMapUrl}. + * + * This is set if and only if {@link Options.sourceMap} is `true`. + */ + sourceMap?: RawSourceMap; +} + +/** + * The result of creating a synchronous compiler. Returned by + * {@link initCompiler}. + * + * @category Compile + */ +export class Compiler { + /** + * Throws an error if constructed directly, instead of via + * {@link initCompiler}. + */ + private constructor(); + + /** + * The {@link compile} method exposed through a Compiler instance while it is + * active. If this is called after {@link dispose} on the Compiler + * instance, an error will be thrown. + * + * During the Compiler instance's lifespan, given the same input, this will + * return an identical result to the {@link compile} method exposed at the + * module root. + */ + compile(path: string, options?: Options<'sync'>): CompileResult; + + /** + * The {@link compileString} method exposed through a Compiler instance while + * it is active. If this is called after {@link dispose} on the Compiler + * instance, an error will be thrown. + * + * During the Compiler instance's lifespan, given the same input, this will + * return an identical result to the {@link compileString} method exposed at + * the module root. + */ + compileString(source: string, options?: StringOptions<'sync'>): CompileResult; + + /** + * Ends the lifespan of this Compiler instance. After this is invoked, all + * calls to the Compiler instance's {@link compile} or {@link compileString} + * methods will result in an error. + */ + dispose(): void; +} + +/** + * The result of creating an asynchronous compiler. Returned by + * {@link initAsyncCompiler}. + * + * @category Compile + */ +export class AsyncCompiler { + /** + * Throws an error if constructed directly, instead of via + * {@link initAsyncCompiler}. + */ + private constructor(); + + /** + * The {@link compileAsync} method exposed through an Async Compiler instance + * while it is active. If this is called after {@link dispose} on the Async + * Compiler instance, an error will be thrown. + * + * During the Async Compiler instance's lifespan, given the same input, this + * will return an identical result to the {@link compileAsync} method exposed + * at the module root. + */ + compileAsync( + path: string, + options?: Options<'async'> + ): Promise; + + /** + * The {@link compileStringAsync} method exposed through an Async Compiler + * instance while it is active. If this is called after {@link dispose} on the + * Async Compiler instance, an error will be thrown. + * + * During the Async Compiler instance's lifespan, given the same input, this + * will return an identical result to the {@link compileStringAsync} method + * exposed at the module root. + */ + compileStringAsync( + source: string, + options?: StringOptions<'async'> + ): Promise; + + /** + * Ends the lifespan of this Async Compiler instance. After this is invoked, + * all subsequent calls to the Compiler instance's `compileAsync` or + * `compileStringAsync` methods will result in an error. + * + * Any compilations that are submitted before `dispose` will not be cancelled, + * and will be allowed to settle. + * + * After all compilations have been settled and Sass completes any internal + * task cleanup, `dispose` will resolve its promise. + */ + dispose(): Promise; +} + +/** + * Synchronously compiles the Sass file at `path` to CSS. If it succeeds it + * returns a {@link CompileResult}, and if it fails it throws an {@link + * Exception}. + * + * This only allows synchronous {@link Importer}s and {@link CustomFunction}s. + * + * **Heads up!** When using the [sass-embedded] npm package for single + * compilations, **{@link compileAsync} is almost always faster than + * {@link compile}**, due to the overhead of emulating synchronous messaging + * with worker threads and concurrent compilations being blocked on main thread. + * + * If you are running multiple compilations with the [sass-embedded] npm + * package, using a {@link Compiler} will provide some speed improvements over + * the module-level methods, and an {@link AsyncCompiler} will be much faster. + * + * [sass-embedded]: https://www.npmjs.com/package/sass-embedded + * + * @example + * + * ```js + * const sass = require('sass'); + * + * const result = sass.compile("style.scss"); + * console.log(result.css); + * ``` + * + * @category Compile + * @compatibility dart: "1.45.0", node: false + */ +export function compile(path: string, options?: Options<'sync'>): CompileResult; + +/** + * Asynchronously compiles the Sass file at `path` to CSS. Returns a promise + * that resolves with a {@link CompileResult} if it succeeds and rejects with an + * {@link Exception} if it fails. + * + * This only allows synchronous or asynchronous {@link Importer}s and + * {@link CustomFunction}s. + * + * **Heads up!** When using the `sass` npm package, **{@link compile} is almost + * twice as fast as {@link compileAsync}**, due to the overhead of making the + * entire evaluation process asynchronous. + * + * @example + * + * ```js + * const sass = require('sass'); + * + * const result = await sass.compileAsync("style.scss"); + * console.log(result.css); + * ``` + * + * @category Compile + * @compatibility dart: "1.45.0", node: false + */ +export function compileAsync( + path: string, + options?: Options<'async'> +): Promise; + +/** + * Synchronously compiles a stylesheet whose contents is `source` to CSS. If it + * succeeds it returns a {@link CompileResult}, and if it fails it throws an + * {@link Exception}. + * + * This only allows synchronous {@link Importer}s and {@link CustomFunction}s. + * + * **Heads up!** When using the [sass-embedded] npm package for single + * compilations, **{@link compileStringAsync} is almost always faster than + * {@link compileString}**, due to the overhead of emulating synchronous + * messaging with worker threads and concurrent compilations being blocked on + * main thread. + * + * If you are running multiple compilations with the [sass-embedded] npm + * package, using a {@link Compiler} will provide some speed improvements over + * the module-level methods, and an {@link AsyncCompiler} will be much faster. + * + * [sass-embedded]: https://www.npmjs.com/package/sass-embedded + * + * @example + * + * ```js + * const sass = require('sass'); + * + * const result = sass.compileString(` + * h1 { + * font-size: 40px; + * code { + * font-face: Roboto Mono; + * } + * }`); + * console.log(result.css); + * ``` + * + * @category Compile + * @compatibility dart: "1.45.0", node: false + */ +export function compileString( + source: string, + options?: StringOptions<'sync'> +): CompileResult; + +/** + * Asynchronously compiles a stylesheet whose contents is `source` to CSS. + * Returns a promise that resolves with a {@link CompileResult} if it succeeds + * and rejects with an {@link Exception} if it fails. + * + * This only allows synchronous or asynchronous {@link Importer}s and {@link + * CustomFunction}s. + * + * **Heads up!** When using the `sass` npm package, **{@link compileString} is + * almost twice as fast as {@link compileStringAsync}**, due to the overhead + * of making the entire evaluation process asynchronous. + * + * @example + * + * ```js + * const sass = require('sass'); + * + * const result = await sass.compileStringAsync(` + * h1 { + * font-size: 40px; + * code { + * font-face: Roboto Mono; + * } + * }`); + * console.log(result.css); + * ``` + * + * @category Compile + * @compatibility dart: "1.45.0", node: false + */ +export function compileStringAsync( + source: string, + options?: StringOptions<'async'> +): Promise; + +/** + * Creates a synchronous {@link Compiler}. Each compiler instance exposes the + * {@link compile} and {@link compileString} methods within the lifespan of the + * Compiler. Given identical input, these methods will return results identical + * to their counterparts exposed at the module root. To use asynchronous + * compilation, use {@link initAsyncCompiler}. + * + * When calling the compile functions multiple times, using a compiler instance + * with the [sass-embedded] npm package is much faster than using the top-level + * compilation methods or the [sass] npm package. + * + * [sass-embedded]: https://www.npmjs.com/package/sass-embedded + * + * [sass]: https://www.npmjs.com/package/sass + * + * @example + * + * ```js + * const sass = require('sass'); + * function setup() { + * const compiler = sass.initCompiler(); + * const result1 = compiler.compileString('a {b: c}').css; + * const result2 = compiler.compileString('a {b: c}').css; + * compiler.dispose(); + * + * // throws error + * const result3 = sass.compileString('a {b: c}').css; + * } + * ``` + * @category Compile + * @compatibility dart: "1.70.0", node: false + */ +export function initCompiler(): Compiler; + +/** + * Creates an asynchronous {@link AsyncCompiler}. Each compiler + * instance exposes the {@link compileAsync} and {@link compileStringAsync} + * methods within the lifespan of the Compiler. Given identical input, these + * methods will return results identical to their counterparts exposed at the + * module root. To use synchronous compilation, use {@link initCompiler}; + * + * When calling the compile functions multiple times, using a compiler instance + * with the [sass-embedded] npm package is much faster than using the top-level + * compilation methods or the [sass] npm package. + * + * [sass-embedded]: https://www.npmjs.com/package/sass-embedded + * + * [sass]: https://www.npmjs.com/package/sass + * + * @example + * + * ```js + * const sass = require('sass'); + * async function setup() { + * const compiler = await sass.initAsyncCompiler(); + * const result1 = await compiler.compileStringAsync('a {b: c}').css; + * const result2 = await compiler.compileStringAsync('a {b: c}').css; + * await compiler.dispose(); + * + * // throws error + * const result3 = await sass.compileStringAsync('a {b: c}').css; + * } + * ``` + * @category Compile + * @compatibility dart: "1.70.0", node: false + */ +export function initAsyncCompiler(): Promise; diff --git a/node_modules/sass/types/deprecations.d.ts b/node_modules/sass/types/deprecations.d.ts new file mode 100644 index 0000000..caa9b02 --- /dev/null +++ b/node_modules/sass/types/deprecations.d.ts @@ -0,0 +1,267 @@ +/** + * All of the deprecation types currently used by Sass. + * + * Any of these IDs or the deprecation objects they point to can be passed to + * `fatalDeprecations`, `futureDeprecations`, or `silenceDeprecations`. + */ +export interface Deprecations { + // START AUTOGENERATED LIST + // Checksum: 3639e60773866019c018ae16267c8f23e4df86cf + + /** + * Deprecation for passing a string directly to meta.call(). + * + * This deprecation was active in the first version of Dart Sass. + */ + 'call-string': Deprecation<'call-string'>; + + /** + * Deprecation for @elseif. + * + * This deprecation became active in Dart Sass 1.3.2. + */ + elseif: Deprecation<'elseif'>; + + /** + * Deprecation for @-moz-document. + * + * This deprecation became active in Dart Sass 1.7.2. + */ + 'moz-document': Deprecation<'moz-document'>; + + /** + * Deprecation for imports using relative canonical URLs. + * + * This deprecation became active in Dart Sass 1.14.2. + */ + 'relative-canonical': Deprecation<'relative-canonical'>; + + /** + * Deprecation for declaring new variables with !global. + * + * This deprecation became active in Dart Sass 1.17.2. + */ + 'new-global': Deprecation<'new-global'>; + + /** + * Deprecation for using color module functions in place of plain CSS functions. + * + * This deprecation became active in Dart Sass 1.23.0. + */ + 'color-module-compat': Deprecation<'color-module-compat'>; + + /** + * Deprecation for / operator for division. + * + * This deprecation became active in Dart Sass 1.33.0. + */ + 'slash-div': Deprecation<'slash-div'>; + + /** + * Deprecation for leading, trailing, and repeated combinators. + * + * This deprecation became active in Dart Sass 1.54.0. + */ + 'bogus-combinators': Deprecation<'bogus-combinators'>; + + /** + * Deprecation for ambiguous + and - operators. + * + * This deprecation became active in Dart Sass 1.55.0. + */ + 'strict-unary': Deprecation<'strict-unary'>; + + /** + * Deprecation for passing invalid units to built-in functions. + * + * This deprecation became active in Dart Sass 1.56.0. + */ + 'function-units': Deprecation<'function-units'>; + + /** + * Deprecation for using !default or !global multiple times for one variable. + * + * This deprecation became active in Dart Sass 1.62.0. + */ + 'duplicate-var-flags': Deprecation<'duplicate-var-flags'>; + + /** + * Deprecation for passing null as alpha in the JS API. + * + * This deprecation became active in Dart Sass 1.62.3. + */ + 'null-alpha': Deprecation<'null-alpha'>; + + /** + * Deprecation for passing percentages to the Sass abs() function. + * + * This deprecation became active in Dart Sass 1.65.0. + */ + 'abs-percent': Deprecation<'abs-percent'>; + + /** + * Deprecation for using the current working directory as an implicit load path. + * + * This deprecation became active in Dart Sass 1.73.0. + */ + 'fs-importer-cwd': Deprecation<'fs-importer-cwd'>; + + /** + * Deprecation for function and mixin names beginning with --. + * + * This deprecation became active in Dart Sass 1.76.0. + */ + 'css-function-mixin': Deprecation<'css-function-mixin'>; + + /** + * Deprecation for declarations after or between nested rules. + * + * This deprecation became active in Dart Sass 1.77.7. + */ + 'mixed-decls': Deprecation<'mixed-decls'>; + + /** + * Deprecation for meta.feature-exists + * + * This deprecation became active in Dart Sass 1.78.0. + */ + 'feature-exists': Deprecation<'feature-exists'>; + + /** + * Deprecation for certain uses of built-in sass:color functions. + * + * This deprecation became active in Dart Sass 1.79.0. + */ + 'color-4-api': Deprecation<'color-4-api'>; + + /** + * Deprecation for using global color functions instead of sass:color. + * + * This deprecation became active in Dart Sass 1.79.0. + */ + 'color-functions': Deprecation<'color-functions'>; + + /** + * Deprecation for legacy JS API. + * + * This deprecation became active in Dart Sass 1.79.0. + */ + 'legacy-js-api': Deprecation<'legacy-js-api'>; + + /** + * Deprecation for @import rules. + * + * This deprecation became active in Dart Sass 1.80.0. + */ + import: Deprecation<'import'>; + + /** + * Deprecation for global built-in functions that are available in sass: modules. + * + * This deprecation became active in Dart Sass 1.80.0. + */ + 'global-builtin': Deprecation<'global-builtin'>; + + /** + * Deprecation for functions named "type". + * + * This deprecation became active in Dart Sass 1.86.0. + */ + 'type-function': Deprecation<'type-function'>; + + // END AUTOGENERATED LIST + + /** + * Used for any user-emitted deprecation warnings. + */ + 'user-authored': Deprecation<'user-authored', 'user'>; +} + +/** + * Either a deprecation or its ID, either of which can be passed to any of + * the relevant compiler options. + * + * @category Messages + * @compatibility dart: "1.74.0", node: false + */ +export type DeprecationOrId = Deprecation | keyof Deprecations; + +/** + * The possible statuses that each deprecation can have. + * + * "active" deprecations are currently emitting deprecation warnings. + * "future" deprecations are not yet active, but will be in the future. + * "obsolete" deprecations were once active, but no longer are. + * + * The only "user" deprecation is "user-authored", which is used for deprecation + * warnings coming from user code. + * + * @category Messages + * @compatibility dart: "1.74.0", node: false + */ +export type DeprecationStatus = 'active' | 'user' | 'future' | 'obsolete'; + +/** + * A deprecated feature in the language. + * + * @category Messages + * @compatibility dart: "1.74.0", node: false + */ +export interface Deprecation< + id extends keyof Deprecations = keyof Deprecations, + status extends DeprecationStatus = DeprecationStatus +> { + /** The unique ID of this deprecation. */ + id: id; + + /** The current status of this deprecation. */ + status: status; + + /** A human-readable description of this deprecation. */ + description?: string; + + /** The version this deprecation first became active in. */ + deprecatedIn: status extends 'future' | 'user' ? null : Version; + + /** The version this deprecation became obsolete in. */ + obsoleteIn: status extends 'obsolete' ? Version : null; +} + +/** + * A semantic version of the compiler. + * + * @category Messages + * @compatibility dart: "1.74.0", node: false + */ +export class Version { + /** + * Constructs a new version. + * + * All components must be non-negative integers. + * + * @param major - The major version. + * @param minor - The minor version. + * @param patch - The patch version. + */ + constructor(major: number, minor: number, patch: number); + readonly major: number; + readonly minor: number; + readonly patch: number; + + /** + * Parses a version from a string. + * + * This throws an error if a valid version can't be parsed. + * + * @param version - A string in the form "major.minor.patch". + */ + static parse(version: string): Version; +} + +/** + * An object containing all deprecation types. + * + * @category Messages + * @compatibility dart: "1.74.0", node: false + */ +export const deprecations: Deprecations; diff --git a/node_modules/sass/types/exception.d.ts b/node_modules/sass/types/exception.d.ts new file mode 100644 index 0000000..616d652 --- /dev/null +++ b/node_modules/sass/types/exception.d.ts @@ -0,0 +1,41 @@ +import {SourceSpan} from './logger'; + +/** + * An exception thrown because a Sass compilation failed. + * + * @category Other + */ +export class Exception extends Error { + private constructor(); + + /** + * A human-friendly representation of the exception. + * + * Because many tools simply print `Error.message` directly, this includes not + * only the textual description of what went wrong (the {@link sassMessage}) + * but also an indication of where in the Sass stylesheet the error occurred + * (the {@link span}) and the Sass stack trace at the point of error (the + * {@link sassStack}). + */ + message: string; + + /** + * A textual description of what went wrong. + * + * Unlike {@link message}, this does *not* include representations of {@link + * span} or {@link sassStack}. + */ + readonly sassMessage: string; + + /** + * A human-friendly representation of the Sass stack trace at the point of + * error. + */ + readonly sassStack: string; + + /** The location the error occurred in the Sass file that triggered it. */ + readonly span: SourceSpan; + + /** Returns the same string as {@link message}. */ + toString(): string; +} diff --git a/node_modules/sass/types/importer.d.ts b/node_modules/sass/types/importer.d.ts new file mode 100644 index 0000000..dca4266 --- /dev/null +++ b/node_modules/sass/types/importer.d.ts @@ -0,0 +1,465 @@ +import {Syntax} from './options'; +import {PromiseOr} from './util/promise_or'; + +/** + * Contextual information passed to {@link Importer.canonicalize} and {@link + * FileImporter.findFileUrl}. Not all importers will need this information to + * resolve loads, but some may find it useful. + */ +export interface CanonicalizeContext { + /** + * Whether this is being invoked because of a Sass + * `@import` rule, as opposed to a `@use` or `@forward` rule. + * + * This should *only* be used for determining whether or not to load + * [import-only files](https://sass-lang.com/documentation/at-rules/import#import-only-files). + */ + fromImport: boolean; + + /** + * The canonical URL of the file that contains the load, if that information + * is available. + * + * For an {@link Importer}, this is only passed when the `url` parameter is a + * relative URL _or_ when its [URL scheme] is included in {@link + * Importer.nonCanonicalScheme}. This ensures that canonical URLs are always + * resolved the same way regardless of context. + * + * [URL scheme]: https://developer.mozilla.org/en-US/docs/Learn/Common_questions/Web_mechanics/What_is_a_URL#scheme + * + * For a {@link FileImporter}, this is always available as long as Sass knows + * the canonical URL of the containing file. + */ + containingUrl: URL | null; +} + +/** + * A special type of importer that redirects all loads to existing files on + * disk. Although this is less powerful than a full {@link Importer}, it + * automatically takes care of Sass features like resolving partials and file + * extensions and of loading the file from disk. + * + * Like all importers, this implements custom Sass loading logic for [`@use` + * rules](https://sass-lang.com/documentation/at-rules/use) and [`@import` + * rules](https://sass-lang.com/documentation/at-rules/import). It can be passed + * to {@link Options.importers} or {@link StringOptions.importer}. + * + * @typeParam sync - A `FileImporter<'sync'>`'s {@link findFileUrl} must return + * synchronously, but in return it can be passed to {@link compile} and {@link + * compileString} in addition to {@link compileAsync} and {@link + * compileStringAsync}. + * + * A `FileImporter<'async'>`'s {@link findFileUrl} may either return + * synchronously or asynchronously, but it can only be used with {@link + * compileAsync} and {@link compileStringAsync}. + * + * @example + * + * ```js + * const {pathToFileURL} = require('url'); + * + * sass.compile('style.scss', { + * importers: [{ + * // An importer that redirects relative URLs starting with "~" to + * // `node_modules`. + * findFileUrl(url) { + * if (!url.startsWith('~')) return null; + * return new URL(url.substring(1), pathToFileURL('node_modules')); + * } + * }] + * }); + * ``` + * + * @category Importer + */ +export interface FileImporter< + sync extends 'sync' | 'async' = 'sync' | 'async' +> { + /** + * A callback that's called to partially resolve a load (such as + * [`@use`](https://sass-lang.com/documentation/at-rules/use) or + * [`@import`](https://sass-lang.com/documentation/at-rules/import)) to a file + * on disk. + * + * Unlike an {@link Importer}, the compiler will automatically handle relative + * loads for a {@link FileImporter}. See {@link Options.importers} for more + * details on the way loads are resolved. + * + * @param url - The loaded URL. Since this might be relative, it's represented + * as a string rather than a {@link URL} object. + * + * @returns An absolute `file:` URL if this importer recognizes the `url`. + * This may be only partially resolved: the compiler will automatically look + * for [partials](https://sass-lang.com/documentation/at-rules/use#partials), + * [index files](https://sass-lang.com/documentation/at-rules/use#index-files), + * and file extensions based on the returned URL. An importer may also return + * a fully resolved URL if it so chooses. + * + * If this importer doesn't recognize the URL, it should return `null` instead + * to allow other importers or {@link Options.loadPaths | load paths} to + * handle it. + * + * This may also return a `Promise`, but if it does the importer may only be + * passed to {@link compileAsync} and {@link compileStringAsync}, not {@link + * compile} or {@link compileString}. + * + * @throws any - If this importer recognizes `url` but determines that it's + * invalid, it may throw an exception that will be wrapped by Sass. If the + * exception object has a `message` property, it will be used as the wrapped + * exception's message; otherwise, the exception object's `toString()` will be + * used. This means it's safe for importers to throw plain strings. + */ + findFileUrl( + url: string, + context: CanonicalizeContext + ): PromiseOr; + + /** @hidden */ + canonicalize?: never; +} + +/** + * An object that implements custom Sass loading logic for [`@use` + * rules](https://sass-lang.com/documentation/at-rules/use) and [`@import` + * rules](https://sass-lang.com/documentation/at-rules/import). It can be passed + * to {@link Options.importers} or {@link StringOptions.importer}. + * + * Importers that simply redirect to files on disk are encouraged to use the + * {@link FileImporter} interface instead. + * + * ### Resolving a Load + * + * This is the process of resolving a load using a custom importer: + * + * - The compiler encounters `@use "db:foo/bar/baz"`. + * - It calls {@link canonicalize} with `"db:foo/bar/baz"`. + * - {@link canonicalize} returns `new URL("db:foo/bar/baz/_index.scss")`. + * - If the compiler has already loaded a stylesheet with this canonical URL, it + * re-uses the existing module. + * - Otherwise, it calls {@link load} with `new + * URL("db:foo/bar/baz/_index.scss")`. + * - {@link load} returns an {@link ImporterResult} that the compiler uses as + * the contents of the module. + * + * See {@link Options.importers} for more details on the way loads are resolved + * using multiple importers and load paths. + * + * @typeParam sync - An `Importer<'sync'>`'s {@link canonicalize} and {@link + * load} must return synchronously, but in return it can be passed to {@link + * compile} and {@link compileString} in addition to {@link compileAsync} and + * {@link compileStringAsync}. + * + * An `Importer<'async'>`'s {@link canonicalize} and {@link load} may either + * return synchronously or asynchronously, but it can only be used with {@link + * compileAsync} and {@link compileStringAsync}. + * + * @example + * + * ```js + * sass.compile('style.scss', { + * // An importer for URLs like `bgcolor:orange` that generates a + * // stylesheet with the given background color. + * importers: [{ + * canonicalize(url) { + * if (!url.startsWith('bgcolor:')) return null; + * return new URL(url); + * }, + * load(canonicalUrl) { + * return { + * contents: `body {background-color: ${canonicalUrl.pathname}}`, + * syntax: 'scss' + * }; + * } + * }] + * }); + * ``` + * + * @category Importer + */ +export interface Importer { + /** + * If `url` is recognized by this importer, returns its canonical format. + * + * If Sass has already loaded a stylesheet with the returned canonical URL, it + * re-uses the existing parse tree (and the loaded module for `@use`). This + * means that importers **must ensure** that the same canonical URL always + * refers to the same stylesheet, *even across different importers*. As such, + * importers are encouraged to use unique URL schemes to disambiguate between + * one another. + * + * As much as possible, custom importers should canonicalize URLs the same way + * as the built-in filesystem importer: + * + * - The importer should look for stylesheets by adding the prefix `_` to the + * URL's basename, and by adding the extensions `.sass` and `.scss` if the + * URL doesn't already have one of those extensions. For example, if the + * URL was `foo/bar/baz`, the importer would look for: + * - `foo/bar/baz.sass` + * - `foo/bar/baz.scss` + * - `foo/bar/_baz.sass` + * - `foo/bar/_baz.scss` + * + * If the URL was `foo/bar/baz.scss`, the importer would just look for: + * - `foo/bar/baz.scss` + * - `foo/bar/_baz.scss` + * + * If the importer finds a stylesheet at more than one of these URLs, it + * should throw an exception indicating that the URL is ambiguous. Note that + * if the extension is explicitly specified, a stylesheet with the opposite + * extension is allowed to exist. + * + * - If none of the possible paths is valid, the importer should perform the + * same resolution on the URL followed by `/index`. In the example above, + * it would look for: + * - `foo/bar/baz/index.sass` + * - `foo/bar/baz/index.scss` + * - `foo/bar/baz/_index.sass` + * - `foo/bar/baz/_index.scss` + * + * As above, if the importer finds a stylesheet at more than one of these + * URLs, it should throw an exception indicating that the import is + * ambiguous. + * + * If no stylesheets are found, the importer should return `null`. + * + * Calling {@link canonicalize} multiple times with the same URL must return + * the same result. Calling {@link canonicalize} with a URL returned by a + * previous call to {@link canonicalize} must return that URL. + * + * Relative loads in stylesheets loaded from an importer are handled by + * resolving the loaded URL relative to the canonical URL of the stylesheet + * that contains it, and passing that URL back to the importer's {@link + * canonicalize} method. For example, suppose the "Resolving a Load" example + * {@link Importer | above} returned a stylesheet that contained `@use + * "mixins"`: + * + * - The compiler resolves the URL `mixins` relative to the current + * stylesheet's canonical URL `db:foo/bar/baz/_index.scss` to get + * `db:foo/bar/baz/mixins`. + * - It calls {@link canonicalize} with `"db:foo/bar/baz/mixins"`. + * - {@link canonicalize} returns `new URL("db:foo/bar/baz/_mixins.scss")`. + * + * Because of this, {@link canonicalize} must return a meaningful result when + * called with a URL relative to one returned by an earlier call to {@link + * canonicalize}. + * + * @param url - The loaded URL. Since this might be relative, it's represented + * as a string rather than a {@link URL} object. + * + * @returns An absolute URL if this importer recognizes the `url`, or `null` + * if it doesn't. If this returns `null`, other importers or {@link + * Options.loadPaths | load paths} may handle the load. + * + * This may also return a `Promise`, but if it does the importer may only be + * passed to {@link compileAsync} and {@link compileStringAsync}, not {@link + * compile} or {@link compileString}. + * + * @throws any - If this importer recognizes `url` but determines that it's + * invalid, it may throw an exception that will be wrapped by Sass. If the + * exception object has a `message` property, it will be used as the wrapped + * exception's message; otherwise, the exception object's `toString()` will be + * used. This means it's safe for importers to throw plain strings. + */ + canonicalize( + url: string, + context: CanonicalizeContext + ): PromiseOr; + + /** + * Loads the Sass text for the given `canonicalUrl`, or returns `null` if this + * importer can't find the stylesheet it refers to. + * + * @param canonicalUrl - The canonical URL of the stylesheet to load. This is + * guaranteed to come from a call to {@link canonicalize}, although not every + * call to {@link canonicalize} will result in a call to {@link load}. + * + * @returns The contents of the stylesheet at `canonicalUrl` if it can be + * loaded, or `null` if it can't. + * + * This may also return a `Promise`, but if it does the importer may only be + * passed to {@link compileAsync} and {@link compileStringAsync}, not {@link + * compile} or {@link compileString}. + * + * @throws any - If this importer finds a stylesheet at `url` but it fails to + * load for some reason, or if `url` is uniquely associated with this importer + * but doesn't refer to a real stylesheet, the importer may throw an exception + * that will be wrapped by Sass. If the exception object has a `message` + * property, it will be used as the wrapped exception's message; otherwise, + * the exception object's `toString()` will be used. This means it's safe for + * importers to throw plain strings. + */ + load(canonicalUrl: URL): PromiseOr; + + /** @hidden */ + findFileUrl?: never; + + /** + * A URL scheme or set of schemes (without the `:`) that this importer + * promises never to use for URLs returned by {@link canonicalize}. If it does + * return a URL with one of these schemes, that's an error. + * + * If this is set, any call to canonicalize for a URL with a non-canonical + * scheme will be passed {@link CanonicalizeContext.containingUrl} if it's + * known. + * + * These schemes may only contain lowercase ASCII letters, ASCII numerals, + * `+`, `-`, and `.`. They may not be empty. + */ + nonCanonicalScheme?: string | string[]; +} + +declare const nodePackageImporterKey: unique symbol; + +/** + * The built-in Node.js package importer. This loads pkg: URLs from node_modules + * according to the standard Node.js resolution algorithm. + * + * A Node.js package importer is exposed as a class that can be added to the + * `importers` option. + * + *```js + * const sass = require('sass'); + * sass.compileString('@use "pkg:vuetify', { + * importers: [new sass.NodePackageImporter()] + * }); + *``` + * + * ## Writing Sass packages + * + * Package authors can control what is exposed to their users through their + * `package.json` manifest. The recommended method is to add a `sass` + * conditional export to `package.json`. + * + * ```json + * // node_modules/uicomponents/package.json + * { + * "exports": { + * ".": { + * "sass": "./src/scss/index.scss", + * "import": "./dist/js/index.mjs", + * "default": "./dist/js/index.js" + * } + * } + * } + * ``` + * + * This allows a package user to write `@use "pkg:uicomponents"` to load the + * file at `node_modules/uicomponents/src/scss/index.scss`. + * + * The Node.js package importer supports the variety of formats supported by + * Node.js [package entry points], allowing authors to expose multiple subpaths. + * + * [package entry points]: + * https://nodejs.org/api/packages.html#package-entry-points + * + * ```json + * // node_modules/uicomponents/package.json + * { + * "exports": { + * ".": { + * "sass": "./src/scss/index.scss", + * }, + * "./colors.scss": { + * "sass": "./src/scss/_colors.scss", + * }, + * "./theme/*.scss": { + * "sass": "./src/scss/theme/*.scss", + * }, + * } + * } + * ``` + * + * This allows a package user to write: + * + * - `@use "pkg:uicomponents";` to import the root export. + * - `@use "pkg:uicomponents/colors";` to import the colors partial. + * - `@use "pkg:uicomponents/theme/purple";` to import a purple theme. + * + * Note that while library users can rely on the importer to resolve + * [partials](https://sass-lang.com/documentation/at-rules/use#partials), [index + * files](https://sass-lang.com/documentation/at-rules/use#index-files), and + * extensions, library authors must specify the entire file path in `exports`. + * + * In addition to the `sass` condition, the `style` condition is also + * acceptable. Sass will match the `default` condition if it's a relevant file + * type, but authors are discouraged from relying on this. Notably, the key + * order matters, and the importer will resolve to the first value with a key + * that is `sass`, `style`, or `default`, so you should always put `default` + * last. + * + * To help package authors who haven't transitioned to package entry points + * using the `exports` field, the Node.js package importer provides several + * fallback options. If the `pkg:` URL does not have a subpath, the Node.js + * package importer will look for a `sass` or `style` key at the root of + * `package.json`. + * + * ```json + * // node_modules/uicomponents/package.json + * { + * "sass": "./src/scss/index.scss", + * } + * ``` + * + * This allows a user to write `@use "pkg:uicomponents";` to import the + * `index.scss` file. + * + * Finally, the Node.js package importer will look for an `index` file at the + * package root, resolving partials and extensions. For example, if the file + * `_index.scss` exists in the package root of `uicomponents`, a user can import + * that with `@use "pkg:uicomponents";`. + * + * If a `pkg:` URL includes a subpath that doesn't have a match in package entry + * points, the Node.js importer will attempt to find that file relative to the + * package root, resolving for file extensions, partials and index files. For + * example, if the file `src/sass/_colors.scss` exists in the `uicomponents` + * package, a user can import that file using `@use + * "pkg:uicomponents/src/sass/colors";`. + * + * @compatibility dart: "1.71.0", node: false + * @category Importer + */ +export class NodePackageImporter { + /** Used to distinguish this type from any arbitrary object. */ + private readonly [nodePackageImporterKey]: true; + + /** + * The NodePackageImporter has an optional `entryPointDirectory` option, which + * is the directory where the Node Package Importer should start when + * resolving `pkg:` URLs in sources other than files on disk. This will be + * used as the `parentURL` in the [Node Module + * Resolution](https://nodejs.org/api/esm.html#resolution-algorithm-specification) + * algorithm. + * + * In order to be found by the Node Package Importer, a package will need to + * be inside a node_modules folder located in the `entryPointDirectory`, or + * one of its parent directories, up to the filesystem root. + * + * Relative paths will be resolved relative to the current working directory. + * If a path is not provided, this defaults to the parent directory of the + * Node.js entrypoint. If that's not available, this will throw an error. + */ + constructor(entryPointDirectory?: string); +} + +/** + * The result of successfully loading a stylesheet with an {@link Importer}. + * + * @category Importer + */ +export interface ImporterResult { + /** The contents of the stylesheet. */ + contents: string; + + /** The syntax with which to parse {@link contents}. */ + syntax: Syntax; + + /** + * The URL to use to link to the loaded stylesheet's source code in source + * maps. A `file:` URL is ideal because it's accessible to both browsers and + * other build tools, but an `http:` URL is also acceptable. + * + * If this isn't set, it defaults to a `data:` URL that contains the contents + * of the loaded stylesheet. + */ + sourceMapUrl?: URL; +} diff --git a/node_modules/sass/types/index.d.ts b/node_modules/sass/types/index.d.ts new file mode 100644 index 0000000..3520dda --- /dev/null +++ b/node_modules/sass/types/index.d.ts @@ -0,0 +1,122 @@ +// This is a mirror of the JS API definitions in `spec/js-api`, but with comments +// written to provide user-facing documentation rather than to specify behavior for +// implementations. + +export { + AsyncCompiler, + CompileResult, + Compiler, + compile, + compileAsync, + compileString, + compileStringAsync, + initCompiler, + initAsyncCompiler, +} from './compile'; +export { + deprecations, + Deprecation, + Deprecations, + DeprecationOrId, + DeprecationStatus, + Version, +} from './deprecations'; +export {Exception} from './exception'; +export { + CanonicalizeContext, + FileImporter, + Importer, + ImporterResult, + NodePackageImporter, +} from './importer'; +export {Logger, LoggerWarnOptions, SourceSpan, SourceLocation} from './logger'; +export { + CustomFunction, + Options, + OutputStyle, + StringOptions, + StringOptionsWithImporter, + StringOptionsWithoutImporter, + Syntax, +} from './options'; +export {PromiseOr} from './util/promise_or'; +export { + CalculationInterpolation, + CalculationOperation, + CalculationOperator, + CalculationValue, + ChannelName, + ChannelNameHsl, + ChannelNameHwb, + ChannelNameLch, + ChannelNameLab, + ChannelNameRgb, + ChannelNameXyz, + ColorSpaceHsl, + ColorSpaceHwb, + ColorSpaceLch, + ColorSpaceLab, + ColorSpaceRgb, + ColorSpaceXyz, + GamutMapMethod, + HueInterpolationMethod, + KnownColorSpace, + ListSeparator, + PolarColorSpace, + RectangularColorSpace, + SassArgumentList, + SassBoolean, + SassCalculation, + SassColor, + SassFunction, + SassList, + SassMap, + SassMixin, + SassNumber, + SassString, + Value, + sassFalse, + sassNull, + sassTrue, +} from './value'; + +// Legacy APIs +export {LegacyException} from './legacy/exception'; +export { + FALSE, + LegacyAsyncFunction, + LegacyAsyncFunctionDone, + LegacyFunction, + LegacySyncFunction, + LegacyValue, + NULL, + TRUE, + types, +} from './legacy/function'; +export { + LegacyAsyncImporter, + LegacyImporter, + LegacyImporterResult, + LegacyImporterThis, + LegacySyncImporter, +} from './legacy/importer'; +export { + LegacySharedOptions, + LegacyFileOptions, + LegacyStringOptions, + LegacyOptions, +} from './legacy/options'; +export {LegacyPluginThis} from './legacy/plugin_this'; +export {LegacyResult, render, renderSync} from './legacy/render'; + +/** + * Information about the Sass implementation. This always begins with a unique + * identifier for the Sass implementation, followed by U+0009 TAB, followed by + * its npm package version. Some implementations include additional information + * as well, but not in any standardized format. + * + * * For Dart Sass, the implementation name is `dart-sass`. + * * For Node Sass, the implementation name is `node-sass`. + * * For the embedded host, the implementation name is `sass-embedded`. + */ +export const info: string; diff --git a/node_modules/sass/types/legacy/exception.d.ts b/node_modules/sass/types/legacy/exception.d.ts new file mode 100644 index 0000000..29d3a54 --- /dev/null +++ b/node_modules/sass/types/legacy/exception.d.ts @@ -0,0 +1,55 @@ +/** + * The exception type thrown by {@link renderSync} and passed as the error to + * {@link render}'s callback. + * + * @category Legacy + * @deprecated This is only thrown by the legacy {@link render} and {@link + * renderSync} APIs. Use {@link compile}, {@link compileString}, {@link + * compileAsync}, and {@link compileStringAsync} instead. + */ +export interface LegacyException extends Error { + /** + * The error message. For Dart Sass, when possible this includes a highlighted + * indication of where in the source file the error occurred as well as the + * Sass stack trace. + */ + message: string; + + /** + * The error message. For Dart Sass, this is the same as the result of calling + * {@link toString}, which is itself the same as {@link message} but with the + * prefix "Error:". + */ + formatted: string; + + /** + * The (1-based) line number on which the error occurred, if this exception is + * associated with a specific Sass file location. + */ + line?: number; + + /** + * The (1-based) column number within {@link line} at which the error + * occurred, if this exception is associated with a specific Sass file + * location. + */ + column?: number; + + /** + * Analogous to the exit code for an executable. `1` for an error caused by a + * Sass file, `3` for any other type of error. + */ + status: number; + + /** + * If this exception was caused by an error in a Sass file, this will + * represent the Sass file's location. It can be in one of three formats: + * + * * If the Sass file was loaded from disk, this is the path to that file. + * * If the Sass file was generated by an importer, this is its canonical URL. + * * If the Sass file was passed as {@link LegacyStringOptions.data} without a + * corresponding {@link LegacyStringOptions.file}, this is the special + * string `"stdin"`. + */ + file?: string; +} diff --git a/node_modules/sass/types/legacy/function.d.ts b/node_modules/sass/types/legacy/function.d.ts new file mode 100644 index 0000000..7c27eb8 --- /dev/null +++ b/node_modules/sass/types/legacy/function.d.ts @@ -0,0 +1,757 @@ +import {LegacyPluginThis} from './plugin_this'; + +/** + * A synchronous callback that implements a custom Sass function. This can be + * passed to {@link LegacySharedOptions.functions} for either {@link render} or + * {@link renderSync}. + * + * If this throws an error, Sass will treat that as the function failing with + * that error message. + * + * ```js + * const result = sass.renderSync({ + * file: 'style.scss', + * functions: { + * "sum($arg1, $arg2)": (arg1, arg2) => { + * if (!(arg1 instanceof sass.types.Number)) { + * throw new Error("$arg1: Expected a number"); + * } else if (!(arg2 instanceof sass.types.Number)) { + * throw new Error("$arg2: Expected a number"); + * } + * return new sass.types.Number(arg1.getValue() + arg2.getValue()); + * } + * } + * }); + * ``` + * + * @param args - One argument for each argument that's declared in the signature + * that's passed to {@link LegacySharedOptions.functions}. If the signature + * [takes arbitrary + * arguments](https://sass-lang.com/documentation/at-rules/function#taking-arbitrary-arguments), + * they're passed as a single argument list in the last argument. + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link CustomFunction} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +export type LegacySyncFunction = ( + this: LegacyPluginThis, + ...args: LegacyValue[] +) => LegacyValue; + +/** + * An asynchronous callback that implements a custom Sass function. This can be + * passed to {@link LegacySharedOptions.functions}, but only for {@link render}. + * + * An asynchronous function must return `undefined`. Its final argument will + * always be a callback, which it should call with the result of the function + * once it's done running. + * + * If this throws an error, Sass will treat that as the function failing with + * that error message. + * + * ```js + * sass.render({ + * file: 'style.scss', + * functions: { + * "sum($arg1, $arg2)": (arg1, arg2, done) => { + * if (!(arg1 instanceof sass.types.Number)) { + * throw new Error("$arg1: Expected a number"); + * } else if (!(arg2 instanceof sass.types.Number)) { + * throw new Error("$arg2: Expected a number"); + * } + * done(new sass.types.Number(arg1.getValue() + arg2.getValue())); + * } + * } + * }, (result, error) => { + * // ... + * }); + * ``` + * + * This is passed one argument for each argument that's declared in the + * signature that's passed to {@link LegacySharedOptions.functions}. If the + * signature [takes arbitrary + * arguments](https://sass-lang.com/documentation/at-rules/function#taking-arbitrary-arguments), + * they're passed as a single argument list in the last argument before the + * callback. + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link CustomFunction} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +export type LegacyAsyncFunction = + | ((this: LegacyPluginThis, done: (result: LegacyValue) => void) => void) + | (( + this: LegacyPluginThis, + arg1: LegacyValue, + done: LegacyAsyncFunctionDone + ) => void) + | (( + this: LegacyPluginThis, + arg1: LegacyValue, + arg2: LegacyValue, + done: LegacyAsyncFunctionDone + ) => void) + | (( + this: LegacyPluginThis, + arg1: LegacyValue, + arg2: LegacyValue, + arg3: LegacyValue, + done: LegacyAsyncFunctionDone + ) => void) + | (( + this: LegacyPluginThis, + arg1: LegacyValue, + arg2: LegacyValue, + arg3: LegacyValue, + arg4: LegacyValue, + done: LegacyAsyncFunctionDone + ) => void) + | (( + this: LegacyPluginThis, + arg1: LegacyValue, + arg2: LegacyValue, + arg3: LegacyValue, + arg4: LegacyValue, + arg5: LegacyValue, + done: LegacyAsyncFunctionDone + ) => void) + | (( + this: LegacyPluginThis, + arg1: LegacyValue, + arg2: LegacyValue, + arg3: LegacyValue, + arg4: LegacyValue, + arg5: LegacyValue, + arg6: LegacyValue, + done: LegacyAsyncFunctionDone + ) => void) + | (( + this: LegacyPluginThis, + ...args: [...LegacyValue[], LegacyAsyncFunctionDone] + ) => void); + +/** + * The function called by a {@link LegacyAsyncFunction} to indicate that it's + * finished. + * + * @param result - If this is a {@link LegacyValue}, that indicates that the + * function call completed successfully. If it's a {@link types.Error}, that + * indicates that the function call failed. + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link CustomFunction} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +export type LegacyAsyncFunctionDone = ( + result: LegacyValue | types.Error +) => void; + +/** + * A callback that implements a custom Sass function. For {@link renderSync}, + * this must be a {@link LegacySyncFunction} which returns its result directly; + * for {@link render}, it may be either a {@link LegacySyncFunction} or a {@link + * LegacyAsyncFunction} which calls a callback with its result. + * + * See {@link LegacySharedOptions.functions} for more details. + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link CustomFunction} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +export type LegacyFunction = sync extends 'async' + ? LegacySyncFunction | LegacyAsyncFunction + : LegacySyncFunction; + +/** + * A type representing all the possible values that may be passed to or returned + * from a {@link LegacyFunction}. + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link Value} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +export type LegacyValue = + | types.Null + | types.Number + | types.String + | types.Boolean + | types.Color + | types.List + | types.Map; + +/** + * A shorthand for `sass.types.Boolean.TRUE`. + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link sassTrue} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +export const TRUE: types.Boolean; + +/** + * A shorthand for `sass.types.Boolean.FALSE`. + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link sassFalse} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +export const FALSE: types.Boolean; + +/** + * A shorthand for `sass.types.Null.NULL`. + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link sassNull} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +export const NULL: types.Null; + +/** + * The namespace for value types used in the legacy function API. + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link Value} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +export namespace types { + /** + * The class for Sass's singleton [`null` + * value](https://sass-lang.com/documentation/values/null). The value itself + * can be accessed through the {@link NULL} field. + */ + export class Null { + /** Sass's singleton `null` value. */ + static readonly NULL: Null; + } + + /** + * Sass's [number type](https://sass-lang.com/documentation/values/numbers). + */ + export class Number { + /** + * @param value - The numeric value of the number. + * + * @param unit - If passed, the number's unit. + * + * Complex units can be represented as + * `**.../**...`, with numerator units on the + * left-hand side of the `/` and denominator units on the right. A number + * with only numerator units may omit the `/` and the units after it, and a + * number with only denominator units may be represented + * with no units before the `/`. + * + * @example + * + * ```scss + * new sass.types.Number(0.5); // == 0.5 + * new sass.types.Number(10, "px"); // == 10px + * new sass.types.Number(10, "px*px"); // == 10px * 1px + * new sass.types.Number(10, "px/s"); // == math.div(10px, 1s) + * new sass.types.Number(10, "px*px/s*s"); // == 10px * math.div(math.div(1px, 1s), 1s) + * ``` + */ + constructor(value: number, unit?: string); + + /** + * Returns the value of the number, ignoring units. + * + * **Heads up!** This means that `96px` and `1in` will return different + * values, even though they represent the same length. + * + * @example + * + * ```js + * const number = new sass.types.Number(10, "px"); + * number.getValue(); // 10 + * ``` + */ + getValue(): number; + + /** + * Destructively modifies this number by setting its numeric value to + * `value`, independent of its units. + * + * @deprecated Use {@link constructor} instead. + */ + setValue(value: number): void; + + /** + * Returns a string representation of this number's units. Complex units are + * returned in the same format that {@link constructor} accepts them. + * + * @example + * + * ```js + * // number is `10px`. + * number.getUnit(); // "px" + * + * // number is `math.div(10px, 1s)`. + * number.getUnit(); // "px/s" + * ``` + */ + getUnit(): string; + + /** + * Destructively modifies this number by setting its units to `unit`, + * independent of its numeric value. Complex units are specified in the same + * format as {@link constructor}. + * + * @deprecated Use {@link constructor} instead. + */ + setUnit(unit: string): void; + } + + /** + * Sass's [string type](https://sass-lang.com/documentation/values/strings). + * + * **Heads up!** This API currently provides no way of distinguishing between + * a [quoted](https://sass-lang.com/documentation/values/strings#quoted) and + * [unquoted](https://sass-lang.com/documentation/values/strings#unquoted) + * string. + */ + export class String { + /** + * Creates an unquoted string with the given contents. + * + * **Heads up!** This API currently provides no way of creating a + * [quoted](https://sass-lang.com/documentation/values/strings#quoted) + * string. + */ + constructor(value: string); + + /** + * Returns the contents of the string. If the string contains escapes, + * those escapes are included literally if it’s + * [unquoted](https://sass-lang.com/documentation/values/strings#unquoted), + * while the values of the escapes are included if it’s + * [quoted](https://sass-lang.com/documentation/values/strings#quoted). + * + * @example + * + * ``` + * // string is `Arial`. + * string.getValue(); // "Arial" + * + * // string is `"Helvetica Neue"`. + * string.getValue(); // "Helvetica Neue" + * + * // string is `\1F46D`. + * string.getValue(); // "\\1F46D" + * + * // string is `"\1F46D"`. + * string.getValue(); // "👭" + * ``` + */ + getValue(): string; + + /** + * Destructively modifies this string by setting its numeric value to + * `value`. + * + * **Heads up!** Even if the string was originally quoted, this will cause + * it to become unquoted. + * + * @deprecated Use {@link constructor} instead. + */ + setValue(value: string): void; + } + + /** + * Sass's [boolean type](https://sass-lang.com/documentation/values/booleans). + * + * Custom functions should respect Sass’s notion of + * [truthiness](https://sass-lang.com/documentation/at-rules/control/if#truthiness-and-falsiness) + * by treating `false` and `null` as falsey and everything else as truthy. + * + * **Heads up!** Boolean values can't be constructed, they can only be + * accessed through the {@link TRUE} and {@link FALSE} constants. + */ + export class Boolean { + /** + * Returns `true` if this is Sass's `true` value and `false` if this is + * Sass's `false` value. + * + * @example + * + * ```js + * // boolean is `true`. + * boolean.getValue(); // true + * boolean === sass.types.Boolean.TRUE; // true + * + * // boolean is `false`. + * boolean.getValue(); // false + * boolean === sass.types.Boolean.FALSE; // true + * ``` + */ + getValue(): T; + + /** Sass's `true` value. */ + static readonly TRUE: Boolean; + + /** Sass's `false` value. */ + static readonly FALSE: Boolean; + } + + /** + * Sass's [color type](https://sass-lang.com/documentation/values/colors). + */ + export class Color { + /** + * Creates a new Sass color with the given red, green, blue, and alpha + * channels. The red, green, and blue channels must be integers between 0 + * and 255 (inclusive), and alpha must be between 0 and 1 (inclusive). + * + * @example + * + * ```js + * new sass.types.Color(107, 113, 127); // #6b717f + * new sass.types.Color(0, 0, 0, 0); // rgba(0, 0, 0, 0) + * ``` + */ + constructor(r: number, g: number, b: number, a?: number); + + /** + * Creates a new Sass color with alpha, red, green, and blue channels taken + * from respective two-byte chunks of a hexidecimal number. + * + * @example + * + * ```js + * new sass.types.Color(0xff6b717f); // #6b717f + * new sass.types.Color(0x00000000); // rgba(0, 0, 0, 0) + * ``` + */ + constructor(argb: number); + + /** + * Returns the red channel of the color as an integer from 0 to 255. + * + * @example + * + * ```js + * // color is `#6b717f`. + * color.getR(); // 107 + * + * // color is `#b37399`. + * color.getR(); // 179 + * ``` + */ + getR(): number; + + /** + * Sets the red channel of the color. The value must be an integer between 0 + * and 255 (inclusive). + * + * @deprecated Use {@link constructor} instead. + */ + setR(value: number): void; + + /** + * Returns the green channel of the color as an integer from 0 to 255. + * + * @example + * + * ```js + * // color is `#6b717f`. + * color.getG(); // 113 + * + * // color is `#b37399`. + * color.getG(); // 115 + * ``` + */ + getG(): number; + + /** + * Sets the green channel of the color. The value must be an integer between + * 0 and 255 (inclusive). + * + * @deprecated Use {@link constructor} instead. + */ + setG(value: number): void; + + /** + * Returns the blue channel of the color as an integer from 0 to 255. + * + * @example + * + * ```js + * // color is `#6b717f`. + * color.getB(); // 127 + * + * // color is `#b37399`. + * color.getB(); // 153 + * ``` + */ + getB(): number; + + /** + * Sets the blue channel of the color. The value must be an integer between + * 0 and 255 (inclusive). + * + * @deprecated Use {@link constructor} instead. + */ + setB(value: number): void; + + /** + * Returns the alpha channel of the color as a number from 0 to 1. + * + * @example + * + * ```js + * // color is `#6b717f`. + * color.getA(); // 1 + * + * // color is `transparent`. + * color.getA(); // 0 + * ``` + */ + getA(): number; + + /** + * Sets the alpha channel of the color. The value must be between 0 and 1 + * (inclusive). + * + * @deprecated Use {@link constructor} instead. + */ + setA(value: number): void; + } + + /** + * Sass's [list type](https://sass-lang.com/documentation/values/lists). + * + * **Heads up!** This list type’s methods use 0-based indexing, even though + * within Sass lists use 1-based indexing. These methods also don’t support + * using negative numbers to index backwards from the end of the list. + */ + export class List { + /** + * Creates a new Sass list. + * + * **Heads up!** The initial values of the list elements are undefined. + * These elements must be set using {@link setValue} before accessing them + * or passing the list back to Sass. + * + * @example + * + * ```js + * const list = new sass.types.List(3); + * list.setValue(0, new sass.types.Number(10, "px")); + * list.setValue(1, new sass.types.Number(15, "px")); + * list.setValue(2, new sass.types.Number(32, "px")); + * list; // 10px, 15px, 32px + * ``` + * + * @param length - The number of (initially undefined) elements in the list. + * @param commaSeparator - If `true`, the list is comma-separated; otherwise, + * it's space-separated. Defaults to `true`. + */ + constructor(length: number, commaSeparator?: boolean); + + /** + * Returns the element at `index`, or `undefined` if that value hasn't yet + * been set. + * + * @example + * + * ```js + * // list is `10px, 15px, 32px` + * list.getValue(0); // 10px + * list.getValue(2); // 32px + * ``` + * + * @param index - A (0-based) index into this list. + * @throws `Error` if `index` is less than 0 or greater than or equal to the + * number of elements in this list. + */ + getValue(index: number): LegacyValue | undefined; + + /** + * Sets the element at `index` to `value`. + * + * @example + * + * ```js + * // list is `10px, 15px, 32px` + * list.setValue(1, new sass.types.Number(18, "px")); + * list; // 10px, 18px, 32px + * ``` + * + * @param index - A (0-based) index into this list. + * @throws `Error` if `index` is less than 0 or greater than or equal to the + * number of elements in this list. + */ + setValue(index: number, value: LegacyValue): void; + + /** + * Returns `true` if this list is comma-separated and `false` otherwise. + * + * @example + * + * ```js + * // list is `10px, 15px, 32px` + * list.getSeparator(); // true + * + * // list is `1px solid` + * list.getSeparator(); // false + * ``` + */ + getSeparator(): boolean; + + /** + * Sets whether the list is comma-separated. + * + * @param isComma - `true` to make the list comma-separated, `false` otherwise. + */ + setSeparator(isComma: boolean): void; + + /** + * Returns the number of elements in the list. + * + * @example + * + * ```js + * // list is `10px, 15px, 32px` + * list.getLength(); // 3 + * + * // list is `1px solid` + * list.getLength(); // 2 + * ``` + */ + getLength(): number; + } + + /** + * Sass's [map type](https://sass-lang.com/documentation/values/maps). + * + * **Heads up!** This map type is represented as a list of key-value pairs + * rather than a mapping from keys to values. The only way to find the value + * associated with a given key is to iterate through the map checking for that + * key. Maps created through this API are still forbidden from having duplicate + * keys. + */ + export class Map { + /** + * Creates a new Sass map. + * + * **Heads up!** The initial keys and values of the map are undefined. They + * must be set using {@link setKey} and {@link setValue} before accessing + * them or passing the map back to Sass. + * + * @example + * + * ```js + * const map = new sass.types.Map(2); + * map.setKey(0, new sass.types.String("width")); + * map.setValue(0, new sass.types.Number(300, "px")); + * map.setKey(1, new sass.types.String("height")); + * map.setValue(1, new sass.types.Number(100, "px")); + * map; // (width: 300px, height: 100px) + * ``` + * + * @param length - The number of (initially undefined) key/value pairs in the map. + */ + constructor(length: number); + + /** + * Returns the value in the key/value pair at `index`. + * + * @example + * + * ```js + * // map is `(width: 300px, height: 100px)` + * map.getValue(0); // 300px + * map.getValue(1); // 100px + * ``` + * + * @param index - A (0-based) index of a key/value pair in this map. + * @throws `Error` if `index` is less than 0 or greater than or equal to the + * number of pairs in this map. + */ + getValue(index: number): LegacyValue; + + /** + * Sets the value in the key/value pair at `index` to `value`. + * + * @example + * + * ```js + * // map is `("light": 200, "medium": 400, "bold": 600)` + * map.setValue(1, new sass.types.Number(300)); + * map; // ("light": 200, "medium": 300, "bold": 600) + * ``` + * + * @param index - A (0-based) index of a key/value pair in this map. + * @throws `Error` if `index` is less than 0 or greater than or equal to the + * number of pairs in this map. + */ + setValue(index: number, value: LegacyValue): void; + + /** + * Returns the key in the key/value pair at `index`. + * + * @example + * + * ```js + * // map is `(width: 300px, height: 100px)` + * map.getKey(0); // width + * map.getKey(1); // height + * ``` + * + * @param index - A (0-based) index of a key/value pair in this map. + * @throws `Error` if `index` is less than 0 or greater than or equal to the + * number of pairs in this map. + */ + getKey(index: number): LegacyValue; + + /** + * Sets the value in the key/value pair at `index` to `value`. + * + * @example + * + * ```js + * // map is `("light": 200, "medium": 400, "bold": 600)` + * map.setValue(1, new sass.types.String("lighter")); + * map; // ("lighter": 200, "medium": 300, "bold": 600) + * ``` + * + * @param index - A (0-based) index of a key/value pair in this map. + * @throws `Error` if `index` is less than 0 or greater than or equal to the + * number of pairs in this map. + */ + setKey(index: number, key: LegacyValue): void; + + /** + * Returns the number of key/value pairs in this map. + * + * @example + * + * ```js + * // map is `("light": 200, "medium": 400, "bold": 600)` + * map.getLength(); // 3 + * + * // map is `(width: 300px, height: 100px)` + * map.getLength(); // 2 + * ``` + */ + getLength(): number; + } + + /** + * An error that can be returned from a Sass function to signal that it + * encountered an error. This is the only way to signal an error + * asynchronously from a {@link LegacyAsyncFunction}. + */ + export class Error { + constructor(message: string); + } +} diff --git a/node_modules/sass/types/legacy/importer.d.ts b/node_modules/sass/types/legacy/importer.d.ts new file mode 100644 index 0000000..4b7777a --- /dev/null +++ b/node_modules/sass/types/legacy/importer.d.ts @@ -0,0 +1,169 @@ +import {LegacyPluginThis} from './plugin_this'; + +/** + * The value of `this` in the context of a {@link LegacyImporter} function. + * + * @category Legacy + * @deprecated This is only used by the legacy {@link render} and {@link + * renderSync} APIs. Use {@link Importer} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +interface LegacyImporterThis extends LegacyPluginThis { + /** + * Whether the importer is being invoked because of a Sass `@import` rule, as + * opposed to a `@use` or `@forward` rule. + * + * This should *only* be used for determining whether or not to load + * [import-only files](https://sass-lang.com/documentation/at-rules/import#import-only-files). + * + * @compatibility dart: "1.33.0", node: false + */ + fromImport: boolean; +} + +/** + * The result of running a {@link LegacyImporter}. It must be one of the + * following types: + * + * * An object with the key `contents` whose value is the contents of a stylesheet + * (in SCSS syntax). This causes Sass to load that stylesheet’s contents. + * + * * An object with the key `file` whose value is a path on disk. This causes Sass + * to load that file as though it had been imported directly. + * + * * `null`, which indicates that it doesn’t recognize the URL and another + * importer should be tried instead. + * + * * An [Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) + * object, indicating that importing failed. + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link ImporterResult} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +export type LegacyImporterResult = + | {file: string} + | {contents: string} + | Error + | null; + +/** + * A synchronous callback that implements custom Sass loading logic for + * [`@import` rules](https://sass-lang.com/documentation/at-rules/import) and + * [`@use` rules](https://sass-lang.com/documentation/at-rules/use). This can be + * passed to {@link LegacySharedOptions.importer} for either {@link render} or + * {@link renderSync}. + * + * See {@link LegacySharedOptions.importer} for more detailed documentation. + * + * ```js + * sass.renderSync({ + * file: "style.scss", + * importer: [ + * function(url, prev) { + * if (url != "big-headers") return null; + * + * return { + * contents: 'h1 { font-size: 40px; }' + * }; + * } + * ] + * }); + * ``` + * + * @param url - The `@use` or `@import` rule’s URL as a string, exactly as it + * appears in the stylesheet. + * + * @param prev - A string identifying the stylesheet that contained the `@use` + * or `@import`. This string’s format depends on how that stylesheet was loaded: + * + * * If the stylesheet was loaded from the filesystem, it’s the absolute path of + * its file. + * * If the stylesheet was loaded from an importer that returned its contents, + * it’s the URL of the `@use` or `@import` rule that loaded it. + * * If the stylesheet came from the data option, it’s the string "stdin". + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link Importer} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +type LegacySyncImporter = ( + this: LegacyImporterThis, + url: string, + prev: string +) => LegacyImporterResult; + +/** + * An asynchronous callback that implements custom Sass loading logic for + * [`@import` rules](https://sass-lang.com/documentation/at-rules/import) and + * [`@use` rules](https://sass-lang.com/documentation/at-rules/use). This can be + * passed to {@link LegacySharedOptions.importer} for either {@link render} or + * {@link renderSync}. + * + * An asynchronous importer must return `undefined`, and then call `done` with + * the result of its {@link LegacyImporterResult} once it's done running. + * + * See {@link LegacySharedOptions.importer} for more detailed documentation. + * + * ```js + * sass.render({ + * file: "style.scss", + * importer: [ + * function(url, prev, done) { + * if (url != "big-headers") done(null); + * + * done({ + * contents: 'h1 { font-size: 40px; }' + * }); + * } + * ] + * }); + * ``` + * + * @param url - The `@use` or `@import` rule’s URL as a string, exactly as it + * appears in the stylesheet. + * + * @param prev - A string identifying the stylesheet that contained the `@use` + * or `@import`. This string’s format depends on how that stylesheet was loaded: + * + * * If the stylesheet was loaded from the filesystem, it’s the absolute path of + * its file. + * * If the stylesheet was loaded from an importer that returned its contents, + * it’s the URL of the `@use` or `@import` rule that loaded it. + * * If the stylesheet came from the data option, it’s the string "stdin". + * + * @param done - The callback to call once the importer has finished running. + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link Importer} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +type LegacyAsyncImporter = ( + this: LegacyImporterThis, + url: string, + prev: string, + done: (result: LegacyImporterResult) => void +) => void; + +/** + * A callback that implements custom Sass loading logic for [`@import` + * rules](https://sass-lang.com/documentation/at-rules/import) and [`@use` + * rules](https://sass-lang.com/documentation/at-rules/use). For {@link + * renderSync}, this must be a {@link LegacySyncImporter} which returns its + * result directly; for {@link render}, it may be either a {@link + * LegacySyncImporter} or a {@link LegacyAsyncImporter} which calls a callback + * with its result. + * + * See {@link LegacySharedOptions.importer} for more details. + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link Importer} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +export type LegacyImporter = sync extends 'async' + ? LegacySyncImporter | LegacyAsyncImporter + : LegacySyncImporter; diff --git a/node_modules/sass/types/legacy/options.d.ts b/node_modules/sass/types/legacy/options.d.ts new file mode 100644 index 0000000..922fd5d --- /dev/null +++ b/node_modules/sass/types/legacy/options.d.ts @@ -0,0 +1,700 @@ +import {DeprecationOrId, Version} from '../deprecations'; +import {Logger} from '../logger'; +import {LegacyImporter} from './importer'; +import {LegacyFunction} from './function'; +import {NodePackageImporter} from '../importer'; + +/** + * Options for {@link render} and {@link renderSync} that are shared between + * {@link LegacyFileOptions} and {@link LegacyStringOptions}. + * + * @typeParam sync - This lets the TypeScript checker verify that {@link + * LegacyAsyncImporter}s and {@link LegacyAsyncFunction}s aren't passed to + * {@link renderSync}. + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link Options} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +export interface LegacySharedOptions { + /** + * This array of strings option provides [load + * paths](https://sass-lang.com/documentation/at-rules/import#load-paths) for + * Sass to look for stylesheets. Earlier load paths will take precedence over + * later ones. + * + * ```js + * sass.renderSync({ + * file: "style.scss", + * includePaths: ["node_modules/bootstrap/dist/css"] + * }); + * ``` + * + * Load paths are also loaded from the `SASS_PATH` environment variable, if + * it’s set. This variable should be a list of paths separated by `;` (on + * Windows) or `:` (on other operating systems). Load paths from the + * `includePaths` option take precedence over load paths from `SASS_PATH`. + * + * ```sh + * $ SASS_PATH=node_modules/bootstrap/dist/css sass style.scss style.css + * ``` + * + * @category Input + * @compatibility feature: "SASS_PATH", dart: "1.15.0", node: "3.9.0" + * + * Earlier versions of Dart Sass and Node Sass didn’t support the `SASS_PATH` + * environment variable. + */ + includePaths?: string[]; + + /** + * Whether the generated CSS should use spaces or tabs for indentation. + * + * ```js + * const result = sass.renderSync({ + * file: "style.scss", + * indentType: "tab", + * indentWidth: 1 + * }); + * + * result.css.toString(); + * // "h1 {\n\tfont-size: 40px;\n}\n" + * ``` + * + * @defaultValue `'space'` + * @category Output + * @compatibility dart: true, node: "3.0.0" + */ + indentType?: 'space' | 'tab'; + + /** + * How many spaces or tabs (depending on {@link indentType}) should be used + * per indentation level in the generated CSS. It must be between 0 and 10 + * (inclusive). + * + * @defaultValue `2` + * @category Output + * @compatibility dart: true, node: "3.0.0" + */ + indentWidth?: number; + + /** + * Which character sequence to use at the end of each line in the generated + * CSS. It can have the following values: + * + * * `'lf'` uses U+000A LINE FEED. + * * `'lfcr'` uses U+000A LINE FEED followed by U+000D CARRIAGE RETURN. + * * `'cr'` uses U+000D CARRIAGE RETURN. + * * `'crlf'` uses U+000D CARRIAGE RETURN followed by U+000A LINE FEED. + * + * @defaultValue `'lf'` + * @category Output + * @compatibility dart: true, node: "3.0.0" + */ + linefeed?: 'cr' | 'crlf' | 'lf' | 'lfcr'; + + /** + * If `true`, Sass won't add a link from the generated CSS to the source map. + * + * ```js + * const result = sass.renderSync({ + * file: "style.scss", + * sourceMap: "out.map", + * omitSourceMapUrl: true + * }) + * console.log(result.css.toString()); + * // h1 { + * // font-size: 40px; + * // } + * ``` + * + * @defaultValue `false` + * @category Source Maps + */ + omitSourceMapUrl?: boolean; + + /** + * The location that Sass expects the generated CSS to be saved to. It’s used + * to determine the URL used to link from the generated CSS to the source map, + * and from the source map to the Sass source files. + * + * **Heads up!** Despite the name, Sass does *not* write the CSS output to + * this file. The caller must do that themselves. + * + * ```js + * result = sass.renderSync({ + * file: "style.scss", + * sourceMap: true, + * outFile: "out.css" + * }) + * console.log(result.css.toString()); + * // h1 { + * // font-size: 40px; + * // } + * // /*# sourceMappingURL=out.css.map * / + * ``` + * + * @category Source Maps + */ + outFile?: string; + + /** + * The output style of the compiled CSS. There are four possible output styles: + * + * * `"expanded"` (the default for Dart Sass) writes each selector and + * declaration on its own line. + * + * * `"compressed"` removes as many extra characters as possible, and writes + * the entire stylesheet on a single line. + * + * * `"nested"` (the default for Node Sass, not supported by Dart Sass) + * indents CSS rules to match the nesting of the Sass source. + * + * * `"compact"` (not supported by Dart Sass) puts each CSS rule on its own single line. + * + * @example + * + * ```js + * const source = ` + * h1 { + * font-size: 40px; + * code { + * font-face: Roboto Mono; + * } + * }`; + * + * let result = sass.renderSync({ + * data: source, + * outputStyle: "expanded" + * }); + * console.log(result.css.toString()); + * // h1 { + * // font-size: 40px; + * // } + * // h1 code { + * // font-face: Roboto Mono; + * // } + * + * result = sass.renderSync({ + * data: source, + * outputStyle: "compressed" + * }); + * console.log(result.css.toString()); + * // h1{font-size:40px}h1 code{font-face:Roboto Mono} + * + * result = sass.renderSync({ + * data: source, + * outputStyle: "nested" + * }); + * console.log(result.css.toString()); + * // h1 { + * // font-size: 40px; } + * // h1 code { + * // font-face: Roboto Mono; } + * + * result = sass.renderSync({ + * data: source, + * outputStyle: "compact" + * }); + * console.log(result.css.toString()); + * // h1 { font-size: 40px; } + * // h1 code { font-face: Roboto Mono; } + * ``` + * + * @category Output + */ + outputStyle?: 'compressed' | 'expanded' | 'nested' | 'compact'; + + /** + * Whether or not Sass should generate a source map. If it does, the source + * map will be available as {@link LegacyResult.map} (unless {@link + * sourceMapEmbed} is `true`). + * + * If this option is a string, it’s the path that the source map is expected + * to be written to, which is used to link to the source map from the + * generated CSS and to link *from* the source map to the Sass source files. + * Note that if `sourceMap` is a string and {@link outFile} isn’t passed, Sass + * assumes that the CSS will be written to the same directory as the file + * option if it’s passed. + * + * If this option is `true`, the path is assumed to be {@link outFile} with + * `.map` added to the end. If it’s `true` and {@link outFile} isn’t passed, + * it has no effect. + * + * @example + * + * ```js + * let result = sass.renderSync({ + * file: "style.scss", + * sourceMap: "out.map" + * }) + * console.log(result.css.toString()); + * // h1 { + * // font-size: 40px; + * // } + * // /*# sourceMappingURL=out.map * / + * + * result = sass.renderSync({ + * file: "style.scss", + * sourceMap: true, + * outFile: "out.css" + * }) + * console.log(result.css.toString()); + * // h1 { + * // font-size: 40px; + * // } + * // /*# sourceMappingURL=out.css.map * / + * ``` + * + * @defaultValue `false` + * @category Source Maps + */ + sourceMap?: boolean | string; + + /** + * Whether to embed the entire contents of the Sass files that contributed to + * the generated CSS in the source map. This may produce very large source + * maps, but it guarantees that the source will be available on any computer + * no matter how the CSS is served. + * + * @example + * + * ```js + * sass.renderSync({ + * file: "style.scss", + * sourceMap: "out.map", + * sourceMapContents: true + * }) + * ``` + * + * @defaultValue `false` + * @category Source Maps + */ + sourceMapContents?: boolean; + + /** + * Whether to embed the contents of the source map file in the generated CSS, + * rather than creating a separate file and linking to it from the CSS. + * + * @example + * + * ```js + * sass.renderSync({ + * file: "style.scss", + * sourceMap: "out.map", + * sourceMapEmbed: true + * }); + * ``` + * + * @defaultValue `false` + * @category Source Maps + */ + sourceMapEmbed?: boolean; + + /** + * If this is passed, it's prepended to all the links from the source map to + * the Sass source files. + * + * @category Source Maps + */ + sourceMapRoot?: string; + + /** + * Additional handler(s) for loading files when a [`@use` + * rule](https://sass-lang.com/documentation/at-rules/use) or an [`@import` + * rule](https://sass-lang.com/documentation/at-rules/import) is encountered. + * It can either be a single {@link LegacyImporter} function, or an array of + * {@link LegacyImporter}s. + * + * Importers take the URL of the `@import` or `@use` rule and return a {@link + * LegacyImporterResult} indicating how to handle that rule. For more details, + * see {@link LegacySyncImporter} and {@link LegacyAsyncImporter}. + * + * Loads are resolved by trying, in order: + * + * * Loading a file from disk relative to the file in which the `@use` or + * `@import` appeared. + * + * * Each custom importer. + * + * * Loading a file relative to the current working directory. + * + * * Each load path in {@link includePaths}. + * + * * Each load path specified in the `SASS_PATH` environment variable, which + * should be semicolon-separated on Windows and colon-separated elsewhere. + * + * @example + * + * ```js + * sass.render({ + * file: "style.scss", + * importer: [ + * // This importer uses the synchronous API, and can be passed to either + * // renderSync() or render(). + * function(url, prev) { + * // This generates a stylesheet from scratch for `@use "big-headers"`. + * if (url != "big-headers") return null; + * + * return { + * contents: ` + * h1 { + * font-size: 40px; + * }` + * }; + * }, + * + * // This importer uses the asynchronous API, and can only be passed to + * // render(). + * function(url, prev, done) { + * // Convert `@use "foo/bar"` to "node_modules/foo/sass/bar". + * const components = url.split('/'); + * const innerPath = components.slice(1).join('/'); + * done({ + * file: `node_modules/${components.first}/sass/${innerPath}` + * }); + * } + * ] + * }, function(err, result) { + * // ... + * }); + * ``` + * + * @category Plugins + * @compatibility dart: true, node: "3.0.0" + * + * Versions of Node Sass before 3.0.0 don’t support arrays of importers, nor + * do they support importers that return `Error` objects. + * + * Versions of Node Sass before 2.0.0 don’t support the `importer` option at + * all. + * + * @compatibility feature: "Import order", dart: "1.20.2", node: false + * + * Versions of Dart Sass before 1.20.2 preferred resolving imports using + * {@link includePaths} before resolving them using custom importers. + * + * All versions of Node Sass currently pass imports to importers before + * loading them relative to the file in which the `@import` appears. This + * behavior is considered incorrect and should not be relied on because it + * violates the principle of *locality*, which says that it should be possible + * to reason about a stylesheet without knowing everything about how the + * entire system is set up. If a user tries to import a stylesheet relative to + * another stylesheet, that import should *always* work. It shouldn’t be + * possible for some configuration somewhere else to break it. + */ + importer?: LegacyImporter | LegacyImporter[]; + + /** + * Additional built-in Sass functions that are available in all stylesheets. + * This option takes an object whose keys are Sass function signatures and + * whose values are {@link LegacyFunction}s. Each function should take the + * same arguments as its signature. + * + * Functions are passed subclasses of {@link LegacyValue}, and must return the + * same. + * + * **Heads up!** When writing custom functions, it’s important to ensure that + * all the arguments are the types you expect. Otherwise, users’ stylesheets + * could crash in hard-to-debug ways or, worse, compile to meaningless CSS. + * + * @example + * + * ```js + * sass.render({ + * data: ` + * h1 { + * font-size: pow(2, 5) * 1px; + * }`, + * functions: { + * // This function uses the synchronous API, and can be passed to either + * // renderSync() or render(). + * 'pow($base, $exponent)': function(base, exponent) { + * if (!(base instanceof sass.types.Number)) { + * throw "$base: Expected a number."; + * } else if (base.getUnit()) { + * throw "$base: Expected a unitless number."; + * } + * + * if (!(exponent instanceof sass.types.Number)) { + * throw "$exponent: Expected a number."; + * } else if (exponent.getUnit()) { + * throw "$exponent: Expected a unitless number."; + * } + * + * return new sass.types.Number( + * Math.pow(base.getValue(), exponent.getValue())); + * }, + * + * // This function uses the asynchronous API, and can only be passed to + * // render(). + * 'sqrt($number)': function(number, done) { + * if (!(number instanceof sass.types.Number)) { + * throw "$number: Expected a number."; + * } else if (number.getUnit()) { + * throw "$number: Expected a unitless number."; + * } + * + * done(new sass.types.Number(Math.sqrt(number.getValue()))); + * } + * } + * }, function(err, result) { + * console.log(result.css.toString()); + * // h1 { + * // font-size: 32px; + * // } + * }); + * ``` + * + * @category Plugins + */ + functions?: {[key: string]: LegacyFunction}; + + /** + * By default, if the CSS document contains non-ASCII characters, Sass adds a + * `@charset` declaration (in expanded output mode) or a byte-order mark (in + * compressed mode) to indicate its encoding to browsers or other consumers. + * If `charset` is `false`, these annotations are omitted. + * + * @category Output + * @compatibility dart: "1.39.0", node: false + */ + charset?: boolean; + + /** + * If this option is set to `true`, Sass won’t print warnings that are caused + * by dependencies. A “dependency” is defined as any file that’s loaded + * through {@link includePaths} or {@link importer}. Stylesheets that are + * imported relative to the entrypoint are not considered dependencies. + * + * This is useful for silencing deprecation warnings that you can’t fix on + * your own. However, please also notify your dependencies of the deprecations + * so that they can get fixed as soon as possible! + * + * **Heads up!** If {@link render} or {@link renderSync} is called without + * {@link LegacyFileOptions.file} or {@link LegacyStringOptions.file}, + * all stylesheets it loads will be considered dependencies. Since it + * doesn’t have a path of its own, everything it loads is coming from a load + * path rather than a relative import. + * + * @defaultValue `false` + * @category Messages + * @compatibility dart: "1.35.0", node: false + */ + quietDeps?: boolean; + + /** + * A set of deprecations to treat as fatal. + * + * If a deprecation warning of any provided type is encountered during + * compilation, the compiler will error instead. + * + * If a `Version` is provided, then all deprecations that were active in that + * compiler version will be treated as fatal. + * + * @category Messages + * @compatiblity dart: "1.78.0", node: false + */ + fatalDeprecations?: (DeprecationOrId | Version)[]; + + /** + * A set of future deprecations to opt into early. + * + * Future deprecations passed here will be treated as active by the compiler, + * emitting warnings as necessary. + * + * @category Messages + * @compatiblity dart: "1.78.0", node: false + */ + futureDeprecations?: DeprecationOrId[]; + + /** + * A set of active deprecations to ignore. + * + * If a deprecation warning of any provided type is encountered during + * compilation, the compiler will ignore it instead. + * + * **Heads up!** The deprecated functionality you're depending on will + * eventually break. + * + * @category Messages + * @compatiblity dart: "1.78.0", node: false + */ + silenceDeprecations?: DeprecationOrId[]; + + /** + * By default, Dart Sass will print only five instances of the same + * deprecation warning per compilation to avoid deluging users in console + * noise. If you set `verbose` to `true`, it will instead print every + * deprecation warning it encounters. + * + * @defaultValue `false` + * @category Messages + * @compatibility dart: "1.35.0", node: false + */ + verbose?: boolean; + + /** + * An object to use to handle warnings and/or debug messages from Sass. + * + * By default, Sass emits warnings and debug messages to standard error, but + * if {@link Logger.warn} or {@link Logger.debug} is set, this will invoke + * them instead. + * + * The special value {@link Logger.silent} can be used to easily silence all + * messages. + * + * @category Messages + * @compatibility dart: "1.43.0", node: false + */ + logger?: Logger; + + /** + * If this option is set to an instance of `NodePackageImporter`, Sass will + * use the built-in Node.js package importer to resolve Sass files with a + * `pkg:` URL scheme. Details for library authors and users can be found in + * the {@link NodePackageImporter} documentation. + * + * @example + * ```js + * sass.renderSync({ + * data: '@use "pkg:vuetify";', + * pkgImporter: new sass.NodePackageImporter() + * }); + * ``` + * @category Plugins + * @compatibility dart: "2.0", node: false + */ + pkgImporter?: NodePackageImporter; +} + +/** + * If {@link file} is passed without {@link data}, Sass will load the stylesheet + * at {@link file} and compile it to CSS. + * + * @typeParam sync - This lets the TypeScript checker verify that {@link + * LegacyAsyncImporter}s and {@link LegacyAsyncFunction}s aren't passed to + * {@link renderSync}. + */ +export interface LegacyFileOptions + extends LegacySharedOptions { + /** + * The path to the file for Sass to load and compile. If the file’s extension + * is `.scss`, it will be parsed as SCSS; if it’s `.sass`, it will be parsed + * as the indented syntax; and if it’s `.css`, it will be parsed as plain CSS. + * If it has no extension, it will be parsed as SCSS. + * + * @example + * + * ```js + * sass.renderSync({file: "style.scss"}); + * ``` + * + * @category Input + * @compatibility feature: "Plain CSS files", dart: "1.11.0", node: "partial" + * + * Node Sass and older versions of Dart Sass support loading files with the + * extension `.css`, but contrary to the specification they’re treated as SCSS + * files rather than being parsed as CSS. This behavior has been deprecated + * and should not be relied on. Any files that use Sass features should use + * the `.scss` extension. + * + * All versions of Node Sass and Dart Sass otherwise support the file option + * as described below. + */ + file: string; + + /** + * See {@link LegacyStringOptions.file} for documentation of passing {@link + * file} along with {@link data}. + * + * @category Input + */ + data?: never; +} + +/** + * If {@link data} is passed, Sass will use it as the contents of the stylesheet + * to compile. + * + * @typeParam sync - This lets the TypeScript checker verify that {@link + * LegacyAsyncImporter}s and {@link LegacyAsyncFunction}s aren't passed to + * {@link renderSync}. + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link StringOptions} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +export interface LegacyStringOptions + extends LegacySharedOptions { + /** + * The contents of the stylesheet to compile. Unless {@link file} is passed as + * well, the stylesheet’s URL is set to `"stdin"`. + * + * By default, this stylesheet is parsed as SCSS. This can be controlled using + * {@link indentedSyntax}. + * + * @example + * + * ```js + * sass.renderSync({ + * data: ` + * h1 { + * font-size: 40px; + * }` + * }); + * ``` + * + * @category Input + */ + data: string; + + /** + * If `file` and {@link data} are both passed, `file` is used as the path of + * the stylesheet for error reporting, but {@link data} is used as the + * contents of the stylesheet. In this case, `file`’s extension is not used to + * determine the syntax of the stylesheet. + * + * @category Input + */ + file?: string; + + /** + * This flag controls whether {@link data} is parsed as the indented syntax or + * not. + * + * @example + * + * ```js + * sass.renderSync({ + * data: ` + * h1 + * font-size: 40px`, + * indentedSyntax: true + * }); + * ``` + * + * @defaultValue `false` + * @category Input + */ + indentedSyntax?: boolean; +} + +/** + * Options for {@link render} and {@link renderSync}. This can either be {@link + * LegacyFileOptions} to load a file from disk, or {@link LegacyStringOptions} + * to compile a string of Sass code. + * + * See {@link LegacySharedOptions} for options that are shared across both file + * and string inputs. + * + * @category Legacy + * @deprecated This only works with the legacy {@link render} and {@link + * renderSync} APIs. Use {@link Options} with {@link compile}, {@link + * compileString}, {@link compileAsync}, and {@link compileStringAsync} instead. + */ +export type LegacyOptions = + | LegacyFileOptions + | LegacyStringOptions; diff --git a/node_modules/sass/types/legacy/plugin_this.d.ts b/node_modules/sass/types/legacy/plugin_this.d.ts new file mode 100644 index 0000000..8ccffa7 --- /dev/null +++ b/node_modules/sass/types/legacy/plugin_this.d.ts @@ -0,0 +1,74 @@ +/** + * The value of `this` in the context of a {@link LegacyImporter} or {@link + * LegacyFunction} callback. + * + * @category Legacy + * @deprecated This is only used by the legacy {@link render} and {@link + * renderSync} APIs. Use {@link compile}, {@link compileString}, {@link + * compileAsync}, and {@link compileStringAsync} instead. + */ +export interface LegacyPluginThis { + /** + * A partial representation of the options passed to {@link render} or {@link + * renderSync}. + */ + options: { + /** The same {@link LegacyPluginThis} instance that contains this object. */ + context: LegacyPluginThis; + + /** + * The value passed to {@link LegacyFileOptions.file} or {@link + * LegacyStringOptions.file}. + */ + file?: string; + + /** The value passed to {@link LegacyStringOptions.data}. */ + data?: string; + + /** + * The value passed to {@link LegacySharedOptions.includePaths} separated by + * `";"` on Windows or `":"` on other operating systems. This always + * includes the current working directory as the first entry. + */ + includePaths: string; + + /** Always the number 10. */ + precision: 10; + + /** Always the number 1. */ + style: 1; + + /** 1 if {@link LegacySharedOptions.indentType} was `"tab"`, 0 otherwise. */ + indentType: 1 | 0; + + /** + * The value passed to {@link LegacySharedOptions.indentWidth}, or `2` + * otherwise. + */ + indentWidth: number; + + /** + * The value passed to {@link LegacySharedOptions.linefeed}, or `"\n"` + * otherwise. + */ + linefeed: '\r' | '\r\n' | '\n' | '\n\r'; + + /** A partially-constructed {@link LegacyResult} object. */ + result: { + /** Partial information about the compilation in progress. */ + stats: { + /** + * The number of milliseconds between 1 January 1970 at 00:00:00 UTC and + * the time at which Sass compilation began. + */ + start: number; + + /** + * {@link LegacyFileOptions.file} if it was passed, otherwise the string + * `"data"`. + */ + entry: string; + }; + }; + }; +} diff --git a/node_modules/sass/types/legacy/render.d.ts b/node_modules/sass/types/legacy/render.d.ts new file mode 100644 index 0000000..9f78816 --- /dev/null +++ b/node_modules/sass/types/legacy/render.d.ts @@ -0,0 +1,144 @@ +import {LegacyException} from './exception'; +import {LegacyOptions} from './options'; + +/** + * The object returned by {@link render} and {@link renderSync} after a + * successful compilation. + * + * @category Legacy + * @deprecated This is only used by the legacy {@link render} and {@link + * renderSync} APIs. Use {@link compile}, {@link compileString}, {@link + * compileAsync}, and {@link compileStringAsync} instead. + */ +export interface LegacyResult { + /** + * The compiled CSS. This can be converted to a string by calling + * [Buffer.toString](https://nodejs.org/api/buffer.html#buffer_buf_tostring_encoding_start_end). + * + * @example + * + * ```js + * const result = sass.renderSync({file: "style.scss"}); + * + * console.log(result.css.toString()); + * ``` + */ + css: Buffer; + + /** + * The source map that maps the compiled CSS to the source files from which it + * was generated. This can be converted to a string by calling + * [Buffer.toString](https://nodejs.org/api/buffer.html#buffer_buf_tostring_encoding_start_end). + * + * This is `undefined` unless either + * + * * {@link LegacySharedOptions.sourceMap} is a string; or + * * {@link LegacySharedOptions.sourceMap} is `true` and + * {@link LegacySharedOptions.outFile} is set. + * + * The source map uses absolute [`file:` + * URLs](https://en.wikipedia.org/wiki/File_URI_scheme) to link to the Sass + * source files, except if the source file comes from {@link + * LegacyStringOptions.data} in which case it lists its URL as `"stdin"`. + * + * @example + * + * ```js + * const result = sass.renderSync({ + * file: "style.scss", + * sourceMap: true, + * outFile: "style.css" + * }) + * + * console.log(result.map.toString()); + * ``` + */ + map?: Buffer; + + /** Additional information about the compilation. */ + stats: { + /** + * The absolute path of {@link LegacyFileOptions.file} or {@link + * LegacyStringOptions.file}, or `"data"` if {@link + * LegacyStringOptions.file} wasn't set. + */ + entry: string; + + /** + * The number of milliseconds between 1 January 1970 at 00:00:00 UTC and the + * time at which Sass compilation began. + */ + start: number; + + /** + * The number of milliseconds between 1 January 1970 at 00:00:00 UTC and the + * time at which Sass compilation ended. + */ + end: number; + + /** + * The number of milliseconds it took to compile the Sass file. This is + * always equal to `start` minus `end`. + */ + duration: number; + + /** + * An array of the absolute paths of all Sass files loaded during + * compilation. If a stylesheet was loaded from a {@link LegacyImporter} + * that returned the stylesheet’s contents, the raw string of the `@use` or + * `@import` that loaded that stylesheet included in this array. + */ + includedFiles: string[]; + }; +} + +/** + * This function synchronously compiles a Sass file to CSS. If it succeeds, it + * returns the result, and if it fails it throws an error. + * + * **Heads up!** When using the `sass-embedded` npm package, **{@link render} + * is almost always faster than {@link renderSync}**, due to the overhead of + * emulating synchronous messaging with worker threads and concurrent + * compilations being blocked on main thread. + * + * @example + * + * ```js + * const sass = require('sass'); // or require('node-sass'); + * + * const result = sass.renderSync({file: "style.scss"}); + * // ... + * ``` + * + * @category Legacy + * @deprecated Use {@link compile} or {@link compileString} instead. + */ +export function renderSync(options: LegacyOptions<'sync'>): LegacyResult; + +/** + + * This function asynchronously compiles a Sass file to CSS, and calls + * `callback` with a {@link LegacyResult} if compilation succeeds or {@link + * LegacyException} if it fails. + * + * **Heads up!** When using the `sass` npm package, **{@link renderSync} is + * almost twice as fast as {@link render}** by default, due to the overhead of + * making the entire evaluation process asynchronous. + * + * ```js + * const sass = require('sass'); // or require('node-sass'); + * + * sass.render({ + * file: "style.scss" + * }, function(err, result) { + * // ... + * }); + * ``` + * + * @category Legacy + * @deprecated Use {@link compileAsync} or {@link compileStringAsync} instead. + */ +export function render( + options: LegacyOptions<'async'>, + callback: (exception?: LegacyException, result?: LegacyResult) => void +): void; diff --git a/node_modules/sass/types/logger/index.d.ts b/node_modules/sass/types/logger/index.d.ts new file mode 100644 index 0000000..84ee9c2 --- /dev/null +++ b/node_modules/sass/types/logger/index.d.ts @@ -0,0 +1,115 @@ +import {Deprecation} from '../deprecations'; +import {SourceSpan} from './source_span'; + +export {SourceLocation} from './source_location'; +export {SourceSpan} from './source_span'; + +/** + * The options passed to {@link Logger.warn}. + * + * * `deprecation`: Whether this is a deprecation warning. + * + * * `deprecationType`: The type of deprecation. Only set if `deprecation` is + * true. + * + * * `span`: The location in the Sass source code that generated this warning. + * This may be unset if the warning didn't come from Sass source, for + * example if it's from a deprecated JavaScript option. + * + * * `stack`: The Sass stack trace at the point the warning was issued. This may + * be unset if the warning didn't come from Sass source, for example if it's + * from a deprecated JavaScript option. + * + * @category Logger + */ +export type LoggerWarnOptions = ( + | { + deprecation: true; + deprecationType: Deprecation; + } + | {deprecation: false} +) & { + span?: SourceSpan; + stack?: string; +}; + +/** + * An object that can be passed to {@link LegacySharedOptions.logger} to control + * how Sass emits warnings and debug messages. + * + * @example + * + * ```js + * const fs = require('fs'); + * const sass = require('sass'); + * + * let log = ""; + * sass.renderSync({ + * file: 'input.scss', + * logger: { + * warn(message, options) { + * if (options.span) { + * log += `${span.url}:${span.start.line}:${span.start.column}: ` + + * `${message}\n`; + * } else { + * log += `::: ${message}\n`; + * } + * } + * } + * }); + * + * fs.writeFileSync('log.txt', log); + * ``` + * + * @category Logger + */ +export interface Logger { + /** + * This method is called when Sass emits a warning, whether due to a [`@warn` + * rule](https://sass-lang.com/documentation/at-rules/warn) or a warning + * generated by the Sass compiler. + * + * If this is `undefined`, Sass will print warnings to standard error. + * + * `options` may contain the following fields: + * + * @param message - The warning message. + */ + warn?(message: string, options: LoggerWarnOptions): void; + + /** + * This method is called when Sass emits a debug message due to a [`@debug` + * rule](https://sass-lang.com/documentation/at-rules/debug). + * + * If this is `undefined`, Sass will print debug messages to standard error. + * + * @param message - The debug message. + * @param options.span - The location in the Sass source code that generated this + * debug message. + */ + debug?(message: string, options: {span: SourceSpan}): void; +} + +/** + * A namespace for built-in {@link Logger}s. + * + * @category Logger + * @compatibility dart: "1.43.0", node: false + */ +export namespace Logger { + /** + * A {@link Logger} that silently ignores all warnings and debug messages. + * + * @example + * + * ```js + * const sass = require('sass'); + * + * const result = sass.renderSync({ + * file: 'input.scss', + * logger: sass.Logger.silent, + * }); + * ``` + */ + export const silent: Logger; +} diff --git a/node_modules/sass/types/logger/source_location.d.ts b/node_modules/sass/types/logger/source_location.d.ts new file mode 100644 index 0000000..7192714 --- /dev/null +++ b/node_modules/sass/types/logger/source_location.d.ts @@ -0,0 +1,21 @@ +/** + * A specific location within a source file. + * + * This is always associated with a {@link SourceSpan} which indicates *which* + * file it refers to. + * + * @category Logger + */ +export interface SourceLocation { + /** + * The 0-based index of this location within its source file, in terms of + * UTF-16 code units. + */ + offset: number; + + /** The 0-based line number of this location. */ + line: number; + + /** The 0-based column number of this location. */ + column: number; +} diff --git a/node_modules/sass/types/logger/source_span.d.ts b/node_modules/sass/types/logger/source_span.d.ts new file mode 100644 index 0000000..88eb47f --- /dev/null +++ b/node_modules/sass/types/logger/source_span.d.ts @@ -0,0 +1,34 @@ +import {SourceLocation} from './source_location'; + +/** + * A span of text within a source file. + * + * @category Logger + */ +export interface SourceSpan { + /** The beginning of this span, inclusive. */ + start: SourceLocation; + + /** + * The end of this span, exclusive. + * + * If {@link start} and {@link end} refer to the same location, the span has + * zero length and refers to the point immediately after {@link start} and + * before the next character. + */ + end: SourceLocation; + + /** The canonical URL of the file this span refers to. */ + url?: URL; + + /** The text covered by the span. */ + text: string; + + /** + * Text surrounding the span. + * + * If this is set, it must include only whole lines, and it must include at + * least all line(s) which are partially covered by this span. + */ + context?: string; +} diff --git a/node_modules/sass/types/options.d.ts b/node_modules/sass/types/options.d.ts new file mode 100644 index 0000000..124bdb9 --- /dev/null +++ b/node_modules/sass/types/options.d.ts @@ -0,0 +1,455 @@ +import {DeprecationOrId, Version} from './deprecations'; +import {FileImporter, Importer, NodePackageImporter} from './importer'; +import {Logger} from './logger'; +import {Value} from './value'; +import {PromiseOr} from './util/promise_or'; + +/** + * Syntaxes supported by Sass: + * + * - `'scss'` is the [SCSS + * syntax](https://sass-lang.com/documentation/syntax#scss). + * - `'indented'` is the [indented + * syntax](https://sass-lang.com/documentation/syntax#the-indented-syntax) + * - `'css'` is plain CSS, which is parsed like SCSS but forbids the use of any + * special Sass features. + * + * @category Options + */ +export type Syntax = 'scss' | 'indented' | 'css'; + +/** + * Possible output styles for the compiled CSS: + * + * - `"expanded"` (the default for Dart Sass) writes each selector and + * declaration on its own line. + * + * - `"compressed"` removes as many extra characters as possible, and writes + * the entire stylesheet on a single line. + * + * @category Options + */ +export type OutputStyle = 'expanded' | 'compressed'; + +/** + * A callback that implements a custom Sass function. This can be passed to + * {@link Options.functions}. + * + * ```js + * const result = sass.compile('style.scss', { + * functions: { + * "sum($arg1, $arg2)": (args) => { + * const arg1 = args[0].assertNumber('arg1'); + * const value1 = arg1.value; + * const value2 = args[1].assertNumber('arg2') + * .convertValueToMatch(arg1, 'arg2', 'arg1'); + * return new sass.SassNumber(value1 + value2).coerceToMatch(arg1); + * } + * } + * }); + * ``` + * + * @typeParam sync - A `CustomFunction<'sync'>` must return synchronously, but + * in return it can be passed to {@link compile} and {@link compileString} in + * addition to {@link compileAsync} and {@link compileStringAsync}. + * + * A `CustomFunction<'async'>` may either return synchronously or + * asynchronously, but it can only be used with {@link compileAsync} and {@link + * compileStringAsync}. + * + * @param args - An array of arguments passed by the function's caller. If the + * function takes [arbitrary + * arguments](https://sass-lang.com/documentation/at-rules/function#taking-arbitrary-arguments), + * the last element will be a {@link SassArgumentList}. + * + * @returns The function's result. This may be in the form of a `Promise`, but + * if it is the function may only be passed to {@link compileAsync} and {@link + * compileStringAsync}, not {@link compile} or {@link compileString}. + * + * @throws any - This function may throw an error, which the Sass compiler will + * treat as the function call failing. If the exception object has a `message` + * property, it will be used as the wrapped exception's message; otherwise, the + * exception object's `toString()` will be used. This means it's safe for custom + * functions to throw plain strings. + * + * @category Custom Function + */ +export type CustomFunction = ( + args: Value[] +) => PromiseOr; + +/** + * Options that can be passed to {@link compile}, {@link compileAsync}, {@link + * compileString}, or {@link compileStringAsync}. + * + * @typeParam sync - This lets the TypeScript checker verify that asynchronous + * {@link Importer}s, {@link FileImporter}s, and {@link CustomFunction}s aren't + * passed to {@link compile} or {@link compileString}. + * + * @category Options + */ +export interface Options { + /** + * If this is `true`, the compiler will exclusively use ASCII characters in + * its error and warning messages. Otherwise, it may use non-ASCII Unicode + * characters as well. + * + * @defaultValue `false` + * @category Messages + */ + alertAscii?: boolean; + + /** + * If this is `true`, the compiler will use ANSI color escape codes in its + * error and warning messages. If it's `false`, it won't use these. If it's + * undefined, the compiler will determine whether or not to use colors + * depending on whether the user is using an interactive terminal. + * + * @category Messages + */ + alertColor?: boolean; + + /** + * If `true`, the compiler may prepend `@charset "UTF-8";` or U+FEFF + * (byte-order marker) if it outputs non-ASCII CSS. + * + * If `false`, the compiler never emits these byte sequences. This is ideal + * when concatenating or embedding in HTML ` diff --git a/node_modules/uview-ui/components/u-album/props.js b/node_modules/uview-ui/components/u-album/props.js new file mode 100644 index 0000000..75cdb37 --- /dev/null +++ b/node_modules/uview-ui/components/u-album/props.js @@ -0,0 +1,59 @@ +export default { + props: { + // 图片地址，Array|Array形式 + urls: { + type: Array, + default: uni.$u.props.album.urls + }, + // 指定从数组的对象元素中读取哪个属性作为图片地址 + keyName: { + type: String, + default: uni.$u.props.album.keyName + }, + // 单图时，图片长边的长度 + singleSize: { + type: [String, Number], + default: uni.$u.props.album.singleSize + }, + // 多图时，图片边长 + multipleSize: { + type: [String, Number], + default: uni.$u.props.album.multipleSize + }, + // 多图时，图片水平和垂直之间的间隔 + space: { + type: [String, Number], + default: uni.$u.props.album.space + }, + // 单图时，图片缩放裁剪的模式 + singleMode: { + type: String, + default: uni.$u.props.album.singleMode + }, + // 多图时，图片缩放裁剪的模式 + multipleMode: { + type: String, + default: uni.$u.props.album.multipleMode + }, + // 最多展示的图片数量，超出时最后一个位置将会显示剩余图片数量 + maxCount: { + type: [String, Number], + default: uni.$u.props.album.maxCount + }, + // 是否可以预览图片 + previewFullImage: { + type: Boolean, + default: uni.$u.props.album.previewFullImage + }, + // 每行展示图片数量，如设置，singleSize和multipleSize将会无效 + rowCount: { + type: [String, Number], + default: uni.$u.props.album.rowCount + }, + // 超出maxCount时是否显示查看更多的提示 + showMore: { + type: Boolean, + default: uni.$u.props.album.showMore + } + } +} diff --git a/node_modules/uview-ui/components/u-album/u-album.vue b/node_modules/uview-ui/components/u-album/u-album.vue new file mode 100644 index 0000000..687e2d5 --- /dev/null +++ b/node_modules/uview-ui/components/u-album/u-album.vue @@ -0,0 +1,259 @@ + + + + + \ No newline at end of file diff --git a/node_modules/uview-ui/components/u-alert/props.js b/node_modules/uview-ui/components/u-alert/props.js new file mode 100644 index 0000000..4297e2c --- /dev/null +++ b/node_modules/uview-ui/components/u-alert/props.js @@ -0,0 +1,44 @@ +export default { + props: { + // 显示文字 + title: { + type: String, + default: uni.$u.props.alert.title + }, + // 主题，success/warning/info/error + type: { + type: String, + default: uni.$u.props.alert.type + }, + // 辅助性文字 + description: { + type: String, + default: uni.$u.props.alert.description + }, + // 是否可关闭 + closable: { + type: Boolean, + default: uni.$u.props.alert.closable + }, + // 是否显示图标 + showIcon: { + type: Boolean, + default: uni.$u.props.alert.showIcon + }, + // 浅或深色调，light-浅色，dark-深色 + effect: { + type: String, + default: uni.$u.props.alert.effect + }, + // 文字是否居中 + center: { + type: Boolean, + default: uni.$u.props.alert.center + }, + // 字体大小 + fontSize: { + type: [String, Number], + default: uni.$u.props.alert.fontSize + } + } +} diff --git a/node_modules/uview-ui/components/u-alert/u-alert.vue b/node_modules/uview-ui/components/u-alert/u-alert.vue new file mode 100644 index 0000000..81f7d43 --- /dev/null +++ b/node_modules/uview-ui/components/u-alert/u-alert.vue @@ -0,0 +1,243 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-avatar-group/props.js b/node_modules/uview-ui/components/u-avatar-group/props.js new file mode 100644 index 0000000..58b42ac --- /dev/null +++ b/node_modules/uview-ui/components/u-avatar-group/props.js @@ -0,0 +1,52 @@ +export default { + props: { + // 头像图片组 + urls: { + type: Array, + default: uni.$u.props.avatarGroup.urls + }, + // 最多展示的头像数量 + maxCount: { + type: [String, Number], + default: uni.$u.props.avatarGroup.maxCount + }, + // 头像形状 + shape: { + type: String, + default: uni.$u.props.avatarGroup.shape + }, + // 图片裁剪模式 + mode: { + type: String, + default: uni.$u.props.avatarGroup.mode + }, + // 超出maxCount时是否显示查看更多的提示 + showMore: { + type: Boolean, + default: uni.$u.props.avatarGroup.showMore + }, + // 头像大小 + size: { + type: [String, Number], + default: uni.$u.props.avatarGroup.size + }, + // 指定从数组的对象元素中读取哪个属性作为图片地址 + keyName: { + type: String, + default: uni.$u.props.avatarGroup.keyName + }, + // 头像之间的遮挡比例 + gap: { + type: [String, Number], + validator(value) { + return value >= 0 && value <= 1 + }, + default: uni.$u.props.avatarGroup.gap + }, + // 需额外显示的值 + extraValue: { + type: [Number, String], + default: uni.$u.props.avatarGroup.extraValue + } + } +} diff --git a/node_modules/uview-ui/components/u-avatar-group/u-avatar-group.vue b/node_modules/uview-ui/components/u-avatar-group/u-avatar-group.vue new file mode 100644 index 0000000..7e996d7 --- /dev/null +++ b/node_modules/uview-ui/components/u-avatar-group/u-avatar-group.vue @@ -0,0 +1,103 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-avatar/props.js b/node_modules/uview-ui/components/u-avatar/props.js new file mode 100644 index 0000000..34ca0f2 --- /dev/null +++ b/node_modules/uview-ui/components/u-avatar/props.js @@ -0,0 +1,78 @@ +export default { + props: { + // 头像图片路径(不能为相对路径) + src: { + type: String, + default: uni.$u.props.avatar.src + }, + // 头像形状，circle-圆形，square-方形 + shape: { + type: String, + default: uni.$u.props.avatar.shape + }, + // 头像尺寸 + size: { + type: [String, Number], + default: uni.$u.props.avatar.size + }, + // 裁剪模式 + mode: { + type: String, + default: uni.$u.props.avatar.mode + }, + // 显示的文字 + text: { + type: String, + default: uni.$u.props.avatar.text + }, + // 背景色 + bgColor: { + type: String, + default: uni.$u.props.avatar.bgColor + }, + // 文字颜色 + color: { + type: String, + default: uni.$u.props.avatar.color + }, + // 文字大小 + fontSize: { + type: [String, Number], + default: uni.$u.props.avatar.fontSize + }, + // 显示的图标 + icon: { + type: String, + default: uni.$u.props.avatar.icon + }, + // 显示小程序头像，只对百度，微信，QQ小程序有效 + mpAvatar: { + type: Boolean, + default: uni.$u.props.avatar.mpAvatar + }, + // 是否使用随机背景色 + randomBgColor: { + type: Boolean, + default: uni.$u.props.avatar.randomBgColor + }, + // 加载失败的默认头像(组件有内置默认图片) + defaultUrl: { + type: String, + default: uni.$u.props.avatar.defaultUrl + }, + // 如果配置了randomBgColor为true，且配置了此值，则从默认的背景色数组中取出对应索引的颜色值，取值0-19之间 + colorIndex: { + type: [String, Number], + // 校验参数规则，索引在0-19之间 + validator(n) { + return uni.$u.test.range(n, [0, 19]) || n === '' + }, + default: uni.$u.props.avatar.colorIndex + }, + // 组件标识符 + name: { + type: String, + default: uni.$u.props.avatar.name + } + } +} diff --git a/node_modules/uview-ui/components/u-avatar/u-avatar.vue b/node_modules/uview-ui/components/u-avatar/u-avatar.vue new file mode 100644 index 0000000..d38d8a6 --- /dev/null +++ b/node_modules/uview-ui/components/u-avatar/u-avatar.vue @@ -0,0 +1,173 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-back-top/props.js b/node_modules/uview-ui/components/u-back-top/props.js new file mode 100644 index 0000000..6c702c2 --- /dev/null +++ b/node_modules/uview-ui/components/u-back-top/props.js @@ -0,0 +1,54 @@ +export default { + props: { + // 返回顶部的形状，circle-圆形，square-方形 + mode: { + type: String, + default: uni.$u.props.backtop.mode + }, + // 自定义图标 + icon: { + type: String, + default: uni.$u.props.backtop.icon + }, + // 提示文字 + text: { + type: String, + default: uni.$u.props.backtop.text + }, + // 返回顶部滚动时间 + duration: { + type: [String, Number], + default: uni.$u.props.backtop.duration + }, + // 滚动距离 + scrollTop: { + type: [String, Number], + default: uni.$u.props.backtop.scrollTop + }, + // 距离顶部多少距离显示，单位px + top: { + type: [String, Number], + default: uni.$u.props.backtop.top + }, + // 返回顶部按钮到底部的距离，单位px + bottom: { + type: [String, Number], + default: uni.$u.props.backtop.bottom + }, + // 返回顶部按钮到右边的距离，单位px + right: { + type: [String, Number], + default: uni.$u.props.backtop.right + }, + // 层级 + zIndex: { + type: [String, Number], + default: uni.$u.props.backtop.zIndex + }, + // 图标的样式，对象形式 + iconStyle: { + type: Object, + default: uni.$u.props.backtop.iconStyle + } + } +} diff --git a/node_modules/uview-ui/components/u-back-top/u-back-top.vue b/node_modules/uview-ui/components/u-back-top/u-back-top.vue new file mode 100644 index 0000000..2d07566 --- /dev/null +++ b/node_modules/uview-ui/components/u-back-top/u-back-top.vue @@ -0,0 +1,129 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-badge/props.js b/node_modules/uview-ui/components/u-badge/props.js new file mode 100644 index 0000000..74c032c --- /dev/null +++ b/node_modules/uview-ui/components/u-badge/props.js @@ -0,0 +1,72 @@ +export default { + props: { + // 是否显示圆点 + isDot: { + type: Boolean, + default: uni.$u.props.badge.isDot + }, + // 显示的内容 + value: { + type: [Number, String], + default: uni.$u.props.badge.value + }, + // 是否显示 + show: { + type: Boolean, + default: uni.$u.props.badge.show + }, + // 最大值，超过最大值会显示 '{max}+' + max: { + type: [Number, String], + default: uni.$u.props.badge.max + }, + // 主题类型，error|warning|success|primary + type: { + type: String, + default: uni.$u.props.badge.type + }, + // 当数值为 0 时，是否展示 Badge + showZero: { + type: Boolean, + default: uni.$u.props.badge.showZero + }, + // 背景颜色，优先级比type高，如设置，type参数会失效 + bgColor: { + type: [String, null], + default: uni.$u.props.badge.bgColor + }, + // 字体颜色 + color: { + type: [String, null], + default: uni.$u.props.badge.color + }, + // 徽标形状，circle-四角均为圆角，horn-左下角为直角 + shape: { + type: String, + default: uni.$u.props.badge.shape + }, + // 设置数字的显示方式，overflow|ellipsis|limit + // overflow会根据max字段判断，超出显示`${max}+` + // ellipsis会根据max判断，超出显示`${max}...` + // limit会依据1000作为判断条件，超出1000，显示`${value/1000}K`，比如2.2k、3.34w，最多保留2位小数 + numberType: { + type: String, + default: uni.$u.props.badge.numberType + }, + // 设置badge的位置偏移，格式为 [x, y]，也即设置的为top和right的值，absolute为true时有效 + offset: { + type: Array, + default: uni.$u.props.badge.offset + }, + // 是否反转背景和字体颜色 + inverted: { + type: Boolean, + default: uni.$u.props.badge.inverted + }, + // 是否绝对定位 + absolute: { + type: Boolean, + default: uni.$u.props.badge.absolute + } + } +} diff --git a/node_modules/uview-ui/components/u-badge/u-badge.vue b/node_modules/uview-ui/components/u-badge/u-badge.vue new file mode 100644 index 0000000..53cfc81 --- /dev/null +++ b/node_modules/uview-ui/components/u-badge/u-badge.vue @@ -0,0 +1,171 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-button/nvue.scss b/node_modules/uview-ui/components/u-button/nvue.scss new file mode 100644 index 0000000..490db7d --- /dev/null +++ b/node_modules/uview-ui/components/u-button/nvue.scss @@ -0,0 +1,46 @@ +$u-button-active-opacity:0.75 !default; +$u-button-loading-text-margin-left:4px !default; +$u-button-text-color: #FFFFFF !default; +$u-button-text-plain-error-color:$u-error !default; +$u-button-text-plain-warning-color:$u-warning !default; +$u-button-text-plain-success-color:$u-success !default; +$u-button-text-plain-info-color:$u-info !default; +$u-button-text-plain-primary-color:$u-primary !default; +.u-button { + &--active { + opacity: $u-button-active-opacity; + } + + &--active--plain { + background-color: rgb(217, 217, 217); + } + + &__loading-text { + margin-left:$u-button-loading-text-margin-left; + } + + &__text, + &__loading-text { + color:$u-button-text-color; + } + + &__text--plain--error { + color:$u-button-text-plain-error-color; + } + + &__text--plain--warning { + color:$u-button-text-plain-warning-color; + } + + &__text--plain--success{ + color:$u-button-text-plain-success-color; + } + + &__text--plain--info { + color:$u-button-text-plain-info-color; + } + + &__text--plain--primary { + color:$u-button-text-plain-primary-color; + } +} \ No newline at end of file diff --git a/node_modules/uview-ui/components/u-button/props.js b/node_modules/uview-ui/components/u-button/props.js new file mode 100644 index 0000000..07fd844 --- /dev/null +++ b/node_modules/uview-ui/components/u-button/props.js @@ -0,0 +1,161 @@ +/* + * @Author : LQ + * @Description : + * @version : 1.0 + * @Date : 2021-08-16 10:04:04 + * @LastAuthor : LQ + * @lastTime : 2021-08-16 10:04:24 + * @FilePath : /u-view2.0/uview-ui/components/u-button/props.js + */ +export default { + props: { + // 是否细边框 + hairline: { + type: Boolean, + default: uni.$u.props.button.hairline + }, + // 按钮的预置样式，info，primary，error，warning，success + type: { + type: String, + default: uni.$u.props.button.type + }, + // 按钮尺寸，large，normal，small，mini + size: { + type: String, + default: uni.$u.props.button.size + }, + // 按钮形状，circle（两边为半圆），square（带圆角） + shape: { + type: String, + default: uni.$u.props.button.shape + }, + // 按钮是否镂空 + plain: { + type: Boolean, + default: uni.$u.props.button.plain + }, + // 是否禁止状态 + disabled: { + type: Boolean, + default: uni.$u.props.button.disabled + }, + // 是否加载中 + loading: { + type: Boolean, + default: uni.$u.props.button.loading + }, + // 加载中提示文字 + loadingText: { + type: [String, Number], + default: uni.$u.props.button.loadingText + }, + // 加载状态图标类型 + loadingMode: { + type: String, + default: uni.$u.props.button.loadingMode + }, + // 加载图标大小 + loadingSize: { + type: [String, Number], + default: uni.$u.props.button.loadingSize + }, + // 开放能力，具体请看uniapp稳定关于button组件部分说明 + // https://uniapp.dcloud.io/component/button + openType: { + type: String, + default: uni.$u.props.button.openType + }, + // 用于
组件，点击分别会触发 组件的 submit/reset 事件 + // 取值为submit（提交表单），reset（重置表单） + formType: { + type: String, + default: uni.$u.props.button.formType + }, + // 打开 APP 时，向 APP 传递的参数，open-type=launchApp时有效 + // 只微信小程序、QQ小程序有效 + appParameter: { + type: String, + default: uni.$u.props.button.appParameter + }, + // 指定是否阻止本节点的祖先节点出现点击态，微信小程序有效 + hoverStopPropagation: { + type: Boolean, + default: uni.$u.props.button.hoverStopPropagation + }, + // 指定返回用户信息的语言，zh_CN 简体中文，zh_TW 繁体中文，en 英文。只微信小程序有效 + lang: { + type: String, + default: uni.$u.props.button.lang + }, + // 会话来源，open-type="contact"时有效。只微信小程序有效 + sessionFrom: { + type: String, + default: uni.$u.props.button.sessionFrom + }, + // 会话内消息卡片标题，open-type="contact"时有效 + // 默认当前标题，只微信小程序有效 + sendMessageTitle: { + type: String, + default: uni.$u.props.button.sendMessageTitle + }, + // 会话内消息卡片点击跳转小程序路径，open-type="contact"时有效 + // 默认当前分享路径，只微信小程序有效 + sendMessagePath: { + type: String, + default: uni.$u.props.button.sendMessagePath + }, + // 会话内消息卡片图片，open-type="contact"时有效 + // 默认当前页面截图，只微信小程序有效 + sendMessageImg: { + type: String, + default: uni.$u.props.button.sendMessageImg + }, + // 是否显示会话内消息卡片，设置此参数为 true，用户进入客服会话会在右下角显示"可能要发送的小程序"提示， + // 用户点击后可以快速发送小程序消息，open-type="contact"时有效 + showMessageCard: { + type: Boolean, + default: uni.$u.props.button.showMessageCard + }, + // 额外传参参数，用于小程序的data-xxx属性，通过target.dataset.name获取 + dataName: { + type: String, + default: uni.$u.props.button.dataName + }, + // 节流，一定时间内只能触发一次 + throttleTime: { + type: [String, Number], + default: uni.$u.props.button.throttleTime + }, + // 按住后多久出现点击态，单位毫秒 + hoverStartTime: { + type: [String, Number], + default: uni.$u.props.button.hoverStartTime + }, + // 手指松开后点击态保留时间，单位毫秒 + hoverStayTime: { + type: [String, Number], + default: uni.$u.props.button.hoverStayTime + }, + // 按钮文字，之所以通过props传入，是因为slot传入的话 + // nvue中无法控制文字的样式 + text: { + type: [String, Number], + default: uni.$u.props.button.text + }, + // 按钮图标 + icon: { + type: String, + default: uni.$u.props.button.icon + }, + // 按钮图标 + iconColor: { + type: String, + default: uni.$u.props.button.icon + }, + // 按钮颜色，支持传入linear-gradient渐变色 + color: { + type: String, + default: uni.$u.props.button.color + } + } +} diff --git a/node_modules/uview-ui/components/u-button/u-button.vue b/node_modules/uview-ui/components/u-button/u-button.vue new file mode 100644 index 0000000..d60f73e --- /dev/null +++ b/node_modules/uview-ui/components/u-button/u-button.vue @@ -0,0 +1,495 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-button/vue.scss b/node_modules/uview-ui/components/u-button/vue.scss new file mode 100644 index 0000000..32019b2 --- /dev/null +++ b/node_modules/uview-ui/components/u-button/vue.scss @@ -0,0 +1,80 @@ +// nvue下hover-class无效 +$u-button-before-top:50% !default; +$u-button-before-left:50% !default; +$u-button-before-width:100% !default; +$u-button-before-height:100% !default; +$u-button-before-transform:translate(-50%, -50%) !default; +$u-button-before-opacity:0 !default; +$u-button-before-background-color:#000 !default; +$u-button-before-border-color:#000 !default; +$u-button-active-before-opacity:.15 !default; +$u-button-icon-margin-left:4px !default; +$u-button-plain-u-button-info-color:$u-info; +$u-button-plain-u-button-success-color:$u-success; +$u-button-plain-u-button-error-color:$u-error; +$u-button-plain-u-button-warning-color:$u-error; + +.u-button { + width: 100%; + + &__text { + white-space: nowrap; + line-height: 1; + } + + &:before { + position: absolute; + top:$u-button-before-top; + left:$u-button-before-left; + width:$u-button-before-width; + height:$u-button-before-height; + border: inherit; + border-radius: inherit; + transform:$u-button-before-transform; + opacity:$u-button-before-opacity; + content: " "; + background-color:$u-button-before-background-color; + border-color:$u-button-before-border-color; + } + + &--active { + &:before { + opacity: .15 + } + } + + &__icon+&__text:not(:empty), + &__loading-text { + margin-left:$u-button-icon-margin-left; + } + + &--plain { + &.u-button--primary { + color: $u-primary; + } + } + + &--plain { + &.u-button--info { + color:$u-button-plain-u-button-info-color; + } + } + + &--plain { + &.u-button--success { + color:$u-button-plain-u-button-success-color; + } + } + + &--plain { + &.u-button--error { + color:$u-button-plain-u-button-error-color; + } + } + + &--plain { + &.u-button--warning { + color:$u-button-plain-u-button-warning-color; + } + } +} diff --git a/node_modules/uview-ui/components/u-calendar/header.vue b/node_modules/uview-ui/components/u-calendar/header.vue new file mode 100644 index 0000000..dc4f7d0 --- /dev/null +++ b/node_modules/uview-ui/components/u-calendar/header.vue @@ -0,0 +1,99 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-calendar/month.vue b/node_modules/uview-ui/components/u-calendar/month.vue new file mode 100644 index 0000000..c20937f --- /dev/null +++ b/node_modules/uview-ui/components/u-calendar/month.vue @@ -0,0 +1,579 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-calendar/props.js b/node_modules/uview-ui/components/u-calendar/props.js new file mode 100644 index 0000000..2ad7bc7 --- /dev/null +++ b/node_modules/uview-ui/components/u-calendar/props.js @@ -0,0 +1,144 @@ +export default { + props: { + // 日历顶部标题 + title: { + type: String, + default: uni.$u.props.calendar.title + }, + // 是否显示标题 + showTitle: { + type: Boolean, + default: uni.$u.props.calendar.showTitle + }, + // 是否显示副标题 + showSubtitle: { + type: Boolean, + default: uni.$u.props.calendar.showSubtitle + }, + // 日期类型选择，single-选择单个日期，multiple-可以选择多个日期，range-选择日期范围 + mode: { + type: String, + default: uni.$u.props.calendar.mode + }, + // mode=range时，第一个日期底部的提示文字 + startText: { + type: String, + default: uni.$u.props.calendar.startText + }, + // mode=range时，最后一个日期底部的提示文字 + endText: { + type: String, + default: uni.$u.props.calendar.endText + }, + // 自定义列表 + customList: { + type: Array, + default: uni.$u.props.calendar.customList + }, + // 主题色，对底部按钮和选中日期有效 + color: { + type: String, + default: uni.$u.props.calendar.color + }, + // 最小的可选日期 + minDate: { + type: [String, Number], + default: uni.$u.props.calendar.minDate + }, + // 最大可选日期 + maxDate: { + type: [String, Number], + default: uni.$u.props.calendar.maxDate + }, + // 默认选中的日期，mode为multiple或range是必须为数组格式 + defaultDate: { + type: [Array, String, Date, null], + default: uni.$u.props.calendar.defaultDate + }, + // mode=multiple时，最多可选多少个日期 + maxCount: { + type: [String, Number], + default: uni.$u.props.calendar.maxCount + }, + // 日期行高 + rowHeight: { + type: [String, Number], + default: uni.$u.props.calendar.rowHeight + }, + // 日期格式化函数 + formatter: { + type: [Function, null], + default: uni.$u.props.calendar.formatter + }, + // 是否显示农历 + showLunar: { + type: Boolean, + default: uni.$u.props.calendar.showLunar + }, + // 是否显示月份背景色 + showMark: { + type: Boolean, + default: uni.$u.props.calendar.showMark + }, + // 确定按钮的文字 + confirmText: { + type: String, + default: uni.$u.props.calendar.confirmText + }, + // 确认按钮处于禁用状态时的文字 + confirmDisabledText: { + type: String, + default: uni.$u.props.calendar.confirmDisabledText + }, + // 是否显示日历弹窗 + show: { + type: Boolean, + default: uni.$u.props.calendar.show + }, + // 是否允许点击遮罩关闭日历 + closeOnClickOverlay: { + type: Boolean, + default: uni.$u.props.calendar.closeOnClickOverlay + }, + // 是否为只读状态，只读状态下禁止选择日期 + readonly: { + type: Boolean, + default: uni.$u.props.calendar.readonly + }, + // 是否展示确认按钮 + showConfirm: { + type: Boolean, + default: uni.$u.props.calendar.showConfirm + }, + // 日期区间最多可选天数，默认无限制，mode = range时有效 + maxRange: { + type: [Number, String], + default: uni.$u.props.calendar.maxRange + }, + // 范围选择超过最多可选天数时的提示文案，mode = range时有效 + rangePrompt: { + type: String, + default: uni.$u.props.calendar.rangePrompt + }, + // 范围选择超过最多可选天数时，是否展示提示文案，mode = range时有效 + showRangePrompt: { + type: Boolean, + default: uni.$u.props.calendar.showRangePrompt + }, + // 是否允许日期范围的起止时间为同一天，mode = range时有效 + allowSameDay: { + type: Boolean, + default: uni.$u.props.calendar.allowSameDay + }, + // 圆角值 + round: { + type: [Boolean, String, Number], + default: uni.$u.props.calendar.round + }, + // 最多展示月份数量 + monthNum: { + type: [Number, String], + default: 3 + } + } +} diff --git a/node_modules/uview-ui/components/u-calendar/u-calendar.vue b/node_modules/uview-ui/components/u-calendar/u-calendar.vue new file mode 100644 index 0000000..511f993 --- /dev/null +++ b/node_modules/uview-ui/components/u-calendar/u-calendar.vue @@ -0,0 +1,384 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-calendar/util.js b/node_modules/uview-ui/components/u-calendar/util.js new file mode 100644 index 0000000..ca4736b --- /dev/null +++ b/node_modules/uview-ui/components/u-calendar/util.js @@ -0,0 +1,85 @@ +export default { + methods: { + // 设置月份数据 + setMonth() { + // 月初是周几 + const day = dayjs(this.date).date(1).day() + const start = day == 0 ? 6 : day - 1 + + // 本月天数 + const days = dayjs(this.date).endOf('month').format('D') + + // 上个月天数 + const prevDays = dayjs(this.date).endOf('month').subtract(1, 'month').format('D') + + // 日期数据 + const arr = [] + // 清空表格 + this.month = [] + + // 添加上月数据 + arr.push( + ...new Array(start).fill(1).map((e, i) => { + const day = prevDays - start + i + 1 + + return { + value: day, + disabled: true, + date: dayjs(this.date).subtract(1, 'month').date(day).format('YYYY-MM-DD') + } + }) + ) + + // 添加本月数据 + arr.push( + ...new Array(days - 0).fill(1).map((e, i) => { + const day = i + 1 + + return { + value: day, + date: dayjs(this.date).date(day).format('YYYY-MM-DD') + } + }) + ) + + // 添加下个月 + arr.push( + ...new Array(42 - days - start).fill(1).map((e, i) => { + const day = i + 1 + + return { + value: day, + disabled: true, + date: dayjs(this.date).add(1, 'month').date(day).format('YYYY-MM-DD') + } + }) + ) + + // 分割数组 + for (let n = 0; n < arr.length; n += 7) { + this.month.push( + arr.slice(n, n + 7).map((e, i) => { + e.index = i + n + + // 自定义信息 + const custom = this.customList.find((c) => c.date == e.date) + + // 农历 + if (this.lunar) { + const { + IDayCn, + IMonthCn + } = this.getLunar(e.date) + e.lunar = IDayCn == '初一' ? IMonthCn : IDayCn + } + + return { + ...e, + ...custom + } + }) + ) + } + } + } +} diff --git a/node_modules/uview-ui/components/u-car-keyboard/props.js b/node_modules/uview-ui/components/u-car-keyboard/props.js new file mode 100644 index 0000000..3553647 --- /dev/null +++ b/node_modules/uview-ui/components/u-car-keyboard/props.js @@ -0,0 +1,14 @@ +export default { + props: { + // 是否打乱键盘按键的顺序 + random: { + type: Boolean, + default: false + }, + // 输入一个中文后，是否自动切换到英文 + autoChange: { + type: Boolean, + default: false + } + } +} diff --git a/node_modules/uview-ui/components/u-car-keyboard/u-car-keyboard.vue b/node_modules/uview-ui/components/u-car-keyboard/u-car-keyboard.vue new file mode 100644 index 0000000..51175b5 --- /dev/null +++ b/node_modules/uview-ui/components/u-car-keyboard/u-car-keyboard.vue @@ -0,0 +1,311 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-cell-group/props.js b/node_modules/uview-ui/components/u-cell-group/props.js new file mode 100644 index 0000000..350ef40 --- /dev/null +++ b/node_modules/uview-ui/components/u-cell-group/props.js @@ -0,0 +1,14 @@ +export default { + props: { + // 分组标题 + title: { + type: String, + default: uni.$u.props.cellGroup.title + }, + // 是否显示外边框 + border: { + type: Boolean, + default: uni.$u.props.cellGroup.border + } + } +} diff --git a/node_modules/uview-ui/components/u-cell-group/u-cell-group.vue b/node_modules/uview-ui/components/u-cell-group/u-cell-group.vue new file mode 100644 index 0000000..a9508c0 --- /dev/null +++ b/node_modules/uview-ui/components/u-cell-group/u-cell-group.vue @@ -0,0 +1,61 @@ + + + + + + diff --git a/node_modules/uview-ui/components/u-cell/props.js b/node_modules/uview-ui/components/u-cell/props.js new file mode 100644 index 0000000..da03330 --- /dev/null +++ b/node_modules/uview-ui/components/u-cell/props.js @@ -0,0 +1,110 @@ +export default { + props: { + // 标题 + title: { + type: [String, Number], + default: uni.$u.props.cell.title + }, + // 标题下方的描述信息 + label: { + type: [String, Number], + default: uni.$u.props.cell.label + }, + // 右侧的内容 + value: { + type: [String, Number], + default: uni.$u.props.cell.value + }, + // 左侧图标名称，或者图片链接(本地文件建议使用绝对地址) + icon: { + type: String, + default: uni.$u.props.cell.icon + }, + // 是否禁用cell + disabled: { + type: Boolean, + default: uni.$u.props.cell.disabled + }, + // 是否显示下边框 + border: { + type: Boolean, + default: uni.$u.props.cell.border + }, + // 内容是否垂直居中(主要是针对右侧的value部分) + center: { + type: Boolean, + default: uni.$u.props.cell.center + }, + // 点击后跳转的URL地址 + url: { + type: String, + default: uni.$u.props.cell.url + }, + // 链接跳转的方式，内部使用的是uView封装的route方法，可能会进行拦截操作 + linkType: { + type: String, + default: uni.$u.props.cell.linkType + }, + // 是否开启点击反馈(表现为点击时加上灰色背景) + clickable: { + type: Boolean, + default: uni.$u.props.cell.clickable + }, + // 是否展示右侧箭头并开启点击反馈 + isLink: { + type: Boolean, + default: uni.$u.props.cell.isLink + }, + // 是否显示表单状态下的必填星号(此组件可能会内嵌入input组件) + required: { + type: Boolean, + default: uni.$u.props.cell.required + }, + // 右侧的图标箭头 + rightIcon: { + type: String, + default: uni.$u.props.cell.rightIcon + }, + // 右侧箭头的方向，可选值为：left，up，down + arrowDirection: { + type: String, + default: uni.$u.props.cell.arrowDirection + }, + // 左侧图标样式 + iconStyle: { + type: [Object, String], + default: () => { + return uni.$u.props.cell.iconStyle + } + }, + // 右侧箭头图标的样式 + rightIconStyle: { + type: [Object, String], + default: () => { + return uni.$u.props.cell.rightIconStyle + } + }, + // 标题的样式 + titleStyle: { + type: [Object, String], + default: () => { + return uni.$u.props.cell.titleStyle + } + }, + // 单位元的大小，可选值为large + size: { + type: String, + default: uni.$u.props.cell.size + }, + // 点击cell是否阻止事件传播 + stop: { + type: Boolean, + default: uni.$u.props.cell.stop + }, + // 标识符，cell被点击时返回 + name: { + type: [Number, String], + default: uni.$u.props.cell.name + } + } +} diff --git a/node_modules/uview-ui/components/u-cell/u-cell.vue b/node_modules/uview-ui/components/u-cell/u-cell.vue new file mode 100644 index 0000000..b099c90 --- /dev/null +++ b/node_modules/uview-ui/components/u-cell/u-cell.vue @@ -0,0 +1,229 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-checkbox-group/props.js b/node_modules/uview-ui/components/u-checkbox-group/props.js new file mode 100644 index 0000000..2f818a1 --- /dev/null +++ b/node_modules/uview-ui/components/u-checkbox-group/props.js @@ -0,0 +1,82 @@ +export default { + props: { + // 标识符 + name: { + type: String, + default: uni.$u.props.checkboxGroup.name + }, + // 绑定的值 + value: { + type: Array, + default: uni.$u.props.checkboxGroup.value + }, + // 形状，circle-圆形，square-方形 + shape: { + type: String, + default: uni.$u.props.checkboxGroup.shape + }, + // 是否禁用全部checkbox + disabled: { + type: Boolean, + default: uni.$u.props.checkboxGroup.disabled + }, + + // 选中状态下的颜色，如设置此值，将会覆盖parent的activeColor值 + activeColor: { + type: String, + default: uni.$u.props.checkboxGroup.activeColor + }, + // 未选中的颜色 + inactiveColor: { + type: String, + default: uni.$u.props.checkboxGroup.inactiveColor + }, + + // 整个组件的尺寸，默认px + size: { + type: [String, Number], + default: uni.$u.props.checkboxGroup.size + }, + // 布局方式，row-横向，column-纵向 + placement: { + type: String, + default: uni.$u.props.checkboxGroup.placement + }, + // label的字体大小，px单位 + labelSize: { + type: [String, Number], + default: uni.$u.props.checkboxGroup.labelSize + }, + // label的字体颜色 + labelColor: { + type: [String], + default: uni.$u.props.checkboxGroup.labelColor + }, + // 是否禁止点击文本操作 + labelDisabled: { + type: Boolean, + default: uni.$u.props.checkboxGroup.labelDisabled + }, + // 图标颜色 + iconColor: { + type: String, + default: uni.$u.props.checkboxGroup.iconColor + }, + // 图标的大小，单位px + iconSize: { + type: [String, Number], + default: uni.$u.props.checkboxGroup.iconSize + }, + // 勾选图标的对齐方式，left-左边，right-右边 + iconPlacement: { + type: String, + default: uni.$u.props.checkboxGroup.iconPlacement + }, + // 竖向配列时，是否显示下划线 + borderBottom: { + type: Boolean, + default: uni.$u.props.checkboxGroup.borderBottom + } + + } +} diff --git a/node_modules/uview-ui/components/u-checkbox-group/u-checkbox-group.vue b/node_modules/uview-ui/components/u-checkbox-group/u-checkbox-group.vue new file mode 100644 index 0000000..7a6b4fa --- /dev/null +++ b/node_modules/uview-ui/components/u-checkbox-group/u-checkbox-group.vue @@ -0,0 +1,103 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-checkbox/props.js b/node_modules/uview-ui/components/u-checkbox/props.js new file mode 100644 index 0000000..93f4fd9 --- /dev/null +++ b/node_modules/uview-ui/components/u-checkbox/props.js @@ -0,0 +1,69 @@ +export default { + props: { + // checkbox的名称 + name: { + type: [String, Number, Boolean], + default: uni.$u.props.checkbox.name + }, + // 形状，square为方形，circle为圆型 + shape: { + type: String, + default: uni.$u.props.checkbox.shape + }, + // 整体的大小 + size: { + type: [String, Number], + default: uni.$u.props.checkbox.size + }, + // 是否默认选中 + checked: { + type: Boolean, + default: uni.$u.props.checkbox.checked + }, + // 是否禁用 + disabled: { + type: [String, Boolean], + default: uni.$u.props.checkbox.disabled + }, + // 选中状态下的颜色，如设置此值，将会覆盖parent的activeColor值 + activeColor: { + type: String, + default: uni.$u.props.checkbox.activeColor + }, + // 未选中的颜色 + inactiveColor: { + type: String, + default: uni.$u.props.checkbox.inactiveColor + }, + // 图标的大小，单位px + iconSize: { + type: [String, Number], + default: uni.$u.props.checkbox.iconSize + }, + // 图标颜色 + iconColor: { + type: String, + default: uni.$u.props.checkbox.iconColor + }, + // label提示文字，因为nvue下，直接slot进来的文字，由于特殊的结构，无法修改样式 + label: { + type: [String, Number], + default: uni.$u.props.checkbox.label + }, + // label的字体大小，px单位 + labelSize: { + type: [String, Number], + default: uni.$u.props.checkbox.labelSize + }, + // label的颜色 + labelColor: { + type: String, + default: uni.$u.props.checkbox.labelColor + }, + // 是否禁止点击提示语选中复选框 + labelDisabled: { + type: [String, Boolean], + default: uni.$u.props.checkbox.labelDisabled + } + } +} diff --git a/node_modules/uview-ui/components/u-checkbox/u-checkbox.vue b/node_modules/uview-ui/components/u-checkbox/u-checkbox.vue new file mode 100644 index 0000000..6429cca --- /dev/null +++ b/node_modules/uview-ui/components/u-checkbox/u-checkbox.vue @@ -0,0 +1,344 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-circle-progress/props.js b/node_modules/uview-ui/components/u-circle-progress/props.js new file mode 100644 index 0000000..d776cfb --- /dev/null +++ b/node_modules/uview-ui/components/u-circle-progress/props.js @@ -0,0 +1,8 @@ +export default { + props: { + percentage: { + type: [String, Number], + default: uni.$u.props.circleProgress.percentage + } + } +} diff --git a/node_modules/uview-ui/components/u-circle-progress/u-circle-progress.vue b/node_modules/uview-ui/components/u-circle-progress/u-circle-progress.vue new file mode 100644 index 0000000..d1ee286 --- /dev/null +++ b/node_modules/uview-ui/components/u-circle-progress/u-circle-progress.vue @@ -0,0 +1,198 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-code-input/props.js b/node_modules/uview-ui/components/u-code-input/props.js new file mode 100644 index 0000000..0f016ee --- /dev/null +++ b/node_modules/uview-ui/components/u-code-input/props.js @@ -0,0 +1,79 @@ +export default { + props: { + // 键盘弹起时，是否自动上推页面 + adjustPosition: { + type: Boolean, + default: uni.$u.props.codeInput.adjustPosition + }, + // 最大输入长度 + maxlength: { + type: [String, Number], + default: uni.$u.props.codeInput.maxlength + }, + // 是否用圆点填充 + dot: { + type: Boolean, + default: uni.$u.props.codeInput.dot + }, + // 显示模式，box-盒子模式，line-底部横线模式 + mode: { + type: String, + default: uni.$u.props.codeInput.mode + }, + // 是否细边框 + hairline: { + type: Boolean, + default: uni.$u.props.codeInput.hairline + }, + // 字符间的距离 + space: { + type: [String, Number], + default: uni.$u.props.codeInput.space + }, + // 预置值 + value: { + type: [String, Number], + default: uni.$u.props.codeInput.value + }, + // 是否自动获取焦点 + focus: { + type: Boolean, + default: uni.$u.props.codeInput.focus + }, + // 字体是否加粗 + bold: { + type: Boolean, + default: uni.$u.props.codeInput.bold + }, + // 字体颜色 + color: { + type: String, + default: uni.$u.props.codeInput.color + }, + // 字体大小 + fontSize: { + type: [String, Number], + default: uni.$u.props.codeInput.fontSize + }, + // 输入框的大小，宽等于高 + size: { + type: [String, Number], + default: uni.$u.props.codeInput.size + }, + // 是否隐藏原生键盘，如果想用自定义键盘的话，需设置此参数为true + disabledKeyboard: { + type: Boolean, + default: uni.$u.props.codeInput.disabledKeyboard + }, + // 边框和线条颜色 + borderColor: { + type: String, + default: uni.$u.props.codeInput.borderColor + }, + // 是否禁止输入"."符号 + disabledDot: { + type: Boolean, + default: uni.$u.props.codeInput.disabledDot + } + } +} diff --git a/node_modules/uview-ui/components/u-code-input/u-code-input.vue b/node_modules/uview-ui/components/u-code-input/u-code-input.vue new file mode 100644 index 0000000..96241cf --- /dev/null +++ b/node_modules/uview-ui/components/u-code-input/u-code-input.vue @@ -0,0 +1,252 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-code/props.js b/node_modules/uview-ui/components/u-code/props.js new file mode 100644 index 0000000..eaf80d0 --- /dev/null +++ b/node_modules/uview-ui/components/u-code/props.js @@ -0,0 +1,34 @@ +export default { + props: { + // 倒计时总秒数 + seconds: { + type: [String, Number], + default: uni.$u.props.code.seconds + }, + // 尚未开始时提示 + startText: { + type: String, + default: uni.$u.props.code.startText + }, + // 正在倒计时中的提示 + changeText: { + type: String, + default: uni.$u.props.code.changeText + }, + // 倒计时结束时的提示 + endText: { + type: String, + default: uni.$u.props.code.endText + }, + // 是否在H5刷新或各端返回再进入时继续倒计时 + keepRunning: { + type: Boolean, + default: uni.$u.props.code.keepRunning + }, + // 为了区分多个页面，或者一个页面多个倒计时组件本地存储的继续倒计时变了 + uniqueKey: { + type: String, + default: uni.$u.props.code.uniqueKey + } + } +} diff --git a/node_modules/uview-ui/components/u-code/u-code.vue b/node_modules/uview-ui/components/u-code/u-code.vue new file mode 100644 index 0000000..f79a09a --- /dev/null +++ b/node_modules/uview-ui/components/u-code/u-code.vue @@ -0,0 +1,129 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-col/props.js b/node_modules/uview-ui/components/u-col/props.js new file mode 100644 index 0000000..0622251 --- /dev/null +++ b/node_modules/uview-ui/components/u-col/props.js @@ -0,0 +1,29 @@ +export default { + props: { + // 占父容器宽度的多少等分，总分为12份 + span: { + type: [String, Number], + default: uni.$u.props.col.span + }, + // 指定栅格左侧的间隔数(总12栏) + offset: { + type: [String, Number], + default: uni.$u.props.col.offset + }, + // 水平排列方式，可选值为`start`(或`flex-start`)、`end`(或`flex-end`)、`center`、`around`(或`space-around`)、`between`(或`space-between`) + justify: { + type: String, + default: uni.$u.props.col.justify + }, + // 垂直对齐方式，可选值为top、center、bottom、stretch + align: { + type: String, + default: uni.$u.props.col.align + }, + // 文字对齐方式 + textAlign: { + type: String, + default: uni.$u.props.col.textAlign + } + } +} diff --git a/node_modules/uview-ui/components/u-col/u-col.vue b/node_modules/uview-ui/components/u-col/u-col.vue new file mode 100644 index 0000000..8be1517 --- /dev/null +++ b/node_modules/uview-ui/components/u-col/u-col.vue @@ -0,0 +1,162 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-collapse-item/props.js b/node_modules/uview-ui/components/u-collapse-item/props.js new file mode 100644 index 0000000..bd5749b --- /dev/null +++ b/node_modules/uview-ui/components/u-collapse-item/props.js @@ -0,0 +1,59 @@ +export default { + props: { + // 标题 + title: { + type: String, + default: uni.$u.props.collapseItem.title + }, + // 标题右侧内容 + value: { + type: String, + default: uni.$u.props.collapseItem.value + }, + // 标题下方的描述信息 + label: { + type: String, + default: uni.$u.props.collapseItem.label + }, + // 是否禁用折叠面板 + disabled: { + type: Boolean, + default: uni.$u.props.collapseItem.disabled + }, + // 是否展示右侧箭头并开启点击反馈 + isLink: { + type: Boolean, + default: uni.$u.props.collapseItem.isLink + }, + // 是否开启点击反馈 + clickable: { + type: Boolean, + default: uni.$u.props.collapseItem.clickable + }, + // 是否显示内边框 + border: { + type: Boolean, + default: uni.$u.props.collapseItem.border + }, + // 标题的对齐方式 + align: { + type: String, + default: uni.$u.props.collapseItem.align + }, + // 唯一标识符 + name: { + type: [String, Number], + default: uni.$u.props.collapseItem.name + }, + // 标题左侧图片，可为绝对路径的图片或内置图标 + icon: { + type: String, + default: uni.$u.props.collapseItem.icon + }, + // 面板展开收起的过渡时间，单位ms + duration: { + type: Number, + default: uni.$u.props.collapseItem.duration + } + } +} diff --git a/node_modules/uview-ui/components/u-collapse-item/u-collapse-item.vue b/node_modules/uview-ui/components/u-collapse-item/u-collapse-item.vue new file mode 100644 index 0000000..0e1b703 --- /dev/null +++ b/node_modules/uview-ui/components/u-collapse-item/u-collapse-item.vue @@ -0,0 +1,225 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-collapse/props.js b/node_modules/uview-ui/components/u-collapse/props.js new file mode 100644 index 0000000..7ee6d31 --- /dev/null +++ b/node_modules/uview-ui/components/u-collapse/props.js @@ -0,0 +1,19 @@ +export default { + props: { + // 当前展开面板的name，非手风琴模式：[]，手风琴模式：string | number + value: { + type: [String, Number, Array, null], + default: uni.$u.props.collapse.value + }, + // 是否手风琴模式 + accordion: { + type: Boolean, + default: uni.$u.props.collapse.accordion + }, + // 是否显示外边框 + border: { + type: Boolean, + default: uni.$u.props.collapse.border + } + } +} diff --git a/node_modules/uview-ui/components/u-collapse/u-collapse.vue b/node_modules/uview-ui/components/u-collapse/u-collapse.vue new file mode 100644 index 0000000..fc188a2 --- /dev/null +++ b/node_modules/uview-ui/components/u-collapse/u-collapse.vue @@ -0,0 +1,90 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-column-notice/props.js b/node_modules/uview-ui/components/u-column-notice/props.js new file mode 100644 index 0000000..4809154 --- /dev/null +++ b/node_modules/uview-ui/components/u-column-notice/props.js @@ -0,0 +1,55 @@ +export default { + props: { + // 显示的内容，字符串 + text: { + type: [Array], + default: uni.$u.props.columnNotice.text + }, + // 是否显示左侧的音量图标 + icon: { + type: String, + default: uni.$u.props.columnNotice.icon + }, + // 通告模式，link-显示右箭头，closable-显示右侧关闭图标 + mode: { + type: String, + default: uni.$u.props.columnNotice.mode + }, + // 文字颜色，各图标也会使用文字颜色 + color: { + type: String, + default: uni.$u.props.columnNotice.color + }, + // 背景颜色 + bgColor: { + type: String, + default: uni.$u.props.columnNotice.bgColor + }, + // 字体大小，单位px + fontSize: { + type: [String, Number], + default: uni.$u.props.columnNotice.fontSize + }, + // 水平滚动时的滚动速度，即每秒滚动多少px(px)，这有利于控制文字无论多少时，都能有一个恒定的速度 + speed: { + type: [String, Number], + default: uni.$u.props.columnNotice.speed + }, + // direction = row时，是否使用步进形式滚动 + step: { + type: Boolean, + default: uni.$u.props.columnNotice.step + }, + // 滚动一个周期的时间长，单位ms + duration: { + type: [String, Number], + default: uni.$u.props.columnNotice.duration + }, + // 是否禁止用手滑动切换 + // 目前HX2.6.11，只支持App 2.5.5+、H5 2.5.5+、支付宝小程序、字节跳动小程序 + disableTouch: { + type: Boolean, + default: uni.$u.props.columnNotice.disableTouch + } + } +} diff --git a/node_modules/uview-ui/components/u-column-notice/u-column-notice.vue b/node_modules/uview-ui/components/u-column-notice/u-column-notice.vue new file mode 100644 index 0000000..fc39532 --- /dev/null +++ b/node_modules/uview-ui/components/u-column-notice/u-column-notice.vue @@ -0,0 +1,160 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-count-down/props.js b/node_modules/uview-ui/components/u-count-down/props.js new file mode 100644 index 0000000..d62f025 --- /dev/null +++ b/node_modules/uview-ui/components/u-count-down/props.js @@ -0,0 +1,24 @@ +export default { + props: { + // 倒计时时长，单位ms + time: { + type: [String, Number], + default: uni.$u.props.countDown.time + }, + // 时间格式，DD-日，HH-时，mm-分，ss-秒，SSS-毫秒 + format: { + type: String, + default: uni.$u.props.countDown.format + }, + // 是否自动开始倒计时 + autoStart: { + type: Boolean, + default: uni.$u.props.countDown.autoStart + }, + // 是否展示毫秒倒计时 + millisecond: { + type: Boolean, + default: uni.$u.props.countDown.millisecond + } + } +} diff --git a/node_modules/uview-ui/components/u-count-down/u-count-down.vue b/node_modules/uview-ui/components/u-count-down/u-count-down.vue new file mode 100644 index 0000000..b5e85a6 --- /dev/null +++ b/node_modules/uview-ui/components/u-count-down/u-count-down.vue @@ -0,0 +1,163 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-count-down/utils.js b/node_modules/uview-ui/components/u-count-down/utils.js new file mode 100644 index 0000000..8c75005 --- /dev/null +++ b/node_modules/uview-ui/components/u-count-down/utils.js @@ -0,0 +1,62 @@ +// 补0，如1 -> 01 +function padZero(num, targetLength = 2) { + let str = `${num}` + while (str.length < targetLength) { + str = `0${str}` + } + return str +} +const SECOND = 1000 +const MINUTE = 60 * SECOND +const HOUR = 60 * MINUTE +const DAY = 24 * HOUR +export function parseTimeData(time) { + const days = Math.floor(time / DAY) + const hours = Math.floor((time % DAY) / HOUR) + const minutes = Math.floor((time % HOUR) / MINUTE) + const seconds = Math.floor((time % MINUTE) / SECOND) + const milliseconds = Math.floor(time % SECOND) + return { + days, + hours, + minutes, + seconds, + milliseconds + } +} +export function parseFormat(format, timeData) { + let { + days, + hours, + minutes, + seconds, + milliseconds + } = timeData + // 如果格式化字符串中不存在DD(天)，则将天的时间转为小时中去 + if (format.indexOf('DD') === -1) { + hours += days * 24 + } else { + // 对天补0 + format = format.replace('DD', padZero(days)) + } + // 其他同理于DD的格式化处理方式 + if (format.indexOf('HH') === -1) { + minutes += hours * 60 + } else { + format = format.replace('HH', padZero(hours)) + } + if (format.indexOf('mm') === -1) { + seconds += minutes * 60 + } else { + format = format.replace('mm', padZero(minutes)) + } + if (format.indexOf('ss') === -1) { + milliseconds += seconds * 1000 + } else { + format = format.replace('ss', padZero(seconds)) + } + return format.replace('SSS', padZero(milliseconds, 3)) +} +export function isSameSecond(time1, time2) { + return Math.floor(time1 / 1000) === Math.floor(time2 / 1000) +} diff --git a/node_modules/uview-ui/components/u-count-to/props.js b/node_modules/uview-ui/components/u-count-to/props.js new file mode 100644 index 0000000..86873c1 --- /dev/null +++ b/node_modules/uview-ui/components/u-count-to/props.js @@ -0,0 +1,59 @@ +export default { + props: { + // 开始的数值，默认从0增长到某一个数 + startVal: { + type: [String, Number], + default: uni.$u.props.countTo.startVal + }, + // 要滚动的目标数值，必须 + endVal: { + type: [String, Number], + default: uni.$u.props.countTo.endVal + }, + // 滚动到目标数值的动画持续时间，单位为毫秒（ms） + duration: { + type: [String, Number], + default: uni.$u.props.countTo.duration + }, + // 设置数值后是否自动开始滚动 + autoplay: { + type: Boolean, + default: uni.$u.props.countTo.autoplay + }, + // 要显示的小数位数 + decimals: { + type: [String, Number], + default: uni.$u.props.countTo.decimals + }, + // 是否在即将到达目标数值的时候，使用缓慢滚动的效果 + useEasing: { + type: Boolean, + default: uni.$u.props.countTo.useEasing + }, + // 十进制分割 + decimal: { + type: [String, Number], + default: uni.$u.props.countTo.decimal + }, + // 字体颜色 + color: { + type: String, + default: uni.$u.props.countTo.color + }, + // 字体大小 + fontSize: { + type: [String, Number], + default: uni.$u.props.countTo.fontSize + }, + // 是否加粗字体 + bold: { + type: Boolean, + default: uni.$u.props.countTo.bold + }, + // 千位分隔符，类似金额的分割(￥23,321.05中的",") + separator: { + type: String, + default: uni.$u.props.countTo.separator + } + } +} diff --git a/node_modules/uview-ui/components/u-count-to/u-count-to.vue b/node_modules/uview-ui/components/u-count-to/u-count-to.vue new file mode 100644 index 0000000..417b732 --- /dev/null +++ b/node_modules/uview-ui/components/u-count-to/u-count-to.vue @@ -0,0 +1,184 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-datetime-picker/props.js b/node_modules/uview-ui/components/u-datetime-picker/props.js new file mode 100644 index 0000000..20c461a --- /dev/null +++ b/node_modules/uview-ui/components/u-datetime-picker/props.js @@ -0,0 +1,120 @@ +export default { + props: { + // 是否打开组件 + show: { + type: Boolean, + default: uni.$u.props.datetimePicker.show + }, + // 是否展示顶部的操作栏 + showToolbar: { + type: Boolean, + default: uni.$u.props.datetimePicker.showToolbar + }, + // 绑定值 + value: { + type: [String, Number], + default: uni.$u.props.datetimePicker.value + }, + // 顶部标题 + title: { + type: String, + default: uni.$u.props.datetimePicker.title + }, + // 展示格式，mode=date为日期选择，mode=time为时间选择，mode=year-month为年月选择，mode=datetime为日期时间选择 + mode: { + type: String, + default: uni.$u.props.datetimePicker.mode + }, + // 可选的最大时间 + maxDate: { + type: Number, + // 最大默认值为后10年 + default: uni.$u.props.datetimePicker.maxDate + }, + // 可选的最小时间 + minDate: { + type: Number, + // 最小默认值为前10年 + default: uni.$u.props.datetimePicker.minDate + }, + // 可选的最小小时，仅mode=time有效 + minHour: { + type: Number, + default: uni.$u.props.datetimePicker.minHour + }, + // 可选的最大小时，仅mode=time有效 + maxHour: { + type: Number, + default: uni.$u.props.datetimePicker.maxHour + }, + // 可选的最小分钟，仅mode=time有效 + minMinute: { + type: Number, + default: uni.$u.props.datetimePicker.minMinute + }, + // 可选的最大分钟，仅mode=time有效 + maxMinute: { + type: Number, + default: uni.$u.props.datetimePicker.maxMinute + }, + // 选项过滤函数 + filter: { + type: [Function, null], + default: uni.$u.props.datetimePicker.filter + }, + // 选项格式化函数 + formatter: { + type: [Function, null], + default: uni.$u.props.datetimePicker.formatter + }, + // 是否显示加载中状态 + loading: { + type: Boolean, + default: uni.$u.props.datetimePicker.loading + }, + // 各列中，单个选项的高度 + itemHeight: { + type: [String, Number], + default: uni.$u.props.datetimePicker.itemHeight + }, + // 取消按钮的文字 + cancelText: { + type: String, + default: uni.$u.props.datetimePicker.cancelText + }, + // 确认按钮的文字 + confirmText: { + type: String, + default: uni.$u.props.datetimePicker.confirmText + }, + // 取消按钮的颜色 + cancelColor: { + type: String, + default: uni.$u.props.datetimePicker.cancelColor + }, + // 确认按钮的颜色 + confirmColor: { + type: String, + default: uni.$u.props.datetimePicker.confirmColor + }, + // 每列中可见选项的数量 + visibleItemCount: { + type: [String, Number], + default: uni.$u.props.datetimePicker.visibleItemCount + }, + // 是否允许点击遮罩关闭选择器 + closeOnClickOverlay: { + type: Boolean, + default: uni.$u.props.datetimePicker.closeOnClickOverlay + }, + // 各列的默认索引 + defaultIndex: { + type: Array, + default: uni.$u.props.datetimePicker.defaultIndex + }, + immediateChange: { + type: Boolean, + default: uni.$u.props.datetimePicker.immediateChange + } + } +} diff --git a/node_modules/uview-ui/components/u-datetime-picker/u-datetime-picker.vue b/node_modules/uview-ui/components/u-datetime-picker/u-datetime-picker.vue new file mode 100644 index 0000000..986b212 --- /dev/null +++ b/node_modules/uview-ui/components/u-datetime-picker/u-datetime-picker.vue @@ -0,0 +1,361 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-divider/props.js b/node_modules/uview-ui/components/u-divider/props.js new file mode 100644 index 0000000..1fa8359 --- /dev/null +++ b/node_modules/uview-ui/components/u-divider/props.js @@ -0,0 +1,44 @@ +export default { + props: { + // 是否虚线 + dashed: { + type: Boolean, + default: uni.$u.props.divider.dashed + }, + // 是否细线 + hairline: { + type: Boolean, + default: uni.$u.props.divider.hairline + }, + // 是否以点替代文字，优先于text字段起作用 + dot: { + type: Boolean, + default: uni.$u.props.divider.dot + }, + // 内容文本的位置，left-左边，center-中间，right-右边 + textPosition: { + type: String, + default: uni.$u.props.divider.textPosition + }, + // 文本内容 + text: { + type: [String, Number], + default: uni.$u.props.divider.text + }, + // 文本大小 + textSize: { + type: [String, Number], + default: uni.$u.props.divider.textSize + }, + // 文本颜色 + textColor: { + type: String, + default: uni.$u.props.divider.textColor + }, + // 线条颜色 + lineColor: { + type: String, + default: uni.$u.props.divider.lineColor + } + } +} diff --git a/node_modules/uview-ui/components/u-divider/u-divider.vue b/node_modules/uview-ui/components/u-divider/u-divider.vue new file mode 100644 index 0000000..b629da6 --- /dev/null +++ b/node_modules/uview-ui/components/u-divider/u-divider.vue @@ -0,0 +1,116 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-dropdown-item/props.js b/node_modules/uview-ui/components/u-dropdown-item/props.js new file mode 100644 index 0000000..501a1f0 --- /dev/null +++ b/node_modules/uview-ui/components/u-dropdown-item/props.js @@ -0,0 +1,36 @@ +export default { + props: { + // 当前选中项的value值 + value: { + type: [Number, String, Array], + default: '' + }, + // 菜单项标题 + title: { + type: [String, Number], + default: '' + }, + // 选项数据，如果传入了默认slot，此参数无效 + options: { + type: Array, + default() { + return [] + } + }, + // 是否禁用此菜单项 + disabled: { + type: Boolean, + default: false + }, + // 下拉弹窗的高度 + height: { + type: [Number, String], + default: 'auto' + }, + // 点击遮罩是否可以收起弹窗 + closeOnClickOverlay: { + type: Boolean, + default: true + } + } +} diff --git a/node_modules/uview-ui/components/u-dropdown-item/u-dropdown-item.vue b/node_modules/uview-ui/components/u-dropdown-item/u-dropdown-item.vue new file mode 100644 index 0000000..f830291 --- /dev/null +++ b/node_modules/uview-ui/components/u-dropdown-item/u-dropdown-item.vue @@ -0,0 +1,127 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-dropdown/props.js b/node_modules/uview-ui/components/u-dropdown/props.js new file mode 100644 index 0000000..5f8465e --- /dev/null +++ b/node_modules/uview-ui/components/u-dropdown/props.js @@ -0,0 +1,65 @@ +export default { + props: { + // 标题选中时的样式 + activeStyle: { + type: [String, Object], + default: () => ({ + color: '#2979ff', + fontSize: '14px' + }) + }, + // 标题未选中时的样式 + inactiveStyle: { + type: [String, Object], + default: () => ({ + color: '#606266', + fontSize: '14px' + }) + }, + // 点击遮罩是否关闭菜单 + closeOnClickMask: { + type: Boolean, + default: true + }, + // 点击当前激活项标题是否关闭菜单 + closeOnClickSelf: { + type: Boolean, + default: true + }, + // 过渡时间 + duration: { + type: [Number, String], + default: 300 + }, + // 标题菜单的高度 + height: { + type: [Number, String], + default: 40 + }, + // 是否显示下边框 + borderBottom: { + type: Boolean, + default: false + }, + // 标题的字体大小 + titleSize: { + type: [Number, String], + default: 14 + }, + // 下拉出来的内容部分的圆角值 + borderRadius: { + type: [Number, String], + default: 0 + }, + // 菜单右侧的icon图标 + menuIcon: { + type: String, + default: 'arrow-down' + }, + // 菜单右侧图标的大小 + menuIconSize: { + type: [Number, String], + default: 14 + } + } +} diff --git a/node_modules/uview-ui/components/u-dropdown/u-dropdown.vue b/node_modules/uview-ui/components/u-dropdown/u-dropdown.vue new file mode 100644 index 0000000..f830291 --- /dev/null +++ b/node_modules/uview-ui/components/u-dropdown/u-dropdown.vue @@ -0,0 +1,127 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-empty/props.js b/node_modules/uview-ui/components/u-empty/props.js new file mode 100644 index 0000000..78662f8 --- /dev/null +++ b/node_modules/uview-ui/components/u-empty/props.js @@ -0,0 +1,59 @@ +export default { + props: { + // 内置图标名称，或图片路径，建议绝对路径 + icon: { + type: String, + default: uni.$u.props.empty.icon + }, + // 提示文字 + text: { + type: String, + default: uni.$u.props.empty.text + }, + // 文字颜色 + textColor: { + type: String, + default: uni.$u.props.empty.textColor + }, + // 文字大小 + textSize: { + type: [String, Number], + default: uni.$u.props.empty.textSize + }, + // 图标的颜色 + iconColor: { + type: String, + default: uni.$u.props.empty.iconColor + }, + // 图标的大小 + iconSize: { + type: [String, Number], + default: uni.$u.props.empty.iconSize + }, + // 选择预置的图标类型 + mode: { + type: String, + default: uni.$u.props.empty.mode + }, + // 图标宽度，单位px + width: { + type: [String, Number], + default: uni.$u.props.empty.width + }, + // 图标高度，单位px + height: { + type: [String, Number], + default: uni.$u.props.empty.height + }, + // 是否显示组件 + show: { + type: Boolean, + default: uni.$u.props.empty.show + }, + // 组件距离上一个元素之间的距离，默认px单位 + marginTop: { + type: [String, Number], + default: uni.$u.props.empty.marginTop + } + } +} diff --git a/node_modules/uview-ui/components/u-empty/u-empty.vue b/node_modules/uview-ui/components/u-empty/u-empty.vue new file mode 100644 index 0000000..03d6a27 --- /dev/null +++ b/node_modules/uview-ui/components/u-empty/u-empty.vue @@ -0,0 +1,128 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-form-item/props.js b/node_modules/uview-ui/components/u-form-item/props.js new file mode 100644 index 0000000..7b16655 --- /dev/null +++ b/node_modules/uview-ui/components/u-form-item/props.js @@ -0,0 +1,48 @@ +export default { + props: { + // input的label提示语 + label: { + type: String, + default: uni.$u.props.formItem.label + }, + // 绑定的值 + prop: { + type: String, + default: uni.$u.props.formItem.prop + }, + // 是否显示表单域的下划线边框 + borderBottom: { + type: [String, Boolean], + default: uni.$u.props.formItem.borderBottom + }, + // label的位置，left-左边，top-上边 + labelPosition: { + type: String, + default: uni.$u.props.formItem.labelPosition + }, + // label的宽度，单位px + labelWidth: { + type: [String, Number], + default: uni.$u.props.formItem.labelWidth + }, + // 右侧图标 + rightIcon: { + type: String, + default: uni.$u.props.formItem.rightIcon + }, + // 左侧图标 + leftIcon: { + type: String, + default: uni.$u.props.formItem.leftIcon + }, + // 是否显示左边的必填星号，只作显示用，具体校验必填的逻辑，请在rules中配置 + required: { + type: Boolean, + default: uni.$u.props.formItem.required + }, + leftIconStyle: { + type: [String, Object], + default: uni.$u.props.formItem.leftIconStyle, + } + } +} diff --git a/node_modules/uview-ui/components/u-form-item/u-form-item.vue b/node_modules/uview-ui/components/u-form-item/u-form-item.vue new file mode 100644 index 0000000..a2ee2b7 --- /dev/null +++ b/node_modules/uview-ui/components/u-form-item/u-form-item.vue @@ -0,0 +1,235 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-form/props.js b/node_modules/uview-ui/components/u-form/props.js new file mode 100644 index 0000000..f2a629c --- /dev/null +++ b/node_modules/uview-ui/components/u-form/props.js @@ -0,0 +1,45 @@ +export default { + props: { + // 当前form的需要验证字段的集合 + model: { + type: Object, + default: uni.$u.props.form.model + }, + // 验证规则 + rules: { + type: [Object, Function, Array], + default: uni.$u.props.form.rules + }, + // 有错误时的提示方式，message-提示信息，toast-进行toast提示 + // border-bottom-下边框呈现红色，none-无提示 + errorType: { + type: String, + default: uni.$u.props.form.errorType + }, + // 是否显示表单域的下划线边框 + borderBottom: { + type: Boolean, + default: uni.$u.props.form.borderBottom + }, + // label的位置，left-左边，top-上边 + labelPosition: { + type: String, + default: uni.$u.props.form.labelPosition + }, + // label的宽度，单位px + labelWidth: { + type: [String, Number], + default: uni.$u.props.form.labelWidth + }, + // lable字体的对齐方式 + labelAlign: { + type: String, + default: uni.$u.props.form.labelAlign + }, + // lable的样式，对象形式 + labelStyle: { + type: Object, + default: uni.$u.props.form.labelStyle + } + } +} diff --git a/node_modules/uview-ui/components/u-form/u-form.vue b/node_modules/uview-ui/components/u-form/u-form.vue new file mode 100644 index 0000000..fe2dde2 --- /dev/null +++ b/node_modules/uview-ui/components/u-form/u-form.vue @@ -0,0 +1,214 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-gap/props.js b/node_modules/uview-ui/components/u-gap/props.js new file mode 100644 index 0000000..89953e3 --- /dev/null +++ b/node_modules/uview-ui/components/u-gap/props.js @@ -0,0 +1,24 @@ +export default { + props: { + // 背景颜色（默认transparent） + bgColor: { + type: String, + default: uni.$u.props.gap.bgColor + }, + // 分割槽高度，单位px（默认30） + height: { + type: [String, Number], + default: uni.$u.props.gap.height + }, + // 与上一个组件的距离 + marginTop: { + type: [String, Number], + default: uni.$u.props.gap.marginTop + }, + // 与下一个组件的距离 + marginBottom: { + type: [String, Number], + default: uni.$u.props.gap.marginBottom + } + } +} diff --git a/node_modules/uview-ui/components/u-gap/u-gap.vue b/node_modules/uview-ui/components/u-gap/u-gap.vue new file mode 100644 index 0000000..e4429f0 --- /dev/null +++ b/node_modules/uview-ui/components/u-gap/u-gap.vue @@ -0,0 +1,38 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-grid-item/props.js b/node_modules/uview-ui/components/u-grid-item/props.js new file mode 100644 index 0000000..06c3c66 --- /dev/null +++ b/node_modules/uview-ui/components/u-grid-item/props.js @@ -0,0 +1,14 @@ +export default { + props: { + // 宫格的name + name: { + type: [String, Number, null], + default: uni.$u.props.gridItem.name + }, + // 背景颜色 + bgColor: { + type: String, + default: uni.$u.props.gridItem.bgColor + } + } +} diff --git a/node_modules/uview-ui/components/u-grid-item/u-grid-item.vue b/node_modules/uview-ui/components/u-grid-item/u-grid-item.vue new file mode 100644 index 0000000..fc0c7cf --- /dev/null +++ b/node_modules/uview-ui/components/u-grid-item/u-grid-item.vue @@ -0,0 +1,209 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-grid/props.js b/node_modules/uview-ui/components/u-grid/props.js new file mode 100644 index 0000000..87b0f6a --- /dev/null +++ b/node_modules/uview-ui/components/u-grid/props.js @@ -0,0 +1,19 @@ +export default { + props: { + // 分成几列 + col: { + type: [String, Number], + default: uni.$u.props.grid.col + }, + // 是否显示边框 + border: { + type: Boolean, + default: uni.$u.props.grid.border + }, + // 宫格对齐方式，表现为数量少的时候，靠左，居中，还是靠右 + align: { + type: String, + default: uni.$u.props.grid.align + } + } +} diff --git a/node_modules/uview-ui/components/u-grid/u-grid.vue b/node_modules/uview-ui/components/u-grid/u-grid.vue new file mode 100644 index 0000000..b43cc27 --- /dev/null +++ b/node_modules/uview-ui/components/u-grid/u-grid.vue @@ -0,0 +1,97 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-icon/icons.js b/node_modules/uview-ui/components/u-icon/icons.js new file mode 100644 index 0000000..f4d0fe2 --- /dev/null +++ b/node_modules/uview-ui/components/u-icon/icons.js @@ -0,0 +1,214 @@ +export default { + 'uicon-level': '\ue693', + 'uicon-column-line': '\ue68e', + 'uicon-checkbox-mark': '\ue807', + 'uicon-folder': '\ue7f5', + 'uicon-movie': '\ue7f6', + 'uicon-star-fill': '\ue669', + 'uicon-star': '\ue65f', + 'uicon-phone-fill': '\ue64f', + 'uicon-phone': '\ue622', + 'uicon-apple-fill': '\ue881', + 'uicon-chrome-circle-fill': '\ue885', + 'uicon-backspace': '\ue67b', + 'uicon-attach': '\ue632', + 'uicon-cut': '\ue948', + 'uicon-empty-car': '\ue602', + 'uicon-empty-coupon': '\ue682', + 'uicon-empty-address': '\ue646', + 'uicon-empty-favor': '\ue67c', + 'uicon-empty-permission': '\ue686', + 'uicon-empty-news': '\ue687', + 'uicon-empty-search': '\ue664', + 'uicon-github-circle-fill': '\ue887', + 'uicon-rmb': '\ue608', + 'uicon-person-delete-fill': '\ue66a', + 'uicon-reload': '\ue788', + 'uicon-order': '\ue68f', + 'uicon-server-man': '\ue6bc', + 'uicon-search': '\ue62a', + 'uicon-fingerprint': '\ue955', + 'uicon-more-dot-fill': '\ue630', + 'uicon-scan': '\ue662', + 'uicon-share-square': '\ue60b', + 'uicon-map': '\ue61d', + 'uicon-map-fill': '\ue64e', + 'uicon-tags': '\ue629', + 'uicon-tags-fill': '\ue651', + 'uicon-bookmark-fill': '\ue63b', + 'uicon-bookmark': '\ue60a', + 'uicon-eye': '\ue613', + 'uicon-eye-fill': '\ue641', + 'uicon-mic': '\ue64a', + 'uicon-mic-off': '\ue649', + 'uicon-calendar': '\ue66e', + 'uicon-calendar-fill': '\ue634', + 'uicon-trash': '\ue623', + 'uicon-trash-fill': '\ue658', + 'uicon-play-left': '\ue66d', + 'uicon-play-right': '\ue610', + 'uicon-minus': '\ue618', + 'uicon-plus': '\ue62d', + 'uicon-info': '\ue653', + 'uicon-info-circle': '\ue7d2', + 'uicon-info-circle-fill': '\ue64b', + 'uicon-question': '\ue715', + 'uicon-error': '\ue6d3', + 'uicon-close': '\ue685', + 'uicon-checkmark': '\ue6a8', + 'uicon-android-circle-fill': '\ue67e', + 'uicon-android-fill': '\ue67d', + 'uicon-ie': '\ue87b', + 'uicon-IE-circle-fill': '\ue889', + 'uicon-google': '\ue87a', + 'uicon-google-circle-fill': '\ue88a', + 'uicon-setting-fill': '\ue872', + 'uicon-setting': '\ue61f', + 'uicon-minus-square-fill': '\ue855', + 'uicon-plus-square-fill': '\ue856', + 'uicon-heart': '\ue7df', + 'uicon-heart-fill': '\ue851', + 'uicon-camera': '\ue7d7', + 'uicon-camera-fill': '\ue870', + 'uicon-more-circle': '\ue63e', + 'uicon-more-circle-fill': '\ue645', + 'uicon-chat': '\ue620', + 'uicon-chat-fill': '\ue61e', + 'uicon-bag-fill': '\ue617', + 'uicon-bag': '\ue619', + 'uicon-error-circle-fill': '\ue62c', + 'uicon-error-circle': '\ue624', + 'uicon-close-circle': '\ue63f', + 'uicon-close-circle-fill': '\ue637', + 'uicon-checkmark-circle': '\ue63d', + 'uicon-checkmark-circle-fill': '\ue635', + 'uicon-question-circle-fill': '\ue666', + 'uicon-question-circle': '\ue625', + 'uicon-share': '\ue631', + 'uicon-share-fill': '\ue65e', + 'uicon-shopping-cart': '\ue621', + 'uicon-shopping-cart-fill': '\ue65d', + 'uicon-bell': '\ue609', + 'uicon-bell-fill': '\ue640', + 'uicon-list': '\ue650', + 'uicon-list-dot': '\ue616', + 'uicon-zhihu': '\ue6ba', + 'uicon-zhihu-circle-fill': '\ue709', + 'uicon-zhifubao': '\ue6b9', + 'uicon-zhifubao-circle-fill': '\ue6b8', + 'uicon-weixin-circle-fill': '\ue6b1', + 'uicon-weixin-fill': '\ue6b2', + 'uicon-twitter-circle-fill': '\ue6ab', + 'uicon-twitter': '\ue6aa', + 'uicon-taobao-circle-fill': '\ue6a7', + 'uicon-taobao': '\ue6a6', + 'uicon-weibo-circle-fill': '\ue6a5', + 'uicon-weibo': '\ue6a4', + 'uicon-qq-fill': '\ue6a1', + 'uicon-qq-circle-fill': '\ue6a0', + 'uicon-moments-circel-fill': '\ue69a', + 'uicon-moments': '\ue69b', + 'uicon-qzone': '\ue695', + 'uicon-qzone-circle-fill': '\ue696', + 'uicon-baidu-circle-fill': '\ue680', + 'uicon-baidu': '\ue681', + 'uicon-facebook-circle-fill': '\ue68a', + 'uicon-facebook': '\ue689', + 'uicon-car': '\ue60c', + 'uicon-car-fill': '\ue636', + 'uicon-warning-fill': '\ue64d', + 'uicon-warning': '\ue694', + 'uicon-clock-fill': '\ue638', + 'uicon-clock': '\ue60f', + 'uicon-edit-pen': '\ue612', + 'uicon-edit-pen-fill': '\ue66b', + 'uicon-email': '\ue611', + 'uicon-email-fill': '\ue642', + 'uicon-minus-circle': '\ue61b', + 'uicon-minus-circle-fill': '\ue652', + 'uicon-plus-circle': '\ue62e', + 'uicon-plus-circle-fill': '\ue661', + 'uicon-file-text': '\ue663', + 'uicon-file-text-fill': '\ue665', + 'uicon-pushpin': '\ue7e3', + 'uicon-pushpin-fill': '\ue86e', + 'uicon-grid': '\ue673', + 'uicon-grid-fill': '\ue678', + 'uicon-play-circle': '\ue647', + 'uicon-play-circle-fill': '\ue655', + 'uicon-pause-circle-fill': '\ue654', + 'uicon-pause': '\ue8fa', + 'uicon-pause-circle': '\ue643', + 'uicon-eye-off': '\ue648', + 'uicon-eye-off-outline': '\ue62b', + 'uicon-gift-fill': '\ue65c', + 'uicon-gift': '\ue65b', + 'uicon-rmb-circle-fill': '\ue657', + 'uicon-rmb-circle': '\ue677', + 'uicon-kefu-ermai': '\ue656', + 'uicon-server-fill': '\ue751', + 'uicon-coupon-fill': '\ue8c4', + 'uicon-coupon': '\ue8ae', + 'uicon-integral': '\ue704', + 'uicon-integral-fill': '\ue703', + 'uicon-home-fill': '\ue964', + 'uicon-home': '\ue965', + 'uicon-hourglass-half-fill': '\ue966', + 'uicon-hourglass': '\ue967', + 'uicon-account': '\ue628', + 'uicon-plus-people-fill': '\ue626', + 'uicon-minus-people-fill': '\ue615', + 'uicon-account-fill': '\ue614', + 'uicon-thumb-down-fill': '\ue726', + 'uicon-thumb-down': '\ue727', + 'uicon-thumb-up': '\ue733', + 'uicon-thumb-up-fill': '\ue72f', + 'uicon-lock-fill': '\ue979', + 'uicon-lock-open': '\ue973', + 'uicon-lock-opened-fill': '\ue974', + 'uicon-lock': '\ue97a', + 'uicon-red-packet-fill': '\ue690', + 'uicon-photo-fill': '\ue98b', + 'uicon-photo': '\ue98d', + 'uicon-volume-off-fill': '\ue659', + 'uicon-volume-off': '\ue644', + 'uicon-volume-fill': '\ue670', + 'uicon-volume': '\ue633', + 'uicon-red-packet': '\ue691', + 'uicon-download': '\ue63c', + 'uicon-arrow-up-fill': '\ue6b0', + 'uicon-arrow-down-fill': '\ue600', + 'uicon-play-left-fill': '\ue675', + 'uicon-play-right-fill': '\ue676', + 'uicon-rewind-left-fill': '\ue679', + 'uicon-rewind-right-fill': '\ue67a', + 'uicon-arrow-downward': '\ue604', + 'uicon-arrow-leftward': '\ue601', + 'uicon-arrow-rightward': '\ue603', + 'uicon-arrow-upward': '\ue607', + 'uicon-arrow-down': '\ue60d', + 'uicon-arrow-right': '\ue605', + 'uicon-arrow-left': '\ue60e', + 'uicon-arrow-up': '\ue606', + 'uicon-skip-back-left': '\ue674', + 'uicon-skip-forward-right': '\ue672', + 'uicon-rewind-right': '\ue66f', + 'uicon-rewind-left': '\ue671', + 'uicon-arrow-right-double': '\ue68d', + 'uicon-arrow-left-double': '\ue68c', + 'uicon-wifi-off': '\ue668', + 'uicon-wifi': '\ue667', + 'uicon-empty-data': '\ue62f', + 'uicon-empty-history': '\ue684', + 'uicon-empty-list': '\ue68b', + 'uicon-empty-page': '\ue627', + 'uicon-empty-order': '\ue639', + 'uicon-man': '\ue697', + 'uicon-woman': '\ue69c', + 'uicon-man-add': '\ue61c', + 'uicon-man-add-fill': '\ue64c', + 'uicon-man-delete': '\ue61a', + 'uicon-man-delete-fill': '\ue66a', + 'uicon-zh': '\ue70a', + 'uicon-en': '\ue692' +} diff --git a/node_modules/uview-ui/components/u-icon/props.js b/node_modules/uview-ui/components/u-icon/props.js new file mode 100644 index 0000000..71845b7 --- /dev/null +++ b/node_modules/uview-ui/components/u-icon/props.js @@ -0,0 +1,89 @@ +export default { + props: { + // 图标类名 + name: { + type: String, + default: uni.$u.props.icon.name + }, + // 图标颜色，可接受主题色 + color: { + type: String, + default: uni.$u.props.icon.color + }, + // 字体大小，单位px + size: { + type: [String, Number], + default: uni.$u.props.icon.size + }, + // 是否显示粗体 + bold: { + type: Boolean, + default: uni.$u.props.icon.bold + }, + // 点击图标的时候传递事件出去的index（用于区分点击了哪一个） + index: { + type: [String, Number], + default: uni.$u.props.icon.index + }, + // 触摸图标时的类名 + hoverClass: { + type: String, + default: uni.$u.props.icon.hoverClass + }, + // 自定义扩展前缀，方便用户扩展自己的图标库 + customPrefix: { + type: String, + default: uni.$u.props.icon.customPrefix + }, + // 图标右边或者下面的文字 + label: { + type: [String, Number], + default: uni.$u.props.icon.label + }, + // label的位置，只能右边或者下边 + labelPos: { + type: String, + default: uni.$u.props.icon.labelPos + }, + // label的大小 + labelSize: { + type: [String, Number], + default: uni.$u.props.icon.labelSize + }, + // label的颜色 + labelColor: { + type: String, + default: uni.$u.props.icon.labelColor + }, + // label与图标的距离 + space: { + type: [String, Number], + default: uni.$u.props.icon.space + }, + // 图片的mode + imgMode: { + type: String, + default: uni.$u.props.icon.imgMode + }, + // 用于显示图片小图标时，图片的宽度 + width: { + type: [String, Number], + default: uni.$u.props.icon.width + }, + // 用于显示图片小图标时，图片的高度 + height: { + type: [String, Number], + default: uni.$u.props.icon.height + }, + // 用于解决某些情况下，让图标垂直居中的用途 + top: { + type: [String, Number], + default: uni.$u.props.icon.top + }, + // 是否阻止事件传播 + stop: { + type: Boolean, + default: uni.$u.props.icon.stop + } + } +} diff --git a/node_modules/uview-ui/components/u-icon/u-icon.vue b/node_modules/uview-ui/components/u-icon/u-icon.vue new file mode 100644 index 0000000..9340328 --- /dev/null +++ b/node_modules/uview-ui/components/u-icon/u-icon.vue @@ -0,0 +1,234 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-image/props.js b/node_modules/uview-ui/components/u-image/props.js new file mode 100644 index 0000000..2eabb74 --- /dev/null +++ b/node_modules/uview-ui/components/u-image/props.js @@ -0,0 +1,84 @@ +export default { + props: { + // 图片地址 + src: { + type: String, + default: uni.$u.props.image.src + }, + // 裁剪模式 + mode: { + type: String, + default: uni.$u.props.image.mode + }, + // 宽度，单位任意 + width: { + type: [String, Number], + default: uni.$u.props.image.width + }, + // 高度，单位任意 + height: { + type: [String, Number], + default: uni.$u.props.image.height + }, + // 图片形状，circle-圆形，square-方形 + shape: { + type: String, + default: uni.$u.props.image.shape + }, + // 圆角，单位任意 + radius: { + type: [String, Number], + default: uni.$u.props.image.radius + }, + // 是否懒加载，微信小程序、App、百度小程序、字节跳动小程序 + lazyLoad: { + type: Boolean, + default: uni.$u.props.image.lazyLoad + }, + // 开启长按图片显示识别微信小程序码菜单 + showMenuByLongpress: { + type: Boolean, + default: uni.$u.props.image.showMenuByLongpress + }, + // 加载中的图标，或者小图片 + loadingIcon: { + type: String, + default: uni.$u.props.image.loadingIcon + }, + // 加载失败的图标，或者小图片 + errorIcon: { + type: String, + default: uni.$u.props.image.errorIcon + }, + // 是否显示加载中的图标或者自定义的slot + showLoading: { + type: Boolean, + default: uni.$u.props.image.showLoading + }, + // 是否显示加载错误的图标或者自定义的slot + showError: { + type: Boolean, + default: uni.$u.props.image.showError + }, + // 是否需要淡入效果 + fade: { + type: Boolean, + default: uni.$u.props.image.fade + }, + // 只支持网络资源，只对微信小程序有效 + webp: { + type: Boolean, + default: uni.$u.props.image.webp + }, + // 过渡时间，单位ms + duration: { + type: [String, Number], + default: uni.$u.props.image.duration + }, + // 背景颜色，用于深色页面加载图片时，为了和背景色融合 + bgColor: { + type: String, + default: uni.$u.props.image.bgColor + } + } +} diff --git a/node_modules/uview-ui/components/u-image/u-image.vue b/node_modules/uview-ui/components/u-image/u-image.vue new file mode 100644 index 0000000..392159a --- /dev/null +++ b/node_modules/uview-ui/components/u-image/u-image.vue @@ -0,0 +1,232 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-index-anchor/props.js b/node_modules/uview-ui/components/u-index-anchor/props.js new file mode 100644 index 0000000..6d8b59a --- /dev/null +++ b/node_modules/uview-ui/components/u-index-anchor/props.js @@ -0,0 +1,29 @@ +export default { + props: { + // 列表锚点文本内容 + text: { + type: [String, Number], + default: uni.$u.props.indexAnchor.text + }, + // 列表锚点文字颜色 + color: { + type: String, + default: uni.$u.props.indexAnchor.color + }, + // 列表锚点文字大小，单位默认px + size: { + type: [String, Number], + default: uni.$u.props.indexAnchor.size + }, + // 列表锚点背景颜色 + bgColor: { + type: String, + default: uni.$u.props.indexAnchor.bgColor + }, + // 列表锚点高度，单位默认px + height: { + type: [String, Number], + default: uni.$u.props.indexAnchor.height + } + } +} diff --git a/node_modules/uview-ui/components/u-index-anchor/u-index-anchor.vue b/node_modules/uview-ui/components/u-index-anchor/u-index-anchor.vue new file mode 100644 index 0000000..b95ddef --- /dev/null +++ b/node_modules/uview-ui/components/u-index-anchor/u-index-anchor.vue @@ -0,0 +1,91 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-index-item/props.js b/node_modules/uview-ui/components/u-index-item/props.js new file mode 100644 index 0000000..7c11331 --- /dev/null +++ b/node_modules/uview-ui/components/u-index-item/props.js @@ -0,0 +1,5 @@ +export default { + props: { + + } +} diff --git a/node_modules/uview-ui/components/u-index-item/u-index-item.vue b/node_modules/uview-ui/components/u-index-item/u-index-item.vue new file mode 100644 index 0000000..0bc7fb3 --- /dev/null +++ b/node_modules/uview-ui/components/u-index-item/u-index-item.vue @@ -0,0 +1,87 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-index-list/props.js b/node_modules/uview-ui/components/u-index-list/props.js new file mode 100644 index 0000000..354d459 --- /dev/null +++ b/node_modules/uview-ui/components/u-index-list/props.js @@ -0,0 +1,29 @@ +export default { + props: { + // 右边锚点非激活的颜色 + inactiveColor: { + type: String, + default: uni.$u.props.indexList.inactiveColor + }, + // 右边锚点激活的颜色 + activeColor: { + type: String, + default: uni.$u.props.indexList.activeColor + }, + // 索引字符列表，数组形式 + indexList: { + type: Array, + default: uni.$u.props.indexList.indexList + }, + // 是否开启锚点自动吸顶 + sticky: { + type: Boolean, + default: uni.$u.props.indexList.sticky + }, + // 自定义导航栏的高度 + customNavHeight: { + type: [String, Number], + default: uni.$u.props.indexList.customNavHeight + } + } +} diff --git a/node_modules/uview-ui/components/u-index-list/u-index-list.vue b/node_modules/uview-ui/components/u-index-list/u-index-list.vue new file mode 100644 index 0000000..d712618 --- /dev/null +++ b/node_modules/uview-ui/components/u-index-list/u-index-list.vue @@ -0,0 +1,440 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-input/props.js b/node_modules/uview-ui/components/u-input/props.js new file mode 100644 index 0000000..2c50870 --- /dev/null +++ b/node_modules/uview-ui/components/u-input/props.js @@ -0,0 +1,187 @@ +export default { + props: { + // 输入的值 + value: { + type: [String, Number], + default: uni.$u.props.input.value + }, + // 输入框类型 + // number-数字输入键盘，app-vue下可以输入浮点数，app-nvue和小程序平台下只能输入整数 + // idcard-身份证输入键盘，微信、支付宝、百度、QQ小程序 + // digit-带小数点的数字键盘，App的nvue页面、微信、支付宝、百度、头条、QQ小程序 + // text-文本输入键盘 + type: { + type: String, + default: uni.$u.props.input.type + }, + // 如果 textarea 是在一个 position:fixed 的区域，需要显示指定属性 fixed 为 true， + // 兼容性：微信小程序、百度小程序、字节跳动小程序、QQ小程序 + fixed: { + type: Boolean, + default: uni.$u.props.input.fixed + }, + // 是否禁用输入框 + disabled: { + type: Boolean, + default: uni.$u.props.input.disabled + }, + // 禁用状态时的背景色 + disabledColor: { + type: String, + default: uni.$u.props.input.disabledColor + }, + // 是否显示清除控件 + clearable: { + type: Boolean, + default: uni.$u.props.input.clearable + }, + // 是否密码类型 + password: { + type: Boolean, + default: uni.$u.props.input.password + }, + // 最大输入长度，设置为 -1 的时候不限制最大长度 + maxlength: { + type: [String, Number], + default: uni.$u.props.input.maxlength + }, + // 输入框为空时的占位符 + placeholder: { + type: String, + default: uni.$u.props.input.placeholder + }, + // 指定placeholder的样式类，注意页面或组件的style中写了scoped时，需要在类名前写/deep/ + placeholderClass: { + type: String, + default: uni.$u.props.input.placeholderClass + }, + // 指定placeholder的样式 + placeholderStyle: { + type: [String, Object], + default: uni.$u.props.input.placeholderStyle + }, + // 是否显示输入字数统计，只在 type ="text"或type ="textarea"时有效 + showWordLimit: { + type: Boolean, + default: uni.$u.props.input.showWordLimit + }, + // 设置右下角按钮的文字，有效值：send|search|next|go|done，兼容性详见uni-app文档 + // https://uniapp.dcloud.io/component/input + // https://uniapp.dcloud.io/component/textarea + confirmType: { + type: String, + default: uni.$u.props.input.confirmType + }, + // 点击键盘右下角按钮时是否保持键盘不收起，H5无效 + confirmHold: { + type: Boolean, + default: uni.$u.props.input.confirmHold + }, + // focus时，点击页面的时候不收起键盘，微信小程序有效 + holdKeyboard: { + type: Boolean, + default: uni.$u.props.input.holdKeyboard + }, + // 自动获取焦点 + // 在 H5 平台能否聚焦以及软键盘是否跟随弹出，取决于当前浏览器本身的实现。nvue 页面不支持，需使用组件的 focus()、blur() 方法控制焦点 + focus: { + type: Boolean, + default: uni.$u.props.input.focus + }, + // 键盘收起时，是否自动失去焦点，目前仅App3.0.0+有效 + autoBlur: { + type: Boolean, + default: uni.$u.props.input.autoBlur + }, + // 是否去掉 iOS 下的默认内边距，仅微信小程序，且type=textarea时有效 + disableDefaultPadding: { + type: Boolean, + default: uni.$u.props.input.disableDefaultPadding + }, + // 指定focus时光标的位置 + cursor: { + type: [String, Number], + default: uni.$u.props.input.cursor + }, + // 输入框聚焦时底部与键盘的距离 + cursorSpacing: { + type: [String, Number], + default: uni.$u.props.input.cursorSpacing + }, + // 光标起始位置，自动聚集时有效，需与selection-end搭配使用 + selectionStart: { + type: [String, Number], + default: uni.$u.props.input.selectionStart + }, + // 光标结束位置，自动聚集时有效，需与selection-start搭配使用 + selectionEnd: { + type: [String, Number], + default: uni.$u.props.input.selectionEnd + }, + // 键盘弹起时，是否自动上推页面 + adjustPosition: { + type: Boolean, + default: uni.$u.props.input.adjustPosition + }, + // 输入框内容对齐方式，可选值为：left|center|right + inputAlign: { + type: String, + default: uni.$u.props.input.inputAlign + }, + // 输入框字体的大小 + fontSize: { + type: [String, Number], + default: uni.$u.props.input.fontSize + }, + // 输入框字体颜色 + color: { + type: String, + default: uni.$u.props.input.color + }, + // 输入框前置图标 + prefixIcon: { + type: String, + default: uni.$u.props.input.prefixIcon + }, + // 前置图标样式，对象或字符串 + prefixIconStyle: { + type: [String, Object], + default: uni.$u.props.input.prefixIconStyle + }, + // 输入框后置图标 + suffixIcon: { + type: String, + default: uni.$u.props.input.suffixIcon + }, + // 后置图标样式，对象或字符串 + suffixIconStyle: { + type: [String, Object], + default: uni.$u.props.input.suffixIconStyle + }, + // 边框类型，surround-四周边框，bottom-底部边框，none-无边框 + border: { + type: String, + default: uni.$u.props.input.border + }, + // 是否只读，与disabled不同之处在于disabled会置灰组件，而readonly则不会 + readonly: { + type: Boolean, + default: uni.$u.props.input.readonly + }, + // 输入框形状，circle-圆形，square-方形 + shape: { + type: String, + default: uni.$u.props.input.shape + }, + // 用于处理或者过滤输入框内容的方法 + formatter: { + type: [Function, null], + default: uni.$u.props.input.formatter + }, + // 是否忽略组件内对文本合成系统事件的处理 + ignoreCompositionEvent: { + type: Boolean, + default: true + } + } +} diff --git a/node_modules/uview-ui/components/u-input/u-input.vue b/node_modules/uview-ui/components/u-input/u-input.vue new file mode 100644 index 0000000..dac3393 --- /dev/null +++ b/node_modules/uview-ui/components/u-input/u-input.vue @@ -0,0 +1,369 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-keyboard/props.js b/node_modules/uview-ui/components/u-keyboard/props.js new file mode 100644 index 0000000..cfdb00a --- /dev/null +++ b/node_modules/uview-ui/components/u-keyboard/props.js @@ -0,0 +1,84 @@ +export default { + props: { + // 键盘的类型，number-数字键盘，card-身份证键盘，car-车牌号键盘 + mode: { + type: String, + default: uni.$u.props.keyboard.mode + }, + // 是否显示键盘的"."符号 + dotDisabled: { + type: Boolean, + default: uni.$u.props.keyboard.dotDisabled + }, + // 是否显示顶部工具条 + tooltip: { + type: Boolean, + default: uni.$u.props.keyboard.tooltip + }, + // 是否显示工具条中间的提示 + showTips: { + type: Boolean, + default: uni.$u.props.keyboard.showTips + }, + // 工具条中间的提示文字 + tips: { + type: String, + default: uni.$u.props.keyboard.tips + }, + // 是否显示工具条左边的"取消"按钮 + showCancel: { + type: Boolean, + default: uni.$u.props.keyboard.showCancel + }, + // 是否显示工具条右边的"完成"按钮 + showConfirm: { + type: Boolean, + default: uni.$u.props.keyboard.showConfirm + }, + // 是否打乱键盘按键的顺序 + random: { + type: Boolean, + default: uni.$u.props.keyboard.random + }, + // 是否开启底部安全区适配，开启的话，会在iPhoneX机型底部添加一定的内边距 + safeAreaInsetBottom: { + type: Boolean, + default: uni.$u.props.keyboard.safeAreaInsetBottom + }, + // 是否允许通过点击遮罩关闭键盘 + closeOnClickOverlay: { + type: Boolean, + default: uni.$u.props.keyboard.closeOnClickOverlay + }, + // 控制键盘的弹出与收起 + show: { + type: Boolean, + default: uni.$u.props.keyboard.show + }, + // 是否显示遮罩，某些时候数字键盘时，用户希望看到自己的数值，所以可能不想要遮罩 + overlay: { + type: Boolean, + default: uni.$u.props.keyboard.overlay + }, + // z-index值 + zIndex: { + type: [String, Number], + default: uni.$u.props.keyboard.zIndex + }, + // 取消按钮的文字 + cancelText: { + type: String, + default: uni.$u.props.keyboard.cancelText + }, + // 确认按钮的文字 + confirmText: { + type: String, + default: uni.$u.props.keyboard.confirmText + }, + // 输入一个中文后，是否自动切换到英文 + autoChange: { + type: Boolean, + default: uni.$u.props.keyboard.autoChange + } + } +} diff --git a/node_modules/uview-ui/components/u-keyboard/u-keyboard.vue b/node_modules/uview-ui/components/u-keyboard/u-keyboard.vue new file mode 100644 index 0000000..14228cb --- /dev/null +++ b/node_modules/uview-ui/components/u-keyboard/u-keyboard.vue @@ -0,0 +1,164 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-line-progress/props.js b/node_modules/uview-ui/components/u-line-progress/props.js new file mode 100644 index 0000000..a4210bd --- /dev/null +++ b/node_modules/uview-ui/components/u-line-progress/props.js @@ -0,0 +1,28 @@ +export default { + props: { + // 激活部分的颜色 + activeColor: { + type: String, + default: uni.$u.props.lineProgress.activeColor + }, + inactiveColor: { + type: String, + default: uni.$u.props.lineProgress.color + }, + // 进度百分比，数值 + percentage: { + type: [String, Number], + default: uni.$u.props.lineProgress.inactiveColor + }, + // 是否在进度条内部显示百分比的值 + showText: { + type: Boolean, + default: uni.$u.props.lineProgress.showText + }, + // 进度条的高度，单位px + height: { + type: [String, Number], + default: uni.$u.props.lineProgress.height + } + } +} diff --git a/node_modules/uview-ui/components/u-line-progress/u-line-progress.vue b/node_modules/uview-ui/components/u-line-progress/u-line-progress.vue new file mode 100644 index 0000000..4e27931 --- /dev/null +++ b/node_modules/uview-ui/components/u-line-progress/u-line-progress.vue @@ -0,0 +1,144 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-line/props.js b/node_modules/uview-ui/components/u-line/props.js new file mode 100644 index 0000000..2308cc3 --- /dev/null +++ b/node_modules/uview-ui/components/u-line/props.js @@ -0,0 +1,33 @@ +export default { + props: { + color: { + type: String, + default: uni.$u.props.line.color + }, + // 长度，竖向时表现为高度，横向时表现为长度，可以为百分比，带px单位的值等 + length: { + type: [String, Number], + default: uni.$u.props.line.length + }, + // 线条方向，col-竖向，row-横向 + direction: { + type: String, + default: uni.$u.props.line.direction + }, + // 是否显示细边框 + hairline: { + type: Boolean, + default: uni.$u.props.line.hairline + }, + // 线条与上下左右元素的间距，字符串形式，如"30px"、"20px 30px" + margin: { + type: [String, Number], + default: uni.$u.props.line.margin + }, + // 是否虚线，true-虚线，false-实线 + dashed: { + type: Boolean, + default: uni.$u.props.line.dashed + } + } +} diff --git a/node_modules/uview-ui/components/u-line/u-line.vue b/node_modules/uview-ui/components/u-line/u-line.vue new file mode 100644 index 0000000..e0a6d92 --- /dev/null +++ b/node_modules/uview-ui/components/u-line/u-line.vue @@ -0,0 +1,62 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-link/props.js b/node_modules/uview-ui/components/u-link/props.js new file mode 100644 index 0000000..d39353f --- /dev/null +++ b/node_modules/uview-ui/components/u-link/props.js @@ -0,0 +1,39 @@ +export default { + props: { + // 文字颜色 + color: { + type: String, + default: uni.$u.props.link.color + }, + // 字体大小，单位px + fontSize: { + type: [String, Number], + default: uni.$u.props.link.fontSize + }, + // 是否显示下划线 + underLine: { + type: Boolean, + default: uni.$u.props.link.underLine + }, + // 要跳转的链接 + href: { + type: String, + default: uni.$u.props.link.href + }, + // 小程序中复制到粘贴板的提示语 + mpTips: { + type: String, + default: uni.$u.props.link.mpTips + }, + // 下划线颜色 + lineColor: { + type: String, + default: uni.$u.props.link.lineColor + }, + // 超链接的问题，不使用slot形式传入，是因为nvue下无法修改颜色 + text: { + type: String, + default: uni.$u.props.link.text + } + } +} diff --git a/node_modules/uview-ui/components/u-link/u-link.vue b/node_modules/uview-ui/components/u-link/u-link.vue new file mode 100644 index 0000000..c6802a5 --- /dev/null +++ b/node_modules/uview-ui/components/u-link/u-link.vue @@ -0,0 +1,83 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-list-item/props.js b/node_modules/uview-ui/components/u-list-item/props.js new file mode 100644 index 0000000..58ddc49 --- /dev/null +++ b/node_modules/uview-ui/components/u-list-item/props.js @@ -0,0 +1,9 @@ +export default { + props: { + // 用于滚动到指定item + anchor: { + type: [String, Number], + default: uni.$u.props.listItem.anchor + } + } +} diff --git a/node_modules/uview-ui/components/u-list-item/u-list-item.vue b/node_modules/uview-ui/components/u-list-item/u-list-item.vue new file mode 100644 index 0000000..1a25db6 --- /dev/null +++ b/node_modules/uview-ui/components/u-list-item/u-list-item.vue @@ -0,0 +1,116 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-list/props.js b/node_modules/uview-ui/components/u-list/props.js new file mode 100644 index 0000000..25406f4 --- /dev/null +++ b/node_modules/uview-ui/components/u-list/props.js @@ -0,0 +1,76 @@ +export default { + props: { + // 控制是否出现滚动条，仅nvue有效 + showScrollbar: { + type: Boolean, + default: uni.$u.props.list.showScrollbar + }, + // 距底部多少时触发scrolltolower事件 + lowerThreshold: { + type: [String, Number], + default: uni.$u.props.list.lowerThreshold + }, + // 距顶部多少时触发scrolltoupper事件，非nvue有效 + upperThreshold: { + type: [String, Number], + default: uni.$u.props.list.upperThreshold + }, + // 设置竖向滚动条位置 + scrollTop: { + type: [String, Number], + default: uni.$u.props.list.scrollTop + }, + // 控制 onscroll 事件触发的频率，仅nvue有效 + offsetAccuracy: { + type: [String, Number], + default: uni.$u.props.list.offsetAccuracy + }, + // 启用 flexbox 布局。开启后，当前节点声明了display: flex就会成为flex container，并作用于其孩子节点，仅微信小程序有效 + enableFlex: { + type: Boolean, + default: uni.$u.props.list.enableFlex + }, + // 是否按分页模式显示List，默认值false + pagingEnabled: { + type: Boolean, + default: uni.$u.props.list.pagingEnabled + }, + // 是否允许List滚动 + scrollable: { + type: Boolean, + default: uni.$u.props.list.scrollable + }, + // 值应为某子元素id（id不能以数字开头） + scrollIntoView: { + type: String, + default: uni.$u.props.list.scrollIntoView + }, + // 在设置滚动条位置时使用动画过渡 + scrollWithAnimation: { + type: Boolean, + default: uni.$u.props.list.scrollWithAnimation + }, + // iOS点击顶部状态栏、安卓双击标题栏时，滚动条返回顶部，只对微信小程序有效 + enableBackToTop: { + type: Boolean, + default: uni.$u.props.list.enableBackToTop + }, + // 列表的高度 + height: { + type: [String, Number], + default: uni.$u.props.list.height + }, + // 列表宽度 + width: { + type: [String, Number], + default: uni.$u.props.list.width + }, + // 列表前后预渲染的屏数，1代表一个屏幕的高度，1.5代表1个半屏幕高度 + preLoadScreen: { + type: [String, Number], + default: uni.$u.props.list.preLoadScreen + } + // vue下，是否开启虚拟列表 + + } +} diff --git a/node_modules/uview-ui/components/u-list/u-list.vue b/node_modules/uview-ui/components/u-list/u-list.vue new file mode 100644 index 0000000..4447cab --- /dev/null +++ b/node_modules/uview-ui/components/u-list/u-list.vue @@ -0,0 +1,157 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-loading-icon/props.js b/node_modules/uview-ui/components/u-loading-icon/props.js new file mode 100644 index 0000000..c35524e --- /dev/null +++ b/node_modules/uview-ui/components/u-loading-icon/props.js @@ -0,0 +1,59 @@ +export default { + props: { + // 是否显示组件 + show: { + type: Boolean, + default: uni.$u.props.loadingIcon.show + }, + // 颜色 + color: { + type: String, + default: uni.$u.props.loadingIcon.color + }, + // 提示文字颜色 + textColor: { + type: String, + default: uni.$u.props.loadingIcon.textColor + }, + // 文字和图标是否垂直排列 + vertical: { + type: Boolean, + default: uni.$u.props.loadingIcon.vertical + }, + // 模式选择，circle-圆形，spinner-花朵形，semicircle-半圆形 + mode: { + type: String, + default: uni.$u.props.loadingIcon.mode + }, + // 图标大小，单位默认px + size: { + type: [String, Number], + default: uni.$u.props.loadingIcon.size + }, + // 文字大小 + textSize: { + type: [String, Number], + default: uni.$u.props.loadingIcon.textSize + }, + // 文字内容 + text: { + type: [String, Number], + default: uni.$u.props.loadingIcon.text + }, + // 动画模式 + timingFunction: { + type: String, + default: uni.$u.props.loadingIcon.timingFunction + }, + // 动画执行周期时间 + duration: { + type: [String, Number], + default: uni.$u.props.loadingIcon.duration + }, + // mode=circle时的暗边颜色 + inactiveColor: { + type: String, + default: uni.$u.props.loadingIcon.inactiveColor + } + } +} diff --git a/node_modules/uview-ui/components/u-loading-icon/u-loading-icon.vue b/node_modules/uview-ui/components/u-loading-icon/u-loading-icon.vue new file mode 100644 index 0000000..2ede5c3 --- /dev/null +++ b/node_modules/uview-ui/components/u-loading-icon/u-loading-icon.vue @@ -0,0 +1,343 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-loading-page/props.js b/node_modules/uview-ui/components/u-loading-page/props.js new file mode 100644 index 0000000..e239b61 --- /dev/null +++ b/node_modules/uview-ui/components/u-loading-page/props.js @@ -0,0 +1,49 @@ +export default { + props: { + // 提示内容 + loadingText: { + type: [String, Number], + default: uni.$u.props.loadingPage.loadingText + }, + // 文字上方用于替换loading动画的图片 + image: { + type: String, + default: uni.$u.props.loadingPage.image + }, + // 加载动画的模式，circle-圆形，spinner-花朵形，semicircle-半圆形 + loadingMode: { + type: String, + default: uni.$u.props.loadingPage.loadingMode + }, + // 是否加载中 + loading: { + type: Boolean, + default: uni.$u.props.loadingPage.loading + }, + // 背景色 + bgColor: { + type: String, + default: uni.$u.props.loadingPage.bgColor + }, + // 文字颜色 + color: { + type: String, + default: uni.$u.props.loadingPage.color + }, + // 文字大小 + fontSize: { + type: [String, Number], + default: uni.$u.props.loadingPage.fontSize + }, + // 图标大小 + iconSize: { + type: [String, Number], + default: uni.$u.props.loadingPage.fontSize + }, + // 加载中图标的颜色，只能rgb或者十六进制颜色值 + loadingColor: { + type: String, + default: uni.$u.props.loadingPage.loadingColor + } + } +} diff --git a/node_modules/uview-ui/components/u-loading-page/u-loading-page.vue b/node_modules/uview-ui/components/u-loading-page/u-loading-page.vue new file mode 100644 index 0000000..03a78ad --- /dev/null +++ b/node_modules/uview-ui/components/u-loading-page/u-loading-page.vue @@ -0,0 +1,115 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-loadmore/props.js b/node_modules/uview-ui/components/u-loadmore/props.js new file mode 100644 index 0000000..1e67d89 --- /dev/null +++ b/node_modules/uview-ui/components/u-loadmore/props.js @@ -0,0 +1,94 @@ +export default { + props: { + // 组件状态，loadmore-加载前的状态，loading-加载中的状态，nomore-没有更多的状态 + status: { + type: String, + default: uni.$u.props.loadmore.status + }, + // 组件背景色 + bgColor: { + type: String, + default: uni.$u.props.loadmore.bgColor + }, + // 是否显示加载中的图标 + icon: { + type: Boolean, + default: uni.$u.props.loadmore.icon + }, + // 字体大小 + fontSize: { + type: [String, Number], + default: uni.$u.props.loadmore.fontSize + }, + // 图标大小 + iconSize: { + type: [String, Number], + default: uni.$u.props.loadmore.iconSize + }, + // 字体颜色 + color: { + type: String, + default: uni.$u.props.loadmore.color + }, + // 加载中状态的图标，spinner-花朵状图标，circle-圆圈状，semicircle-半圆 + loadingIcon: { + type: String, + default: uni.$u.props.loadmore.loadingIcon + }, + // 加载前的提示语 + loadmoreText: { + type: String, + default: uni.$u.props.loadmore.loadmoreText + }, + // 加载中提示语 + loadingText: { + type: String, + default: uni.$u.props.loadmore.loadingText + }, + // 没有更多的提示语 + nomoreText: { + type: String, + default: uni.$u.props.loadmore.nomoreText + }, + // 在“没有更多”状态下，是否显示粗点 + isDot: { + type: Boolean, + default: uni.$u.props.loadmore.isDot + }, + // 加载中图标的颜色 + iconColor: { + type: String, + default: uni.$u.props.loadmore.iconColor + }, + // 上边距 + marginTop: { + type: [String, Number], + default: uni.$u.props.loadmore.marginTop + }, + // 下边距 + marginBottom: { + type: [String, Number], + default: uni.$u.props.loadmore.marginBottom + }, + // 高度，单位px + height: { + type: [String, Number], + default: uni.$u.props.loadmore.height + }, + // 是否显示左边分割线 + line: { + type: Boolean, + default: uni.$u.props.loadmore.line + }, + // 线条颜色 + lineColor: { + type: String, + default: uni.$u.props.loadmore.lineColor + }, + // 是否虚线，true-虚线，false-实线 + dashed: { + type: Boolean, + default: uni.$u.props.loadmore.dashed + } + } +} diff --git a/node_modules/uview-ui/components/u-loadmore/u-loadmore.vue b/node_modules/uview-ui/components/u-loadmore/u-loadmore.vue new file mode 100644 index 0000000..73c79fe --- /dev/null +++ b/node_modules/uview-ui/components/u-loadmore/u-loadmore.vue @@ -0,0 +1,150 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-modal/props.js b/node_modules/uview-ui/components/u-modal/props.js new file mode 100644 index 0000000..94b3078 --- /dev/null +++ b/node_modules/uview-ui/components/u-modal/props.js @@ -0,0 +1,89 @@ +export default { + props: { + // 是否展示modal + show: { + type: Boolean, + default: uni.$u.props.modal.show + }, + // 标题 + title: { + type: [String], + default: uni.$u.props.modal.title + }, + // 弹窗内容 + content: { + type: String, + default: uni.$u.props.modal.content + }, + // 确认文案 + confirmText: { + type: String, + default: uni.$u.props.modal.confirmText + }, + // 取消文案 + cancelText: { + type: String, + default: uni.$u.props.modal.cancelText + }, + // 是否显示确认按钮 + showConfirmButton: { + type: Boolean, + default: uni.$u.props.modal.showConfirmButton + }, + // 是否显示取消按钮 + showCancelButton: { + type: Boolean, + default: uni.$u.props.modal.showCancelButton + }, + // 确认按钮颜色 + confirmColor: { + type: String, + default: uni.$u.props.modal.confirmColor + }, + // 取消文字颜色 + cancelColor: { + type: String, + default: uni.$u.props.modal.cancelColor + }, + // 对调确认和取消的位置 + buttonReverse: { + type: Boolean, + default: uni.$u.props.modal.buttonReverse + }, + // 是否开启缩放效果 + zoom: { + type: Boolean, + default: uni.$u.props.modal.zoom + }, + // 是否异步关闭，只对确定按钮有效 + asyncClose: { + type: Boolean, + default: uni.$u.props.modal.asyncClose + }, + // 是否允许点击遮罩关闭modal + closeOnClickOverlay: { + type: Boolean, + default: uni.$u.props.modal.closeOnClickOverlay + }, + // 给一个负的margin-top，往上偏移，避免和键盘重合的情况 + negativeTop: { + type: [String, Number], + default: uni.$u.props.modal.negativeTop + }, + // modal宽度，不支持百分比，可以数值，px，rpx单位 + width: { + type: [String, Number], + default: uni.$u.props.modal.width + }, + // 确认按钮的样式，circle-圆形，square-方形，如设置，将不会显示取消按钮 + confirmButtonShape: { + type: String, + default: uni.$u.props.modal.confirmButtonShape + }, + // 弹窗动画过度时间 + duration:{ + type:String | Number, + default: uni.$u.props.modal.duration + } + } +} diff --git a/node_modules/uview-ui/components/u-modal/u-modal.vue b/node_modules/uview-ui/components/u-modal/u-modal.vue new file mode 100644 index 0000000..72e1ed2 --- /dev/null +++ b/node_modules/uview-ui/components/u-modal/u-modal.vue @@ -0,0 +1,228 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-navbar/props.js b/node_modules/uview-ui/components/u-navbar/props.js new file mode 100644 index 0000000..5398de2 --- /dev/null +++ b/node_modules/uview-ui/components/u-navbar/props.js @@ -0,0 +1,84 @@ +export default { + props: { + // 是否开启顶部安全区适配 + safeAreaInsetTop: { + type: Boolean, + default: uni.$u.props.navbar.safeAreaInsetTop + }, + // 固定在顶部时，是否生成一个等高元素，以防止塌陷 + placeholder: { + type: Boolean, + default: uni.$u.props.navbar.placeholder + }, + // 是否固定在顶部 + fixed: { + type: Boolean, + default: uni.$u.props.navbar.fixed + }, + // 是否显示下边框 + border: { + type: Boolean, + default: uni.$u.props.navbar.border + }, + // 左边的图标 + leftIcon: { + type: String, + default: uni.$u.props.navbar.leftIcon + }, + // 左边的提示文字 + leftText: { + type: String, + default: uni.$u.props.navbar.leftText + }, + // 左右的提示文字 + rightText: { + type: String, + default: uni.$u.props.navbar.rightText + }, + // 右边的图标 + rightIcon: { + type: String, + default: uni.$u.props.navbar.rightIcon + }, + // 标题 + title: { + type: [String, Number], + default: uni.$u.props.navbar.title + }, + // 背景颜色 + bgColor: { + type: String, + default: uni.$u.props.navbar.bgColor + }, + // 标题的宽度 + titleWidth: { + type: [String, Number], + default: uni.$u.props.navbar.titleWidth + }, + // 导航栏高度 + height: { + type: [String, Number], + default: uni.$u.props.navbar.height + }, + // 左侧返回图标的大小 + leftIconSize: { + type: [String, Number], + default: uni.$u.props.navbar.leftIconSize + }, + // 左侧返回图标的颜色 + leftIconColor: { + type: String, + default: uni.$u.props.navbar.leftIconColor + }, + // 点击左侧区域(返回图标)，是否自动返回上一页 + autoBack: { + type: Boolean, + default: uni.$u.props.navbar.autoBack + }, + // 标题的样式，对象或字符串 + titleStyle: { + type: [String, Object], + default: uni.$u.props.navbar.titleStyle + } + } +} diff --git a/node_modules/uview-ui/components/u-navbar/u-navbar.vue b/node_modules/uview-ui/components/u-navbar/u-navbar.vue new file mode 100644 index 0000000..2b206b7 --- /dev/null +++ b/node_modules/uview-ui/components/u-navbar/u-navbar.vue @@ -0,0 +1,186 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-no-network/props.js b/node_modules/uview-ui/components/u-no-network/props.js new file mode 100644 index 0000000..9f3af62 --- /dev/null +++ b/node_modules/uview-ui/components/u-no-network/props.js @@ -0,0 +1,19 @@ +export default { + props: { + // 页面文字提示 + tips: { + type: String, + default: uni.$u.props.noNetwork.tips + }, + // 一个z-index值，用于设置没有网络这个组件的层次，因为页面可能会有其他定位的元素层级过高，导致此组件被覆盖 + zIndex: { + type: [String, Number], + default: uni.$u.props.noNetwork.zIndex + }, + // image 没有网络的图片提示 + image: { + type: String, + default: uni.$u.props.noNetwork.image + } + } +} diff --git a/node_modules/uview-ui/components/u-no-network/u-no-network.vue b/node_modules/uview-ui/components/u-no-network/u-no-network.vue new file mode 100644 index 0000000..9710729 --- /dev/null +++ b/node_modules/uview-ui/components/u-no-network/u-no-network.vue @@ -0,0 +1,220 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-notice-bar/props.js b/node_modules/uview-ui/components/u-notice-bar/props.js new file mode 100644 index 0000000..7040c29 --- /dev/null +++ b/node_modules/uview-ui/components/u-notice-bar/props.js @@ -0,0 +1,70 @@ +export default { + props: { + // 显示的内容，数组 + text: { + type: [Array, String], + default: uni.$u.props.noticeBar.text + }, + // 通告滚动模式，row-横向滚动，column-竖向滚动 + direction: { + type: String, + default: uni.$u.props.noticeBar.direction + }, + // direction = row时，是否使用步进形式滚动 + step: { + type: Boolean, + default: uni.$u.props.noticeBar.step + }, + // 是否显示左侧的音量图标 + icon: { + type: String, + default: uni.$u.props.noticeBar.icon + }, + // 通告模式，link-显示右箭头，closable-显示右侧关闭图标 + mode: { + type: String, + default: uni.$u.props.noticeBar.mode + }, + // 文字颜色，各图标也会使用文字颜色 + color: { + type: String, + default: uni.$u.props.noticeBar.color + }, + // 背景颜色 + bgColor: { + type: String, + default: uni.$u.props.noticeBar.bgColor + }, + // 水平滚动时的滚动速度，即每秒滚动多少px(px)，这有利于控制文字无论多少时，都能有一个恒定的速度 + speed: { + type: [String, Number], + default: uni.$u.props.noticeBar.speed + }, + // 字体大小 + fontSize: { + type: [String, Number], + default: uni.$u.props.noticeBar.fontSize + }, + // 滚动一个周期的时间长，单位ms + duration: { + type: [String, Number], + default: uni.$u.props.noticeBar.duration + }, + // 是否禁止用手滑动切换 + // 目前HX2.6.11，只支持App 2.5.5+、H5 2.5.5+、支付宝小程序、字节跳动小程序 + disableTouch: { + type: Boolean, + default: uni.$u.props.noticeBar.disableTouch + }, + // 跳转的页面路径 + url: { + type: String, + default: uni.$u.props.noticeBar.url + }, + // 页面跳转的类型 + linkType: { + type: String, + default: uni.$u.props.noticeBar.linkType + } + } +} diff --git a/node_modules/uview-ui/components/u-notice-bar/u-notice-bar.vue b/node_modules/uview-ui/components/u-notice-bar/u-notice-bar.vue new file mode 100644 index 0000000..a06eb39 --- /dev/null +++ b/node_modules/uview-ui/components/u-notice-bar/u-notice-bar.vue @@ -0,0 +1,101 @@ + + + + diff --git a/node_modules/uview-ui/components/u-notify/props.js b/node_modules/uview-ui/components/u-notify/props.js new file mode 100644 index 0000000..57a9d71 --- /dev/null +++ b/node_modules/uview-ui/components/u-notify/props.js @@ -0,0 +1,49 @@ +export default { + props: { + // 到顶部的距离 + top: { + type: [String, Number], + default: uni.$u.props.notify.top + }, + // 是否展示组件 + // show: { + // type: Boolean, + // default: uni.$u.props.notify.show + // }, + // type主题，primary，success，warning，error + type: { + type: String, + default: uni.$u.props.notify.type + }, + // 字体颜色 + color: { + type: String, + default: uni.$u.props.notify.color + }, + // 背景颜色 + bgColor: { + type: String, + default: uni.$u.props.notify.bgColor + }, + // 展示的文字内容 + message: { + type: String, + default: uni.$u.props.notify.message + }, + // 展示时长，为0时不消失，单位ms + duration: { + type: [String, Number], + default: uni.$u.props.notify.duration + }, + // 字体大小 + fontSize: { + type: [String, Number], + default: uni.$u.props.notify.fontSize + }, + // 是否留出顶部安全距离（状态栏高度） + safeAreaInsetTop: { + type: Boolean, + default: uni.$u.props.notify.safeAreaInsetTop + } + } +} diff --git a/node_modules/uview-ui/components/u-notify/u-notify.vue b/node_modules/uview-ui/components/u-notify/u-notify.vue new file mode 100644 index 0000000..30adb72 --- /dev/null +++ b/node_modules/uview-ui/components/u-notify/u-notify.vue @@ -0,0 +1,211 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-number-box/props.js b/node_modules/uview-ui/components/u-number-box/props.js new file mode 100644 index 0000000..fb0fa94 --- /dev/null +++ b/node_modules/uview-ui/components/u-number-box/props.js @@ -0,0 +1,109 @@ +export default { + props: { + // 步进器标识符，在change回调返回 + name: { + type: [String, Number], + default: uni.$u.props.numberBox.name + }, + // 用于双向绑定的值，初始化时设置设为默认min值(最小值) + value: { + type: [String, Number], + default: uni.$u.props.numberBox.value + }, + // 最小值 + min: { + type: [String, Number], + default: uni.$u.props.numberBox.min + }, + // 最大值 + max: { + type: [String, Number], + default: uni.$u.props.numberBox.max + }, + // 加减的步长，可为小数 + step: { + type: [String, Number], + default: uni.$u.props.numberBox.step + }, + // 是否只允许输入整数 + integer: { + type: Boolean, + default: uni.$u.props.numberBox.integer + }, + // 是否禁用，包括输入框，加减按钮 + disabled: { + type: Boolean, + default: uni.$u.props.numberBox.disabled + }, + // 是否禁用输入框 + disabledInput: { + type: Boolean, + default: uni.$u.props.numberBox.disabledInput + }, + // 是否开启异步变更，开启后需要手动控制输入值 + asyncChange: { + type: Boolean, + default: uni.$u.props.numberBox.asyncChange + }, + // 输入框宽度，单位为px + inputWidth: { + type: [String, Number], + default: uni.$u.props.numberBox.inputWidth + }, + // 是否显示减少按钮 + showMinus: { + type: Boolean, + default: uni.$u.props.numberBox.showMinus + }, + // 是否显示增加按钮 + showPlus: { + type: Boolean, + default: uni.$u.props.numberBox.showPlus + }, + // 显示的小数位数 + decimalLength: { + type: [String, Number, null], + default: uni.$u.props.numberBox.decimalLength + }, + // 是否开启长按加减手势 + longPress: { + type: Boolean, + default: uni.$u.props.numberBox.longPress + }, + // 输入框文字和加减按钮图标的颜色 + color: { + type: String, + default: uni.$u.props.numberBox.color + }, + // 按钮大小，宽高等于此值，单位px，输入框高度和此值保持一致 + buttonSize: { + type: [String, Number], + default: uni.$u.props.numberBox.buttonSize + }, + // 输入框和按钮的背景颜色 + bgColor: { + type: String, + default: uni.$u.props.numberBox.bgColor + }, + // 指定光标于键盘的距离，避免键盘遮挡输入框，单位px + cursorSpacing: { + type: [String, Number], + default: uni.$u.props.numberBox.cursorSpacing + }, + // 是否禁用增加按钮 + disablePlus: { + type: Boolean, + default: uni.$u.props.numberBox.disablePlus + }, + // 是否禁用减少按钮 + disableMinus: { + type: Boolean, + default: uni.$u.props.numberBox.disableMinus + }, + // 加减按钮图标的样式 + iconStyle: { + type: [Object, String], + default: uni.$u.props.numberBox.iconStyle + } + } +} diff --git a/node_modules/uview-ui/components/u-number-box/u-number-box.vue b/node_modules/uview-ui/components/u-number-box/u-number-box.vue new file mode 100644 index 0000000..69211c5 --- /dev/null +++ b/node_modules/uview-ui/components/u-number-box/u-number-box.vue @@ -0,0 +1,416 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-number-keyboard/props.js b/node_modules/uview-ui/components/u-number-keyboard/props.js new file mode 100644 index 0000000..5e3bf55 --- /dev/null +++ b/node_modules/uview-ui/components/u-number-keyboard/props.js @@ -0,0 +1,19 @@ +export default { + props: { + // 键盘的类型，number-数字键盘，card-身份证键盘 + mode: { + type: String, + default: uni.$u.props.numberKeyboard.value + }, + // 是否显示键盘的"."符号 + dotDisabled: { + type: Boolean, + default: uni.$u.props.numberKeyboard.dotDisabled + }, + // 是否打乱键盘按键的顺序 + random: { + type: Boolean, + default: uni.$u.props.numberKeyboard.random + } + } +} diff --git a/node_modules/uview-ui/components/u-number-keyboard/u-number-keyboard.vue b/node_modules/uview-ui/components/u-number-keyboard/u-number-keyboard.vue new file mode 100644 index 0000000..4f505c6 --- /dev/null +++ b/node_modules/uview-ui/components/u-number-keyboard/u-number-keyboard.vue @@ -0,0 +1,196 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-overlay/props.js b/node_modules/uview-ui/components/u-overlay/props.js new file mode 100644 index 0000000..e6974df --- /dev/null +++ b/node_modules/uview-ui/components/u-overlay/props.js @@ -0,0 +1,24 @@ +export default { + props: { + // 是否显示遮罩 + show: { + type: Boolean, + default: uni.$u.props.overlay.show + }, + // 层级z-index + zIndex: { + type: [String, Number], + default: uni.$u.props.overlay.zIndex + }, + // 遮罩的过渡时间，单位为ms + duration: { + type: [String, Number], + default: uni.$u.props.overlay.duration + }, + // 不透明度值，当做rgba的第四个参数 + opacity: { + type: [String, Number], + default: uni.$u.props.overlay.opacity + } + } +} diff --git a/node_modules/uview-ui/components/u-overlay/u-overlay.vue b/node_modules/uview-ui/components/u-overlay/u-overlay.vue new file mode 100644 index 0000000..92de4e9 --- /dev/null +++ b/node_modules/uview-ui/components/u-overlay/u-overlay.vue @@ -0,0 +1,68 @@ + + + + + diff --git a/node_modules/uview-ui/components/u-parse/node/node.vue b/node_modules/uview-ui/components/u-parse/node/node.vue new file mode 100644 index 0000000..73e30fd --- /dev/null +++ b/node_modules/uview-ui/components/u-parse/node/node.vue @@ -0,0 +1,499 @@ +