update
This commit is contained in:
@@ -0,0 +1,123 @@
|
||||
export type ObjectDefinition = import("./types.ts").ObjectDefinition;
|
||||
export type PropertyDefinition = import("./types.ts").PropertyDefinition;
|
||||
/**
|
||||
* @fileoverview Merge Strategy
|
||||
*/
|
||||
/**
|
||||
* Container class for several different merge strategies.
|
||||
*/
|
||||
export class MergeStrategy {
|
||||
/**
|
||||
* Merges two keys by overwriting the first with the second.
|
||||
* @param {*} value1 The value from the first object key.
|
||||
* @param {*} value2 The value from the second object key.
|
||||
* @returns {*} The second value.
|
||||
*/
|
||||
static overwrite(value1: any, value2: any): any;
|
||||
/**
|
||||
* Merges two keys by replacing the first with the second only if the
|
||||
* second is defined.
|
||||
* @param {*} value1 The value from the first object key.
|
||||
* @param {*} value2 The value from the second object key.
|
||||
* @returns {*} The second value if it is defined.
|
||||
*/
|
||||
static replace(value1: any, value2: any): any;
|
||||
/**
|
||||
* Merges two properties by assigning properties from the second to the first.
|
||||
* @param {*} value1 The value from the first object key.
|
||||
* @param {*} value2 The value from the second object key.
|
||||
* @returns {*} A new object containing properties from both value1 and
|
||||
* value2.
|
||||
*/
|
||||
static assign(value1: any, value2: any): any;
|
||||
}
|
||||
/**
|
||||
* Represents an object validation/merging schema.
|
||||
*/
|
||||
export class ObjectSchema {
|
||||
/**
|
||||
* Creates a new instance.
|
||||
* @param {ObjectDefinition} definitions The schema definitions.
|
||||
*/
|
||||
constructor(definitions: ObjectDefinition);
|
||||
/**
|
||||
* Determines if a strategy has been registered for the given object key.
|
||||
* @param {string} key The object key to find a strategy for.
|
||||
* @returns {boolean} True if the key has a strategy registered, false if not.
|
||||
*/
|
||||
hasKey(key: string): boolean;
|
||||
/**
|
||||
* Merges objects together to create a new object comprised of the keys
|
||||
* of the all objects. Keys are merged based on the each key's merge
|
||||
* strategy.
|
||||
* @param {...Object} objects The objects to merge.
|
||||
* @returns {Object} A new object with a mix of all objects' keys.
|
||||
* @throws {Error} If any object is invalid.
|
||||
*/
|
||||
merge(...objects: any[]): any;
|
||||
/**
|
||||
* Validates an object's keys based on the validate strategy for each key.
|
||||
* @param {Object} object The object to validate.
|
||||
* @returns {void}
|
||||
* @throws {Error} When the object is invalid.
|
||||
*/
|
||||
validate(object: any): void;
|
||||
#private;
|
||||
}
|
||||
/**
|
||||
* @fileoverview Validation Strategy
|
||||
*/
|
||||
/**
|
||||
* Container class for several different validation strategies.
|
||||
*/
|
||||
export class ValidationStrategy {
|
||||
/**
|
||||
* Validates that a value is an array.
|
||||
* @param {*} value The value to validate.
|
||||
* @returns {void}
|
||||
* @throws {TypeError} If the value is invalid.
|
||||
*/
|
||||
static array(value: any): void;
|
||||
/**
|
||||
* Validates that a value is a boolean.
|
||||
* @param {*} value The value to validate.
|
||||
* @returns {void}
|
||||
* @throws {TypeError} If the value is invalid.
|
||||
*/
|
||||
static boolean(value: any): void;
|
||||
/**
|
||||
* Validates that a value is a number.
|
||||
* @param {*} value The value to validate.
|
||||
* @returns {void}
|
||||
* @throws {TypeError} If the value is invalid.
|
||||
*/
|
||||
static number(value: any): void;
|
||||
/**
|
||||
* Validates that a value is a object.
|
||||
* @param {*} value The value to validate.
|
||||
* @returns {void}
|
||||
* @throws {TypeError} If the value is invalid.
|
||||
*/
|
||||
static object(value: any): void;
|
||||
/**
|
||||
* Validates that a value is a object or null.
|
||||
* @param {*} value The value to validate.
|
||||
* @returns {void}
|
||||
* @throws {TypeError} If the value is invalid.
|
||||
*/
|
||||
static "object?"(value: any): void;
|
||||
/**
|
||||
* Validates that a value is a string.
|
||||
* @param {*} value The value to validate.
|
||||
* @returns {void}
|
||||
* @throws {TypeError} If the value is invalid.
|
||||
*/
|
||||
static string(value: any): void;
|
||||
/**
|
||||
* Validates that a value is a non-empty string.
|
||||
* @param {*} value The value to validate.
|
||||
* @returns {void}
|
||||
* @throws {TypeError} If the value is invalid.
|
||||
*/
|
||||
static "string!"(value: any): void;
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
{
|
||||
"name": "react-pdf",
|
||||
"version": "9.2.1",
|
||||
"description": "Display PDFs in your React app as easily as if they were images.",
|
||||
"type": "module",
|
||||
"sideEffects": [
|
||||
"*.css"
|
||||
],
|
||||
"main": "./dist/cjs/index.js",
|
||||
"module": "./dist/esm/index.js",
|
||||
"source": "./src/index.ts",
|
||||
"types": "./dist/cjs/index.d.ts",
|
||||
"exports": {
|
||||
".": {
|
||||
"import": "./dist/esm/index.js",
|
||||
"require": "./dist/cjs/index.js"
|
||||
},
|
||||
"./dist/Page/AnnotationLayer.css": {
|
||||
"import": "./dist/esm/Page/AnnotationLayer.css",
|
||||
"require": "./dist/cjs/Page/AnnotationLayer.css"
|
||||
},
|
||||
"./dist/Page/TextLayer.css": {
|
||||
"import": "./dist/esm/Page/TextLayer.css",
|
||||
"require": "./dist/cjs/Page/TextLayer.css"
|
||||
},
|
||||
"./*": "./*"
|
||||
},
|
||||
"scripts": {
|
||||
"build": "yarn build-js && yarn copy-styles",
|
||||
"build-js": "yarn build-js-esm && yarn build-js-cjs && yarn build-js-cjs-package",
|
||||
"build-js-esm": "tsc --project tsconfig.build.json --outDir dist/esm",
|
||||
"build-js-cjs": "tsc --project tsconfig.build.json --outDir dist/cjs --module commonjs --moduleResolution node --verbatimModuleSyntax false",
|
||||
"build-js-cjs-package": "echo '{\n \"type\": \"commonjs\"\n}' > dist/cjs/package.json",
|
||||
"clean": "rimraf dist",
|
||||
"copy-styles": "cpy 'src/**/*.css' dist/esm && cpy 'src/**/*.css' dist/cjs",
|
||||
"format": "biome format",
|
||||
"lint": "biome lint",
|
||||
"prepack": "yarn clean && yarn build",
|
||||
"test": "yarn lint && yarn tsc && yarn format && yarn unit",
|
||||
"tsc": "tsc",
|
||||
"unit": "vitest",
|
||||
"watch": "yarn build-js-esm --watch & yarn build-js-cjs --watch & node --eval \"fs.watch('src', () => child_process.exec('yarn copy-styles'))\""
|
||||
},
|
||||
"keywords": [
|
||||
"pdf",
|
||||
"pdf-viewer",
|
||||
"react"
|
||||
],
|
||||
"author": {
|
||||
"name": "Wojciech Maj",
|
||||
"email": "kontakt@wojtekmaj.pl"
|
||||
},
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"clsx": "^2.0.0",
|
||||
"dequal": "^2.0.3",
|
||||
"make-cancellable-promise": "^1.3.1",
|
||||
"make-event-props": "^1.6.0",
|
||||
"merge-refs": "^1.3.0",
|
||||
"pdfjs-dist": "4.8.69",
|
||||
"tiny-invariant": "^1.0.0",
|
||||
"warning": "^4.0.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@biomejs/biome": "1.9.0",
|
||||
"@testing-library/dom": "^10.0.0",
|
||||
"@testing-library/jest-dom": "^6.0.0",
|
||||
"@testing-library/react": "^16.0.0",
|
||||
"@types/node": "*",
|
||||
"@types/react": "*",
|
||||
"@types/react-dom": "*",
|
||||
"@types/warning": "^3.0.0",
|
||||
"canvas": "^3.0.0-rc2",
|
||||
"core-js": "^3.37.0",
|
||||
"cpy-cli": "^5.0.0",
|
||||
"jsdom": "^24.0.0",
|
||||
"react": "^18.2.0",
|
||||
"react-dom": "^18.2.0",
|
||||
"rimraf": "^6.0.0",
|
||||
"typescript": "^5.5.2",
|
||||
"vitest": "^2.1.1"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@types/react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
|
||||
"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
|
||||
"react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
|
||||
},
|
||||
"peerDependenciesMeta": {
|
||||
"@types/react": {
|
||||
"optional": true
|
||||
}
|
||||
},
|
||||
"publishConfig": {
|
||||
"access": "public",
|
||||
"provenance": true
|
||||
},
|
||||
"files": [
|
||||
"dist",
|
||||
"src"
|
||||
],
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+https://github.com/wojtekmaj/react-pdf.git",
|
||||
"directory": "packages/react-pdf"
|
||||
},
|
||||
"funding": "https://github.com/wojtekmaj/react-pdf?sponsor=1"
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* @fileoverview Package exports for @eslint/eslintrc
|
||||
* @author Nicholas C. Zakas
|
||||
*/
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
import {
|
||||
ConfigArrayFactory,
|
||||
createContext as createConfigArrayFactoryContext,
|
||||
loadConfigFile
|
||||
} from "./config-array-factory.js";
|
||||
|
||||
import { CascadingConfigArrayFactory } from "./cascading-config-array-factory.js";
|
||||
import * as ModuleResolver from "./shared/relative-module-resolver.js";
|
||||
import { ConfigArray, getUsedExtractedConfigs } from "./config-array/index.js";
|
||||
import { ConfigDependency } from "./config-array/config-dependency.js";
|
||||
import { ExtractedConfig } from "./config-array/extracted-config.js";
|
||||
import { IgnorePattern } from "./config-array/ignore-pattern.js";
|
||||
import { OverrideTester } from "./config-array/override-tester.js";
|
||||
import * as ConfigOps from "./shared/config-ops.js";
|
||||
import ConfigValidator from "./shared/config-validator.js";
|
||||
import * as naming from "./shared/naming.js";
|
||||
import { FlatCompat } from "./flat-compat.js";
|
||||
import environments from "../conf/environments.js";
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Exports
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
const Legacy = {
|
||||
ConfigArray,
|
||||
createConfigArrayFactoryContext,
|
||||
CascadingConfigArrayFactory,
|
||||
ConfigArrayFactory,
|
||||
ConfigDependency,
|
||||
ExtractedConfig,
|
||||
IgnorePattern,
|
||||
OverrideTester,
|
||||
getUsedExtractedConfigs,
|
||||
environments,
|
||||
loadConfigFile,
|
||||
|
||||
// shared
|
||||
ConfigOps,
|
||||
ConfigValidator,
|
||||
ModuleResolver,
|
||||
naming
|
||||
};
|
||||
|
||||
export {
|
||||
|
||||
Legacy,
|
||||
|
||||
FlatCompat
|
||||
|
||||
};
|
||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1 @@
|
||||
import"./chunk-MLJ7HIKW.mjs";import"./chunk-P5FH2LZE.mjs";import"./chunk-HTB5LLOP.mjs";function i(r){let n={};for(let[e,t]of Object.entries(r??{}))if(e!=="__CSS_VALUES__")if(typeof t=="object"&&t!==null)for(let[o,f]of Object.entries(i(t)))n[`${e}${o==="DEFAULT"?"":`-${o}`}`]=f;else n[e]=t;if("__CSS_VALUES__"in r)for(let[e,t]of Object.entries(r.__CSS_VALUES__))(Number(t)&4)===0&&(n[e]=r[e]);return n}export{i as default};
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_options","require","_parse","_populate","stringTemplate","formatter","code","opts","metadata","arg","replacements","normalizeReplacements","parseAndBuildMetadata","unwrap","populatePlaceholders"],"sources":["../src/string.ts"],"sourcesContent":["import type { Formatter } from \"./formatters.ts\";\nimport type { TemplateOpts } from \"./options.ts\";\nimport type { Metadata } from \"./parse.ts\";\nimport { normalizeReplacements } from \"./options.ts\";\nimport parseAndBuildMetadata from \"./parse.ts\";\nimport populatePlaceholders from \"./populate.ts\";\n\nexport default function stringTemplate<T>(\n formatter: Formatter<T>,\n code: string,\n opts: TemplateOpts,\n): (arg?: unknown) => T {\n code = formatter.code(code);\n\n let metadata: Metadata;\n\n return (arg?: unknown) => {\n const replacements = normalizeReplacements(arg);\n\n if (!metadata) metadata = parseAndBuildMetadata(formatter, code, opts);\n\n return formatter.unwrap(populatePlaceholders(metadata, replacements));\n };\n}\n"],"mappings":";;;;;;AAGA,IAAAA,QAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,SAAA,GAAAF,OAAA;AAEe,SAASG,cAAcA,CACpCC,SAAuB,EACvBC,IAAY,EACZC,IAAkB,EACI;EACtBD,IAAI,GAAGD,SAAS,CAACC,IAAI,CAACA,IAAI,CAAC;EAE3B,IAAIE,QAAkB;EAEtB,OAAQC,GAAa,IAAK;IACxB,MAAMC,YAAY,GAAG,IAAAC,8BAAqB,EAACF,GAAG,CAAC;IAE/C,IAAI,CAACD,QAAQ,EAAEA,QAAQ,GAAG,IAAAI,cAAqB,EAACP,SAAS,EAAEC,IAAI,EAAEC,IAAI,CAAC;IAEtE,OAAOF,SAAS,CAACQ,MAAM,CAAC,IAAAC,iBAAoB,EAACN,QAAQ,EAAEE,YAAY,CAAC,CAAC;EACvE,CAAC;AACH","ignoreList":[]}
|
||||
@@ -0,0 +1,40 @@
|
||||
/**
|
||||
* @license React
|
||||
* react-jsx-runtime.react-server.production.js
|
||||
*
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
var React = require("react"),
|
||||
REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
|
||||
REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
|
||||
if (!React.__SERVER_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE)
|
||||
throw Error(
|
||||
'The "react" package in this environment is not configured correctly. The "react-server" condition must be enabled in any environment that runs React Server Components.'
|
||||
);
|
||||
function jsxProd(type, config, maybeKey) {
|
||||
var key = null;
|
||||
void 0 !== maybeKey && (key = "" + maybeKey);
|
||||
void 0 !== config.key && (key = "" + config.key);
|
||||
if ("key" in config) {
|
||||
maybeKey = {};
|
||||
for (var propName in config)
|
||||
"key" !== propName && (maybeKey[propName] = config[propName]);
|
||||
} else maybeKey = config;
|
||||
config = maybeKey.ref;
|
||||
return {
|
||||
$$typeof: REACT_ELEMENT_TYPE,
|
||||
type: type,
|
||||
key: key,
|
||||
ref: void 0 !== config ? config : null,
|
||||
props: maybeKey
|
||||
};
|
||||
}
|
||||
exports.Fragment = REACT_FRAGMENT_TYPE;
|
||||
exports.jsx = jsxProd;
|
||||
exports.jsxDEV = void 0;
|
||||
exports.jsxs = jsxProd;
|
||||
@@ -0,0 +1,13 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = _checkPrivateRedeclaration;
|
||||
function _checkPrivateRedeclaration(obj, privateCollection) {
|
||||
if (privateCollection.has(obj)) {
|
||||
throw new TypeError("Cannot initialize the same private elements twice on an object");
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=checkPrivateRedeclaration.js.map
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_classApplyDescriptorGet","receiver","descriptor","get","call","value"],"sources":["../../src/helpers/classApplyDescriptorGet.js"],"sourcesContent":["/* @minVersion 7.13.10 */\n/* @onlyBabel7 */\n\nexport default function _classApplyDescriptorGet(receiver, descriptor) {\n if (descriptor.get) {\n return descriptor.get.call(receiver);\n }\n return descriptor.value;\n}\n"],"mappings":";;;;;;AAGe,SAASA,wBAAwBA,CAACC,QAAQ,EAAEC,UAAU,EAAE;EACrE,IAAIA,UAAU,CAACC,GAAG,EAAE;IAClB,OAAOD,UAAU,CAACC,GAAG,CAACC,IAAI,CAACH,QAAQ,CAAC;EACtC;EACA,OAAOC,UAAU,CAACG,KAAK;AACzB","ignoreList":[]}
|
||||
@@ -0,0 +1,168 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema#",
|
||||
"$id": "http://json-schema.org/draft-07/schema#",
|
||||
"title": "Core schema meta-schema",
|
||||
"definitions": {
|
||||
"schemaArray": {
|
||||
"type": "array",
|
||||
"minItems": 1,
|
||||
"items": { "$ref": "#" }
|
||||
},
|
||||
"nonNegativeInteger": {
|
||||
"type": "integer",
|
||||
"minimum": 0
|
||||
},
|
||||
"nonNegativeIntegerDefault0": {
|
||||
"allOf": [
|
||||
{ "$ref": "#/definitions/nonNegativeInteger" },
|
||||
{ "default": 0 }
|
||||
]
|
||||
},
|
||||
"simpleTypes": {
|
||||
"enum": [
|
||||
"array",
|
||||
"boolean",
|
||||
"integer",
|
||||
"null",
|
||||
"number",
|
||||
"object",
|
||||
"string"
|
||||
]
|
||||
},
|
||||
"stringArray": {
|
||||
"type": "array",
|
||||
"items": { "type": "string" },
|
||||
"uniqueItems": true,
|
||||
"default": []
|
||||
}
|
||||
},
|
||||
"type": ["object", "boolean"],
|
||||
"properties": {
|
||||
"$id": {
|
||||
"type": "string",
|
||||
"format": "uri-reference"
|
||||
},
|
||||
"$schema": {
|
||||
"type": "string",
|
||||
"format": "uri"
|
||||
},
|
||||
"$ref": {
|
||||
"type": "string",
|
||||
"format": "uri-reference"
|
||||
},
|
||||
"$comment": {
|
||||
"type": "string"
|
||||
},
|
||||
"title": {
|
||||
"type": "string"
|
||||
},
|
||||
"description": {
|
||||
"type": "string"
|
||||
},
|
||||
"default": true,
|
||||
"readOnly": {
|
||||
"type": "boolean",
|
||||
"default": false
|
||||
},
|
||||
"examples": {
|
||||
"type": "array",
|
||||
"items": true
|
||||
},
|
||||
"multipleOf": {
|
||||
"type": "number",
|
||||
"exclusiveMinimum": 0
|
||||
},
|
||||
"maximum": {
|
||||
"type": "number"
|
||||
},
|
||||
"exclusiveMaximum": {
|
||||
"type": "number"
|
||||
},
|
||||
"minimum": {
|
||||
"type": "number"
|
||||
},
|
||||
"exclusiveMinimum": {
|
||||
"type": "number"
|
||||
},
|
||||
"maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
|
||||
"minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
|
||||
"pattern": {
|
||||
"type": "string",
|
||||
"format": "regex"
|
||||
},
|
||||
"additionalItems": { "$ref": "#" },
|
||||
"items": {
|
||||
"anyOf": [
|
||||
{ "$ref": "#" },
|
||||
{ "$ref": "#/definitions/schemaArray" }
|
||||
],
|
||||
"default": true
|
||||
},
|
||||
"maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
|
||||
"minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
|
||||
"uniqueItems": {
|
||||
"type": "boolean",
|
||||
"default": false
|
||||
},
|
||||
"contains": { "$ref": "#" },
|
||||
"maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
|
||||
"minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
|
||||
"required": { "$ref": "#/definitions/stringArray" },
|
||||
"additionalProperties": { "$ref": "#" },
|
||||
"definitions": {
|
||||
"type": "object",
|
||||
"additionalProperties": { "$ref": "#" },
|
||||
"default": {}
|
||||
},
|
||||
"properties": {
|
||||
"type": "object",
|
||||
"additionalProperties": { "$ref": "#" },
|
||||
"default": {}
|
||||
},
|
||||
"patternProperties": {
|
||||
"type": "object",
|
||||
"additionalProperties": { "$ref": "#" },
|
||||
"propertyNames": { "format": "regex" },
|
||||
"default": {}
|
||||
},
|
||||
"dependencies": {
|
||||
"type": "object",
|
||||
"additionalProperties": {
|
||||
"anyOf": [
|
||||
{ "$ref": "#" },
|
||||
{ "$ref": "#/definitions/stringArray" }
|
||||
]
|
||||
}
|
||||
},
|
||||
"propertyNames": { "$ref": "#" },
|
||||
"const": true,
|
||||
"enum": {
|
||||
"type": "array",
|
||||
"items": true,
|
||||
"minItems": 1,
|
||||
"uniqueItems": true
|
||||
},
|
||||
"type": {
|
||||
"anyOf": [
|
||||
{ "$ref": "#/definitions/simpleTypes" },
|
||||
{
|
||||
"type": "array",
|
||||
"items": { "$ref": "#/definitions/simpleTypes" },
|
||||
"minItems": 1,
|
||||
"uniqueItems": true
|
||||
}
|
||||
]
|
||||
},
|
||||
"format": { "type": "string" },
|
||||
"contentMediaType": { "type": "string" },
|
||||
"contentEncoding": { "type": "string" },
|
||||
"if": {"$ref": "#"},
|
||||
"then": {"$ref": "#"},
|
||||
"else": {"$ref": "#"},
|
||||
"allOf": { "$ref": "#/definitions/schemaArray" },
|
||||
"anyOf": { "$ref": "#/definitions/schemaArray" },
|
||||
"oneOf": { "$ref": "#/definitions/schemaArray" },
|
||||
"not": { "$ref": "#" }
|
||||
},
|
||||
"default": true
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"1":"F A B","2":"mC","8":"K D E"},B:{"1":"0 9 C L M G N O P Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I"},C:{"1":"0 1 2 3 4 5 6 7 8 9 LC J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC oC pC qC rC","8":"nC"},D:{"1":"0 1 2 3 4 5 6 7 8 9 J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC"},E:{"1":"J PB K D E F A B C L M G sC SC tC uC vC wC TC FC GC xC yC zC UC VC HC 0C IC WC XC YC ZC aC 1C JC bC cC dC eC fC 2C KC gC hC iC jC 3C"},F:{"1":"0 1 2 3 4 5 6 7 8 B C G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z 4C 5C 6C 7C FC kC 8C GC","2":"F"},G:{"1":"E SC 9C lC AD BD CD DD ED FD GD HD ID JD KD LD MD ND OD PD QD RD SD UC VC HC TD IC WC XC YC ZC aC UD JC bC cC dC eC fC VD KC gC hC iC jC"},H:{"1":"WD"},I:{"1":"LC J I XD YD ZD aD lC bD cD"},J:{"1":"D A"},K:{"1":"A B C H FC kC GC"},L:{"1":"I"},M:{"1":"EC"},N:{"1":"A B"},O:{"1":"HC"},P:{"1":"1 2 3 4 5 6 7 8 J dD eD fD gD hD TC iD jD kD lD mD IC JC KC nD"},Q:{"1":"oD"},R:{"1":"pD"},S:{"1":"qD rD"}},B:1,C:"getElementsByClassName",D:true};
|
||||
@@ -0,0 +1,398 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports._guessExecutionStatusRelativeTo = _guessExecutionStatusRelativeTo;
|
||||
exports._resolve = _resolve;
|
||||
exports.canHaveVariableDeclarationOrExpression = canHaveVariableDeclarationOrExpression;
|
||||
exports.canSwapBetweenExpressionAndStatement = canSwapBetweenExpressionAndStatement;
|
||||
exports.getSource = getSource;
|
||||
exports.isCompletionRecord = isCompletionRecord;
|
||||
exports.isConstantExpression = isConstantExpression;
|
||||
exports.isInStrictMode = isInStrictMode;
|
||||
exports.isNodeType = isNodeType;
|
||||
exports.isStatementOrBlock = isStatementOrBlock;
|
||||
exports.isStatic = isStatic;
|
||||
exports.matchesPattern = matchesPattern;
|
||||
exports.referencesImport = referencesImport;
|
||||
exports.resolve = resolve;
|
||||
exports.willIMaybeExecuteBefore = willIMaybeExecuteBefore;
|
||||
var _t = require("@babel/types");
|
||||
const {
|
||||
STATEMENT_OR_BLOCK_KEYS,
|
||||
VISITOR_KEYS,
|
||||
isBlockStatement,
|
||||
isExpression,
|
||||
isIdentifier,
|
||||
isLiteral,
|
||||
isStringLiteral,
|
||||
isType,
|
||||
matchesPattern: _matchesPattern
|
||||
} = _t;
|
||||
function matchesPattern(pattern, allowPartial) {
|
||||
return _matchesPattern(this.node, pattern, allowPartial);
|
||||
}
|
||||
{
|
||||
exports.has = function has(key) {
|
||||
var _this$node;
|
||||
const val = (_this$node = this.node) == null ? void 0 : _this$node[key];
|
||||
if (val && Array.isArray(val)) {
|
||||
return !!val.length;
|
||||
} else {
|
||||
return !!val;
|
||||
}
|
||||
};
|
||||
}
|
||||
function isStatic() {
|
||||
return this.scope.isStatic(this.node);
|
||||
}
|
||||
{
|
||||
exports.is = exports.has;
|
||||
exports.isnt = function isnt(key) {
|
||||
return !this.has(key);
|
||||
};
|
||||
exports.equals = function equals(key, value) {
|
||||
return this.node[key] === value;
|
||||
};
|
||||
}
|
||||
function isNodeType(type) {
|
||||
return isType(this.type, type);
|
||||
}
|
||||
function canHaveVariableDeclarationOrExpression() {
|
||||
return (this.key === "init" || this.key === "left") && this.parentPath.isFor();
|
||||
}
|
||||
function canSwapBetweenExpressionAndStatement(replacement) {
|
||||
if (this.key !== "body" || !this.parentPath.isArrowFunctionExpression()) {
|
||||
return false;
|
||||
}
|
||||
if (this.isExpression()) {
|
||||
return isBlockStatement(replacement);
|
||||
} else if (this.isBlockStatement()) {
|
||||
return isExpression(replacement);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function isCompletionRecord(allowInsideFunction) {
|
||||
let path = this;
|
||||
let first = true;
|
||||
do {
|
||||
const {
|
||||
type,
|
||||
container
|
||||
} = path;
|
||||
if (!first && (path.isFunction() || type === "StaticBlock")) {
|
||||
return !!allowInsideFunction;
|
||||
}
|
||||
first = false;
|
||||
if (Array.isArray(container) && path.key !== container.length - 1) {
|
||||
return false;
|
||||
}
|
||||
} while ((path = path.parentPath) && !path.isProgram() && !path.isDoExpression());
|
||||
return true;
|
||||
}
|
||||
function isStatementOrBlock() {
|
||||
if (this.parentPath.isLabeledStatement() || isBlockStatement(this.container)) {
|
||||
return false;
|
||||
} else {
|
||||
return STATEMENT_OR_BLOCK_KEYS.includes(this.key);
|
||||
}
|
||||
}
|
||||
function referencesImport(moduleSource, importName) {
|
||||
if (!this.isReferencedIdentifier()) {
|
||||
if (this.isJSXMemberExpression() && this.node.property.name === importName || (this.isMemberExpression() || this.isOptionalMemberExpression()) && (this.node.computed ? isStringLiteral(this.node.property, {
|
||||
value: importName
|
||||
}) : this.node.property.name === importName)) {
|
||||
const object = this.get("object");
|
||||
return object.isReferencedIdentifier() && object.referencesImport(moduleSource, "*");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
const binding = this.scope.getBinding(this.node.name);
|
||||
if (!binding || binding.kind !== "module") return false;
|
||||
const path = binding.path;
|
||||
const parent = path.parentPath;
|
||||
if (!parent.isImportDeclaration()) return false;
|
||||
if (parent.node.source.value === moduleSource) {
|
||||
if (!importName) return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
if (path.isImportDefaultSpecifier() && importName === "default") {
|
||||
return true;
|
||||
}
|
||||
if (path.isImportNamespaceSpecifier() && importName === "*") {
|
||||
return true;
|
||||
}
|
||||
if (path.isImportSpecifier() && isIdentifier(path.node.imported, {
|
||||
name: importName
|
||||
})) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function getSource() {
|
||||
const node = this.node;
|
||||
if (node.end) {
|
||||
const code = this.hub.getCode();
|
||||
if (code) return code.slice(node.start, node.end);
|
||||
}
|
||||
return "";
|
||||
}
|
||||
function willIMaybeExecuteBefore(target) {
|
||||
return this._guessExecutionStatusRelativeTo(target) !== "after";
|
||||
}
|
||||
function getOuterFunction(path) {
|
||||
return path.isProgram() ? path : (path.parentPath.scope.getFunctionParent() || path.parentPath.scope.getProgramParent()).path;
|
||||
}
|
||||
function isExecutionUncertain(type, key) {
|
||||
switch (type) {
|
||||
case "LogicalExpression":
|
||||
return key === "right";
|
||||
case "ConditionalExpression":
|
||||
case "IfStatement":
|
||||
return key === "consequent" || key === "alternate";
|
||||
case "WhileStatement":
|
||||
case "DoWhileStatement":
|
||||
case "ForInStatement":
|
||||
case "ForOfStatement":
|
||||
return key === "body";
|
||||
case "ForStatement":
|
||||
return key === "body" || key === "update";
|
||||
case "SwitchStatement":
|
||||
return key === "cases";
|
||||
case "TryStatement":
|
||||
return key === "handler";
|
||||
case "AssignmentPattern":
|
||||
return key === "right";
|
||||
case "OptionalMemberExpression":
|
||||
return key === "property";
|
||||
case "OptionalCallExpression":
|
||||
return key === "arguments";
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
function isExecutionUncertainInList(paths, maxIndex) {
|
||||
for (let i = 0; i < maxIndex; i++) {
|
||||
const path = paths[i];
|
||||
if (isExecutionUncertain(path.parent.type, path.parentKey)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
const SYMBOL_CHECKING = Symbol();
|
||||
function _guessExecutionStatusRelativeTo(target) {
|
||||
return _guessExecutionStatusRelativeToCached(this, target, new Map());
|
||||
}
|
||||
function _guessExecutionStatusRelativeToCached(base, target, cache) {
|
||||
const funcParent = {
|
||||
this: getOuterFunction(base),
|
||||
target: getOuterFunction(target)
|
||||
};
|
||||
if (funcParent.target.node !== funcParent.this.node) {
|
||||
return _guessExecutionStatusRelativeToDifferentFunctionsCached(base, funcParent.target, cache);
|
||||
}
|
||||
const paths = {
|
||||
target: target.getAncestry(),
|
||||
this: base.getAncestry()
|
||||
};
|
||||
if (paths.target.includes(base)) return "after";
|
||||
if (paths.this.includes(target)) return "before";
|
||||
let commonPath;
|
||||
const commonIndex = {
|
||||
target: 0,
|
||||
this: 0
|
||||
};
|
||||
while (!commonPath && commonIndex.this < paths.this.length) {
|
||||
const path = paths.this[commonIndex.this];
|
||||
commonIndex.target = paths.target.indexOf(path);
|
||||
if (commonIndex.target >= 0) {
|
||||
commonPath = path;
|
||||
} else {
|
||||
commonIndex.this++;
|
||||
}
|
||||
}
|
||||
if (!commonPath) {
|
||||
throw new Error("Internal Babel error - The two compared nodes" + " don't appear to belong to the same program.");
|
||||
}
|
||||
if (isExecutionUncertainInList(paths.this, commonIndex.this - 1) || isExecutionUncertainInList(paths.target, commonIndex.target - 1)) {
|
||||
return "unknown";
|
||||
}
|
||||
const divergence = {
|
||||
this: paths.this[commonIndex.this - 1],
|
||||
target: paths.target[commonIndex.target - 1]
|
||||
};
|
||||
if (divergence.target.listKey && divergence.this.listKey && divergence.target.container === divergence.this.container) {
|
||||
return divergence.target.key > divergence.this.key ? "before" : "after";
|
||||
}
|
||||
const keys = VISITOR_KEYS[commonPath.type];
|
||||
const keyPosition = {
|
||||
this: keys.indexOf(divergence.this.parentKey),
|
||||
target: keys.indexOf(divergence.target.parentKey)
|
||||
};
|
||||
return keyPosition.target > keyPosition.this ? "before" : "after";
|
||||
}
|
||||
function _guessExecutionStatusRelativeToDifferentFunctionsInternal(base, target, cache) {
|
||||
if (!target.isFunctionDeclaration()) {
|
||||
if (_guessExecutionStatusRelativeToCached(base, target, cache) === "before") {
|
||||
return "before";
|
||||
}
|
||||
return "unknown";
|
||||
} else if (target.parentPath.isExportDeclaration()) {
|
||||
return "unknown";
|
||||
}
|
||||
const binding = target.scope.getBinding(target.node.id.name);
|
||||
if (!binding.references) return "before";
|
||||
const referencePaths = binding.referencePaths;
|
||||
let allStatus;
|
||||
for (const path of referencePaths) {
|
||||
const childOfFunction = !!path.find(path => path.node === target.node);
|
||||
if (childOfFunction) continue;
|
||||
if (path.key !== "callee" || !path.parentPath.isCallExpression()) {
|
||||
return "unknown";
|
||||
}
|
||||
const status = _guessExecutionStatusRelativeToCached(base, path, cache);
|
||||
if (allStatus && allStatus !== status) {
|
||||
return "unknown";
|
||||
} else {
|
||||
allStatus = status;
|
||||
}
|
||||
}
|
||||
return allStatus;
|
||||
}
|
||||
function _guessExecutionStatusRelativeToDifferentFunctionsCached(base, target, cache) {
|
||||
let nodeMap = cache.get(base.node);
|
||||
let cached;
|
||||
if (!nodeMap) {
|
||||
cache.set(base.node, nodeMap = new Map());
|
||||
} else if (cached = nodeMap.get(target.node)) {
|
||||
if (cached === SYMBOL_CHECKING) {
|
||||
return "unknown";
|
||||
}
|
||||
return cached;
|
||||
}
|
||||
nodeMap.set(target.node, SYMBOL_CHECKING);
|
||||
const result = _guessExecutionStatusRelativeToDifferentFunctionsInternal(base, target, cache);
|
||||
nodeMap.set(target.node, result);
|
||||
return result;
|
||||
}
|
||||
function resolve(dangerous, resolved) {
|
||||
return _resolve.call(this, dangerous, resolved) || this;
|
||||
}
|
||||
function _resolve(dangerous, resolved) {
|
||||
var _resolved;
|
||||
if ((_resolved = resolved) != null && _resolved.includes(this)) return;
|
||||
resolved = resolved || [];
|
||||
resolved.push(this);
|
||||
if (this.isVariableDeclarator()) {
|
||||
if (this.get("id").isIdentifier()) {
|
||||
return this.get("init").resolve(dangerous, resolved);
|
||||
} else {}
|
||||
} else if (this.isReferencedIdentifier()) {
|
||||
const binding = this.scope.getBinding(this.node.name);
|
||||
if (!binding) return;
|
||||
if (!binding.constant) return;
|
||||
if (binding.kind === "module") return;
|
||||
if (binding.path !== this) {
|
||||
const ret = binding.path.resolve(dangerous, resolved);
|
||||
if (this.find(parent => parent.node === ret.node)) return;
|
||||
return ret;
|
||||
}
|
||||
} else if (this.isTypeCastExpression()) {
|
||||
return this.get("expression").resolve(dangerous, resolved);
|
||||
} else if (dangerous && this.isMemberExpression()) {
|
||||
const targetKey = this.toComputedKey();
|
||||
if (!isLiteral(targetKey)) return;
|
||||
const targetName = targetKey.value;
|
||||
const target = this.get("object").resolve(dangerous, resolved);
|
||||
if (target.isObjectExpression()) {
|
||||
const props = target.get("properties");
|
||||
for (const prop of props) {
|
||||
if (!prop.isProperty()) continue;
|
||||
const key = prop.get("key");
|
||||
let match = prop.isnt("computed") && key.isIdentifier({
|
||||
name: targetName
|
||||
});
|
||||
match = match || key.isLiteral({
|
||||
value: targetName
|
||||
});
|
||||
if (match) return prop.get("value").resolve(dangerous, resolved);
|
||||
}
|
||||
} else if (target.isArrayExpression() && !isNaN(+targetName)) {
|
||||
const elems = target.get("elements");
|
||||
const elem = elems[targetName];
|
||||
if (elem) return elem.resolve(dangerous, resolved);
|
||||
}
|
||||
}
|
||||
}
|
||||
function isConstantExpression() {
|
||||
if (this.isIdentifier()) {
|
||||
const binding = this.scope.getBinding(this.node.name);
|
||||
if (!binding) return false;
|
||||
return binding.constant;
|
||||
}
|
||||
if (this.isLiteral()) {
|
||||
if (this.isRegExpLiteral()) {
|
||||
return false;
|
||||
}
|
||||
if (this.isTemplateLiteral()) {
|
||||
return this.get("expressions").every(expression => expression.isConstantExpression());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (this.isUnaryExpression()) {
|
||||
if (this.node.operator !== "void") {
|
||||
return false;
|
||||
}
|
||||
return this.get("argument").isConstantExpression();
|
||||
}
|
||||
if (this.isBinaryExpression()) {
|
||||
const {
|
||||
operator
|
||||
} = this.node;
|
||||
return operator !== "in" && operator !== "instanceof" && this.get("left").isConstantExpression() && this.get("right").isConstantExpression();
|
||||
}
|
||||
if (this.isMemberExpression()) {
|
||||
return !this.node.computed && this.get("object").isIdentifier({
|
||||
name: "Symbol"
|
||||
}) && !this.scope.hasBinding("Symbol", {
|
||||
noGlobals: true
|
||||
});
|
||||
}
|
||||
if (this.isCallExpression()) {
|
||||
return this.node.arguments.length === 1 && this.get("callee").matchesPattern("Symbol.for") && !this.scope.hasBinding("Symbol", {
|
||||
noGlobals: true
|
||||
}) && this.get("arguments")[0].isStringLiteral();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function isInStrictMode() {
|
||||
const start = this.isProgram() ? this : this.parentPath;
|
||||
const strictParent = start.find(path => {
|
||||
if (path.isProgram({
|
||||
sourceType: "module"
|
||||
})) return true;
|
||||
if (path.isClass()) return true;
|
||||
if (path.isArrowFunctionExpression() && !path.get("body").isBlockStatement()) {
|
||||
return false;
|
||||
}
|
||||
let body;
|
||||
if (path.isFunction()) {
|
||||
body = path.node.body;
|
||||
} else if (path.isProgram()) {
|
||||
body = path.node;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
for (const directive of body.directives) {
|
||||
if (directive.value.value === "use strict") {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
});
|
||||
return !!strictParent;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=introspection.js.map
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"RouterProvider.cjs","sources":["../../src/RouterProvider.tsx"],"sourcesContent":["import * as React from 'react'\nimport { Matches } from './Matches'\nimport { getRouterContext } from './routerContext'\nimport type {\n AnyRouter,\n RegisteredRouter,\n RouterOptions,\n} from '@tanstack/router-core'\n\nexport function RouterContextProvider<\n TRouter extends AnyRouter = RegisteredRouter,\n TDehydrated extends Record<string, any> = Record<string, any>,\n>({\n router,\n children,\n ...rest\n}: RouterProps<TRouter, TDehydrated> & {\n children: React.ReactNode\n}) {\n // Allow the router to update options on the router instance\n router.update({\n ...router.options,\n ...rest,\n context: {\n ...router.options.context,\n ...rest.context,\n },\n } as any)\n\n const routerContext = getRouterContext()\n\n const provider = (\n <routerContext.Provider value={router as AnyRouter}>\n {children}\n </routerContext.Provider>\n )\n\n if (router.options.Wrap) {\n return <router.options.Wrap>{provider}</router.options.Wrap>\n }\n\n return provider\n}\n\nexport function RouterProvider<\n TRouter extends AnyRouter = RegisteredRouter,\n TDehydrated extends Record<string, any> = Record<string, any>,\n>({ router, ...rest }: RouterProps<TRouter, TDehydrated>) {\n return (\n <RouterContextProvider router={router} {...rest}>\n <Matches />\n </RouterContextProvider>\n )\n}\n\nexport type RouterProps<\n TRouter extends AnyRouter = RegisteredRouter,\n TDehydrated extends Record<string, any> = Record<string, any>,\n> = Omit<\n RouterOptions<\n TRouter['routeTree'],\n NonNullable<TRouter['options']['trailingSlash']>,\n NonNullable<TRouter['options']['defaultStructuralSharing']>,\n TRouter['history'],\n TDehydrated\n >,\n 'context'\n> & {\n router: TRouter\n context?: Partial<\n RouterOptions<\n TRouter['routeTree'],\n NonNullable<TRouter['options']['trailingSlash']>,\n NonNullable<TRouter['options']['defaultStructuralSharing']>,\n TRouter['history'],\n TDehydrated\n >['context']\n >\n}\n"],"names":["routerContext","getRouterContext","jsx","Matches"],"mappings":";;;;;AASO,SAAS,sBAGd;AAAA,EACA;AAAA,EACA;AAAA,EACA,GAAG;AACL,GAEG;AAED,SAAO,OAAO;AAAA,IACZ,GAAG,OAAO;AAAA,IACV,GAAG;AAAA,IACH,SAAS;AAAA,MACP,GAAG,OAAO,QAAQ;AAAA,MAClB,GAAG,KAAK;AAAA,IAAA;AAAA,EACV,CACM;AAER,QAAMA,kBAAgBC,cAAAA,iBAAiB;AAEvC,QAAM,WACHC,2BAAA,IAAAF,gBAAc,UAAd,EAAuB,OAAO,QAC5B,UACH;AAGE,MAAA,OAAO,QAAQ,MAAM;AACvB,WAAQE,2BAAAA,IAAA,OAAO,QAAQ,MAAf,EAAqB,UAAS,UAAA;AAAA,EAAA;AAGjC,SAAA;AACT;AAEO,SAAS,eAGd,EAAE,QAAQ,GAAG,QAA2C;AACxD,wCACG,uBAAsB,EAAA,QAAiB,GAAG,MACzC,UAAAA,+BAACC,QAAAA,UAAQ,CAAA,GACX;AAEJ;;;"}
|
||||
@@ -0,0 +1,796 @@
|
||||
// Copyright (c) 2010 LearnBoost <tj@learnboost.com>
|
||||
|
||||
#include "color.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <limits>
|
||||
#include <map>
|
||||
#include <string>
|
||||
|
||||
// Compatibility with Visual Studio versions prior to VS2015
|
||||
#if defined(_MSC_VER) && _MSC_VER < 1900
|
||||
#define snprintf _snprintf
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Parse integer value
|
||||
*/
|
||||
|
||||
template <typename parsed_t>
|
||||
static bool
|
||||
parse_integer(const char** pStr, parsed_t *pParsed) {
|
||||
parsed_t& c = *pParsed;
|
||||
const char*& str = *pStr;
|
||||
int8_t sign=1;
|
||||
|
||||
c = 0;
|
||||
if (*str == '-') {
|
||||
sign=-1;
|
||||
++str;
|
||||
}
|
||||
else if (*str == '+')
|
||||
++str;
|
||||
|
||||
if (*str >= '0' && *str <= '9') {
|
||||
do {
|
||||
c *= 10;
|
||||
c += *str++ - '0';
|
||||
} while (*str >= '0' && *str <= '9');
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
if (sign<0)
|
||||
c=-c;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Parse CSS <number> value
|
||||
* Adapted from http://crackprogramming.blogspot.co.il/2012/10/implement-atof.html
|
||||
*/
|
||||
|
||||
template <typename parsed_t>
|
||||
static bool
|
||||
parse_css_number(const char** pStr, parsed_t *pParsed) {
|
||||
parsed_t &parsed = *pParsed;
|
||||
const char*& str = *pStr;
|
||||
const char* startStr = str;
|
||||
if (!str || !*str)
|
||||
return false;
|
||||
parsed_t integerPart = 0;
|
||||
parsed_t fractionPart = 0;
|
||||
int divisorForFraction = 1;
|
||||
int sign = 1;
|
||||
int exponent = 0;
|
||||
int digits = 0;
|
||||
bool inFraction = false;
|
||||
|
||||
if (*str == '-') {
|
||||
++str;
|
||||
sign = -1;
|
||||
}
|
||||
else if (*str == '+')
|
||||
++str;
|
||||
while (*str != '\0') {
|
||||
if (*str >= '0' && *str <= '9') {
|
||||
if (digits>=std::numeric_limits<parsed_t>::digits10) {
|
||||
if (!inFraction)
|
||||
return false;
|
||||
}
|
||||
else {
|
||||
++digits;
|
||||
|
||||
if (inFraction) {
|
||||
fractionPart = fractionPart*10 + (*str - '0');
|
||||
divisorForFraction *= 10;
|
||||
}
|
||||
else {
|
||||
integerPart = integerPart*10 + (*str - '0');
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (*str == '.') {
|
||||
if (inFraction)
|
||||
break;
|
||||
else
|
||||
inFraction = true;
|
||||
}
|
||||
else if (*str == 'e') {
|
||||
++str;
|
||||
if (!parse_integer(&str, &exponent))
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
else
|
||||
break;
|
||||
++str;
|
||||
}
|
||||
if (str != startStr) {
|
||||
parsed = sign * (integerPart + fractionPart/divisorForFraction);
|
||||
for (;exponent>0;--exponent)
|
||||
parsed *= 10;
|
||||
for (;exponent<0;++exponent)
|
||||
parsed /= 10;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Clip value to the range [minValue, maxValue]
|
||||
*/
|
||||
|
||||
template <typename T>
|
||||
static T
|
||||
clip(T value, T minValue, T maxValue) {
|
||||
if (value > maxValue)
|
||||
value = maxValue;
|
||||
if (value < minValue)
|
||||
value = minValue;
|
||||
return value;
|
||||
}
|
||||
|
||||
/*
|
||||
* Wrap value to the range [0, limit]
|
||||
*/
|
||||
|
||||
template <typename T>
|
||||
static T
|
||||
wrap_float(T value, T limit) {
|
||||
return fmod(fmod(value, limit) + limit, limit);
|
||||
}
|
||||
|
||||
/*
|
||||
* Wrap value to the range [0, limit] - currently-unused integer version of wrap_float
|
||||
*/
|
||||
|
||||
// template <typename T>
|
||||
// static T wrap_int(T value, T limit) {
|
||||
// return (value % limit + limit) % limit;
|
||||
// }
|
||||
|
||||
/*
|
||||
* Parse color channel value
|
||||
*/
|
||||
|
||||
static bool
|
||||
parse_rgb_channel(const char** pStr, uint8_t *pChannel) {
|
||||
float f_channel;
|
||||
if (parse_css_number(pStr, &f_channel)) {
|
||||
int channel = (int) ceil(f_channel);
|
||||
*pChannel = clip(channel, 0, 255);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Parse a value in degrees
|
||||
*/
|
||||
|
||||
static bool
|
||||
parse_degrees(const char** pStr, float *pDegrees) {
|
||||
float degrees;
|
||||
if (parse_css_number(pStr, °rees)) {
|
||||
*pDegrees = wrap_float(degrees, 360.0f);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Parse and clip a percentage value. Returns a float in the range [0, 1].
|
||||
*/
|
||||
|
||||
static bool
|
||||
parse_clipped_percentage(const char** pStr, float *pFraction) {
|
||||
float percentage;
|
||||
bool result = parse_css_number(pStr,&percentage);
|
||||
const char*& str = *pStr;
|
||||
if (result) {
|
||||
if (*str == '%') {
|
||||
++str;
|
||||
*pFraction = clip(percentage, 0.0f, 100.0f) / 100.0f;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Macros to help with parsing inside rgba_from_*_string
|
||||
*/
|
||||
|
||||
#define WHITESPACE \
|
||||
while (' ' == *str) ++str;
|
||||
|
||||
#define WHITESPACE_OR_COMMA \
|
||||
while (' ' == *str || ',' == *str) ++str;
|
||||
|
||||
#define WHITESPACE_OR_COMMA_OR_SLASH \
|
||||
while (' ' == *str || ',' == *str || '/' == *str) ++str;
|
||||
|
||||
#define CHANNEL(NAME) \
|
||||
if (!parse_rgb_channel(&str, &NAME)) \
|
||||
return 0; \
|
||||
|
||||
#define HUE(NAME) \
|
||||
if (!parse_degrees(&str, &NAME)) \
|
||||
return 0;
|
||||
|
||||
#define SATURATION(NAME) \
|
||||
if (!parse_clipped_percentage(&str, &NAME)) \
|
||||
return 0;
|
||||
|
||||
#define LIGHTNESS(NAME) SATURATION(NAME)
|
||||
|
||||
#define ALPHA(NAME) \
|
||||
if (*str >= '1' && *str <= '9') { \
|
||||
NAME = 0; \
|
||||
float n = .1f; \
|
||||
while(*str >='0' && *str <= '9') { \
|
||||
NAME += (*str - '0') * n; \
|
||||
str++; \
|
||||
} \
|
||||
while(*str == ' ')str++; \
|
||||
if(*str != '%') { \
|
||||
NAME = 1; \
|
||||
} \
|
||||
} else { \
|
||||
if ('0' == *str) { \
|
||||
NAME = 0; \
|
||||
++str; \
|
||||
} \
|
||||
if ('.' == *str) { \
|
||||
++str; \
|
||||
NAME = 0; \
|
||||
float n = .1f; \
|
||||
while (*str >= '0' && *str <= '9') { \
|
||||
NAME += (*str++ - '0') * n; \
|
||||
n *= .1f; \
|
||||
} \
|
||||
} \
|
||||
} \
|
||||
do {} while (0) // require trailing semicolon
|
||||
|
||||
/*
|
||||
* Named colors.
|
||||
*/
|
||||
static const std::map<std::string, uint32_t> named_colors = {
|
||||
{ "transparent", 0xFFFFFF00}
|
||||
, { "aliceblue", 0xF0F8FFFF }
|
||||
, { "antiquewhite", 0xFAEBD7FF }
|
||||
, { "aqua", 0x00FFFFFF }
|
||||
, { "aquamarine", 0x7FFFD4FF }
|
||||
, { "azure", 0xF0FFFFFF }
|
||||
, { "beige", 0xF5F5DCFF }
|
||||
, { "bisque", 0xFFE4C4FF }
|
||||
, { "black", 0x000000FF }
|
||||
, { "blanchedalmond", 0xFFEBCDFF }
|
||||
, { "blue", 0x0000FFFF }
|
||||
, { "blueviolet", 0x8A2BE2FF }
|
||||
, { "brown", 0xA52A2AFF }
|
||||
, { "burlywood", 0xDEB887FF }
|
||||
, { "cadetblue", 0x5F9EA0FF }
|
||||
, { "chartreuse", 0x7FFF00FF }
|
||||
, { "chocolate", 0xD2691EFF }
|
||||
, { "coral", 0xFF7F50FF }
|
||||
, { "cornflowerblue", 0x6495EDFF }
|
||||
, { "cornsilk", 0xFFF8DCFF }
|
||||
, { "crimson", 0xDC143CFF }
|
||||
, { "cyan", 0x00FFFFFF }
|
||||
, { "darkblue", 0x00008BFF }
|
||||
, { "darkcyan", 0x008B8BFF }
|
||||
, { "darkgoldenrod", 0xB8860BFF }
|
||||
, { "darkgray", 0xA9A9A9FF }
|
||||
, { "darkgreen", 0x006400FF }
|
||||
, { "darkgrey", 0xA9A9A9FF }
|
||||
, { "darkkhaki", 0xBDB76BFF }
|
||||
, { "darkmagenta", 0x8B008BFF }
|
||||
, { "darkolivegreen", 0x556B2FFF }
|
||||
, { "darkorange", 0xFF8C00FF }
|
||||
, { "darkorchid", 0x9932CCFF }
|
||||
, { "darkred", 0x8B0000FF }
|
||||
, { "darksalmon", 0xE9967AFF }
|
||||
, { "darkseagreen", 0x8FBC8FFF }
|
||||
, { "darkslateblue", 0x483D8BFF }
|
||||
, { "darkslategray", 0x2F4F4FFF }
|
||||
, { "darkslategrey", 0x2F4F4FFF }
|
||||
, { "darkturquoise", 0x00CED1FF }
|
||||
, { "darkviolet", 0x9400D3FF }
|
||||
, { "deeppink", 0xFF1493FF }
|
||||
, { "deepskyblue", 0x00BFFFFF }
|
||||
, { "dimgray", 0x696969FF }
|
||||
, { "dimgrey", 0x696969FF }
|
||||
, { "dodgerblue", 0x1E90FFFF }
|
||||
, { "firebrick", 0xB22222FF }
|
||||
, { "floralwhite", 0xFFFAF0FF }
|
||||
, { "forestgreen", 0x228B22FF }
|
||||
, { "fuchsia", 0xFF00FFFF }
|
||||
, { "gainsboro", 0xDCDCDCFF }
|
||||
, { "ghostwhite", 0xF8F8FFFF }
|
||||
, { "gold", 0xFFD700FF }
|
||||
, { "goldenrod", 0xDAA520FF }
|
||||
, { "gray", 0x808080FF }
|
||||
, { "green", 0x008000FF }
|
||||
, { "greenyellow", 0xADFF2FFF }
|
||||
, { "grey", 0x808080FF }
|
||||
, { "honeydew", 0xF0FFF0FF }
|
||||
, { "hotpink", 0xFF69B4FF }
|
||||
, { "indianred", 0xCD5C5CFF }
|
||||
, { "indigo", 0x4B0082FF }
|
||||
, { "ivory", 0xFFFFF0FF }
|
||||
, { "khaki", 0xF0E68CFF }
|
||||
, { "lavender", 0xE6E6FAFF }
|
||||
, { "lavenderblush", 0xFFF0F5FF }
|
||||
, { "lawngreen", 0x7CFC00FF }
|
||||
, { "lemonchiffon", 0xFFFACDFF }
|
||||
, { "lightblue", 0xADD8E6FF }
|
||||
, { "lightcoral", 0xF08080FF }
|
||||
, { "lightcyan", 0xE0FFFFFF }
|
||||
, { "lightgoldenrodyellow", 0xFAFAD2FF }
|
||||
, { "lightgray", 0xD3D3D3FF }
|
||||
, { "lightgreen", 0x90EE90FF }
|
||||
, { "lightgrey", 0xD3D3D3FF }
|
||||
, { "lightpink", 0xFFB6C1FF }
|
||||
, { "lightsalmon", 0xFFA07AFF }
|
||||
, { "lightseagreen", 0x20B2AAFF }
|
||||
, { "lightskyblue", 0x87CEFAFF }
|
||||
, { "lightslategray", 0x778899FF }
|
||||
, { "lightslategrey", 0x778899FF }
|
||||
, { "lightsteelblue", 0xB0C4DEFF }
|
||||
, { "lightyellow", 0xFFFFE0FF }
|
||||
, { "lime", 0x00FF00FF }
|
||||
, { "limegreen", 0x32CD32FF }
|
||||
, { "linen", 0xFAF0E6FF }
|
||||
, { "magenta", 0xFF00FFFF }
|
||||
, { "maroon", 0x800000FF }
|
||||
, { "mediumaquamarine", 0x66CDAAFF }
|
||||
, { "mediumblue", 0x0000CDFF }
|
||||
, { "mediumorchid", 0xBA55D3FF }
|
||||
, { "mediumpurple", 0x9370DBFF }
|
||||
, { "mediumseagreen", 0x3CB371FF }
|
||||
, { "mediumslateblue", 0x7B68EEFF }
|
||||
, { "mediumspringgreen", 0x00FA9AFF }
|
||||
, { "mediumturquoise", 0x48D1CCFF }
|
||||
, { "mediumvioletred", 0xC71585FF }
|
||||
, { "midnightblue", 0x191970FF }
|
||||
, { "mintcream", 0xF5FFFAFF }
|
||||
, { "mistyrose", 0xFFE4E1FF }
|
||||
, { "moccasin", 0xFFE4B5FF }
|
||||
, { "navajowhite", 0xFFDEADFF }
|
||||
, { "navy", 0x000080FF }
|
||||
, { "oldlace", 0xFDF5E6FF }
|
||||
, { "olive", 0x808000FF }
|
||||
, { "olivedrab", 0x6B8E23FF }
|
||||
, { "orange", 0xFFA500FF }
|
||||
, { "orangered", 0xFF4500FF }
|
||||
, { "orchid", 0xDA70D6FF }
|
||||
, { "palegoldenrod", 0xEEE8AAFF }
|
||||
, { "palegreen", 0x98FB98FF }
|
||||
, { "paleturquoise", 0xAFEEEEFF }
|
||||
, { "palevioletred", 0xDB7093FF }
|
||||
, { "papayawhip", 0xFFEFD5FF }
|
||||
, { "peachpuff", 0xFFDAB9FF }
|
||||
, { "peru", 0xCD853FFF }
|
||||
, { "pink", 0xFFC0CBFF }
|
||||
, { "plum", 0xDDA0DDFF }
|
||||
, { "powderblue", 0xB0E0E6FF }
|
||||
, { "purple", 0x800080FF }
|
||||
, { "rebeccapurple", 0x663399FF } // Source: CSS Color Level 4 draft
|
||||
, { "red", 0xFF0000FF }
|
||||
, { "rosybrown", 0xBC8F8FFF }
|
||||
, { "royalblue", 0x4169E1FF }
|
||||
, { "saddlebrown", 0x8B4513FF }
|
||||
, { "salmon", 0xFA8072FF }
|
||||
, { "sandybrown", 0xF4A460FF }
|
||||
, { "seagreen", 0x2E8B57FF }
|
||||
, { "seashell", 0xFFF5EEFF }
|
||||
, { "sienna", 0xA0522DFF }
|
||||
, { "silver", 0xC0C0C0FF }
|
||||
, { "skyblue", 0x87CEEBFF }
|
||||
, { "slateblue", 0x6A5ACDFF }
|
||||
, { "slategray", 0x708090FF }
|
||||
, { "slategrey", 0x708090FF }
|
||||
, { "snow", 0xFFFAFAFF }
|
||||
, { "springgreen", 0x00FF7FFF }
|
||||
, { "steelblue", 0x4682B4FF }
|
||||
, { "tan", 0xD2B48CFF }
|
||||
, { "teal", 0x008080FF }
|
||||
, { "thistle", 0xD8BFD8FF }
|
||||
, { "tomato", 0xFF6347FF }
|
||||
, { "turquoise", 0x40E0D0FF }
|
||||
, { "violet", 0xEE82EEFF }
|
||||
, { "wheat", 0xF5DEB3FF }
|
||||
, { "white", 0xFFFFFFFF }
|
||||
, { "whitesmoke", 0xF5F5F5FF }
|
||||
, { "yellow", 0xFFFF00FF }
|
||||
, { "yellowgreen", 0x9ACD32FF }
|
||||
};
|
||||
|
||||
/*
|
||||
* Hex digit int val.
|
||||
*/
|
||||
|
||||
static int
|
||||
h(char c) {
|
||||
switch (c) {
|
||||
case '0':
|
||||
case '1':
|
||||
case '2':
|
||||
case '3':
|
||||
case '4':
|
||||
case '5':
|
||||
case '6':
|
||||
case '7':
|
||||
case '8':
|
||||
case '9':
|
||||
return c - '0';
|
||||
case 'a':
|
||||
case 'b':
|
||||
case 'c':
|
||||
case 'd':
|
||||
case 'e':
|
||||
case 'f':
|
||||
return (c - 'a') + 10;
|
||||
case 'A':
|
||||
case 'B':
|
||||
case 'C':
|
||||
case 'D':
|
||||
case 'E':
|
||||
case 'F':
|
||||
return (c - 'A') + 10;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return rgba_t from rgba.
|
||||
*/
|
||||
|
||||
rgba_t
|
||||
rgba_create(uint32_t rgba) {
|
||||
rgba_t color;
|
||||
color.r = (double) (rgba >> 24) / 255;
|
||||
color.g = (double) (rgba >> 16 & 0xff) / 255;
|
||||
color.b = (double) (rgba >> 8 & 0xff) / 255;
|
||||
color.a = (double) (rgba & 0xff) / 255;
|
||||
return color;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return a string representation of the color.
|
||||
*/
|
||||
|
||||
void
|
||||
rgba_to_string(rgba_t rgba, char *buf, size_t len) {
|
||||
if (1 == rgba.a) {
|
||||
snprintf(buf, len, "#%.2x%.2x%.2x",
|
||||
static_cast<int>(round(rgba.r * 255)),
|
||||
static_cast<int>(round(rgba.g * 255)),
|
||||
static_cast<int>(round(rgba.b * 255)));
|
||||
} else {
|
||||
snprintf(buf, len, "rgba(%d, %d, %d, %.2f)",
|
||||
static_cast<int>(round(rgba.r * 255)),
|
||||
static_cast<int>(round(rgba.g * 255)),
|
||||
static_cast<int>(round(rgba.b * 255)),
|
||||
rgba.a);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Return rgba from (r,g,b,a).
|
||||
*/
|
||||
|
||||
static inline int32_t
|
||||
rgba_from_rgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
|
||||
return
|
||||
r << 24
|
||||
| g << 16
|
||||
| b << 8
|
||||
| a;
|
||||
}
|
||||
|
||||
/*
|
||||
* Helper function used in rgba_from_hsla().
|
||||
* Based on http://dev.w3.org/csswg/css-color-4/#hsl-to-rgb
|
||||
*/
|
||||
|
||||
static float
|
||||
hue_to_rgb(float t1, float t2, float hue) {
|
||||
if (hue < 0)
|
||||
hue += 6;
|
||||
if (hue >= 6)
|
||||
hue -= 6;
|
||||
|
||||
if (hue < 1)
|
||||
return (t2 - t1) * hue + t1;
|
||||
else if (hue < 3)
|
||||
return t2;
|
||||
else if (hue < 4)
|
||||
return (t2 - t1) * (4 - hue) + t1;
|
||||
else
|
||||
return t1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return rgba from (h,s,l,a).
|
||||
* Expects h values in the range [0, 360), and s, l, a in the range [0, 1].
|
||||
* Adapted from http://dev.w3.org/csswg/css-color-4/#hsl-to-rgb
|
||||
*/
|
||||
|
||||
static inline int32_t
|
||||
rgba_from_hsla(float h_deg, float s, float l, float a) {
|
||||
uint8_t r, g, b;
|
||||
float h = (6 * h_deg) / 360.0f, m1, m2;
|
||||
|
||||
if (l<=0.5)
|
||||
m2=l*(s+1);
|
||||
else
|
||||
m2=l+s-l*s;
|
||||
m1 = l*2 - m2;
|
||||
|
||||
// Scale and round the RGB components
|
||||
r = (uint8_t)floor(hue_to_rgb(m1, m2, h + 2) * 255 + 0.5);
|
||||
g = (uint8_t)floor(hue_to_rgb(m1, m2, h ) * 255 + 0.5);
|
||||
b = (uint8_t)floor(hue_to_rgb(m1, m2, h - 2) * 255 + 0.5);
|
||||
|
||||
return rgba_from_rgba(r, g, b, (uint8_t) (a * 255));
|
||||
}
|
||||
|
||||
/*
|
||||
* Return rgba from (h,s,l).
|
||||
* Expects h values in the range [0, 360), and s, l in the range [0, 1].
|
||||
*/
|
||||
|
||||
static inline int32_t
|
||||
rgba_from_hsl(float h_deg, float s, float l) {
|
||||
return rgba_from_hsla(h_deg, s, l, 1.0);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Return rgba from (r,g,b).
|
||||
*/
|
||||
|
||||
static int32_t
|
||||
rgba_from_rgb(uint8_t r, uint8_t g, uint8_t b) {
|
||||
return rgba_from_rgba(r, g, b, 255);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return rgba from #RRGGBBAA
|
||||
*/
|
||||
|
||||
static int32_t
|
||||
rgba_from_hex8_string(const char *str) {
|
||||
return rgba_from_rgba(
|
||||
(h(str[0]) << 4) + h(str[1]),
|
||||
(h(str[2]) << 4) + h(str[3]),
|
||||
(h(str[4]) << 4) + h(str[5]),
|
||||
(h(str[6]) << 4) + h(str[7])
|
||||
);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return rgb from "#RRGGBB".
|
||||
*/
|
||||
|
||||
static int32_t
|
||||
rgba_from_hex6_string(const char *str) {
|
||||
return rgba_from_rgb(
|
||||
(h(str[0]) << 4) + h(str[1])
|
||||
, (h(str[2]) << 4) + h(str[3])
|
||||
, (h(str[4]) << 4) + h(str[5])
|
||||
);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return rgba from #RGBA
|
||||
*/
|
||||
|
||||
static int32_t
|
||||
rgba_from_hex4_string(const char *str) {
|
||||
return rgba_from_rgba(
|
||||
(h(str[0]) << 4) + h(str[0]),
|
||||
(h(str[1]) << 4) + h(str[1]),
|
||||
(h(str[2]) << 4) + h(str[2]),
|
||||
(h(str[3]) << 4) + h(str[3])
|
||||
);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return rgb from "#RGB"
|
||||
*/
|
||||
|
||||
static int32_t
|
||||
rgba_from_hex3_string(const char *str) {
|
||||
return rgba_from_rgb(
|
||||
(h(str[0]) << 4) + h(str[0])
|
||||
, (h(str[1]) << 4) + h(str[1])
|
||||
, (h(str[2]) << 4) + h(str[2])
|
||||
);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return rgb from "rgb()"
|
||||
*/
|
||||
|
||||
static int32_t
|
||||
rgba_from_rgb_string(const char *str, short *ok) {
|
||||
if (str == strstr(str, "rgb(")) {
|
||||
str += 4;
|
||||
WHITESPACE;
|
||||
uint8_t r = 0, g = 0, b = 0;
|
||||
float a=1.f;
|
||||
CHANNEL(r);
|
||||
WHITESPACE_OR_COMMA;
|
||||
CHANNEL(g);
|
||||
WHITESPACE_OR_COMMA;
|
||||
CHANNEL(b);
|
||||
WHITESPACE_OR_COMMA_OR_SLASH;
|
||||
ALPHA(a);
|
||||
return *ok = 1, rgba_from_rgba(r, g, b, (int) (255 * a));
|
||||
}
|
||||
return *ok = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return rgb from "rgba()"
|
||||
*/
|
||||
|
||||
static int32_t
|
||||
rgba_from_rgba_string(const char *str, short *ok) {
|
||||
if (str == strstr(str, "rgba(")) {
|
||||
str += 5;
|
||||
WHITESPACE;
|
||||
uint8_t r = 0, g = 0, b = 0;
|
||||
float a = 1.f;
|
||||
CHANNEL(r);
|
||||
WHITESPACE_OR_COMMA;
|
||||
CHANNEL(g);
|
||||
WHITESPACE_OR_COMMA;
|
||||
CHANNEL(b);
|
||||
WHITESPACE_OR_COMMA_OR_SLASH;
|
||||
ALPHA(a);
|
||||
WHITESPACE;
|
||||
return *ok = 1, rgba_from_rgba(r, g, b, (int) (a * 255));
|
||||
}
|
||||
return *ok = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return rgb from "hsla()"
|
||||
*/
|
||||
|
||||
static int32_t
|
||||
rgba_from_hsla_string(const char *str, short *ok) {
|
||||
if (str == strstr(str, "hsla(")) {
|
||||
str += 5;
|
||||
WHITESPACE;
|
||||
float h_deg = 0;
|
||||
float s = 0, l = 0;
|
||||
float a = 0;
|
||||
HUE(h_deg);
|
||||
WHITESPACE_OR_COMMA;
|
||||
SATURATION(s);
|
||||
WHITESPACE_OR_COMMA;
|
||||
LIGHTNESS(l);
|
||||
WHITESPACE_OR_COMMA;
|
||||
ALPHA(a);
|
||||
WHITESPACE;
|
||||
return *ok = 1, rgba_from_hsla(h_deg, s, l, a);
|
||||
}
|
||||
return *ok = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return rgb from "hsl()"
|
||||
*/
|
||||
|
||||
static int32_t
|
||||
rgba_from_hsl_string(const char *str, short *ok) {
|
||||
if (str == strstr(str, "hsl(")) {
|
||||
str += 4;
|
||||
WHITESPACE;
|
||||
float h_deg = 0;
|
||||
float s = 0, l = 0;
|
||||
HUE(h_deg);
|
||||
WHITESPACE_OR_COMMA;
|
||||
SATURATION(s);
|
||||
WHITESPACE_OR_COMMA;
|
||||
LIGHTNESS(l);
|
||||
WHITESPACE;
|
||||
return *ok = 1, rgba_from_hsl(h_deg, s, l);
|
||||
}
|
||||
return *ok = 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Return rgb from:
|
||||
*
|
||||
* - "#RGB"
|
||||
* - "#RGBA"
|
||||
* - "#RRGGBB"
|
||||
* - "#RRGGBBAA"
|
||||
*
|
||||
*/
|
||||
|
||||
static int32_t
|
||||
rgba_from_hex_string(const char *str, short *ok) {
|
||||
size_t len = strlen(str);
|
||||
*ok = 1;
|
||||
switch (len) {
|
||||
case 8: return rgba_from_hex8_string(str);
|
||||
case 6: return rgba_from_hex6_string(str);
|
||||
case 4: return rgba_from_hex4_string(str);
|
||||
case 3: return rgba_from_hex3_string(str);
|
||||
}
|
||||
return *ok = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return named color value.
|
||||
*/
|
||||
|
||||
static int32_t
|
||||
rgba_from_name_string(const char *str, short *ok) {
|
||||
WHITESPACE;
|
||||
std::string lowered(str);
|
||||
std::transform(lowered.begin(), lowered.end(), lowered.begin(), tolower);
|
||||
auto color = named_colors.find(lowered);
|
||||
if (color != named_colors.end()) {
|
||||
return *ok = 1, color->second;
|
||||
}
|
||||
return *ok = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return rgb from:
|
||||
*
|
||||
* - #RGB
|
||||
* - #RGBA
|
||||
* - #RRGGBB
|
||||
* - #RRGGBBAA
|
||||
* - rgb(r,g,b)
|
||||
* - rgba(r,g,b,a)
|
||||
* - hsl(h,s,l)
|
||||
* - hsla(h,s,l,a)
|
||||
* - name
|
||||
*
|
||||
*/
|
||||
|
||||
int32_t
|
||||
rgba_from_string(const char *str, short *ok) {
|
||||
WHITESPACE;
|
||||
if ('#' == str[0])
|
||||
return rgba_from_hex_string(++str, ok);
|
||||
if (str == strstr(str, "rgba"))
|
||||
return rgba_from_rgba_string(str, ok);
|
||||
if (str == strstr(str, "rgb"))
|
||||
return rgba_from_rgb_string(str, ok);
|
||||
if (str == strstr(str, "hsla"))
|
||||
return rgba_from_hsla_string(str, ok);
|
||||
if (str == strstr(str, "hsl"))
|
||||
return rgba_from_hsl_string(str, ok);
|
||||
return rgba_from_name_string(str, ok);
|
||||
}
|
||||
|
||||
/*
|
||||
* Inspect the given rgba color.
|
||||
*/
|
||||
|
||||
void
|
||||
rgba_inspect(int32_t rgba) {
|
||||
printf("rgba(%d,%d,%d,%d)\n"
|
||||
, rgba >> 24 & 0xff
|
||||
, rgba >> 16 & 0xff
|
||||
, rgba >> 8 & 0xff
|
||||
, rgba & 0xff
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,151 @@
|
||||
/**
|
||||
* @fileoverview Rule to suggest using "Reflect" api over Function/Object methods
|
||||
* @author Keith Cirkel <http://keithcirkel.co.uk>
|
||||
* @deprecated in ESLint v3.9.0
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description: "Require `Reflect` methods where applicable",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/prefer-reflect",
|
||||
},
|
||||
|
||||
deprecated: {
|
||||
message: "The original intention of this rule was misguided.",
|
||||
url: "https://eslint.org/docs/latest/rules/prefer-reflect",
|
||||
deprecatedSince: "3.9.0",
|
||||
availableUntil: null,
|
||||
replacedBy: [],
|
||||
},
|
||||
|
||||
schema: [
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
exceptions: {
|
||||
type: "array",
|
||||
items: {
|
||||
enum: [
|
||||
"apply",
|
||||
"call",
|
||||
"delete",
|
||||
"defineProperty",
|
||||
"getOwnPropertyDescriptor",
|
||||
"getPrototypeOf",
|
||||
"setPrototypeOf",
|
||||
"isExtensible",
|
||||
"getOwnPropertyNames",
|
||||
"preventExtensions",
|
||||
],
|
||||
},
|
||||
uniqueItems: true,
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
|
||||
messages: {
|
||||
preferReflect:
|
||||
"Avoid using {{existing}}, instead use {{substitute}}.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const existingNames = {
|
||||
apply: "Function.prototype.apply",
|
||||
call: "Function.prototype.call",
|
||||
defineProperty: "Object.defineProperty",
|
||||
getOwnPropertyDescriptor: "Object.getOwnPropertyDescriptor",
|
||||
getPrototypeOf: "Object.getPrototypeOf",
|
||||
setPrototypeOf: "Object.setPrototypeOf",
|
||||
isExtensible: "Object.isExtensible",
|
||||
getOwnPropertyNames: "Object.getOwnPropertyNames",
|
||||
preventExtensions: "Object.preventExtensions",
|
||||
};
|
||||
|
||||
const reflectSubstitutes = {
|
||||
apply: "Reflect.apply",
|
||||
call: "Reflect.apply",
|
||||
defineProperty: "Reflect.defineProperty",
|
||||
getOwnPropertyDescriptor: "Reflect.getOwnPropertyDescriptor",
|
||||
getPrototypeOf: "Reflect.getPrototypeOf",
|
||||
setPrototypeOf: "Reflect.setPrototypeOf",
|
||||
isExtensible: "Reflect.isExtensible",
|
||||
getOwnPropertyNames: "Reflect.getOwnPropertyNames",
|
||||
preventExtensions: "Reflect.preventExtensions",
|
||||
};
|
||||
|
||||
const exceptions = (context.options[0] || {}).exceptions || [];
|
||||
|
||||
/**
|
||||
* Reports the Reflect violation based on the `existing` and `substitute`
|
||||
* @param {Object} node The node that violates the rule.
|
||||
* @param {string} existing The existing method name that has been used.
|
||||
* @param {string} substitute The Reflect substitute that should be used.
|
||||
* @returns {void}
|
||||
*/
|
||||
function report(node, existing, substitute) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "preferReflect",
|
||||
data: {
|
||||
existing,
|
||||
substitute,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
return {
|
||||
CallExpression(node) {
|
||||
const methodName = (node.callee.property || {}).name;
|
||||
const isReflectCall =
|
||||
(node.callee.object || {}).name === "Reflect";
|
||||
const hasReflectSubstitute = Object.hasOwn(
|
||||
reflectSubstitutes,
|
||||
methodName,
|
||||
);
|
||||
const userConfiguredException = exceptions.includes(methodName);
|
||||
|
||||
if (
|
||||
hasReflectSubstitute &&
|
||||
!isReflectCall &&
|
||||
!userConfiguredException
|
||||
) {
|
||||
report(
|
||||
node,
|
||||
existingNames[methodName],
|
||||
reflectSubstitutes[methodName],
|
||||
);
|
||||
}
|
||||
},
|
||||
UnaryExpression(node) {
|
||||
const isDeleteOperator = node.operator === "delete";
|
||||
const targetsIdentifier = node.argument.type === "Identifier";
|
||||
const userConfiguredException = exceptions.includes("delete");
|
||||
|
||||
if (
|
||||
isDeleteOperator &&
|
||||
!targetsIdentifier &&
|
||||
!userConfiguredException
|
||||
) {
|
||||
report(
|
||||
node,
|
||||
"the delete keyword",
|
||||
"Reflect.deleteProperty",
|
||||
);
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,26 @@
|
||||
import { getRandomBytesAsync } from 'expo-random'
|
||||
import { urlAlphabet } from '../url-alphabet/index.js'
|
||||
let random = getRandomBytesAsync
|
||||
let customAlphabet = (alphabet, defaultSize = 21) => {
|
||||
let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
|
||||
let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
|
||||
let tick = (id, size = defaultSize) =>
|
||||
random(step).then(bytes => {
|
||||
let i = step
|
||||
while (i--) {
|
||||
id += alphabet[bytes[i] & mask] || ''
|
||||
if (id.length >= size) return id
|
||||
}
|
||||
return tick(id, size)
|
||||
})
|
||||
return size => tick('', size)
|
||||
}
|
||||
let nanoid = (size = 21) =>
|
||||
random((size |= 0)).then(bytes => {
|
||||
let id = ''
|
||||
while (size--) {
|
||||
id += urlAlphabet[bytes[size] & 63]
|
||||
}
|
||||
return id
|
||||
})
|
||||
export { nanoid, customAlphabet, random }
|
||||
@@ -0,0 +1,39 @@
|
||||
import type {
|
||||
ErrorPayload,
|
||||
FullReloadPayload,
|
||||
PrunePayload,
|
||||
UpdatePayload,
|
||||
} from './hmrPayload'
|
||||
|
||||
export interface CustomEventMap {
|
||||
'vite:beforeUpdate': UpdatePayload
|
||||
'vite:afterUpdate': UpdatePayload
|
||||
'vite:beforePrune': PrunePayload
|
||||
'vite:beforeFullReload': FullReloadPayload
|
||||
'vite:error': ErrorPayload
|
||||
'vite:invalidate': InvalidatePayload
|
||||
'vite:ws:connect': WebSocketConnectionPayload
|
||||
'vite:ws:disconnect': WebSocketConnectionPayload
|
||||
}
|
||||
|
||||
export interface WebSocketConnectionPayload {
|
||||
/**
|
||||
* @experimental
|
||||
* We expose this instance experimentally to see potential usage.
|
||||
* This might be removed in the future if we didn't find reasonable use cases.
|
||||
* If you find this useful, please open an issue with details so we can discuss and make it stable API.
|
||||
*/
|
||||
// eslint-disable-next-line n/no-unsupported-features/node-builtins
|
||||
webSocket: WebSocket
|
||||
}
|
||||
|
||||
export interface InvalidatePayload {
|
||||
path: string
|
||||
message: string | undefined
|
||||
}
|
||||
|
||||
/**
|
||||
* provides types for built-in Vite events
|
||||
*/
|
||||
export type InferCustomEventPayload<T extends string> =
|
||||
T extends keyof CustomEventMap ? CustomEventMap[T] : any
|
||||
@@ -0,0 +1,78 @@
|
||||
{
|
||||
"name": "flatted",
|
||||
"version": "3.3.3",
|
||||
"description": "A super light and fast circular JSON parser.",
|
||||
"unpkg": "min.js",
|
||||
"main": "./cjs/index.js",
|
||||
"scripts": {
|
||||
"build": "npm run cjs && npm run rollup:esm && npm run rollup:es && npm run rollup:babel && npm run min && npm run test && npm run size",
|
||||
"cjs": "ascjs esm cjs",
|
||||
"rollup:es": "rollup --config rollup/es.config.js && sed -i.bck 's/^var /self./' es.js && rm -rf es.js.bck",
|
||||
"rollup:esm": "rollup --config rollup/esm.config.js",
|
||||
"rollup:babel": "rollup --config rollup/babel.config.js && sed -i.bck 's/^var /self./' index.js && rm -rf index.js.bck",
|
||||
"min": "terser index.js -c -m -o min.js",
|
||||
"size": "cat index.js | wc -c;cat min.js | wc -c;gzip -c9 min.js | wc -c;cat min.js | brotli | wc -c; cat es.js | brotli | wc -c; cat esm.js | brotli | wc -c",
|
||||
"test": "c8 node test/index.js",
|
||||
"test:php": "php php/test.php",
|
||||
"test:py": "python python/test.py",
|
||||
"ts": "tsc -p .",
|
||||
"coverage": "mkdir -p ./coverage; c8 report --reporter=text-lcov > ./coverage/lcov.info"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+https://github.com/WebReflection/flatted.git"
|
||||
},
|
||||
"files": [
|
||||
"LICENSE",
|
||||
"README.md",
|
||||
"cjs/",
|
||||
"es.js",
|
||||
"esm.js",
|
||||
"esm/",
|
||||
"index.js",
|
||||
"min.js",
|
||||
"php/flatted.php",
|
||||
"python/flatted.py",
|
||||
"types/"
|
||||
],
|
||||
"keywords": [
|
||||
"circular",
|
||||
"JSON",
|
||||
"fast",
|
||||
"parser",
|
||||
"minimal"
|
||||
],
|
||||
"author": "Andrea Giammarchi",
|
||||
"license": "ISC",
|
||||
"bugs": {
|
||||
"url": "https://github.com/WebReflection/flatted/issues"
|
||||
},
|
||||
"homepage": "https://github.com/WebReflection/flatted#readme",
|
||||
"devDependencies": {
|
||||
"@babel/core": "^7.26.9",
|
||||
"@babel/preset-env": "^7.26.9",
|
||||
"@rollup/plugin-babel": "^6.0.4",
|
||||
"@rollup/plugin-terser": "^0.4.4",
|
||||
"@ungap/structured-clone": "^1.3.0",
|
||||
"ascjs": "^6.0.3",
|
||||
"c8": "^10.1.3",
|
||||
"circular-json": "^0.5.9",
|
||||
"circular-json-es6": "^2.0.2",
|
||||
"jsan": "^3.1.14",
|
||||
"rollup": "^4.34.8",
|
||||
"terser": "^5.39.0",
|
||||
"typescript": "^5.7.3"
|
||||
},
|
||||
"module": "./esm/index.js",
|
||||
"type": "module",
|
||||
"exports": {
|
||||
".": {
|
||||
"types": "./types/index.d.ts",
|
||||
"import": "./esm/index.js",
|
||||
"default": "./cjs/index.js"
|
||||
},
|
||||
"./esm": "./esm.js",
|
||||
"./package.json": "./package.json"
|
||||
},
|
||||
"types": "./types/index.d.ts"
|
||||
}
|
||||
Reference in New Issue
Block a user