DIRECTORY
ImmutableTioga,
Rope,
Rosary,
TextLooks;

ImmutableTiogaImpl: CEDAR PROGRAM
IMPORTS Rope, Rosary, TextLooks
EXPORTS ImmutableTioga
~ BEGIN OPEN ImmutableTioga;

NChildren: PUBLIC PROC [node: Node] RETURNS [INT] ~ {
children: ROSARY ~ node.children;
RETURN [IF children=NIL THEN 0 ELSE children.size];
};

NthChild: PUBLIC PROC [node: Node, i: INT] RETURNS [Node] ~ {
WITH Rosary.Fetch[node.children, i] SELECT FROM
child: Node => RETURN[child];
ENDCASE => RETURN[NIL];
};


Index: TYPE ~ REF IndexRep;
IndexRep: TYPE ~ RECORD [depth: NAT, seq: SEQUENCE size: NAT OF INT];
Path: TYPE ~ REF PathRep;
PathRep: TYPE ~ RECORD [depth: NAT, seq: SEQUENCE size: NAT OF Node];

IndexedNode: PROC [root: Node, index: Index] RETURNS [Node] ~ {
node: Node _ root;
FOR k: NAT IN [0..index.depth) DO
node _ NthChild[node, index[k]];
ENDLOOP;
RETURN[node];
};

SetPath: PROC [root: Node, index: Index, path: Path] ~ {
depth: NAT ~ index.depth;
node: Node _ root;
FOR k: NAT IN [0..depth) DO
path[k] _ node;
node _ NthChild[node, index[k]];
ENDLOOP;
path[depth] _ node;
path.depth _ depth+1;
};

PropListGet: PUBLIC PROC [propList: PropList, name: ATOM] RETURNS [value: REF] ~ {
FOR list: PropList _ propList, list.rest UNTIL list=NIL DO
prop: Prop ~ list.first;
IF prop.name=name THEN RETURN[prop.value];
ENDLOOP;
RETURN[NIL];
};

PropListPut: PUBLIC PROC [propList: PropList, name: ATOM, value: REF] RETURNS [PropList] ~ {
IF PropListGet[propList, name]=value THEN RETURN [propList]
ELSE {
rem: PropList ~ PropListRem[propList, name];
IF value=NIL THEN RETURN [rem]
ELSE RETURN [CONS[NEW[PropRep _ [name, value]], rem]];
};
};

PropListRem: PROC [propList: PropList, name: ATOM] RETURNS [PropList] ~ {
IF propList=NIL THEN RETURN [NIL]
ELSE IF propList.first.name=name THEN RETURN [propList.rest]
ELSE {
remRest: PropList ~ PropListRem[propList.rest, name];
IF propList.rest=remRest THEN RETURN [propList]
ELSE RETURN [CONS[propList.first, remRest]];
};
};


aComment: ATOM ~ $Comment;
aFormat: ATOM ~ $Format;
aStyleDef: ATOM ~ $StyleDef;
aPrefix: ATOM ~ $Prefix;
aPostfix: ATOM ~ $Postfix;
aArtwork: ATOM ~ $Artwork;

refBool: ARRAY BOOL OF REF BOOL ~ [FALSE: NEW[BOOL _ FALSE], TRUE: NEW[BOOL _ TRUE]];

PropsGet: PUBLIC PROC [props: Props, name: ATOM] RETURNS [value: REF] ~ {
SELECT name FROM
aComment => value _ refBool[props.comment];
aFormat => value _ props.formatName;
ENDCASE => value _ PropListGet[props.propList, name];
};

PropsPut: PUBLIC PROC [props: Props, name: ATOM, value: REF] RETURNS [Props] ~ {
propList: PropList _ props.propList;
format: ATOM _ props.formatName;
comment: BOOL _ props.comment;
SELECT name FROM
aComment => comment _ WITH value SELECT FROM x: REF BOOL => x^, ENDCASE => FALSE;
aFormat => format _ WITH value SELECT FROM x: ATOM => x, ENDCASE => NIL;
ENDCASE => propList _ PropListPut[props.propList, name, value];
IF propList#props.propList OR format#props.formatName OR comment#props.comment THEN {
new: Props ~ NEW [PropsRep _ [propList: propList, formatName: format, comment: comment, hasStyleDef: props.hasStyleDef, hasPrefix: props.hasPrefix, hasPostfix: props.hasPostfix, hasArtwork: props.hasArtwork]];
IF new.propList#props.propList THEN {
hasValue: BOOL ~ (value#NIL);
SELECT name FROM
aStyleDef => new.hasStyleDef _ hasValue;
aPrefix => new.hasPrefix _ hasValue;
aPostfix => new.hasPostfix _ hasValue;
aArtwork => new.hasArtwork _ hasValue;
ENDCASE;
};
RETURN[new];
}
ELSE RETURN [props]; -- nothing changed
};


NewText: PUBLIC PROC [props: Props _ NIL] RETURNS [Text] ~ {
IF props=NIL THEN props _ NEW [PropsRep _ []];
RETURN [NEW[TextRep _ [rope: NIL, runs: NIL, charSets: NIL, charProps: NIL, props: props]]];
};

TextFromRope: PUBLIC PROC [rope: ROPE, looks: Looks _ noLooks] RETURNS [Text] ~ {
text: Text ~ NewText[];
text.rope _ rope;
text.runs _ TextLooks.CreateRun[Rope.Size[rope], looks];
RETURN [text];
};


Size: PUBLIC PROC [text: Text] RETURNS [INT] ~ {
RETURN[IF text=NIL THEN 0 ELSE Rope.InlineSize[text.rope]];
};

FetchChar: PUBLIC PROC [text: Text, index: INT] RETURNS [char: XChar _ [0, 0]] ~ {
char.code _ ORD[Rope.Fetch[text.rope, index]];
IF text.charSets#NIL THEN WITH Rosary.Fetch[text.charSets, index] SELECT FROM
refCharSet: REF CharSet => char.set _ refCharSet^;
ENDCASE;
};

FetchLooks: PUBLIC PROC [text: Text, index: INT] RETURNS [Looks] = {
RETURN [TextLooks.FetchLooks[text.runs, index]];
};

Fetch: PUBLIC PROC [text: Text, index: INT] RETURNS [char: XChar, looks: Looks] ~ {
char _ FetchChar[text, index];
looks _ FetchLooks[text, index];
};

GetFormat: PUBLIC PROC [text: Text] RETURNS [ATOM] ~ {
RETURN[text.props.formatName];
};

GetComment: PUBLIC PROC [text: Text] RETURNS [BOOL] ~ {
RETURN[text.props.comment];
};

GetProp: PUBLIC PROC [text: Text, name: ATOM] RETURNS [REF] ~ {
RETURN[PropsGet[text.props, name]];
};

GetCharProp: PUBLIC PROC [text: Text, index: INT, name: ATOM] RETURNS [REF] ~ {
RETURN[PropListGet[GetCharPropList[text, index], name]];
};

GetCharPropList: PUBLIC PROC [text: Text, index: INT] RETURNS [PropList] ~ {
RETURN[NARROW[Rosary.Fetch[text.charProps, index]]];
};


rosaryOfNil: ROSARY ~ Rosary.FromItem[NIL, maxLen];

RosaryReplace: PROC [dest: ROSARY, destSize: INT, destStart: INT, destLen: INT, source: ROSARY, sourceStart: INT, sourceLen: INT] RETURNS [rosary: ROSARY] ~ {
notNil: Rosary.RunActionType ~ { quit _ item#NIL };
d: ROSARY ~ IF dest=NIL THEN rosaryOfNil ELSE dest;
d0: INT ~ 0;
d1: INT ~ destStart;
d2: INT ~ d1+destLen;
d3: INT ~ destSize;
s: ROSARY ~ IF source=NIL THEN rosaryOfNil ELSE source;
s0: INT ~ sourceStart;
s1: INT ~ s0+sourceLen;
rosary _ Rosary.CatSegments[[d, d0, d1-d0], [s, s0, s1-s0], [d, d2, d3-d2]];
IF NOT Rosary.MapRuns[[rosary], notNil] THEN rosary _ NIL;
};

RosaryMapRuns: PROC [rosary: ROSARY, start, len: INT, action: Rosary.RunActionType] ~ {
IF rosary=NIL THEN [] _ action[NIL, len]
ELSE [] _ Rosary.MapRuns[[rosary, start, len], action];
};

DeleteText: PUBLIC PROC [dest: Text, destStart: INT _ 0, destLen: INT _ maxLen] RETURNS [Text] ~ {
destSize: INT ~ Size[dest];
destStart _ MIN[MAX[0, destStart], destSize];
destLen _ MIN[MAX[0, destLen], destSize-destStart];
IF destLen=0 THEN RETURN[dest] -- delete nothing
ELSE {
new: Text ~ NEW[TextRep _ [rope: NIL, runs: NIL, charSets: NIL, charProps: NIL, props: NIL]];
newSize: INT ~ destSize-destLen;
IF newSize#0 THEN {
SELECT TRUE FROM
(destStart=0) => { -- delete from start
new.rope _ Rope.Substr[dest.rope, destLen, newSize];
IF dest.runs#NIL THEN new.runs _ TextLooks.Substr[dest.runs, destLen, newSize];
};
(destStart+destLen=destSize) => { -- delete from end
new.rope _ Rope.Substr[dest.rope, 0, newSize];
IF dest.runs#NIL THEN new.runs _ TextLooks.Substr[dest.runs, 0, newSize];
};
ENDCASE => {
new.rope _ Rope.Replace[base: dest.rope, start: destStart, len: destLen, with: NIL];
IF dest.runs#NIL THEN new.runs _ TextLooks.Replace[base: dest.runs, start: destStart, len: destLen, replace: NIL, baseSize: destSize, repSize: 0];
};
IF dest.charSets#NIL THEN new.charSets _ RosaryReplace[dest: dest.charSets, destSize: destSize, destStart: destStart, destLen: destLen, source: NIL, sourceStart: 0, sourceLen: 0];
IF dest.charProps#NIL THEN new.charProps _ RosaryReplace[dest: dest.charProps, destSize: destSize, destStart: destStart, destLen: destLen, source: NIL, sourceStart: 0, sourceLen: 0];
};
new.props _ dest.props;
RETURN[new];
};
};

ReplaceText: PUBLIC PROC [dest: Text, destStart: INT _ 0, destLen: INT _ maxLen, source: Text _ NIL, sourceStart: INT _ 0, sourceLen: INT _ maxLen] RETURNS [Text] ~ {
sourceSize: INT ~ Size[source];
sourceStart _ MIN[MAX[0, sourceStart], sourceSize];
sourceLen _ MIN[MAX[0, sourceLen], sourceSize-sourceStart];
IF sourceLen=0 THEN RETURN DeleteText[dest, destStart, destLen]
ELSE {
new: Text ~ NEW[TextRep _ [rope: NIL, runs: NIL, charSets: NIL, charProps: NIL, props: NIL]];
replaceRope: ROPE ~ Rope.Substr[source.rope, sourceStart, sourceLen];
replaceRuns: Runs ~ TextLooks.Substr[source.runs, sourceStart, sourceLen];
destSize: INT ~ Size[dest];
destStart _ MIN[MAX[0, destStart], destSize];
destLen _ MIN[MAX[0, destLen], destSize-destStart];
SELECT TRUE FROM
(destLen=0 AND destStart=0) => { -- insert at start
new.rope _ Rope.Concat[replaceRope, dest.rope];
new.runs _ TextLooks.Concat[replaceRuns, dest.runs, sourceLen, destSize];
};
(destLen=0 AND destStart=destSize) => { -- insert at end
new.rope _ Rope.Concat[dest.rope, replaceRope];
new.runs _ TextLooks.Concat[dest.runs, replaceRuns, destSize, sourceLen];
};
ENDCASE => {
new.rope _ Rope.Replace[base: dest.rope, start: destStart, len: destLen, with: replaceRope];
new.runs _ TextLooks.Replace[base: dest.runs, start: destStart, len: destLen, replace: replaceRuns, baseSize: destSize, repSize: sourceLen];
};
IF dest.charSets#NIL OR source.charSets#NIL THEN new.charSets _ RosaryReplace[dest: dest.charSets, destSize: destSize, destStart: destStart, destLen: destLen, source: source.charSets, sourceStart: sourceStart, sourceLen: sourceLen];
IF dest.charProps#NIL OR source.charProps#NIL THEN new.charProps _ RosaryReplace[dest: dest.charProps, destSize: destSize, destStart: destStart, destLen: destLen, source: source.charProps, sourceStart: sourceStart, sourceLen: sourceLen];
new.props _ dest.props;
RETURN[new];
};
};

CharSetsReplaceByRun: PROC [destCharSets: ROSARY, destSize: INT, destStart: INT, destLen: INT, charSet: CharSet, runSize: INT] RETURNS [ROSARY] ~ {
sourceCharSets: ROSARY _ NIL;
IF charSet#0 THEN {
item: REF CharSet _ NIL;
IF destCharSets#NIL THEN {
Try: TYPE ~ {before, after};
tries: ARRAY Try OF INT _ [before: destStart-1, after: destStart+destLen];
FOR try: Try IN Try WHILE item=NIL DO
i: INT ~ tries[try];
IF i IN [0..destSize) THEN WITH Rosary.Fetch[destCharSets, i] SELECT FROM
destItem: REF CharSet => IF destItem^=charSet THEN item _ destItem;
ENDCASE;
ENDLOOP;
};
IF item=NIL THEN item _ NEW[CharSet _ charSet];
sourceCharSets _ Rosary.FromItem[item, runSize];
};
RETURN[RosaryReplace[dest: destCharSets, destSize: destSize, destStart: destStart, destLen: destLen, source: sourceCharSets, sourceStart: 0, sourceLen: runSize]];
};

ReplaceByRope: PUBLIC PROC [dest: Text, destStart: INT, destLen: INT, rope: ROPE, inherit: BOOL, looks: Looks, charSet: CharSet] RETURNS [Text] ~ {
ropeSize: INT ~ Rope.Size[rope];
IF ropeSize=0 THEN RETURN DeleteText[dest, destStart, destLen]
ELSE {
new: Text ~ NEW[TextRep _ [rope: NIL, runs: NIL, charSets: NIL, charProps: NIL, props: NIL]];
destSize: INT ~ Size[dest];
destStart _ MIN[MAX[0, destStart], destSize];
destLen _ MIN[MAX[0, destLen], destSize-destStart];
new.rope _ Rope.Replace[base: dest.rope, start: destStart, len: destLen, with: rope];
new.runs _ TextLooks.ReplaceByRun[dest: dest.runs, start: destStart, len: destLen, runLen: ropeSize, destSize: destSize, inherit: inherit, looks: looks];
IF dest.charSets#NIL OR charSet#0 THEN new.charSets _ CharSetsReplaceByRun[destCharSets: dest.charSets, destSize: destSize, destStart: destStart, destLen: destLen, charSet: charSet, runSize: ropeSize];
IF dest.charProps#NIL THEN new.charProps _ RosaryReplace[dest: dest.charProps, destSize: destSize, destStart: destStart, destLen: destLen, source: NIL, sourceStart: 0, sourceLen: ropeSize];
new.props _ dest.props;
RETURN[new];
};
};

SetProp: PUBLIC PROC [text: Text, name: ATOM, value: REF] RETURNS [Text] ~ {
props: Props ~ PropsPut[text.props, name, value];
IF text.props=props THEN RETURN [text]
ELSE RETURN [NEW[TextRep _ [rope: text.rope, runs: text.runs, charSets: text.charSets, charProps: text.charProps, props: props]]];
};

SetComment: PUBLIC PROC [text: Text, comment: BOOL] RETURNS [Text] ~ {
IF text.props.comment=comment THEN RETURN [text]
ELSE RETURN SetProp[text, aComment, refBool[comment]];
};

SetFormat: PUBLIC PROC [text: Text, formatName: ATOM] RETURNS [Text] ~ {
IF text.props.formatName=formatName THEN RETURN [text]
ELSE RETURN SetProp[text, aFormat, formatName];
};

SetCharProp: PUBLIC PROC [text: Text, start: INT _ 0, len: INT _ maxLen, name: ATOM, value: REF] RETURNS [Text] ~ {
size: INT ~ Size[text];
start _ MIN[MAX[0, start], size];
len _ MIN[MAX[0, len], size-start];
IF len=0 THEN RETURN [text]
ELSE {
p: PROC[q: PROC[REF, INT]] ~ {
action: Rosary.RunActionType ~ { q[PropListPut[NARROW[item], name, value], repeat] };
RosaryMapRuns[text.charProps, start, len, action];
};
replaceCharProps: ROSARY ~ Rosary.FromProcProc[p];
newCharProps: ROSARY ~ RosaryReplace[dest: text.charProps, destSize: size, destStart: start, destLen: len, source: replaceCharProps, sourceStart: 0, sourceLen: len];
RETURN [NEW[TextRep _ [rope: text.rope, runs: text.runs, charSets: text.charSets, charProps: newCharProps, props: text.props]]];
};
};

SetCharPropList: PUBLIC PROC [text: Text, start: INT _ 0, len: INT _ maxLen, propList: PropList] RETURNS [Text] ~ {
size: INT ~ Size[text];
start _ MIN[MAX[0, start], size];
len _ MIN[MAX[0, len], size-start];
IF len=0 THEN RETURN [text]
ELSE {
replaceCharProps: ROSARY ~ Rosary.FromItem[propList, len];
newCharProps: ROSARY ~ RosaryReplace[dest: text.charProps, destSize: size, destStart: start, destLen: len, source: replaceCharProps, sourceStart: 0, sourceLen: len];
RETURN [NEW[TextRep _ [rope: text.rope, runs: text.runs, charSets: text.charSets, charProps: newCharProps, props: text.props]]];
};
};

ChangeLooks: PUBLIC PROC [text: Text, start: INT _ 0, len: INT _ maxLen, remove, add: Looks] RETURNS [Text] ~ {
size: INT ~ Size[text];
start _ MIN[MAX[0, start], size];
len _ MIN[MAX[0, len], size-start];
IF len=0 THEN RETURN [text]
ELSE {
oldRuns: Runs ~ text.runs;
newRuns: Runs ~ TextLooks.ChangeLooks[oldRuns, size, remove, add, start, len]; 
IF newRuns=oldRuns THEN RETURN [text] -- no change
ELSE RETURN [NEW[TextRep _ [rope: text.rope, runs: newRuns, charSets: text.charSets, charProps: text.charProps, props: text.props]]];
};
};


END.
ΤImmutableTiogaImpl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Doug Wyatt, September 16, 1986 5:00:45 pm PDT


Try to find a matching item in destCharSets adjacent to the replacement.
ΚŠ˜
codeš
œ™Kšœ
Οm
œ1™<K™-—K™š
Οk	˜	Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
—K˜KšΡblnœžœ
ž˜!Kšžœ˜Kšžœ˜Kšœžœ
žœ˜K˜š
Οn	œžœ
žœžœžœ˜5Kšœ
žœ˜!Kš
žœžœ
žœ
žœžœ˜3K˜K˜—š
 œžœ
žœžœžœ˜=šžœ žœ
ž˜/Kšœžœ˜Kšžœžœ
žœ˜—K˜K˜—K˜Kšœžœžœ
˜Kšœ
žœžœ	žœžœžœ
žœ
žœ˜EKšœžœžœ	˜š
œ	žœžœ	žœžœžœ
žœ˜EK˜—š œžœžœ˜?K˜šžœžœ
žœž˜!K˜ Kšžœ
˜—Kšžœ˜
K˜K˜—š œžœ+˜8Kšœžœ˜K˜šžœžœ
žœž˜K˜K˜ Kšžœ
˜—Kš
œ˜Kš
œ˜K˜K™—K˜š œžœ
žœžœžœ	žœ˜Ršžœ&žœžœ
ž˜:K˜Kšžœžœ
žœ
˜*Kšžœ
˜—Kšžœ
žœ˜K˜K˜—š œžœ
žœžœ	žœžœ˜\Kšžœ#žœ
žœ˜;šžœ˜Kš
œ,˜,Kšžœžœ
žœ
žœ˜Kšžœ
žœžœ
žœ!˜6K˜—K˜K˜—š œžœžœžœ˜IKš
žœ
žœ
žœ
žœžœ
˜!Kšžœ
žœžœ
žœ˜<šžœ˜Kš
œ5˜5Kšžœžœ
žœ˜/Kšžœ
žœžœ˜,K˜—Kš
œ˜K˜—K˜Kšœ
žœ˜Kšœ	žœ˜Kšœžœ
˜Kšœ	žœ˜Kšœ
žœ˜šœ
žœ˜K˜—šœ	žœ
žœ
žœ
žœ
žœžœžœ
žœžœžœžœ
žœžœ˜UK˜—š œžœ
žœžœžœ	žœ˜Išžœž˜Kš
œ+˜+Kš
œ$˜$Kšžœ.˜5—K˜K˜—š œžœ
žœžœ	žœžœ˜PK˜$Kšœžœ˜ Kšœ	žœ˜šžœž˜Kšœžœžœ
žœžœ
žœžœžœ
˜QKš
œžœžœ
žœžœžœžœ
˜HKšžœ8˜?—šžœžœžœžœ˜UKšœ
žœΑ
˜Ρ
šžœžœ˜%Kšœ
žœ
žœ˜šžœž˜Kš
œ(˜(Kš
œ$˜$Kš
œ&˜&Kš
œ&˜&Kšžœ
˜—K˜—Kšžœ˜K˜
—Kšžœ
žœ
Οc˜'K˜K˜—K˜š
 œžœ
žœžœžœ˜<Kšžœžœ
žœ	žœ˜.Kšžœžœžœžœžœ
žœ˜\K˜K˜—š
 œžœ
žœžœžœ˜QK˜K˜K˜8Kšžœ˜K˜K˜—K˜š
 œžœ
žœžœžœ˜0Kš
žœ
žœžœ
žœžœ˜;K˜K˜—š
 	œžœ
žœžœžœ˜RKšœžœ˜.šžœžœ
žœ
žœ$žœ
ž˜MKšœžœ#˜2Kšžœ
˜—Kš
œ˜K˜—š
 
œžœ
žœžœžœ˜DKšžœ*˜0Kš
œ˜K˜—š
 œžœ
žœžœžœ ˜SKš
œ˜Kš
œ ˜ K˜K˜—š
 	œžœ
žœžœžœ˜6Kšžœ˜K˜K˜—š
 
œžœ
žœžœžœ˜7Kšžœ˜K˜K˜—š œžœ
žœžœžœžœ˜?Kšžœ˜#K˜K˜—š œžœ
žœžœžœžœžœ˜OKšžœ2˜8K˜K˜—š
 œžœ
žœžœžœ˜LKšžœ
žœ'˜4K˜K˜—K˜šœ
žœžœ
˜3K˜—š 
œžœžœžœ
žœžœ
žœžœ
žœžœ
žœ˜ž
Kšœ-žœ˜3Kšœžœžœžœ
žœ
žœ˜3Kšœžœ˜Kšœžœ
˜Kšœžœ˜Kšœžœ˜Kšœžœžœžœ
žœ
žœ˜7Kšœžœ˜Kšœžœ˜Kš
œL˜LKšžœ
žœ"žœ
žœ
˜:K˜K˜—š 
œžœ
žœžœ#˜WKšžœžœ
žœ
žœ˜(Kšžœ3˜7K˜K˜—š 
œžœ
žœžœžœžœ˜bKšœ
žœ˜Kšœžœ
žœ˜-Kšœ
žœ
žœ"˜3Kšžœžœ
žœ‘˜0šžœ˜Kš
œžœžœžœžœ
žœ	žœ˜]Kšœ	žœ˜ šžœžœ˜šžœ
žœ
ž˜šœ‘˜'Kš
œ4˜4Kšžœžœ
žœ:˜OK˜—šœ"‘˜4Kš
œ.˜.Kšžœžœ
žœ4˜IK˜—šžœ˜K•StartOfExpansionM[base: 
ROPE, start: 
INT _ 0, len: 
INT _ 2147483647, with: 
ROPE _ NIL]šœOžœ˜TK–†
[base: 
TextLooks.Runs, start: 
INT, len: 
INT, replace: 
TextLooks.Runs, baseSize: 
INT, repSize: 
INT, tryFlat: 
BOOL _ TRUE]šžœžœ
žœXžœ"˜’
K˜——Kšžœžœ
žœwžœ ˜³
Kšžœžœ
žœyžœ ˜Ά
K˜—Jš
œ˜Jšžœ˜K˜—˜K˜——š œžœ
žœžœžœžœžœžœžœ˜¦
Kšœžœ˜Kšœžœ
žœ˜3Kšœžœ
žœ(˜;Kšžœ
žœ
žœ%˜?šžœ˜Kš
œžœžœžœžœ
žœ	žœ˜]Kšœ
žœ4˜EKš
œJ˜JKšœ
žœ˜Kšœžœ
žœ˜-Kšœ
žœ
žœ"˜3šžœ
žœ
ž˜šœžœ‘˜3Kš
œ/˜/Kš
œI˜IK˜—šœžœ‘˜8Kš
œ/˜/Kš
œI˜IK˜—šžœ˜K–M[base: 
ROPE, start: 
INT _ 0, len: 
INT _ 2147483647, with: 
ROPE _ NIL]š
œ\˜\K–†
[base: 
TextLooks.Runs, start: 
INT, len: 
INT, replace: 
TextLooks.Runs, baseSize: 
INT, repSize: 
INT, tryFlat: 
BOOL _ TRUE]š
œŒ
˜Œ
K˜——Kš
žœžœ
žœžœ
žœΈ
˜θ
Kš
žœžœ
žœžœ
žœ»
˜ν
Jš
œ˜Jšžœ˜K˜—K˜K˜—š œžœžœžœ
žœžœžœžœžœ˜“
Kšœžœžœ
˜šžœžœ˜Kšœžœžœ
˜šžœžœ
žœ˜Kš
œH™HKšœžœ˜Kšœžœžœ
žœ3˜Jš	žœ
žœžœžœ
ž˜%Kšœžœ˜šžœžœžœ
žœžœ
ž˜IKšœ
žœžœžœ˜CKšžœ
˜—Kšžœ
˜—Kš
œ˜—Kšžœžœ
žœžœ˜/Kš
œ0˜0K˜—Kšžœœ
˜’
Kš
œ˜K˜—š 
œžœ
žœžœžœžœžœ"žœ˜“
Kšœ
žœ˜ Kšžœžœ
žœ%˜>šžœ˜Kš
œžœžœžœžœ
žœ	žœ˜]Kšœ
žœ˜Kšœžœ
žœ˜-Kšœ
žœ
žœ"˜3Kš
œU˜UKš
Ϫ
˜™
Kšžœžœ
žœžœ£
˜Ι
Kšžœžœ
žœyžœ'˜½
Jš
œ˜Jšžœ˜K˜—˜K˜——š œžœ
žœžœ	žœžœ˜LKš
œ1˜1Kšžœžœ
žœ˜&Kšžœ
žœžœr˜‚
K˜K˜—š
 
œžœ
žœžœžœ˜FKšžœžœ
žœ˜0Kšžœ
žœ+˜6K˜K˜—š
 	œžœ
žœžœžœ˜HKšžœ"žœ
žœ˜6Kšžœ
žœ$˜/K˜K˜—š œžœ
žœžœžœžœ	žœžœ˜sKšœžœ˜Kšœžœ
žœ˜!Kšœžœ
žœ˜#Kšžœžœ
žœ˜šžœ˜š	œžœžœ
žœžœ˜Kšœ/žœ ˜UKš
œ2˜2Kš
œ˜—Kšœžœ˜2Kšœžœ‘
˜₯
Kšžœžœu˜€
K˜—K˜K˜—š œžœ
žœžœžœžœ˜sKšœžœ˜Kšœžœ
žœ˜!Kšœžœ
žœ˜#Kšžœžœ
žœ˜šžœ˜Kšœžœ"˜:Kšœžœ‘
˜₯
Kšžœžœu˜€
K˜—K˜K˜—š œžœ
žœžœžœžœ˜oKšœžœ˜Kšœžœ
žœ˜!Kšœžœ
žœ˜#Kšžœžœ
žœ˜šžœ˜K˜K˜OKšžœžœ
žœ‘˜2Kšžœ
žœžœu˜…
K˜—K˜K˜—K˜Kšžœ
˜—…—6I^