@visactor/vrender-components
Version:
components library for dp visualization
1,173 lines (1,136 loc) • 1.55 MB
JavaScript
import { tau, halfPi as halfPi$1, AABBBounds, degreeToRadian, Point, PointService, abs, max, min, atan2, epsilon, Matrix, pi2, Logger, pi, isArray, isPointInLine, isNumberClose, TextMeasure, EventEmitter, isBoolean, isObject, isFunction, cos, sin, isString, pointAt, isNumber, sqrt, Color, OBBBounds, isNil, normalTransform, isValidUrl, isBase64, acos, transformBoundsWithMatrix, getContextFont, rotatePoint, clampAngleByRadian, asin, arrayEqual, Bounds, getRectIntersect, isRectIntersect, isEqual, isPlainObject, merge, isValid, clamp, clampRange, normalizePadding, debounce, throttle, hexToRgb, crossProduct, isEmpty, array, rectInsideAnotherRect, radianToDegree, getAngleByPoint, polarToCartesian, normalizeAngle, isValidNumber, flattenArray, isRotateAABBIntersect, isLess, isGreater, aabbSeparation, obbSeparation, cloneDeep, get, last, mixin, interpolateString, minInArray, maxInArray, binaryFuzzySearchInNumberRange, pointInRect, calculateAnchorOfBounds, computeQuadrant, polygonContainPoint } from '@visactor/vutils';
import { isContinuous, isDiscrete, LinearScale } from '@visactor/vscale';
class Generator {
static GenAutoIncrementId() {
return Generator.auto_increment_id++;
}
}
Generator.auto_increment_id = 0;
class ContainerModule {
constructor(registry) {
this.id = Generator.GenAutoIncrementId(), this.registry = registry;
}
}
const NAMED_TAG = "named";
const INJECT_TAG = "inject";
const MULTI_INJECT_TAG = "multi_inject";
const TAGGED = "inversify:tagged";
const PARAM_TYPES = "inversify:paramtypes";
class Metadata {
constructor(key, value) {
this.key = key, this.value = value;
}
toString() {
return this.key === NAMED_TAG ? `named: ${String(this.value).toString()} ` : `tagged: { key:${this.key.toString()}, value: ${String(this.value)} }`;
}
}
var Reflect$1 = (function (Reflect) {
var target;
return function (exporter) {
const supportsSymbol = "function" == typeof Symbol,
toPrimitiveSymbol = supportsSymbol && void 0 !== Symbol.toPrimitive ? Symbol.toPrimitive : "@@toPrimitive",
functionPrototype = (Object.getPrototypeOf(Function)),
_Map = ("object" == typeof process && process.env && process.env.REFLECT_METADATA_USE_MAP_POLYFILL, Map),
Metadata = (new WeakMap());
function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
if (!IsObject(target)) throw new TypeError();
return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
}
function hasMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target)) throw new TypeError();
return IsUndefined(propertyKey) || (propertyKey = ToPropertyKey(propertyKey)), OrdinaryHasMetadata(metadataKey, target, propertyKey);
}
function hasOwnMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target)) throw new TypeError();
return IsUndefined(propertyKey) || (propertyKey = ToPropertyKey(propertyKey)), OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
}
function getMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target)) throw new TypeError();
return IsUndefined(propertyKey) || (propertyKey = ToPropertyKey(propertyKey)), OrdinaryGetMetadata(metadataKey, target, propertyKey);
}
function GetOrCreateMetadataMap(O, P, Create) {
let targetMetadata = Metadata.get(O);
if (IsUndefined(targetMetadata)) {
if (!Create) return;
targetMetadata = new _Map(), Metadata.set(O, targetMetadata);
}
let metadataMap = targetMetadata.get(P);
if (IsUndefined(metadataMap)) {
if (!Create) return;
metadataMap = new _Map(), targetMetadata.set(P, metadataMap);
}
return metadataMap;
}
function OrdinaryHasMetadata(MetadataKey, O, P) {
if (OrdinaryHasOwnMetadata(MetadataKey, O, P)) return !0;
const parent = OrdinaryGetPrototypeOf(O);
return !IsNull(parent) && OrdinaryHasMetadata(MetadataKey, parent, P);
}
function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
const metadataMap = GetOrCreateMetadataMap(O, P, !1);
return !IsUndefined(metadataMap) && ToBoolean(metadataMap.has(MetadataKey));
}
function OrdinaryGetMetadata(MetadataKey, O, P) {
if (OrdinaryHasOwnMetadata(MetadataKey, O, P)) return OrdinaryGetOwnMetadata(MetadataKey, O, P);
const parent = OrdinaryGetPrototypeOf(O);
return IsNull(parent) ? void 0 : OrdinaryGetMetadata(MetadataKey, parent, P);
}
function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
const metadataMap = GetOrCreateMetadataMap(O, P, !1);
if (!IsUndefined(metadataMap)) return metadataMap.get(MetadataKey);
}
function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
GetOrCreateMetadataMap(O, P, !0).set(MetadataKey, MetadataValue);
}
function Type(x) {
if (null === x) return 1;
switch (typeof x) {
case "undefined":
return 0;
case "boolean":
return 2;
case "string":
return 3;
case "symbol":
return 4;
case "number":
return 5;
case "object":
return null === x ? 1 : 6;
default:
return 6;
}
}
function IsUndefined(x) {
return void 0 === x;
}
function IsNull(x) {
return null === x;
}
function IsSymbol(x) {
return "symbol" == typeof x;
}
function IsObject(x) {
return "object" == typeof x ? null !== x : "function" == typeof x;
}
function ToPrimitive(input, PreferredType) {
switch (Type(input)) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
return input;
}
const hint = 3 === PreferredType ? "string" : 5 === PreferredType ? "number" : "default",
exoticToPrim = GetMethod(input, toPrimitiveSymbol);
if (void 0 !== exoticToPrim) {
const result = exoticToPrim.call(input, hint);
if (IsObject(result)) throw new TypeError();
return result;
}
return OrdinaryToPrimitive(input, "default" === hint ? "number" : hint);
}
function OrdinaryToPrimitive(O, hint) {
if ("string" === hint) {
const toString_1 = O.toString;
if (IsCallable(toString_1)) {
const result = toString_1.call(O);
if (!IsObject(result)) return result;
}
const valueOf = O.valueOf;
if (IsCallable(valueOf)) {
const result = valueOf.call(O);
if (!IsObject(result)) return result;
}
} else {
const valueOf = O.valueOf;
if (IsCallable(valueOf)) {
const result = valueOf.call(O);
if (!IsObject(result)) return result;
}
const toString_2 = O.toString;
if (IsCallable(toString_2)) {
const result = toString_2.call(O);
if (!IsObject(result)) return result;
}
}
throw new TypeError();
}
function ToBoolean(argument) {
return !!argument;
}
function ToString(argument) {
return "" + argument;
}
function ToPropertyKey(argument) {
const key = ToPrimitive(argument, 3);
return IsSymbol(key) ? key : ToString(key);
}
function IsCallable(argument) {
return "function" == typeof argument;
}
function GetMethod(V, P) {
const func = V[P];
if (null != func) {
if (!IsCallable(func)) throw new TypeError();
return func;
}
}
function OrdinaryGetPrototypeOf(O) {
const proto = Object.getPrototypeOf(O);
if ("function" != typeof O || O === functionPrototype) return proto;
if (proto !== functionPrototype) return proto;
const prototype = O.prototype,
prototypeProto = prototype && Object.getPrototypeOf(prototype);
if (null == prototypeProto || prototypeProto === Object.prototype) return proto;
const constructor = prototypeProto.constructor;
return "function" != typeof constructor || constructor === O ? proto : constructor;
}
exporter("defineMetadata", defineMetadata), exporter("hasMetadata", hasMetadata), exporter("hasOwnMetadata", hasOwnMetadata), exporter("getMetadata", getMetadata);
}((target = Reflect, function (key, value) {
"function" != typeof target[key] && Object.defineProperty(target, key, {
configurable: !0,
writable: !0,
value: value
});
})), Reflect;
})({});
function _tagParameterOrProperty(metadataKey, annotationTarget, key, metadata) {
const metadatas = [metadata];
let paramsOrPropertiesMetadata = {};
Reflect$1.hasOwnMetadata(metadataKey, annotationTarget) && (paramsOrPropertiesMetadata = Reflect$1.getMetadata(metadataKey, annotationTarget));
let paramOrPropertyMetadata = paramsOrPropertiesMetadata[key];
void 0 === paramOrPropertyMetadata && (paramOrPropertyMetadata = []), paramOrPropertyMetadata.push(...metadatas), paramsOrPropertiesMetadata[key] = paramOrPropertyMetadata, Reflect$1.defineMetadata(metadataKey, paramsOrPropertiesMetadata, annotationTarget);
}
function tagParameter(annotationTarget, parameterName, parameterIndex, metadata) {
_tagParameterOrProperty(TAGGED, annotationTarget, parameterIndex.toString(), metadata);
}
function createTaggedDecorator(metadata) {
return (target, targetKey, indexOrPropertyDescriptor) => {
tagParameter(target, targetKey, indexOrPropertyDescriptor, metadata);
};
}
function injectBase(metadataKey) {
return serviceIdentifier => (target, targetKey, indexOrPropertyDescriptor) => createTaggedDecorator(new Metadata(metadataKey, serviceIdentifier))(target, targetKey, indexOrPropertyDescriptor);
}
const inject = injectBase(INJECT_TAG);
const multiInject = injectBase(MULTI_INJECT_TAG);
function injectable() {
return function (target) {
return Reflect$1.defineMetadata(PARAM_TYPES, null, target), target;
};
}
function named(name) {
return createTaggedDecorator(new Metadata(NAMED_TAG, name));
}
const BindingScopeEnum = {
Singleton: "Singleton",
Transient: "Transient"
},
BindingTypeEnum = {
ConstantValue: "ConstantValue",
Constructor: "Constructor",
DynamicValue: "DynamicValue",
Factory: "Factory",
Function: "Function",
Instance: "Instance",
Invalid: "Invalid",
Provider: "Provider"
};
class Binding {
constructor(serviceIdentifier, scope) {
this.id = Generator.GenAutoIncrementId(), this.activated = !1, this.serviceIdentifier = serviceIdentifier, this.scope = scope, this.type = BindingTypeEnum.Invalid, this.constraint = request => !0, this.implementationType = null, this.cache = null, this.factory = null, this.provider = null, this.dynamicValue = null;
}
clone() {
const clone = new Binding(this.serviceIdentifier, this.scope);
return clone.activated = clone.scope === BindingScopeEnum.Singleton && this.activated, clone.implementationType = this.implementationType, clone.dynamicValue = this.dynamicValue, clone.scope = this.scope, clone.type = this.type, clone.provider = this.provider, clone.constraint = this.constraint, clone.cache = this.cache, clone;
}
}
class MetadataReader {
getConstructorMetadata(constructorFunc) {
return {
compilerGeneratedMetadata: Reflect$1.getMetadata(PARAM_TYPES, constructorFunc),
userGeneratedMetadata: Reflect$1.getMetadata(TAGGED, constructorFunc) || {}
};
}
getPropertiesMetadata(constructorFunc) {
throw new Error("暂未实现");
}
}
const taggedConstraint = key => value => {
const constraint = request => {
if (null == request) return !1;
if (request.key === key && request.value === value) return !0;
if (null == request.constructorArgsMetadata) return !1;
const constructorArgsMetadata = request.constructorArgsMetadata;
for (let i = 0; i < constructorArgsMetadata.length; i++) if (constructorArgsMetadata[i].key === key && constructorArgsMetadata[i].value === value) return !0;
return !1;
};
return constraint.metaData = new Metadata(key, value), constraint;
};
const namedConstraint = taggedConstraint(NAMED_TAG);
class BindingInSyntax {
constructor(binding) {
this._binding = binding;
}
inRequestScope() {
throw new Error("暂未实现");
}
inSingletonScope() {
return this._binding.scope = BindingScopeEnum.Singleton, this;
}
inTransientScope() {
return this._binding.scope = BindingScopeEnum.Transient, this;
}
whenTargetNamed(name) {
return this._binding.constraint = namedConstraint(name), this;
}
}
class BindingToSyntax {
constructor(binding) {
this._binding = binding;
}
to(constructor) {
return this._binding.type = BindingTypeEnum.Instance, this._binding.implementationType = constructor, new BindingInSyntax(this._binding);
}
toSelf() {
const self = this._binding.serviceIdentifier;
return this.to(self);
}
toDynamicValue(func) {
return this._binding.type = BindingTypeEnum.DynamicValue, this._binding.cache = null, this._binding.dynamicValue = func, this._binding.implementationType = null, new BindingInSyntax(this._binding);
}
toConstantValue(value) {
return this._binding.type = BindingTypeEnum.ConstantValue, this._binding.cache = value, this._binding.dynamicValue = null, this._binding.implementationType = null, this._binding.scope = BindingScopeEnum.Singleton, new BindingInSyntax(this._binding);
}
toFactory(factory) {
return this._binding.type = BindingTypeEnum.Factory, this._binding.factory = factory, this._binding.scope = BindingScopeEnum.Singleton, new BindingInSyntax(this._binding);
}
toService(service) {
this.toDynamicValue(context => context.container.get(service));
}
}
class Container {
constructor(containerOptions) {
const options = containerOptions || {};
options.defaultScope = options.defaultScope || BindingScopeEnum.Transient, this.options = options, this.id = Generator.GenAutoIncrementId(), this._bindingDictionary = new Map(), this._metadataReader = new MetadataReader();
}
load(module) {
const containerModuleHelpers = this._getContainerModuleHelpersFactory()(module.id);
module.registry(containerModuleHelpers.bindFunction, containerModuleHelpers.unbindFunction, containerModuleHelpers.isboundFunction, containerModuleHelpers.rebindFunction);
}
get(serviceIdentifier) {
const getArgs = this._getNotAllArgs(serviceIdentifier, !1);
return this._get(getArgs);
}
getAll(serviceIdentifier) {
const getArgs = this._getAllArgs(serviceIdentifier);
return this._get(getArgs);
}
getTagged(serviceIdentifier, key, value) {
const getArgs = this._getNotAllArgs(serviceIdentifier, !1, key, value);
return this._get(getArgs);
}
getNamed(serviceIdentifier, named) {
return this.getTagged(serviceIdentifier, NAMED_TAG, named);
}
isBound(serviceIdentifier) {
return this._bindingDictionary.has(serviceIdentifier);
}
bind(serviceIdentifier) {
const scope = this.options.defaultScope,
binding = new Binding(serviceIdentifier, scope),
list = this._bindingDictionary.get(serviceIdentifier) || [];
return list.push(binding), this._bindingDictionary.set(serviceIdentifier, list), new BindingToSyntax(binding);
}
unbind(serviceIdentifier) {
this._bindingDictionary.delete(serviceIdentifier);
}
rebind(serviceIdentifier) {
return this.unbind(serviceIdentifier), this.bind(serviceIdentifier);
}
_getContainerModuleHelpersFactory() {
const setModuleId = (bindingToSyntax, moduleId) => {
bindingToSyntax._binding.moduleId = moduleId;
},
getBindFunction = moduleId => serviceIdentifier => {
const bindingToSyntax = this.bind(serviceIdentifier);
return setModuleId(bindingToSyntax, moduleId), bindingToSyntax;
},
getUnbindFunction = () => serviceIdentifier => this.unbind(serviceIdentifier),
getIsboundFunction = () => serviceIdentifier => this.isBound(serviceIdentifier),
getRebindFunction = moduleId => serviceIdentifier => {
const bindingToSyntax = this.rebind(serviceIdentifier);
return setModuleId(bindingToSyntax, moduleId), bindingToSyntax;
};
return mId => ({
bindFunction: getBindFunction(mId),
isboundFunction: getIsboundFunction(),
rebindFunction: getRebindFunction(mId),
unbindFunction: getUnbindFunction(),
unbindAsyncFunction: serviceIdentifier => null
});
}
_getNotAllArgs(serviceIdentifier, isMultiInject, key, value) {
return {
avoidConstraints: !1,
isMultiInject: isMultiInject,
serviceIdentifier: serviceIdentifier,
key: key,
value: value
};
}
_getAllArgs(serviceIdentifier) {
return {
avoidConstraints: !0,
isMultiInject: !0,
serviceIdentifier: serviceIdentifier
};
}
_get(getArgs) {
const result = [];
return this._bindingDictionary.get(getArgs.serviceIdentifier).filter(b => b.constraint(getArgs)).forEach(binding => {
result.push(this._resolveFromBinding(binding));
}), getArgs.isMultiInject || 1 !== result.length ? result : result[0];
}
_getChildRequest(binding) {
const constr = binding.implementationType,
{
userGeneratedMetadata: userGeneratedMetadata
} = this._metadataReader.getConstructorMetadata(constr),
keys = Object.keys(userGeneratedMetadata),
arr = [];
for (let i = 0; i < keys.length; i++) {
const constructorArgsMetadata = userGeneratedMetadata[i],
targetMetadataMap = {};
constructorArgsMetadata.forEach(md => {
targetMetadataMap[md.key] = md.value;
});
const metadata = {
inject: targetMetadataMap[INJECT_TAG],
multiInject: targetMetadataMap[MULTI_INJECT_TAG]
},
injectIdentifier = metadata.inject || metadata.multiInject,
target = {
serviceIdentifier: injectIdentifier,
constructorArgsMetadata: constructorArgsMetadata
},
bindings = (this._bindingDictionary.get(injectIdentifier) || []).filter(b => b.constraint(target));
if (bindings.length) {
const request = {
injectIdentifier: injectIdentifier,
metadata: constructorArgsMetadata,
bindings: bindings
};
arr.push(request);
}
}
return arr;
}
_resolveFromBinding(binding) {
const result = this._getResolvedFromBinding(binding);
return this._saveToScope(binding, result), result;
}
_getResolvedFromBinding(binding) {
let result;
switch (binding.type) {
case BindingTypeEnum.ConstantValue:
case BindingTypeEnum.Function:
result = binding.cache;
break;
case BindingTypeEnum.Instance:
result = this._resolveInstance(binding, binding.implementationType);
break;
default:
result = binding.dynamicValue({
container: this
});
}
return result;
}
_resolveInstance(binding, constr) {
if (binding.activated) return binding.cache;
const childRequests = this._getChildRequest(binding);
return this._createInstance(constr, childRequests);
}
_createInstance(constr, childRequests) {
if (childRequests.length) {
return new constr(...this._resolveRequests(childRequests));
}
return new constr();
}
_resolveRequests(childRequests) {
return childRequests.map(request => request.bindings.length > 1 ? request.bindings.map(binding => this._resolveFromBinding(binding)) : this._resolveFromBinding(request.bindings[0]));
}
_saveToScope(binding, result) {
binding.scope === BindingScopeEnum.Singleton && (binding.cache = result, binding.activated = !0);
}
}
const ContributionProvider = Symbol("ContributionProvider");
class ContributionProviderCache {
constructor(serviceIdentifier, container) {
this.serviceIdentifier = serviceIdentifier, this.container = container, ContributionStore.setStore(this.serviceIdentifier, this);
}
getContributions() {
return this.caches || (this.caches = [], this.container && this.container.isBound(this.serviceIdentifier) && this.caches.push(...this.container.getAll(this.serviceIdentifier))), this.caches;
}
refresh() {
this.caches && (this.caches.length = 0, this.container && this.container.isBound(this.serviceIdentifier) && this.caches.push(...this.container.getAll(this.serviceIdentifier)));
}
}
function bindContributionProvider(bind, id) {
bind(ContributionProvider).toDynamicValue(_ref => {
let {
container: container
} = _ref;
return new ContributionProviderCache(id, container);
}).inSingletonScope().whenTargetNamed(id);
}
function bindContributionProviderNoSingletonScope(bind, id) {
bind(ContributionProvider).toDynamicValue(_ref2 => {
let {
container: container
} = _ref2;
return new ContributionProviderCache(id, container);
}).whenTargetNamed(id);
}
class ContributionStore {
static getStore(id) {
return this.store.get(id);
}
static setStore(id, cache) {
this.store.set(id, cache);
}
static refreshAllContributions() {
this.store.forEach(cache => {
cache.refresh();
});
}
}
ContributionStore.store = new Map();
class Hook {
constructor(args, name) {
this._args = args, this.name = name, this.taps = [];
}
tap(options, fn) {
this._tap("sync", options, fn);
}
unTap(options, fn) {
const name = "string" == typeof options ? options.trim() : options.name;
name && (this.taps = this.taps.filter(tap => !(tap.name === name && (!fn || tap.fn === fn))));
}
_parseOptions(type, options, fn) {
let _options;
if ("string" == typeof options) _options = {
name: options.trim()
};else if ("object" != typeof options || null === options) throw new Error("Invalid tap options");
if ("string" != typeof _options.name || "" === _options.name) throw new Error("Missing name for tap");
return _options = Object.assign({
type: type,
fn: fn
}, _options), _options;
}
_tap(type, options, fn) {
this._insert(this._parseOptions(type, options, fn));
}
_insert(item) {
let before;
"string" == typeof item.before ? before = new Set([item.before]) : Array.isArray(item.before) && (before = new Set(item.before));
let stage = 0;
"number" == typeof item.stage && (stage = item.stage);
let i = this.taps.length;
for (; i > 0;) {
i--;
const x = this.taps[i];
this.taps[i + 1] = x;
const xStage = x.stage || 0;
if (before) {
if (before.has(x.name)) {
before.delete(x.name);
continue;
}
if (before.size > 0) continue;
}
if (!(xStage > stage)) {
i++;
break;
}
}
this.taps[i] = item;
}
}
class SyncHook extends Hook {
call() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
this.taps.map(t => t.fn).forEach(cb => cb(...args));
}
}
const EnvContribution = Symbol.for("EnvContribution");
const VGlobal = Symbol.for("VGlobal");
const DEFAULT_TEXT_FONT_FAMILY$1 = "PingFang SC,Helvetica Neue,Microsoft Yahei,system-ui,'-apple-system',segoe ui,Roboto,Helvetica,Arial,sans-serif,apple color emoji,segoe ui emoji,segoe ui symbol";
const container = new Container();
const RenderService = Symbol.for("RenderService");
class Application {
get renderService() {
return this._renderService || (this._renderService = container.get(RenderService)), this._renderService;
}
}
const application = new Application();
let idx = 0;
class PerformanceRAF {
constructor() {
this.nextAnimationFrameCbs = new Map(), this._rafHandle = null, this.runAnimationFrame = time => {
this._rafHandle = null;
const cbs = this.nextAnimationFrameCbs;
this.nextAnimationFrameCbs = new Map(), cbs.forEach(cb => cb(time));
}, this.tryRunAnimationFrameNextFrame = () => {
null === this._rafHandle && 0 !== this.nextAnimationFrameCbs.size && (this._rafHandle = application.global.getRequestAnimationFrame()(this.runAnimationFrame));
};
}
addAnimationFrameCb(callback) {
return this.nextAnimationFrameCbs.set(++idx, callback), this.tryRunAnimationFrameNextFrame(), idx;
}
removeAnimationFrameCb(index) {
return !!this.nextAnimationFrameCbs.has(index) && (this.nextAnimationFrameCbs.delete(index), !0);
}
}
class EventListenerManager {
constructor() {
this._listenerMap = new Map(), this._eventListenerTransformer = event => event;
}
setEventListenerTransformer(transformer) {
this._eventListenerTransformer = transformer || (event => event);
}
addEventListener(type, listener, options) {
if (!listener) return;
const wrappedListener = event => {
const transformedEvent = this._eventListenerTransformer(event);
"function" == typeof listener ? listener(transformedEvent) : listener.handleEvent && listener.handleEvent(transformedEvent);
};
this._listenerMap.has(type) || this._listenerMap.set(type, new Map()), this._listenerMap.get(type).set(listener, wrappedListener), this._nativeAddEventListener(type, wrappedListener, options);
}
removeEventListener(type, listener, options) {
var _a;
if (!listener) return;
const wrappedListener = null === (_a = this._listenerMap.get(type)) || void 0 === _a ? void 0 : _a.get(listener);
wrappedListener && (this._nativeRemoveEventListener(type, wrappedListener, options), this._listenerMap.get(type).delete(listener), 0 === this._listenerMap.get(type).size && this._listenerMap.delete(type));
}
dispatchEvent(event) {
return this._nativeDispatchEvent(event);
}
clearAllEventListeners() {
this._listenerMap.forEach((listenersMap, type) => {
listenersMap.forEach((wrappedListener, originalListener) => {
this._nativeRemoveEventListener(type, wrappedListener, void 0);
});
}), this._listenerMap.clear();
}
_nativeAddEventListener(type, listener, options) {
throw new Error("_nativeAddEventListener must be implemented by derived classes");
}
_nativeRemoveEventListener(type, listener, options) {
throw new Error("_nativeRemoveEventListener must be implemented by derived classes");
}
_nativeDispatchEvent(event) {
throw new Error("_nativeDispatchEvent must be implemented by derived classes");
}
}
var __decorate$Q = undefined && undefined.__decorate || function (decorators, target, key, desc) {
var d,
c = arguments.length,
r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc;
if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) (d = decorators[i]) && (r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r);
return c > 3 && r && Object.defineProperty(target, key, r), r;
},
__metadata$G = undefined && undefined.__metadata || function (k, v) {
if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
},
__param$A = undefined && undefined.__param || function (paramIndex, decorator) {
return function (target, key) {
decorator(target, key, paramIndex);
};
},
__awaiter$4 = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
}
function step(result) {
var value;
result.done ? resolve(result.value) : (value = result.value, value instanceof P ? value : new P(function (resolve) {
resolve(value);
})).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
let DefaultGlobal = class extends EventListenerManager {
get env() {
return this._env;
}
get isImageAnonymous() {
return this._isImageAnonymous;
}
set isImageAnonymous(isImageAnonymous) {
this._isImageAnonymous = isImageAnonymous;
}
get devicePixelRatio() {
return this._env || this.setEnv("browser"), this.envContribution.getDevicePixelRatio();
}
get supportEvent() {
return this._env || this.setEnv("browser"), this.envContribution.supportEvent;
}
set supportEvent(support) {
this._env || this.setEnv("browser"), this.envContribution.supportEvent = support;
}
get supportsTouchEvents() {
return this._env || this.setEnv("browser"), this.envContribution.supportsTouchEvents;
}
set supportsTouchEvents(support) {
this._env || this.setEnv("browser"), this.envContribution.supportsTouchEvents = support;
}
get supportsPointerEvents() {
return this._env || this.setEnv("browser"), this.envContribution.supportsPointerEvents;
}
set supportsPointerEvents(support) {
this._env || this.setEnv("browser"), this.envContribution.supportsPointerEvents = support;
}
get supportsMouseEvents() {
return this._env || this.setEnv("browser"), this.envContribution.supportsMouseEvents;
}
set supportsMouseEvents(support) {
this._env || this.setEnv("browser"), this.envContribution.supportsMouseEvents = support;
}
get applyStyles() {
return this._env || this.setEnv("browser"), this.envContribution.applyStyles;
}
set applyStyles(support) {
this._env || this.setEnv("browser"), this.envContribution.applyStyles = support;
}
constructor(contributions) {
super(), this.contributions = contributions, this._isImageAnonymous = !0, this._performanceRAFList = [], this.eventListenerTransformer = event => event, this.id = Generator.GenAutoIncrementId(), this.hooks = {
onSetEnv: new SyncHook(["lastEnv", "env", "global"])
}, this.measureTextMethod = "native", this.optimizeVisible = !1;
}
_nativeAddEventListener(type, listener, options) {
return this._env || this.setEnv("browser"), this.envContribution.addEventListener(type, listener, options);
}
_nativeRemoveEventListener(type, listener, options) {
return this._env || this.setEnv("browser"), this.envContribution.removeEventListener(type, listener, options);
}
_nativeDispatchEvent(event) {
return this._env || this.setEnv("browser"), this.envContribution.dispatchEvent(event);
}
bindContribution(params) {
const promiseArr = [];
if (this.contributions.getContributions().forEach(contribution => {
const data = contribution.configure(this, params);
data && data.then && promiseArr.push(data);
}), promiseArr.length) return Promise.all(promiseArr);
}
getDynamicCanvasCount() {
return this._env || this.setEnv("browser"), this.envContribution.getDynamicCanvasCount();
}
getStaticCanvasCount() {
return this._env || this.setEnv("browser"), this.envContribution.getStaticCanvasCount();
}
setEnv(env, params) {
if (params && !0 === params.force || this._env !== env) return this.deactiveCurrentEnv(), this.activeEnv(env, params);
}
deactiveCurrentEnv() {
this.envContribution && this.envContribution.release();
}
activeEnv(env, params) {
const lastEnv = this._env;
this._env = env;
const data = this.bindContribution(params);
if (data && data.then) return data.then(() => {
this.envParams = params, this.hooks.onSetEnv.call(lastEnv, env, this);
});
this.envParams = params, this.hooks.onSetEnv.call(lastEnv, env, this);
}
setActiveEnvContribution(contribution) {
this.envContribution = contribution;
}
createCanvas(params) {
return this._env || this.setEnv("browser"), this.envContribution.createCanvas(params);
}
createOffscreenCanvas(params) {
return this._env || this.setEnv("browser"), this.envContribution.createOffscreenCanvas(params);
}
releaseCanvas(canvas) {
return this._env || this.setEnv("browser"), this.envContribution.releaseCanvas(canvas);
}
getRequestAnimationFrame() {
return this._env || this.setEnv("browser"), this.envContribution.getRequestAnimationFrame();
}
getSpecifiedRequestAnimationFrame(id) {
this._env || this.setEnv("browser"), this._performanceRAFList[id] || (this._performanceRAFList[id] = new PerformanceRAF());
const performanceRAF = this._performanceRAFList[id];
return callback => performanceRAF.addAnimationFrameCb(callback);
}
getSpecifiedCancelAnimationFrame(id) {
if (this._env || this.setEnv("browser"), !this._performanceRAFList[id]) return () => !1;
const performanceRAF = this._performanceRAFList[id];
return handle => performanceRAF.removeAnimationFrameCb(handle);
}
getCancelAnimationFrame() {
return this._env || this.setEnv("browser"), this.envContribution.getCancelAnimationFrame();
}
getElementById(str) {
return this._env || this.setEnv("browser"), this.envContribution.getElementById ? this.envContribution.getElementById(str) : null;
}
getRootElement() {
return this._env || this.setEnv("browser"), this.envContribution.getRootElement ? this.envContribution.getRootElement() : null;
}
getDocument() {
return this._env || this.setEnv("browser"), this.envContribution.getDocument ? this.envContribution.getDocument() : null;
}
mapToCanvasPoint(event, domElement) {
return this._env || this.setEnv("browser"), this.envContribution.mapToCanvasPoint ? this.envContribution.mapToCanvasPoint(event, domElement) : null;
}
loadImage(url) {
return this._env || this.setEnv("browser"), this.envContribution.loadImage(url);
}
loadSvg(str) {
return this._env || this.setEnv("browser"), this.envContribution.loadSvg(str);
}
loadJson(url) {
return this._env || this.setEnv("browser"), this.envContribution.loadJson(url);
}
loadArrayBuffer(url) {
return this._env || this.setEnv("browser"), this.envContribution.loadArrayBuffer(url);
}
loadBlob(url) {
return this._env || this.setEnv("browser"), this.envContribution.loadBlob(url);
}
loadFont(name, source, descriptors) {
return __awaiter$4(this, void 0, void 0, function* () {
return this._env || this.setEnv("browser"), this.envContribution.loadFont(name, source, descriptors);
});
}
isChrome() {
return null != this._isChrome || (this._env || this.setEnv("browser"), this._isChrome = "browser" === this._env && navigator.userAgent.indexOf("Chrome") > -1), this._isChrome;
}
isSafari() {
return null != this._isSafari || (this._env || this.setEnv("browser"), this._isSafari = "browser" === this._env && /Safari/.test(navigator.userAgent) && !/Chrome/.test(navigator.userAgent)), this._isSafari;
}
getNativeAABBBounds(dom) {
return this._env || this.setEnv("browser"), this.envContribution.getNativeAABBBounds(dom);
}
removeDom(dom) {
return this._env || this.setEnv("browser"), this.envContribution.removeDom(dom);
}
createDom(params) {
return this._env || this.setEnv("browser"), this.envContribution.createDom(params);
}
updateDom(dom, params) {
return this._env || this.setEnv("browser"), this.envContribution.updateDom(dom, params);
}
getElementTop(dom) {
let baseWindow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : !1;
return this._env || this.setEnv("browser"), this.envContribution.getElementTop(dom, baseWindow);
}
getElementLeft(dom) {
let baseWindow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : !1;
return this._env || this.setEnv("browser"), this.envContribution.getElementLeft(dom, baseWindow);
}
getElementTopLeft(dom) {
let baseWindow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : !1;
return this._env || this.setEnv("browser"), this.envContribution.getElementTopLeft(dom, baseWindow);
}
isMacOS() {
return this._env || this.setEnv("browser"), this.envContribution.isMacOS();
}
copyToClipBoard(text) {
return this._env || this.setEnv("browser"), this.envContribution.copyToClipBoard(text);
}
};
DefaultGlobal = __decorate$Q([injectable(), __param$A(0, inject(ContributionProvider)), __param$A(0, named(EnvContribution)), __metadata$G("design:paramtypes", [Object])], DefaultGlobal);
var MeasureModeEnum;
!function (MeasureModeEnum) {
MeasureModeEnum[MeasureModeEnum.estimate = 0] = "estimate", MeasureModeEnum[MeasureModeEnum.actualBounding = 1] = "actualBounding", MeasureModeEnum[MeasureModeEnum.fontBounding = 2] = "fontBounding";
}(MeasureModeEnum || (MeasureModeEnum = {}));
var AnimateMode;
!function (AnimateMode) {
AnimateMode[AnimateMode.NORMAL = 0] = "NORMAL", AnimateMode[AnimateMode.SET_ATTR_IMMEDIATELY = 1] = "SET_ATTR_IMMEDIATELY";
}(AnimateMode || (AnimateMode = {}));
var STATUS$1;
!function (STATUS) {
STATUS[STATUS.INITIAL = 0] = "INITIAL", STATUS[STATUS.RUNNING = 1] = "RUNNING", STATUS[STATUS.PAUSE = 2] = "PAUSE";
}(STATUS$1 || (STATUS$1 = {}));
var AnimateStepType;
!function (AnimateStepType) {
AnimateStepType.wait = "wait", AnimateStepType.from = "from", AnimateStepType.to = "to", AnimateStepType.customAnimate = "customAnimate";
}(AnimateStepType || (AnimateStepType = {}));
var AnimateStatus;
!function (AnimateStatus) {
AnimateStatus[AnimateStatus.INITIAL = 0] = "INITIAL", AnimateStatus[AnimateStatus.RUNNING = 1] = "RUNNING", AnimateStatus[AnimateStatus.PAUSED = 2] = "PAUSED", AnimateStatus[AnimateStatus.END = 3] = "END";
}(AnimateStatus || (AnimateStatus = {}));
const circleThreshold = tau - 1e-8;
class BoundsContext {
constructor(bounds) {
this.init(bounds);
}
init(bounds) {
this.bounds = bounds;
}
arc(cx, cy, r, sa, ea, ccw) {
if (Math.abs(ea - sa) > circleThreshold) return this.bounds.add(cx - r, cy - r), void this.bounds.add(cx + r, cy + r);
let s,
i,
x,
y,
xmin = 1 / 0,
xmax = -1 / 0,
ymin = 1 / 0,
ymax = -1 / 0;
function update(a) {
x = r * Math.cos(a), y = r * Math.sin(a), x < xmin && (xmin = x), x > xmax && (xmax = x), y < ymin && (ymin = y), y > ymax && (ymax = y);
}
if (update(sa), update(ea), ea !== sa) if ((sa %= tau) < 0 && (sa += tau), (ea %= tau) < 0 && (ea += tau), ea < sa && (ccw = !ccw, s = sa, sa = ea, ea = s), ccw) for (ea -= tau, s = sa - sa % halfPi$1, i = 0; i < 4 && s > ea; ++i, s -= halfPi$1) update(s);else for (s = sa - sa % halfPi$1 + halfPi$1, i = 0; i < 4 && s < ea; ++i, s += halfPi$1) update(s);
this.bounds.add(cx + xmin, cy + ymin), this.bounds.add(cx + xmax, cy + ymax);
}
arcTo(x1, y1, x2, y2, radius) {
this.bounds.add(x1, y1);
}
bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) {
this.bounds.add(cp1x, cp1y), this.bounds.add(cp2x, cp2y), this.bounds.add(x, y);
}
closePath() {}
ellipse() {
throw new Error("不支持ellipse");
}
lineTo(x, y) {
this.bounds.add(x, y);
}
moveTo(x, y) {
this.bounds.add(x, y);
}
quadraticCurveTo(cpx, cpy, x, y) {
this.bounds.add(cpx, cpy), this.bounds.add(x, y);
}
rect(x, y, w, h) {
this.bounds.add(x, y), this.bounds.add(x + w, y + h);
}
clear() {
this.bounds.clear();
}
release() {}
}
class CurvePath {
constructor() {
this._curves = [], this.bounds = new AABBBounds();
}
get curves() {
return this._curves;
}
getCurveLengths() {
return this._curves.map(curve => curve.getLength());
}
getPointAt(t) {
return {
x: 0,
y: 0
};
}
getLength() {
return 0;
}
getBounds() {
return this.bounds;
}
}
const rePathCommand = /([-+]?((\d+\.\d+)|((\d+)|(\.\d+)))(?:[eE][-+]?\d+)?)/gi,
commandLengths = {
m: 2,
l: 2,
h: 1,
v: 1,
c: 6,
s: 4,
q: 4,
t: 2,
a: 7,
M: 2,
L: 2,
H: 1,
V: 1,
C: 6,
S: 4,
Q: 4,
T: 2,
A: 7
};
const enumCommandMap = {
A: 0,
AT: 1,
C: 2,
Z: 3,
E: 4,
L: 5,
M: 6,
Q: 7,
R: 8
};
let currPath, coordsStr, commandChar, coordStr, coordNumber, standardCommandLen;
function parseSvgPath(str) {
if (!str) return [];
const paths = str.match(/[mzlhvcsqta][^mzlhvcsqta]*/gi);
if (null === paths) return [];
let currCommandData, coordsStrArr;
const result = [];
for (let i = 0, len = paths.length; i < len; i++) if (currPath = paths[i], coordsStr = currPath.slice(1), commandChar = currPath[0], currCommandData = [commandChar], coordsStrArr = coordsStr.match(rePathCommand), null !== coordsStrArr) {
for (let i = 0, len = coordsStrArr.length; i < len; i++) coordStr = coordsStrArr[i], coordNumber = parseFloat(coordStr), Number.isNaN(coordNumber) || currCommandData.push(coordNumber);
if (standardCommandLen = commandLengths[commandChar], currCommandData.length - 1 > standardCommandLen) {
let subCommand,
bestCommandChar = commandChar;
for (let i = 1, len = currCommandData.length; i < len; i += standardCommandLen) {
subCommand = [bestCommandChar];
for (let j = i, subLen = i + standardCommandLen; j < subLen; j++) subCommand.push(currCommandData[j]);
result.push(subCommand), "m" === bestCommandChar ? bestCommandChar = "l" : "M" === bestCommandChar && (bestCommandChar = "L");
}
} else result.push(currCommandData);
} else result.push(currCommandData);
return result;
}
var UpdateTag;
!function (UpdateTag) {
UpdateTag[UpdateTag.NONE = 0] = "NONE", UpdateTag[UpdateTag.UPDATE_BOUNDS = 1] = "UPDATE_BOUNDS", UpdateTag[UpdateTag.UPDATE_SHAPE = 2] = "UPDATE_SHAPE", UpdateTag[UpdateTag.CLEAR_SHAPE = 253] = "CLEAR_SHAPE", UpdateTag[UpdateTag.UPDATE_SHAPE_AND_BOUNDS = 3] = "UPDATE_SHAPE_AND_BOUNDS", UpdateTag[UpdateTag.INIT = 179] = "INIT", UpdateTag[UpdateTag.CLEAR_BOUNDS = 254] = "CLEAR_BOUNDS", UpdateTag[UpdateTag.UPDATE_GLOBAL_MATRIX = 32] = "UPDATE_GLOBAL_MATRIX", UpdateTag[UpdateTag.CLEAR_GLOBAL_MATRIX = 223] = "CLEAR_GLOBAL_MATRIX", UpdateTag[UpdateTag.UPDATE_LOCAL_MATRIX = 16] = "UPDATE_LOCAL_MATRIX", UpdateTag[UpdateTag.CLEAR_LOCAL_MATRIX = 239] = "CLEAR_LOCAL_MATRIX", UpdateTag[UpdateTag.UPDATE_GLOBAL_LOCAL_MATRIX = 48] = "UPDATE_GLOBAL_LOCAL_MATRIX", UpdateTag[UpdateTag.UPDATE_LAYOUT = 128] = "UPDATE_LAYOUT", UpdateTag[UpdateTag.CLEAR_LAYOUT = 127] = "CLEAR_LAYOUT";
}(UpdateTag || (UpdateTag = {}));
var IContainPointMode;
!function (IContainPointMode) {
IContainPointMode[IContainPointMode.GLOBAL = 1] = "GLOBAL", IContainPointMode[IContainPointMode.LOCAL = 16] = "LOCAL", IContainPointMode[IContainPointMode.GLOBAL_ACCURATE = 3] = "GLOBAL_ACCURATE", IContainPointMode[IContainPointMode.LOCAL_ACCURATE = 48] = "LOCAL_ACCURATE";
}(IContainPointMode || (IContainPointMode = {}));
var AttributeUpdateType;
!function (AttributeUpdateType) {
AttributeUpdateType[AttributeUpdateType.INIT = 0] = "INIT", AttributeUpdateType[AttributeUpdateType.DEFAULT = 1] = "DEFAULT", AttributeUpdateType[AttributeUpdateType.STATE = 2] = "STATE", AttributeUpdateType[AttributeUpdateType.ANIMATE_BIND = 10] = "ANIMATE_BIND", AttributeUpdateType[AttributeUpdateType.ANIMATE_PLAY = 11] = "ANIMATE_PLAY", AttributeUpdateType[AttributeUpdateType.ANIMATE_START = 12] = "ANIMATE_START", AttributeUpdateType[AttributeUpdateType.ANIMATE_UPDATE = 13] = "ANIMATE_UPDATE", AttributeUpdateType[AttributeUpdateType.ANIMATE_END = 14] = "ANIMATE_END", AttributeUpdateType[AttributeUpdateType.TRANSLATE = 20] = "TRANSLATE", AttributeUpdateType[AttributeUpdateType.TRANSLATE_TO = 21] = "TRANSLATE_TO", AttributeUpdateType[AttributeUpdateType.SCALE = 22] = "SCALE", AttributeUpdateType[AttributeUpdateType.SCALE_TO = 23] = "SCALE_TO", AttributeUpdateType[AttributeUpdateType.ROTATE = 24] = "ROTATE", AttributeUpdateType[AttributeUpdateType.ROTATE_TO = 25] = "ROTATE_TO";
}(AttributeUpdateType || (AttributeUpdateType = {}));
var Direction;
!function (Direction) {
Direction[Direction.ROW = 1] = "ROW", Direction[Direction.COLUMN = 2] = "COLUMN";
}(Direction || (Direction = {}));
var CurveTypeEnum;
!function (CurveTypeEnum) {
CurveTypeEnum[CurveTypeEnum.CubicBezierCurve = 0] = "CubicBezierCurve", CurveTypeEnum[CurveTypeEnum.QuadraticBezierCurve = 1] = "QuadraticBezierCurve", CurveTypeEnum[CurveTypeEnum.ArcCurve = 2] = "ArcCurve", CurveTypeEnum[CurveTypeEnum.LineCurve = 3] = "LineCurve", CurveTypeEnum[CurveTypeEnum.EllipseCurve = 4] = "EllipseCurve", CurveTypeEnum[CurveTypeEnum.MoveCurve = 5] = "MoveCurve";
}(CurveTypeEnum || (CurveTypeEnum = {}));
var BaseRenderContributionTime;
!function (BaseRenderContributionTime) {
BaseRenderContributionTime[BaseRenderContributionTime.beforeFillStroke = 0] = "beforeFillStroke", BaseRenderContributionTime[BaseRenderContributionTime.afterFillStroke = 1] = "afterFillStroke";
}(BaseRenderContributionTime || (BaseRenderContributionTime = {}));
function segments(x, y, rx, ry, large, sweep, rotateX, ox, oy) {
const th = degreeToRadian(rotateX),
sin_th = Math.sin(th),
cos_th = Math.cos(th),
px = cos_th * (ox - x) * .5 + sin_th * (oy - y) * .5,
py = cos_th * (oy - y) * .5 - sin_th * (ox - x) * .5;
let pl = px * px / ((rx = Math.abs(rx)) * rx) + py * py / ((ry = Math.abs(ry)) * ry);
pl > 1 && (pl = Math.sqrt(pl), rx *= pl, ry *= pl);
const a00 = cos_th / rx,
a01 = sin_th / rx,
a10 = -sin_th / ry,
a11 = cos_th / ry,
x0 = a00 * ox + a01 * oy,
y0 = a10 * ox + a11 * oy,
x1 = a00 * x + a01 * y,
y1 = a10 * x + a11 * y;
let sfactor_sq = 1 / ((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)) - .25;
sfactor_sq < 0 && (sfactor_sq = 0);
let sfactor = Math.sqrt(sfactor_sq);
sweep === large && (sfactor = -sfactor);
const xc = .5 * (x0 + x1) - sfactor * (y1 - y0),
yc = .5 * (y0 + y1) + sfactor * (x1 - x0),
th0 = Math.atan2(y0 - yc, x0 - xc);
let th_arc = Math.atan2(y1 - yc, x1 - xc) - th0;
th_arc < 0 && 1 === sweep ? th_arc += tau : th_arc > 0 && 0 === sweep && (th_arc -= tau);
const segs = Math.ceil(Math.abs(th_arc / (halfPi$1 + .001))),
result = [];
for (let i = 0; i < segs; ++i) {
const th2 = th0 + i * th_arc / segs,
th3 = th0 + (i + 1) * th_arc / segs;
result[i] = [xc, yc, th2, th3, rx, ry, sin_th, cos_th];
}
return result;
}
function bezier(params) {
const cx = params[0],
cy = params[1],
th0 = params[2],
th1 = params[3],
rx = params[4],
ry = params[5],
sin_th = params[6],
cos_th = params[7],
a00 = cos_th * rx,
a01 = -sin_th * ry,
a10 = sin_th * rx,
a11 = cos_th * ry,
cos_th0 = Math.cos(th0),
sin_th0 = Math.sin(th0),
cos_th1 = Math.cos(th1),
sin_th1 = Math.sin(th1),
th_half = .5 * (th1 - th0),
sin_th_h2 = Math.sin(.5 * th_half),
t = 8 / 3 * sin_th_h2 * sin_th_h2 / Math.sin(th_half),
x1 = cx + cos_th0 - t * sin_th0,
y1 = cy + sin_th0 + t * cos_th0,
x3 = cx + cos_th1,
y3 = cy + sin_th1,
x2 = x3 + t * sin_th1,
y2 = y3 - t * cos_th1;
return [a00 * x1 + a01 * y1, a10 * x1 + a11 * y1, a00 * x2 + a01 * y2, a10 * x2 + a11 * y2, a00 * x3 + a01 * y3, a10 * x3 + a11 * y3];
}
function drawArc(context, x, y, coords) {
const seg = segments(coords[5], coords[6], coords[0], coords[1], coords[3], coords[4], coords[2], x, y);
for (let i = 0; i < seg.length; ++i) {
const bez = bezier(seg[i]);
context.bezierCurveTo(bez[0], bez[1], bez[2], bez[3], bez[4], bez[5]);
}
}
const addArcToBezierPath = function (bezierPath, startAngle, endAngle, cx, cy, rx, ry) {
let counterclockwise = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : !1;
const PI2 = 2 * Math.PI,
sAngle = (startAngle % PI2 + PI2) % PI2;
let deltaAngle,
eAngle = (endAngle % PI2 + PI2) % PI2;
counterclockwise ? (eAngle >= sAngle && (eAngle -= PI2), deltaAngle = eAngle - sAngle) : (eAngle <= sAngle && (eAngle += PI2), deltaAngle = eAngle - sAngle);
const count = Math.ceil(Math.abs(deltaAngle) / (.5 * Math.PI)),
stepAngle = deltaAngle / count;
for (let i = 0; i < count; i++) {
const sa = sAngle + stepAngle * i,
ea = sAngle + stepAngle * (i + 1),
len = 4 / 3 * Math.tan(Math.abs(stepAngle) / 4),
c1 = Math.cos(sa),
s1 = Math.sin(sa),
c2 = Math.cos(ea),
s2 = Math.sin(ea),
x1 = c1 * rx + cx,
y1 = s1 * ry + cy,
x4 = c2 * rx + cx,
y4 = s2 * ry + cy,
sign = counterclockwise ? -1 : 1,
hx = rx * len * sign,
hy = ry * len * sign;
bezierPath.push(x1 - hx * s1, y1 + hy * c1, x4 + hx * s2, y4 - hy * c2, x4, y4);
}
};
const commandFuncs = [(command, context, x, y, sx, sy, z) => context.arc(command[1] * sx + x, command[2] * sy + y, command[3] * (sx + sy) / 2, command[4], command[5], command[6], z), (command, context, x, y, sx, sy, z) => context.arcTo(command[1] * sx + x, command[2] * sy + y, command[3] * sx + x, command[4] * sy + y, command[5] * (sx + sy) / 2, z), (command, context, x, y, sx, sy, z) => context.bezierCurveTo(command[1] * sx + x, command[2] * sy + y, command[3] * sx + x, command[4] * sy + y, command[5] * sx + x, command[6] * sy + y, z), (command, context, x, y) => context.closePath(), (command, context, x, y, sx, sy) => context.ellipse(command[1] * sx + x, command[2] * sy + y, command[3] * sx, command[4] * sy, command[5], command[6], command[7], command[8]), (command, context, x, y, sx, sy, z) => context.lineTo(command[1] * sx + x, command[2] * sy + y, z), (command, context, x, y, sx, sy, z) => context.moveTo(command[1] * sx + x, command[2] * sy + y, z), (command, context, x, y, sx, sy, z) => context.quadraticCurveTo(command[1] * sx + x, command[2] * sy + y, command[3] * sx + x, command[4] * sy + y, z), (command, context, x, y, sx, sy, z) => context.rect(command[1] * sx + x, command[2] * sy + y, command[3] * sx, command[4] * sy, z)];
function renderCommandList(commandList, context) {
let x = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
let y = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
let sx = argument